refactor(core): agent session protocol changes

Author: adamfweidman

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

@@ -8,6 +8,7 @@ import { describe, expect, it } from 'vitest';
 import {
   geminiPartsToContentParts,
   contentPartsToGeminiParts,
+  toolResultDisplayToContentParts,
   buildToolResponseData,
 } from './content-utils.js';
 import type { Part } from '@google/genai';
@@ -199,6 +200,27 @@ describe('contentPartsToGeminiParts', () => {
   });
 });
 
+describe('toolResultDisplayToContentParts', () => {
+  it('returns undefined for undefined', () => {
+    expect(toolResultDisplayToContentParts(undefined)).toBeUndefined();
+  });
+
+  it('returns undefined for null', () => {
+    expect(toolResultDisplayToContentParts(null)).toBeUndefined();
+  });
+
+  it('handles string resultDisplay as-is', () => {
+    const result = toolResultDisplayToContentParts('File written');
+    expect(result).toEqual([{ type: 'text', text: 'File written' }]);
+  });
+
+  it('stringifies object resultDisplay', () => {
+    const display = { type: 'FileDiff', oldPath: 'a.ts', newPath: 'b.ts' };
+    const result = toolResultDisplayToContentParts(display);
+    expect(result).toEqual([{ type: 'text', text: JSON.stringify(display) }]);
+  });
+});
+
 describe('buildToolResponseData', () => {
   it('preserves outputFile and contentLength', () => {
     const result = buildToolResponseData({

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.
@@ -93,6 +94,9 @@ export function contentPartsToGeminiParts(content: ContentPart[]): Part[] {
         result.push({ text: part.text });
         break;
       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;
@@ -101,6 +105,24 @@ export function contentPartsToGeminiParts(content: ContentPart[]): Part[] {
   return result;
 }
 
+/**
+ * Converts a ToolCallResponseInfo.resultDisplay value into ContentPart[].
+ * Handles string, object-valued (FileDiff, SubagentProgress, etc.),
+ * and undefined resultDisplay consistently.
+ */
+export function toolResultDisplayToContentParts(
+  resultDisplay: unknown,
+): ContentPart[] | undefined {
+  if (resultDisplay === undefined || resultDisplay === null) {
+    return undefined;
+  }
+  const text =
+    typeof resultDisplay === 'string'
+      ? resultDisplay
+      : JSON.stringify(resultDisplay);
+  return [{ type: 'text', text }];
+}
+
 /**
  * Builds the data record for a tool_response AgentEvent, preserving
  * all available metadata from the ToolCallResponseInfo.

packages/core/src/agent/event-translator.test.ts

@@ -155,10 +155,9 @@ describe('translateEvent', () => {
       expect(resp.content).toEqual([
         { type: 'text', text: 'Permission denied to write' },
       ]);
-      expect(resp.display?.result).toEqual({
-        type: 'text',
-        text: 'Permission denied',
-      });
+      expect(resp.displayContent).toEqual([
+        { type: 'text', text: 'Permission denied' },
+      ]);
       expect(resp.data).toEqual({ errorType: 'permission_denied' });
     });
 
@@ -201,12 +200,9 @@ describe('translateEvent', () => {
       };
       const result = translateEvent(event, state);
       const resp = result[0] as AgentEvent<'tool_response'>;
-      expect(resp.display?.result).toEqual({
-        type: 'diff',
-        path: '/tmp/test.txt',
-        beforeText: 'a',
-        afterText: 'b',
-      });
+      expect(resp.displayContent).toEqual([
+        { type: 'text', text: JSON.stringify(objectDisplay) },
+      ]);
     });
 
     it('passes through string resultDisplay as-is', () => {
@@ -224,10 +220,9 @@ describe('translateEvent', () => {
       };
       const result = translateEvent(event, state);
       const resp = result[0] as AgentEvent<'tool_response'>;
-      expect(resp.display?.result).toEqual({
-        type: 'text',
-        text: 'Command output text',
-      });
+      expect(resp.displayContent).toEqual([
+        { type: 'text', text: 'Command output text' },
+      ]);
     });
 
     it('preserves outputFile and contentLength in data', () => {
@@ -378,7 +373,7 @@ describe('translateEvent', () => {
       expect(err.type).toBe('error');
       expect(err.fatal).toBe(false);
       expect(err._meta?.['code']).toBe('AGENT_EXECUTION_BLOCKED');
-      expect(err.message).toBe('Policy violation');
+      expect(err.message).toBe('Agent execution blocked: Policy violation');
     });
 
     it('uses systemMessage in the final error message when available', () => {
@@ -393,7 +388,9 @@ describe('translateEvent', () => {
       };
       const result = translateEvent(event, state);
       const err = result[0] as AgentEvent<'error'>;
-      expect(err.message).toBe('Blocked by policy hook');
+      expect(err.message).toBe(
+        'Agent execution blocked: Blocked by policy hook',
+      );
     });
   });
 

packages/core/src/agent/event-translator.ts

@@ -25,13 +25,12 @@ import type {
   ErrorData,
   Usage,
   AgentEventType,
-  ToolDisplay,
 } from './types.js';
 import {
   geminiPartsToContentParts,
+  toolResultDisplayToContentParts,
   buildToolResponseData,
 } from './content-utils.js';
-import { toolResultDisplayToDisplayContent } from './tool-display-utils.js';
 
 // ---------------------------------------------------------------------------
 // Translation State
@@ -210,7 +209,7 @@ export function translateEvent(
       out.push(
         makeEvent('error', state, {
           status: 'PERMISSION_DENIED',
-          message: event.value.systemMessage?.trim() || event.value.reason,
+          message: `Agent execution blocked: ${event.value.systemMessage?.trim() || event.value.reason}`,
           fatal: false,
           _meta: { code: 'AGENT_EXECUTION_BLOCKED' },
         }),
@@ -236,23 +235,16 @@ export function translateEvent(
           requestId: event.value.callId,
           name: event.value.name,
           args: event.value.args,
-          display: event.value.display,
         }),
       );
       break;
 
     case GeminiEventType.ToolCallResponse: {
       ensureStreamStart(state, out);
+      const displayContent = toolResultDisplayToContentParts(
+        event.value.resultDisplay,
+      );
       const data = buildToolResponseData(event.value);
-      const display: ToolDisplay | undefined =
-        event.value.display ??
-        (event.value.resultDisplay
-          ? {
-              result: toolResultDisplayToDisplayContent(
-                event.value.resultDisplay,
-              ),
-            }
-          : undefined);
       out.push(
         makeEvent('tool_response', state, {
           requestId: event.value.callId,
@@ -261,7 +253,7 @@ export function translateEvent(
             ? [{ type: 'text', text: event.value.error.message }]
             : geminiPartsToContentParts(event.value.responseParts),
           isError: event.value.error !== undefined,
-          ...(display ? { display } : {}),
+          ...(displayContent ? { displayContent } : {}),
           ...(data ? { data } : {}),
         }),
       );
@@ -282,6 +274,7 @@ export function translateEvent(
       ((x: never) => {
         throw new Error(`Unhandled event type: ${JSON.stringify(x)}`);
       })(event);
+      break;
   }
 
   return out;

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

@@ -102,10 +102,7 @@ function makeCompletedToolCall(
     response: {
       callId,
       responseParts: [{ text: responseText }],
-      resultDisplay: responseText,
-      display: {
-        result: { type: 'text', text: responseText },
-      },
+      resultDisplay: undefined,
       error: undefined,
       errorType: undefined,
     },
@@ -203,6 +200,7 @@ describe('LegacyAgentSession', () => {
         expect.any(AbortSignal),
         'test-prompt',
         undefined,
+        false,
         'raw input',
       );
 
@@ -429,12 +427,6 @@ describe('LegacyAgentSession', () => {
         (e): e is AgentEvent<'tool_response'> => e.type === 'tool_response',
       );
       expect(toolResp?.name).toBe('read_file');
-      expect(toolResp?.display).toEqual(
-        expect.objectContaining({
-          name: 'read_file',
-          result: { type: 'text', text: 'file contents' },
-        }),
-      );
       expect(toolResp?.content).toEqual([
         { type: 'text', text: 'file contents' },
       ]);
@@ -497,10 +489,9 @@ describe('LegacyAgentSession', () => {
       expect(toolResp?.content).toEqual([
         { type: 'text', text: 'Permission denied' },
       ]);
-      expect(toolResp?.display?.result).toEqual({
-        type: 'text',
-        text: 'Error display',
-      });
+      expect(toolResp?.displayContent).toEqual([
+        { type: 'text', text: 'Error display' },
+      ]);
     });
 
     it('stops on STOP_EXECUTION tool error', async () => {
@@ -655,7 +646,7 @@ describe('LegacyAgentSession', () => {
           e.type === 'error' && e._meta?.['code'] === 'AGENT_EXECUTION_BLOCKED',
       );
       expect(blocked?.fatal).toBe(false);
-      expect(blocked?.message).toBe('Blocked by hook');
+      expect(blocked?.message).toBe('Agent execution blocked: Blocked by hook');
 
       const messages = events.filter(
         (e): e is AgentEvent<'message'> =>

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

@@ -23,8 +23,8 @@ import {
   buildToolResponseData,
   contentPartsToGeminiParts,
   geminiPartsToContentParts,
+  toolResultDisplayToContentParts,
 } from './content-utils.js';
-import { populateToolDisplay } from './tool-display-utils.js';
 import { AgentSession } from './agent-session.js';
 import {
   createTranslationState,
@@ -166,6 +166,7 @@ export class LegacyAgentProtocol implements AgentProtocol {
       } else {
         this._emitErrorAndAgentEnd(err);
       }
+    } finally {
       this._clearActiveStream();
     }
   }
@@ -196,6 +197,7 @@ export class LegacyAgentProtocol implements AgentProtocol {
         this._abortController.signal,
         this._promptId,
         undefined,
+        false,
         currentDisplayContent,
       );
       currentDisplayContent = undefined;
@@ -261,13 +263,9 @@ export class LegacyAgentProtocol implements AgentProtocol {
         const content: ContentPart[] = response.error
           ? [{ type: 'text', text: response.error.message }]
           : geminiPartsToContentParts(response.responseParts);
-        const display = populateToolDisplay({
-          name: request.name,
-          invocation: 'invocation' in tc ? tc.invocation : undefined,
-          resultDisplay: response.resultDisplay,
-          displayName: 'tool' in tc ? tc.tool?.displayName : undefined,
-          display: response.display,
-        });
+        const displayContent = toolResultDisplayToContentParts(
+          response.resultDisplay,
+        );
         const data = buildToolResponseData(response);
 
         this._emit([
@@ -276,7 +274,7 @@ export class LegacyAgentProtocol implements AgentProtocol {
             name: request.name,
             content,
             isError: response.error !== undefined,
-            ...(display ? { display } : {}),
+            ...(displayContent ? { displayContent } : {}),
             ...(data ? { data } : {}),
           }),
         ]);
@@ -390,6 +388,7 @@ export class LegacyAgentProtocol implements AgentProtocol {
     const meta: Record<string, unknown> = {};
     if (err instanceof Error) {
       meta['errorName'] = err.constructor.name;
+      meta['stack'] = err.stack;
       if ('exitCode' in err && typeof err.exitCode === 'number') {
         meta['exitCode'] = err.exitCode;
       }