fix(copilot/dummy): emit full AI SDK protocol event sequence

The dummy service was missing StreamStartStep, StreamTextStart,
StreamTextEnd, StreamFinishStep, and StreamFinish events that the
Vercel AI SDK protocol requires. This caused the frontend to error
out even on normal messages (no magic keyword).

autogpt_platform/backend/backend/copilot/sdk/dummy.py

@@ -25,8 +25,13 @@ from ..model import ChatSession
 from ..response_model import (
     StreamBaseResponse,
     StreamError,
+    StreamFinish,
+    StreamFinishStep,
     StreamStart,
+    StreamStartStep,
     StreamTextDelta,
+    StreamTextEnd,
+    StreamTextStart,
 )
 
 logger = logging.getLogger(__name__)
@@ -64,15 +69,19 @@ async def stream_chat_completion_dummy(
     message_id = str(uuid.uuid4())
     text_block_id = str(uuid.uuid4())
 
-    # Start the stream
+    # Start the stream (matches baseline: StreamStart → StreamStartStep)
     yield StreamStart(messageId=message_id, sessionId=session_id)
+    yield StreamStartStep()
 
     # --- Magic keyword: transient error (retryable) -------------------------
     if _has_keyword(message, "__test_transient_error__"):
         # Stream some partial text first (simulates mid-stream failure)
+        yield StreamTextStart(id=text_block_id)
         for word in ["Working", "on", "it..."]:
             yield StreamTextDelta(id=text_block_id, delta=f"{word} ")
             await asyncio.sleep(0.1)
+        yield StreamTextEnd(id=text_block_id)
+        yield StreamFinishStep()
         # Then emit a retryable error — frontend should show "Try Again"
         yield StreamError(
             errorText=FRIENDLY_TRANSIENT_MSG,
@@ -82,6 +91,7 @@ async def stream_chat_completion_dummy(
 
     # --- Magic keyword: fatal error (non-retryable) -------------------------
     if _has_keyword(message, "__test_fatal_error__"):
+        yield StreamFinishStep()
         yield StreamError(
             errorText="Internal SDK error: model refused to respond",
             code="sdk_error",
@@ -95,8 +105,12 @@ async def stream_chat_completion_dummy(
     dummy_response = "I counted: 1... 2... 3. All done!"
     words = dummy_response.split()
 
+    yield StreamTextStart(id=text_block_id)
     for i, word in enumerate(words):
         # Add space except for last word
         text = word if i == len(words) - 1 else f"{word} "
         yield StreamTextDelta(id=text_block_id, delta=text)
         await asyncio.sleep(delay)
+    yield StreamTextEnd(id=text_block_id)
+    yield StreamFinishStep()
+    yield StreamFinish()

autogpt_platform/backend/backend/copilot/test_copilot_e2e.py

@@ -6,9 +6,10 @@ external LLM calls.
 
 Enable test mode with CHAT_TEST_MODE=true environment variable (or in .env).
 
-Note: StreamFinish is NOT emitted by the dummy service — it is published
-by mark_session_completed in the processor layer.  These tests only cover
-the service-level streaming output (StreamStart + StreamTextDelta).
+The dummy service emits the full AI SDK protocol event sequence:
+StreamStart → StreamStartStep → StreamTextStart → StreamTextDelta(s) →
+StreamTextEnd → StreamFinishStep → StreamFinish.
+The processor skips StreamFinish and publishes its own via mark_session_completed.
 """
 
 import asyncio
@@ -20,9 +21,14 @@ import pytest
 from backend.copilot.model import ChatMessage, ChatSession, upsert_chat_session
 from backend.copilot.response_model import (
     StreamError,
+    StreamFinish,
+    StreamFinishStep,
     StreamHeartbeat,
     StreamStart,
+    StreamStartStep,
     StreamTextDelta,
+    StreamTextEnd,
+    StreamTextStart,
 )
 from backend.copilot.sdk.dummy import stream_chat_completion_dummy
 
@@ -110,9 +116,14 @@ async def test_streaming_event_types():
     ):
         event_types.add(type(event).__name__)
 
-    # Required event types (StreamFinish is published by processor, not service)
+    # Required event types for full AI SDK protocol
     assert "StreamStart" in event_types, "Missing StreamStart"
+    assert "StreamStartStep" in event_types, "Missing StreamStartStep"
+    assert "StreamTextStart" in event_types, "Missing StreamTextStart"
     assert "StreamTextDelta" in event_types, "Missing StreamTextDelta"
+    assert "StreamTextEnd" in event_types, "Missing StreamTextEnd"
+    assert "StreamFinishStep" in event_types, "Missing StreamFinishStep"
+    assert "StreamFinish" in event_types, "Missing StreamFinish"
 
     print(f"✅ Event types: {sorted(event_types)}")
 
@@ -327,20 +338,28 @@ async def test_stream_completeness():
     ):
         events.append(event)
 
-    # Check for required events (StreamFinish is published by processor)
-    has_start = any(isinstance(e, StreamStart) for e in events)
-    has_text = any(isinstance(e, StreamTextDelta) for e in events)
-
-    assert has_start, "Stream must include StreamStart"
-    assert has_text, "Stream must include text deltas"
+    # Check for all required event types
+    assert any(isinstance(e, StreamStart) for e in events), "Missing StreamStart"
+    assert any(
+        isinstance(e, StreamStartStep) for e in events
+    ), "Missing StreamStartStep"
+    assert any(
+        isinstance(e, StreamTextStart) for e in events
+    ), "Missing StreamTextStart"
+    assert any(
+        isinstance(e, StreamTextDelta) for e in events
+    ), "Missing StreamTextDelta"
+    assert any(isinstance(e, StreamTextEnd) for e in events), "Missing StreamTextEnd"
+    assert any(
+        isinstance(e, StreamFinishStep) for e in events
+    ), "Missing StreamFinishStep"
+    assert any(isinstance(e, StreamFinish) for e in events), "Missing StreamFinish"
 
     # Verify exactly one start
     start_count = sum(1 for e in events if isinstance(e, StreamStart))
     assert start_count == 1, f"Should have exactly 1 StreamStart, got {start_count}"
 
-    print(
-        f"✅ Completeness: 1 start, {sum(1 for e in events if isinstance(e, StreamTextDelta))} text deltas"
-    )
+    print(f"✅ Completeness: {len(events)} events, full protocol sequence")
 
 
 @pytest.mark.asyncio