refactor: address review follow-ups for local protocol

Author: adamfweidman

packages/core/src/agent/content-utils.test.ts

@@ -187,14 +187,16 @@ describe('contentPartsToGeminiParts', () => {
     ]);
   });
 
-  it('throws on unknown ContentPart variants', () => {
+  it('serializes unknown ContentPart variants', () => {
     // Force an unknown variant past the type system
     const content = [
       { type: 'custom_widget', payload: 123 },
     ] as unknown as ContentPart[];
-    expect(() => contentPartsToGeminiParts(content)).toThrow(
-      'Unhandled ContentPart type: {"type":"custom_widget","payload":123}',
-    );
+    const result = contentPartsToGeminiParts(content);
+    expect(result).toHaveLength(1);
+    expect(result[0]).toEqual({
+      text: JSON.stringify({ type: 'custom_widget', payload: 123 }),
+    });
   });
 });
 

packages/core/src/agent/content-utils.ts

@@ -6,6 +6,7 @@
 
 import type { Part } from '@google/genai';
 import type { ContentPart } from './types.js';
+import { debugLogger } from '../utils/debugLogger.js';
 
 /**
  * Converts Gemini API Part objects to framework-agnostic ContentPart objects.
@@ -92,12 +93,13 @@ export function contentPartsToGeminiParts(content: ContentPart[]): Part[] {
         // References are converted to text for the model
         result.push({ text: part.text });
         break;
-      default: {
-        ((x: never) => {
-          throw new Error(`Unhandled ContentPart type: ${JSON.stringify(x)}`);
-        })(part);
+      default:
+        debugLogger.warn(
+          `Unhandled ContentPart type: ${JSON.stringify(part)} fallback to serialization`,
+        );
+        // Serialize unknown ContentPart variants instead of dropping them
+        result.push({ text: JSON.stringify(part) });
         break;
-      }
     }
   }
   return result;

packages/core/src/agent/legacy-agent-session.test.ts

@@ -239,10 +239,11 @@ describe('LegacyAgentSession', () => {
       );
     });
 
-    it('returns null streamId for non-message payloads', async () => {
+    it('throws for non-message payloads', async () => {
       const session = new LegacyAgentSession(deps);
-      const result = await session.send({ update: { title: 'test' } });
-      expect(result.streamId).toBeNull();
+      await expect(session.send({ update: { title: 'test' } })).rejects.toThrow(
+        'only supports message sends',
+      );
     });
 
     it('throws if send is called while a stream is active', async () => {

packages/core/src/agent/legacy-agent-session.ts

@@ -105,10 +105,12 @@ export class LegacyAgentProtocol implements AgentProtocol {
     };
   }
 
-  async send(payload: AgentSend): Promise<{ streamId: string | null }> {
+  async send(payload: AgentSend): Promise<{ streamId: string }> {
     const message = 'message' in payload ? payload.message : undefined;
     if (!message) {
-      return { streamId: null };
+      throw new Error(
+        'LegacyAgentSession.send() only supports message sends for the moment.',
+      );
     }
 
     if (this._activeStreamId) {