@qduc/term2 0.1.6 → 0.1.8

package/dist/services/conversation-session.js

@@ -7,6 +7,33 @@ import { extractReasoningDelta, extractTextDelta } from './stream-event-parsing.
 import { captureToolCallArguments, emitCommandMessagesFromItems } from './command-message-streaming.js';
 import { ApprovalState } from './approval-state.js';
 import { createInvalidToolCallDiagnostic } from './logging-contract.js';
+const asRecord = (value) => value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+const getString = (record, key) => {
+    const value = record?.[key];
+    return typeof value === 'string' ? value : undefined;
+};
+const getMethod = (target, key) => {
+    const record = asRecord(target);
+    const candidate = record?.[key];
+    return typeof candidate === 'function' ? candidate : null;
+};
+const getCallIdFromObject = (value) => {
+    const record = asRecord(value);
+    const callId = getString(record, 'callId') ??
+        getString(record, 'call_id') ??
+        getString(record, 'tool_call_id') ??
+        getString(record, 'toolCallId') ??
+        getString(record, 'id');
+    if (callId) {
+        return callId;
+    }
+    const rawItem = asRecord(record?.rawItem);
+    return (getString(rawItem, 'callId') ??
+        getString(rawItem, 'call_id') ??
+        getString(rawItem, 'tool_call_id') ??
+        getString(rawItem, 'toolCallId') ??
+        getString(rawItem, 'id'));
+};
 const getCommandFromArgs = (args) => {
     if (!args) {
         return '';
@@ -29,15 +56,16 @@ const getCommandFromArgs = (args) => {
         }
     }
     if (typeof args === 'object') {
+        const argsRecord = asRecord(args);
         // Handle shell tool's command parameter
-        const cmdFromObject = 'command' in args ? String(args.command) : undefined;
+        const cmdFromObject = argsRecord?.command !== undefined ? String(argsRecord.command) : undefined;
         // Fallback for old 'commands' array format
-        if ('commands' in args && Array.isArray(args.commands)) {
-            return args.commands.join('\n');
+        if (Array.isArray(argsRecord?.commands)) {
+            return argsRecord.commands.join('\n');
         }
         let argsFromObject;
-        if ('arguments' in args) {
-            const rawArguments = args.arguments;
+        if (argsRecord?.arguments !== undefined) {
+            const rawArguments = argsRecord.arguments;
             if (typeof rawArguments === 'string') {
                 try {
                     argsFromObject = JSON.stringify(JSON.parse(rawArguments));
@@ -59,14 +87,17 @@ const getCommandFromArgs = (args) => {
  */
 const MAX_HALLUCINATION_RETRIES = 2;
 /**
- * Check if an error is a tool hallucination error (model called a non-existent tool)
+ * Check if an error is a recoverable model behavior error (hallucination, parsing error, etc.)
  */
-const isToolHallucinationError = (error) => {
+const isRecoverableModelError = (error) => {
     if (!(error instanceof ModelBehaviorError)) {
         return false;
     }
     const message = error.message.toLowerCase();
-    return message.includes('tool') && message.includes('not found');
+    return ((message.includes('tool') && message.includes('not found')) || // Hallucination
+        message.includes('model did not produce a final response') || // Give up/exhausted
+        message.includes('parsing tool arguments') || // Bad JSON
+        message.includes('valid json'));
 };
 const supportsConversationChaining = (providerId) => {
     const providerDef = getProvider(providerId);
@@ -82,45 +113,7 @@ export class ConversationSession {
     textDeltaCount = 0;
     reasoningDeltaCount = 0;
     toolCallArgumentsById = new Map();
-    lastEventType = null;
-    eventTypeCount = 0;
     emittedInvalidToolCallPackets = new Set();
-    // private logStreamEvent = (eventType: string, eventData: any) => {
-    // 	if (eventData.item) {
-    // 		eventType = eventData.item.type;
-    // 		eventData = eventData.item.rawItem;
-    // 		// this.logStreamEvent(eventType, eventData);
-    // 	}
-    //
-    // 	// Deduplicate consecutive identical event types
-    //     if (eventType !== this.lastEventType) {
-    //         if (this.lastEventType !== null && this.eventTypeCount > 0) {
-    //             this.logger.debug('Stream event summary', {
-    //                 eventType: this.lastEventType,
-    //                 count: this.eventTypeCount,
-    //             });
-    //         }
-    //         this.lastEventType = eventType;
-    //         this.eventTypeCount = 1;
-    //         // Log the first occurrence with details
-    //         this.logger.debug('Stream event', {
-    //             eventType,
-    //             ...eventData,
-    //         });
-    //     } else {
-    //         this.eventTypeCount++;
-    //     }
-    // };
-    flushStreamEventLog = () => {
-        if (this.lastEventType !== null && this.eventTypeCount > 1) {
-            this.logger.debug('Stream event summary', {
-                eventType: this.lastEventType,
-                count: this.eventTypeCount,
-            });
-        }
-        this.lastEventType = null;
-        this.eventTypeCount = 0;
-    };
     constructor(id, { agentClient, deps }) {
         this.id = id;
         this.agentClient = agentClient;
@@ -133,27 +126,23 @@ export class ConversationSession {
         this.approvalState.clearPending();
         this.approvalState.consumeAborted();
         this.toolCallArgumentsById.clear();
-        if (typeof this.agentClient.clearConversations === 'function') {
-            this.agentClient.clearConversations();
-        }
+        const clearConversations = getMethod(this.agentClient, 'clearConversations');
+        clearConversations?.call(this.agentClient);
     }
     setModel(model) {
         this.agentClient.setModel(model);
     }
     setReasoningEffort(effort) {
-        if (typeof this.agentClient.setReasoningEffort === 'function') {
-            this.agentClient.setReasoningEffort(effort);
-        }
+        const setReasoningEffort = getMethod(this.agentClient, 'setReasoningEffort');
+        setReasoningEffort?.call(this.agentClient, effort);
     }
     setTemperature(temperature) {
-        if (typeof this.agentClient.setTemperature === 'function') {
-            this.agentClient.setTemperature(temperature);
-        }
+        const setTemperature = getMethod(this.agentClient, 'setTemperature');
+        setTemperature?.call(this.agentClient, temperature);
     }
     setProvider(provider) {
-        if (typeof this.agentClient.setProvider === 'function') {
-            this.agentClient.setProvider(provider);
-        }
+        const setProvider = getMethod(this.agentClient, 'setProvider');
+        setProvider?.call(this.agentClient, provider);
     }
     setRetryCallback(callback) {
         if (typeof this.agentClient.setRetryCallback === 'function') {
@@ -207,6 +196,7 @@ export class ConversationSession {
                     message: text,
                 });
                 const { state, interruption, emittedCommandIds, toolCallArgumentsById } = abortedContext;
+                const interruptionRecord = asRecord(interruption);
                 // Restore cached tool-call arguments captured before abort so continuation can attach them
                 this.toolCallArgumentsById.clear();
                 if (toolCallArgumentsById?.size) {
@@ -215,8 +205,8 @@ export class ConversationSession {
                     }
                 }
                 // Add interceptor for this tool execution
-                const toolName = interruption.name ?? 'unknown';
-                const expectedCallId = interruption.rawItem?.callId ?? interruption.callId;
+                const toolName = getString(interruptionRecord, 'name') ?? 'unknown';
+                const expectedCallId = getCallIdFromObject(interruption);
                 const rejectionMessage = `Tool execution was not approved. User provided new input instead: ${text}`;
                 const removeInterceptor = this.agentClient.addToolInterceptor(async (name, _params, toolCallId) => {
                     // Match both tool name and call ID for stricter matching
@@ -226,87 +216,35 @@ export class ConversationSession {
                     }
                     return null;
                 });
-                state.approve(interruption);
+                const approve = getMethod(state, 'approve');
+                approve?.call(state, interruption);
                 try {
-                    const stream = await this.agentClient.continueRunStream(state, {
+                    const continuedStream = (await this.agentClient.continueRunStream(state, {
                         previousResponseId: this.previousResponseId,
-                    });
+                    }));
                     const acc = {
                         finalOutput: '',
                         reasoningOutput: '',
                         emittedCommandIds: new Set(emittedCommandIds),
                         latestUsage: undefined,
                     };
-                    yield* this.#streamEvents(stream, acc, {
+                    yield* this.#streamEvents(continuedStream, acc, {
                         preserveExistingToolArgs: true,
                     });
-                    this.previousResponseId = stream.lastResponseId;
-                    this.conversationStore.updateFromResult(stream);
+                    this.previousResponseId = continuedStream.lastResponseId ?? null;
+                    this.conversationStore.updateFromResult(continuedStream);
                     // Check if another interruption occurred
-                    if (stream.interruptions && stream.interruptions.length > 0) {
+                    if (continuedStream.interruptions && continuedStream.interruptions.length > 0) {
                         this.logger.warn('Another interruption occurred after fake execution - handling as approval');
                         // Let the normal flow handle this
-                        const result = this.#buildResult(stream, acc.finalOutput, acc.reasoningOutput, acc.emittedCommandIds, acc.latestUsage);
-                        // Re-emit the terminal event explicitly.
-                        if (result.type === 'approval_required') {
-                            const interruption = result.approval.rawInterruption;
-                            const callId = interruption?.rawItem?.callId ??
-                                interruption?.callId ??
-                                interruption?.call_id ??
-                                interruption?.tool_call_id ??
-                                interruption?.toolCallId ??
-                                interruption?.id;
-                            yield {
-                                type: 'approval_required',
-                                approval: {
-                                    agentName: result.approval.agentName,
-                                    toolName: result.approval.toolName,
-                                    argumentsText: result.approval.argumentsText,
-                                    ...(callId ? { callId: String(callId) } : {}),
-                                },
-                            };
-                        }
-                        else {
-                            yield {
-                                type: 'final',
-                                finalText: result.finalText,
-                                ...(result.reasoningText ? { reasoningText: result.reasoningText } : {}),
-                                ...(result.commandMessages?.length ? { commandMessages: result.commandMessages } : {}),
-                                ...(result.usage ? { usage: result.usage } : {}),
-                            };
-                        }
+                        const result = this.#buildResult(continuedStream, acc.finalOutput, acc.reasoningOutput, acc.emittedCommandIds, acc.latestUsage);
+                        yield this.#toTerminalEvent(result);
                         return;
                     }
                     // Successfully resolved - agent should now have processed the fake rejection
                     this.logger.debug('Fake execution completed, agent received rejection message');
-                    const result = this.#buildResult(stream, acc.finalOutput, acc.reasoningOutput, acc.emittedCommandIds, acc.latestUsage);
-                    if (result.type === 'approval_required') {
-                        const interruption = result.approval.rawInterruption;
-                        const callId = interruption?.rawItem?.callId ??
-                            interruption?.callId ??
-                            interruption?.call_id ??
-                            interruption?.tool_call_id ??
-                            interruption?.toolCallId ??
-                            interruption?.id;
-                        yield {
-                            type: 'approval_required',
-                            approval: {
-                                agentName: result.approval.agentName,
-                                toolName: result.approval.toolName,
-                                argumentsText: result.approval.argumentsText,
-                                ...(callId ? { callId: String(callId) } : {}),
-                            },
-                        };
-                    }
-                    else {
-                        yield {
-                            type: 'final',
-                            finalText: result.finalText,
-                            ...(result.reasoningText ? { reasoningText: result.reasoningText } : {}),
-                            ...(result.commandMessages?.length ? { commandMessages: result.commandMessages } : {}),
-                            ...(result.usage ? { usage: result.usage } : {}),
-                        };
-                    }
+                    const result = this.#buildResult(continuedStream, acc.finalOutput, acc.reasoningOutput, acc.emittedCommandIds, acc.latestUsage);
+                    yield this.#toTerminalEvent(result);
                     return;
                 }
                 catch (error) {
@@ -321,13 +259,12 @@ export class ConversationSession {
                 }
             }
             // Normal message flow
-            const provider = typeof this.agentClient.getProvider === 'function'
-                ? this.agentClient.getProvider()
-                : 'openai';
+            const getProvider = getMethod(this.agentClient, 'getProvider');
+            const provider = getProvider ? getProvider.call(this.agentClient) : 'openai';
             const supportsChaining = supportsConversationChaining(provider);
-            stream = await this.agentClient.startStream(supportsChaining ? text : this.conversationStore.getHistory(), {
+            stream = (await this.agentClient.startStream(supportsChaining ? text : this.conversationStore.getHistory(), {
                 previousResponseId: this.previousResponseId,
-            });
+            }));
             const acc = {
                 finalOutput: '',
                 reasoningOutput: '',
@@ -337,7 +274,7 @@ export class ConversationSession {
             yield* this.#streamEvents(stream, acc, {
                 preserveExistingToolArgs: false,
             });
-            this.previousResponseId = stream.lastResponseId;
+            this.previousResponseId = stream.lastResponseId ?? null;
             this.conversationStore.updateFromResult(stream);
             // Build terminal event (approval_required or final)
             const result = this.#buildResult(stream, acc.finalOutput || undefined, acc.reasoningOutput || undefined, acc.emittedCommandIds, acc.latestUsage);
@@ -350,59 +287,47 @@ export class ConversationSession {
                     traceId: this.logger.getCorrelationId(),
                     toolName: result.approval.toolName,
                 });
-                const interruption = result.approval.rawInterruption;
-                const callId = interruption?.rawItem?.callId ??
-                    interruption?.callId ??
-                    interruption?.call_id ??
-                    interruption?.tool_call_id ??
-                    interruption?.toolCallId ??
-                    interruption?.id;
-                yield {
-                    type: 'approval_required',
-                    approval: {
-                        agentName: result.approval.agentName,
-                        toolName: result.approval.toolName,
-                        argumentsText: result.approval.argumentsText,
-                        ...(callId ? { callId: String(callId) } : {}),
-                    },
-                };
+                yield this.#toTerminalEvent(result);
                 return;
             }
-            yield {
-                type: 'final',
-                finalText: result.finalText,
-                ...(result.reasoningText ? { reasoningText: result.reasoningText } : {}),
-                ...(result.commandMessages?.length ? { commandMessages: result.commandMessages } : {}),
-                ...(result.usage ? { usage: result.usage } : {}),
-            };
+            yield this.#toTerminalEvent(result);
         }
         catch (error) {
-            // Handle tool hallucination: model called a non-existent tool
-            if (isToolHallucinationError(error) && hallucinationRetryCount < MAX_HALLUCINATION_RETRIES) {
-                const toolName = error instanceof Error ? error.message.match(/Tool (\S+) not found/)?.[1] || 'unknown' : 'unknown';
-                this.logger.warn('Tool hallucination detected, retrying', {
-                    eventType: 'retry.hallucination',
+            // Handle recoverable model errors (hallucination, parsing error, etc.)
+            if (isRecoverableModelError(error) && hallucinationRetryCount < MAX_HALLUCINATION_RETRIES) {
+                const message = error instanceof Error ? error.message : String(error);
+                const isHallucination = message.toLowerCase().includes('not found');
+                const isParsingError = message.toLowerCase().includes('parsing tool arguments') || message.toLowerCase().includes('valid json');
+                const toolName = isHallucination ? message.match(/Tool (\S+) not found/)?.[1] || 'unknown' : 'unknown';
+                this.logger.warn('Recoverable model error detected, retrying', {
+                    eventType: 'retry.model_error',
                     category: 'retry',
                     phase: 'retry',
                     toolName,
-                    retryType: 'hallucination',
+                    retryType: isHallucination ? 'hallucination' : isParsingError ? 'parsing_error' : 'behavior',
                     retryAttempt: hallucinationRetryCount + 1,
                     attempt: hallucinationRetryCount + 1,
                     maxRetries: MAX_HALLUCINATION_RETRIES,
                     sessionId: this.id,
                     traceId: this.logger.getCorrelationId(),
-                    errorMessage: error instanceof Error ? error.message : String(error),
+                    errorMessage: message,
                 });
                 yield {
                     type: 'retry',
-                    toolName,
+                    toolName: isHallucination ? toolName : 'model',
                     attempt: hallucinationRetryCount + 1,
                     maxRetries: MAX_HALLUCINATION_RETRIES,
-                    errorMessage: error instanceof Error ? error.message : String(error),
+                    errorMessage: message,
                 };
                 if (stream) {
-                    // Update conversation store with partial results (successful tool calls)
+                    // Update conversation store with partial results (including the parse error output if it was yielded)
                     this.conversationStore.updateFromResult(stream);
+                    // If stream produced no usable history, inject error context so the
+                    // model has explicit feedback about the failure on retry.
+                    const streamHistory = Array.isArray(stream.history) ? stream.history : [];
+                    if (streamHistory.length === 0) {
+                        this.conversationStore.addErrorContext(`[System: Previous attempt failed with error: ${message}. Please retry with corrected output.]`);
+                    }
                     // Retry from current state without re-adding user message
                     yield* this.run(text, {
                         hallucinationRetryCount: hallucinationRetryCount + 1,
@@ -445,6 +370,7 @@ export class ConversationSession {
             return;
         }
         const { state, interruption, emittedCommandIds: previouslyEmittedIds, toolCallArgumentsById, } = pendingApprovalContext;
+        const interruptionRecord = asRecord(interruption);
         let removeInterceptor = null;
         if (answer === 'y') {
             this.logger.info('Tool approval granted', {
@@ -454,11 +380,12 @@ export class ConversationSession {
                 sessionId: this.id,
                 traceId: this.logger.getCorrelationId(),
             });
-            state.approve(interruption);
+            const approve = getMethod(state, 'approve');
+            approve?.call(state, interruption);
         }
         else {
-            const toolName = interruption.name ?? 'unknown';
-            const expectedCallId = interruption.rawItem?.callId ?? interruption.callId;
+            const toolName = getString(interruptionRecord, 'name') ?? 'unknown';
+            const expectedCallId = getCallIdFromObject(interruption);
             const rejectionMessage = rejectionReason
                 ? `Tool execution was not approved. User's reason: ${rejectionReason}`
                 : 'Tool execution was not approved.';
@@ -471,13 +398,15 @@ export class ConversationSession {
                     return null;
                 });
                 // Approve to continue but interceptor will return rejection message
-                state.approve(interruption);
+                const approve = getMethod(state, 'approve');
+                approve?.call(state, interruption);
                 // Store interceptor cleanup for after stream
                 this.approvalState.setPendingRemoveInterceptor(removeInterceptor);
             }
             else {
                 // Fallback for clients without tool interceptors
-                state.reject(interruption);
+                const reject = getMethod(state, 'reject');
+                reject?.call(state, interruption);
             }
             this.logger.info('Tool approval rejected', {
                 eventType: 'approval.rejected',
@@ -496,9 +425,9 @@ export class ConversationSession {
             }
         }
         try {
-            const stream = await this.agentClient.continueRunStream(state, {
+            const stream = (await this.agentClient.continueRunStream(state, {
                 previousResponseId: this.previousResponseId,
-            });
+            }));
             const acc = {
                 finalOutput: '',
                 reasoningOutput: '',
@@ -508,7 +437,7 @@ export class ConversationSession {
             yield* this.#streamEvents(stream, acc, {
                 preserveExistingToolArgs: true,
             });
-            this.previousResponseId = stream.lastResponseId;
+            this.previousResponseId = stream.lastResponseId ?? null;
             this.conversationStore.updateFromResult(stream);
             // Merge previously emitted command IDs with newly emitted ones
             // This prevents duplicates when result.history contains commands from the initial stream
@@ -523,31 +452,10 @@ export class ConversationSession {
                     traceId: this.logger.getCorrelationId(),
                     toolName: result.approval.toolName,
                 });
-                const interruption = result.approval.rawInterruption;
-                const callId = interruption?.rawItem?.callId ??
-                    interruption?.callId ??
-                    interruption?.call_id ??
-                    interruption?.tool_call_id ??
-                    interruption?.toolCallId ??
-                    interruption?.id;
-                yield {
-                    type: 'approval_required',
-                    approval: {
-                        agentName: result.approval.agentName,
-                        toolName: result.approval.toolName,
-                        argumentsText: result.approval.argumentsText,
-                        ...(callId ? { callId: String(callId) } : {}),
-                    },
-                };
+                yield this.#toTerminalEvent(result);
                 return;
             }
-            yield {
-                type: 'final',
-                finalText: result.finalText,
-                ...(result.reasoningText ? { reasoningText: result.reasoningText } : {}),
-                ...(result.commandMessages?.length ? { commandMessages: result.commandMessages } : {}),
-                ...(result.usage ? { usage: result.usage } : {}),
-            };
+            yield this.#toTerminalEvent(result);
         }
         catch (error) {
             yield {
@@ -595,6 +503,7 @@ export class ConversationSession {
                             toolName: event.approval.toolName,
                             argumentsText: event.approval.argumentsText,
                             rawInterruption,
+                            callId: event.approval.callId,
                         },
                     };
                 }
@@ -677,6 +586,7 @@ export class ConversationSession {
                             toolName: event.approval.toolName,
                             argumentsText: event.approval.argumentsText,
                             rawInterruption,
+                            callId: event.approval.callId,
                         },
                     };
                 }
@@ -764,27 +674,37 @@ export class ConversationSession {
                 fullText: acc.reasoningOutput,
             };
         };
-        for await (const event of stream) {
-            // Extract usage if present in any of the common locations
-            const usage = extractUsage(event);
+        for await (const rawEvent of stream) {
+            const event = asRecord(rawEvent);
+            const eventData = asRecord(event?.data);
+            const eventType = getString(event, 'type');
+            // Extract usage if present in any of the common locations.
+            // Check both the top-level event and event.data, since raw_model_stream_event
+            // nests response data (including usage) under .data (e.g. data.response.usage).
+            const usage = extractUsage(rawEvent) ?? (eventData ? extractUsage(eventData) : undefined);
             if (usage) {
                 acc.latestUsage = usage;
                 this.logger.debug('Usage extracted from stream event', {
                     sessionId: this.id,
                     source: 'stream_event',
-                    eventType: event?.type ?? event?.data?.type ?? 'unknown',
+                    eventType: eventType ?? getString(eventData, 'type') ?? 'unknown',
                     usage,
                 });
+                // Emit usage update event for real-time token tracking
+                yield {
+                    type: 'usage_update',
+                    usage,
+                };
             }
             // Log event type with deduplication for ordering understanding
-            const delta1 = extractTextDelta(event);
+            const delta1 = extractTextDelta(rawEvent);
             if (delta1) {
                 const e = emitText(delta1);
                 if (e)
                     yield e;
             }
-            if (event?.data) {
-                const delta2 = extractTextDelta(event.data);
+            if (eventData) {
+                const delta2 = extractTextDelta(eventData);
                 if (delta2) {
                     const e = emitText(delta2);
                     if (e)
@@ -792,7 +712,7 @@ export class ConversationSession {
                 }
             }
             // Handle reasoning items
-            const reasoningDelta = extractReasoningDelta(event);
+            const reasoningDelta = extractReasoningDelta(rawEvent);
             if (reasoningDelta) {
                 const e = emitReasoning(reasoningDelta);
                 if (e)
@@ -802,15 +722,21 @@ export class ConversationSession {
                 toolCallArgumentsById,
                 emittedCommandIds: acc.emittedCommandIds,
             });
-            if (event?.type === 'run_item_stream_event') {
-                captureToolCallArguments(event.item, toolCallArgumentsById);
+            if (eventType === 'run_item_stream_event') {
+                const eventItem = event?.item;
+                const eventItemRecord = asRecord(eventItem);
+                captureToolCallArguments(eventItem, toolCallArgumentsById);
                 // Emit tool_started event when a function_call is detected
-                const rawItem = event.item?.rawItem ?? event.item;
-                if (rawItem?.type === 'function_call') {
-                    const callId = rawItem.callId ?? rawItem.call_id ?? rawItem.tool_call_id ?? rawItem.toolCallId ?? rawItem.id;
+                const rawItem = asRecord(eventItemRecord?.rawItem) ?? eventItemRecord;
+                if (getString(rawItem, 'type') === 'function_call') {
+                    const callId = getString(rawItem, 'callId') ??
+                        getString(rawItem, 'call_id') ??
+                        getString(rawItem, 'tool_call_id') ??
+                        getString(rawItem, 'toolCallId') ??
+                        getString(rawItem, 'id');
                     if (callId) {
-                        const toolName = rawItem.name ?? event.item?.name;
-                        const args = rawItem.arguments ?? rawItem.args ?? event.item?.arguments ?? event.item?.args;
+                        const toolName = getString(rawItem, 'name') ?? getString(eventItemRecord, 'name');
+                        const args = rawItem?.arguments ?? rawItem?.args ?? eventItemRecord?.arguments ?? eventItemRecord?.args;
                         // Providers sometimes surface arguments as a JSON string.
                         // Normalize here so downstream UI (pending/running display)
                         // can reliably render parameters.
@@ -871,13 +797,14 @@ export class ConversationSession {
                         });
                     }
                 }
-                for (const e of maybeEmitCommandMessagesFromItems([event.item])) {
+                for (const e of maybeEmitCommandMessagesFromItems([eventItem])) {
                     yield e;
                 }
             }
-            else if (event?.type === 'tool_call_output_item' || event?.rawItem?.type === 'function_call_output') {
-                captureToolCallArguments(event, toolCallArgumentsById);
-                for (const e of maybeEmitCommandMessagesFromItems([event])) {
+            else if (eventType === 'tool_call_output_item' ||
+                getString(asRecord(event?.rawItem), 'type') === 'function_call_output') {
+                captureToolCallArguments(rawEvent, toolCallArgumentsById);
+                for (const e of maybeEmitCommandMessagesFromItems([rawEvent])) {
                     yield e;
                 }
             }
@@ -924,11 +851,30 @@ export class ConversationSession {
                     usage: Boolean(completedResultRecord?.usage),
                     usageMetadata: Boolean(completedResultRecord?.usageMetadata),
                     usage_metadata: Boolean(completedResultRecord?.usage_metadata),
-                    responseUsage: Boolean(completedResultRecord?.response?.usage),
+                    responseUsage: Boolean(asRecord(completedResultRecord?.response)?.usage),
                 },
             });
         }
-        this.flushStreamEventLog();
+    }
+    #toTerminalEvent(result) {
+        if (result.type === 'approval_required') {
+            return {
+                type: 'approval_required',
+                approval: {
+                    agentName: result.approval.agentName,
+                    toolName: result.approval.toolName,
+                    argumentsText: result.approval.argumentsText,
+                    ...(result.approval.callId ? { callId: result.approval.callId } : {}),
+                },
+            };
+        }
+        return {
+            type: 'final',
+            finalText: result.finalText,
+            ...(result.reasoningText ? { reasoningText: result.reasoningText } : {}),
+            ...(result.commandMessages?.length ? { commandMessages: result.commandMessages } : {}),
+            ...(result.usage ? { usage: result.usage } : {}),
+        };
     }
     #buildResult(result, finalOutputOverride, reasoningOutputOverride, emittedCommandIds, usage) {
         if (result.interruptions && result.interruptions.length > 0) {
@@ -940,29 +886,26 @@ export class ConversationSession {
                 toolCallArgumentsById: new Map(this.toolCallArgumentsById),
             });
             let argumentsText = '';
-            const toolName = interruption.name;
+            const interruptionRecord = asRecord(interruption);
+            const toolName = getString(interruptionRecord, 'name');
             // For shell_call (built-in shell tool), extract commands from action
             // For function tools (bash, shell), extract from arguments
-            if (interruption.type === 'shell_call') {
-                if (interruption.action?.commands) {
-                    argumentsText = Array.isArray(interruption.action.commands)
-                        ? interruption.action.commands.join('\n')
-                        : String(interruption.action.commands);
+            if (getString(interruptionRecord, 'type') === 'shell_call') {
+                const action = asRecord(interruptionRecord?.action);
+                const actionCommands = action?.commands;
+                if (actionCommands) {
+                    argumentsText = Array.isArray(actionCommands) ? actionCommands.join('\n') : String(actionCommands);
                 }
             }
             else {
-                argumentsText = getCommandFromArgs(interruption.arguments);
+                argumentsText = getCommandFromArgs(interruptionRecord?.arguments);
             }
-            const callId = interruption?.rawItem?.callId ??
-                interruption?.callId ??
-                interruption?.call_id ??
-                interruption?.tool_call_id ??
-                interruption?.toolCallId ??
-                interruption?.id;
+            const agent = asRecord(interruptionRecord?.agent);
+            const callId = getCallIdFromObject(interruption);
             return {
                 type: 'approval_required',
                 approval: {
-                    agentName: interruption.agent?.name ?? 'Agent',
+                    agentName: getString(agent, 'name') ?? 'Agent',
                     toolName: toolName ?? 'Unknown Tool',
                     argumentsText,
                     rawInterruption: interruption,