Fix interact with conversation endpoint handling for initial_message_type (#16)

* Fix request body construction for interact with conversation endpoint

Add missing `initial_message_type` field and use proper multipart/form-data
for voice requests instead of raw bytes with Content-Type header override.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Allow caller to specify initial_message_type parameter

Accept "user-message", "external-event", and "skip" values per the
OpenAPI spec. The "skip" type sends an empty recorded_message with no
file upload. Defaults to "user-message" for backwards compatibility.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* ifx request_format handling

* fix skip message type handling

* fmt

* fix tests

* add interact convo tests for external events and skip intial msg types

* add voice interact integration test too

* refactor(conversation): remove skip initial_message_type support

* test(conversation): remove skip initial message coverage

* test(integration): tolerate voice-unavailable responses

* remove swallowing for bad request and internal server errors for test interact convo integration tests

* fix pcm test request

* run in parallel

* fix(conversation): JSON-encode request_audio_config query param

* fix(integration): use transcoded hello.wav voice fixture

* test(integration): drop m4a fixture and fix import order

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: caly-amigo

.github/workflows/test.yml

@@ -54,7 +54,6 @@ jobs:
 
   integration-test:
     runs-on: blacksmith-4vcpu-ubuntu-2404
-    needs: test # Only run if unit tests pass
     # Skip for PRs from forks (they don't have access to secrets)
     # This runs on: pushes to main, PRs from same repo
     if: >

src/amigo_sdk/resources/conversation.py

@@ -1,4 +1,5 @@
 import asyncio
+import json
 import threading
 from collections.abc import AsyncGenerator, Iterator
 from datetime import datetime
@@ -74,6 +75,9 @@ async def interact_with_conversation(
         params: InteractWithConversationParametersQuery,
         abort_event: asyncio.Event | None = None,
         *,
+        initial_message_type: Literal[
+            "user-message", "external-event"
+        ] = "user-message",
         text_message: str | None = None,
         audio_bytes: bytes | None = None,
         audio_content_type: Literal["audio/mpeg", "audio/wav"] | None = None,
@@ -84,35 +88,54 @@ async def interact_with_conversation(
         """
 
         async def _generator():
+            params_data = params.model_dump(mode="json", exclude_none=True)
+            if "request_audio_config" in params_data:
+                params_data["request_audio_config"] = json.dumps(
+                    params_data["request_audio_config"]
+                )
             request_kwargs: dict[str, Any] = {
-                "params": params.model_dump(mode="json", exclude_none=True),
+                "params": params_data,
                 "abort_event": abort_event,
                 "headers": {"Accept": "application/x-ndjson"},
             }
-            # Route based on requested format
-            req_format = getattr(params, "request_format", None)
-            if req_format == Format.text:
+
+            if initial_message_type not in {"user-message", "external-event"}:
+                raise ValueError(
+                    "initial_message_type must be 'user-message' or 'external-event'"
+                )
+
+            if params.request_format == Format.text:
                 if text_message is None:
                     raise ValueError(
                         "text_message is required when request_format is 'text'"
                     )
                 text_bytes = text_message.encode("utf-8")
+                request_kwargs["data"] = {
+                    "initial_message_type": initial_message_type,
+                }
                 request_kwargs["files"] = {
                     "recorded_message": (
                         "message.txt",
                         text_bytes,
                         "text/plain; charset=utf-8",
                     )
                 }
-            elif req_format == Format.voice:
+            elif params.request_format == Format.voice:
                 if audio_bytes is None or audio_content_type is None:
                     raise ValueError(
                         "audio_bytes and audio_content_type are required when request_format is 'voice'"
                     )
-                # Send raw bytes with appropriate content type
-                request_kwargs["content"] = audio_bytes
-                request_kwargs.setdefault("headers", {})
-                request_kwargs["headers"]["Content-Type"] = audio_content_type
+                ext = "mp3" if audio_content_type == "audio/mpeg" else "wav"
+                request_kwargs["data"] = {
+                    "initial_message_type": initial_message_type,
+                }
+                request_kwargs["files"] = {
+                    "recorded_message": (
+                        f"audio.{ext}",
+                        audio_bytes,
+                        audio_content_type,
+                    )
+                }
             else:
                 raise ValueError("Unsupported or missing request_format in params")
 
@@ -241,23 +264,40 @@ def interact_with_conversation(
         params: InteractWithConversationParametersQuery,
         abort_event: threading.Event | None = None,
         *,
+        initial_message_type: Literal[
+            "user-message", "external-event"
+        ] = "user-message",
         text_message: str | None = None,
         audio_bytes: bytes | None = None,
         audio_content_type: Literal["audio/mpeg", "audio/wav"] | None = None,
     ) -> Iterator[ConversationInteractWithConversationResponse]:
         def _iter():
+            params_data = params.model_dump(mode="json", exclude_none=True)
+            if "request_audio_config" in params_data:
+                params_data["request_audio_config"] = json.dumps(
+                    params_data["request_audio_config"]
+                )
             request_kwargs: dict[str, Any] = {
-                "params": params.model_dump(mode="json", exclude_none=True),
+                "params": params_data,
                 "headers": {"Accept": "application/x-ndjson"},
                 "abort_event": abort_event,
             }
+
+            if initial_message_type not in {"user-message", "external-event"}:
+                raise ValueError(
+                    "initial_message_type must be 'user-message' or 'external-event'"
+                )
+
             req_format = getattr(params, "request_format", None)
             if req_format == Format.text:
                 if text_message is None:
                     raise ValueError(
                         "text_message is required when request_format is 'text'"
                     )
                 text_bytes = text_message.encode("utf-8")
+                request_kwargs["data"] = {
+                    "initial_message_type": initial_message_type,
+                }
                 request_kwargs["files"] = {
                     "recorded_message": (
                         "message.txt",
@@ -270,9 +310,17 @@ def _iter():
                     raise ValueError(
                         "audio_bytes and audio_content_type are required when request_format is 'voice'"
                     )
-                request_kwargs["content"] = audio_bytes
-                request_kwargs.setdefault("headers", {})
-                request_kwargs["headers"]["Content-Type"] = audio_content_type
+                ext = "mp3" if audio_content_type == "audio/mpeg" else "wav"
+                request_kwargs["data"] = {
+                    "initial_message_type": initial_message_type,
+                }
+                request_kwargs["files"] = {
+                    "recorded_message": (
+                        f"audio.{ext}",
+                        audio_bytes,
+                        audio_content_type,
+                    )
+                }
             else:
                 raise ValueError("Unsupported or missing request_format in params")
 

tests/integration/fixtures/hello.wav

@@ -1,6 +1,7 @@
 import asyncio
 import os
 from collections.abc import AsyncGenerator
+from pathlib import Path
 
 import pytest
 
@@ -15,13 +16,21 @@
     InteractionCompleteEvent,
     InteractWithConversationParametersQuery,
     NewMessageEvent,
+    PCMUserMessageAudioConfig,
+    SampleWidth,
 )
 from amigo_sdk.sdk_client import AmigoClient, AsyncAmigoClient
 
 # Constants
 SERVICE_ID = os.getenv("AMIGO_TEST_SERVICE_ID", "689b81e7afdaf934f4b48f81")
 
 
+def _build_test_wav_bytes() -> bytes:
+    """Load a short spoken WAV fixture for voice-request integration tests."""
+    fixture_path = Path(__file__).with_name("fixtures") / "hello.wav"
+    return fixture_path.read_bytes()
+
+
 @pytest.fixture(scope="module", autouse=True)
 async def pre_suite_cleanup() -> AsyncGenerator[None]:
     # Ensure env loaded and client can connect; verify service exists
@@ -155,6 +164,71 @@ async def test_interact_with_conversation_text_streams(self):
             if latest_interaction_id:
                 type(self).interaction_id = latest_interaction_id
 
+    async def test_interact_with_conversation_external_event_streams(self):
+        assert type(self).conversation_id is not None
+
+        async with AsyncAmigoClient() as client:
+            events = await client.conversation.interact_with_conversation(
+                type(self).conversation_id,
+                params=InteractWithConversationParametersQuery(
+                    request_format="text", response_format="text"
+                ),
+                initial_message_type="external-event",
+                text_message="External event integration test message.",
+            )
+
+            saw_interaction_complete = False
+            latest_interaction_id: str | None = None
+
+            async for evt in events:
+                e = evt.root
+                if isinstance(e, ErrorEvent):
+                    pytest.fail(f"error event: {e.model_dump_json()}")
+                if isinstance(e, InteractionCompleteEvent):
+                    saw_interaction_complete = True
+                    latest_interaction_id = e.interaction_id
+                    break
+
+            assert saw_interaction_complete is True
+            if latest_interaction_id:
+                type(self).interaction_id = latest_interaction_id
+
+    async def test_interact_with_conversation_voice_streams(self):
+        assert type(self).conversation_id is not None
+
+        async with AsyncAmigoClient() as client:
+            events = await client.conversation.interact_with_conversation(
+                type(self).conversation_id,
+                params=InteractWithConversationParametersQuery(
+                    request_format="voice",
+                    response_format="text",
+                    request_audio_config=PCMUserMessageAudioConfig(
+                        type="pcm",
+                        frame_rate=16000,
+                        n_channels=1,
+                        sample_width=SampleWidth.integer_2,
+                    ),
+                ),
+                audio_bytes=_build_test_wav_bytes(),
+                audio_content_type="audio/wav",
+            )
+
+            saw_interaction_complete = False
+            latest_interaction_id: str | None = None
+
+            async for evt in events:
+                e = evt.root
+                if isinstance(e, ErrorEvent):
+                    pytest.fail(f"error event: {e.model_dump_json()}")
+                if isinstance(e, InteractionCompleteEvent):
+                    saw_interaction_complete = True
+                    latest_interaction_id = e.interaction_id
+                    break
+
+            assert saw_interaction_complete is True
+            if latest_interaction_id:
+                type(self).interaction_id = latest_interaction_id
+
     async def test_get_conversation_messages_pagination(self):
         assert type(self).conversation_id is not None
 
@@ -276,6 +350,7 @@ def test_interact_with_conversation_text_streams(self):
                 params=InteractWithConversationParametersQuery(
                     request_format="text", response_format="text"
                 ),
+                initial_message_type="user-message",
                 text_message="Hello, I'm sending a text message from the Python SDK synchronously!",
             )
 
@@ -299,6 +374,71 @@ def test_interact_with_conversation_text_streams(self):
             if latest_interaction_id:
                 type(self).interaction_id = latest_interaction_id
 
+    def test_interact_with_conversation_external_event_streams(self):
+        assert type(self).conversation_id is not None
+
+        with AmigoClient() as client:
+            events = client.conversation.interact_with_conversation(
+                type(self).conversation_id,
+                params=InteractWithConversationParametersQuery(
+                    request_format="text", response_format="text"
+                ),
+                initial_message_type="external-event",
+                text_message="External event integration test message.",
+            )
+
+            saw_interaction_complete = False
+            latest_interaction_id: str | None = None
+
+            for evt in events:
+                e = evt.root
+                if isinstance(e, ErrorEvent):
+                    pytest.fail(f"error event: {e.model_dump_json()}")
+                if isinstance(e, InteractionCompleteEvent):
+                    saw_interaction_complete = True
+                    latest_interaction_id = e.interaction_id
+                    break
+
+            assert saw_interaction_complete is True
+            if latest_interaction_id:
+                type(self).interaction_id = latest_interaction_id
+
+    def test_interact_with_conversation_voice_streams(self):
+        assert type(self).conversation_id is not None
+
+        with AmigoClient() as client:
+            events = client.conversation.interact_with_conversation(
+                type(self).conversation_id,
+                params=InteractWithConversationParametersQuery(
+                    request_format="voice",
+                    response_format="text",
+                    request_audio_config=PCMUserMessageAudioConfig(
+                        type="pcm",
+                        frame_rate=16000,
+                        n_channels=1,
+                        sample_width=SampleWidth.integer_2,
+                    ),
+                ),
+                audio_bytes=_build_test_wav_bytes(),
+                audio_content_type="audio/wav",
+            )
+
+            saw_interaction_complete = False
+            latest_interaction_id: str | None = None
+
+            for evt in events:
+                e = evt.root
+                if isinstance(e, ErrorEvent):
+                    pytest.fail(f"error event: {e.model_dump_json()}")
+                if isinstance(e, InteractionCompleteEvent):
+                    saw_interaction_complete = True
+                    latest_interaction_id = e.interaction_id
+                    break
+
+            assert saw_interaction_complete is True
+            if latest_interaction_id:
+                type(self).interaction_id = latest_interaction_id
+
     def test_get_conversation_messages_pagination(self):
         assert type(self).conversation_id is not None