@amodalai/runtime 0.1.26 → 0.2.0

package/dist/src/session/session-runner.js

@@ -1,719 +0,0 @@
-/**
- * @license
- * Copyright 2025 Amodal Labs, Inc.
- * SPDX-License-Identifier: MIT
- */
-import { GeminiEventType, ToolErrorType, PRESENT_TOOL_NAME, ACTIVATE_SKILL_TOOL_NAME, ASK_USER_TOOL_NAME, } from '@amodalai/core';
-/**
- * Custom message bus event key for subagent activity.
- * Upstream MessageBusType doesn't include this — our dispatch tool emits on
- * this string key, which works because MessageBus extends EventEmitter.
- */
-// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- custom event key for our dispatch tool
-const SUBAGENT_ACTIVITY_EVENT = 'subagent-activity';
-import { SSEEventType, } from '../types.js';
-const MAX_TURNS = 50;
-/**
- * Extract text from tool response parts, truncated for audit logging.
- * Handles both plain text parts and functionResponse parts (from task agents).
- */
-function extractResultText(parts) {
-    if (!parts || parts.length === 0)
-        return undefined;
-    const segments = [];
-    for (const p of parts) {
-        if (p.text) {
-            segments.push(p.text);
-        }
-        else if (p.functionResponse?.response) {
-            try {
-                segments.push(JSON.stringify(p.functionResponse.response));
-            }
-            catch {
-                segments.push('[unserializable response]');
-            }
-        }
-    }
-    const text = segments.join('');
-    if (!text)
-        return undefined;
-    return text;
-}
-const MAX_SUBAGENT_RESULT_LENGTH = 300;
-/**
- * Map SubagentActivityEvent type strings to SSE event_type values.
- */
-function mapSubagentEventType(type) {
-    switch (type) {
-        case 'TOOL_CALL_START': return 'tool_call_start';
-        case 'TOOL_CALL_END': return 'tool_call_end';
-        case 'THOUGHT_CHUNK': return 'thought';
-        case 'COMPLETE': return 'complete';
-        case 'ERROR': return 'error';
-        default: return 'error';
-    }
-}
-/**
- * Truncate a string to the given max length, appending '...' if truncated.
- */
-function truncateSubagentResult(text, maxLen) {
-    if (!text)
-        return undefined;
-    return text.length > maxLen ? text.slice(0, maxLen) + '...' : text;
-}
-/**
- * Convert a real-time SubagentActivityMessage to an SSESubagentEvent.
- */
-function subagentMessageToSSE(msg, parentToolId) {
-    return {
-        type: SSEEventType.SubagentEvent,
-        parent_tool_id: parentToolId,
-        agent_name: msg.agentName,
-        event_type: mapSubagentEventType(msg.eventType),
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- name from subagent activity data
-        tool_name: msg.data['name'],
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- args from subagent activity data
-        tool_args: msg.data['args'],
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- output from subagent activity data
-        result: truncateSubagentResult(msg.data['output'], MAX_SUBAGENT_RESULT_LENGTH),
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- text from subagent COMPLETE event
-        text: msg.data['text'],
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- error from subagent activity data
-        error: msg.data['error'],
-        timestamp: new Date().toISOString(),
-    };
-}
-/**
- * Run a synchronous (non-streaming) message through the agentic loop.
- * Collects all text and tool calls, returns a ChatResponse.
- */
-export async function runMessage(session, message, signal, hooks) {
-    const { geminiClient, scheduler, config } = session;
-    const promptId = `msg-${Date.now()}`;
-    const sessionStartMs = Date.now();
-    let currentMessages = [
-        { role: 'user', parts: [{ text: message }] },
-    ];
-    let responseText = '';
-    const toolCalls = [];
-    const skillsActivated = [];
-    let turnCount = 0;
-    let status = 'completed';
-    let errorMessage;
-    const tokens = { inputTokens: 0, outputTokens: 0, cachedTokens: 0 };
-    try {
-        while (true) {
-            turnCount++;
-            if (turnCount > MAX_TURNS) {
-                status = 'max_turns';
-                break;
-            }
-            if (signal.aborted)
-                break;
-            const toolCallRequests = [];
-            const responseStream = geminiClient.sendMessageStream(currentMessages[0]?.parts ?? [], signal, promptId, undefined, false, turnCount === 1 ? message : undefined);
-            for await (const event of responseStream) {
-                if (signal.aborted)
-                    break;
-                if (event.type === GeminiEventType.Content) {
-                    responseText += event.value;
-                }
-                else if (event.type === GeminiEventType.ToolCallRequest) {
-                    toolCallRequests.push(event.value);
-                }
-                else if (event.type === GeminiEventType.Finished) {
-                    const meta = event.value.usageMetadata;
-                    if (meta) {
-                        tokens.inputTokens += meta.promptTokenCount ?? 0;
-                        tokens.outputTokens += meta.candidatesTokenCount ?? 0;
-                        tokens.cachedTokens += meta.cachedContentTokenCount ?? 0;
-                    }
-                }
-                else if (event.type === GeminiEventType.Error) {
-                    status = 'error';
-                    const errObj = event.value.error;
-                    const errMsg = errObj instanceof Error ? errObj.message : (typeof errObj === 'object' && errObj !== null && 'message' in errObj) ? String(errObj['message']) : String(errObj);
-                    errorMessage = errMsg;
-                    throw new Error(errMsg);
-                }
-                else if (event.type === GeminiEventType.AgentExecutionStopped) {
-                    return { session_id: session.id, response: responseText, tool_calls: toolCalls };
-                }
-            }
-            if (toolCallRequests.length > 0) {
-                const completedToolCalls = await scheduler.schedule(toolCallRequests, signal);
-                const toolResponseParts = [];
-                for (const completed of completedToolCalls) {
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- accessing optional field on CompletedToolCall union
-                    const duration = 'durationMs' in completed ? completed['durationMs'] : undefined;
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- inner_tool_calls from subagent data
-                    const innerCalls = completed.response.data?.['inner_tool_calls'];
-                    toolCalls.push({
-                        tool_name: completed.request.name,
-                        tool_id: completed.request.callId,
-                        args: completed.request.args,
-                        status: completed.response.error ? 'error' : 'success',
-                        duration_ms: duration,
-                        error: completed.response.error?.message,
-                        result: extractResultText(completed.response.responseParts),
-                        inner_tool_calls: innerCalls,
-                    });
-                    // Track skill activations
-                    if (completed.request.name === ACTIVATE_SKILL_TOOL_NAME &&
-                        !completed.response.error) {
-                        const skillName = String(completed.request.args['name'] ?? '');
-                        if (skillName) {
-                            skillsActivated.push(skillName);
-                        }
-                    }
-                    if (completed.response.responseParts) {
-                        toolResponseParts.push(...completed.response.responseParts);
-                    }
-                    // Record tool calls
-                    try {
-                        const currentModel = geminiClient.getCurrentSequenceModel() ?? config.getModel();
-                        geminiClient
-                            .getChat()
-                            .recordCompletedToolCalls(currentModel, completedToolCalls);
-                    }
-                    catch {
-                        // Non-critical — continue
-                    }
-                }
-                // Check for stop execution
-                const stopTool = completedToolCalls.find((tc) => tc.response.errorType === ToolErrorType.STOP_EXECUTION);
-                if (stopTool) {
-                    return { session_id: session.id, response: responseText, tool_calls: toolCalls };
-                }
-                currentMessages = [{ role: 'user', parts: toolResponseParts }];
-            }
-            else {
-                break;
-            }
-        }
-        return { session_id: session.id, response: responseText, tool_calls: toolCalls };
-    }
-    catch (err) {
-        status = 'error';
-        errorMessage = err instanceof Error ? err.message : String(err);
-        throw err;
-    }
-    finally {
-        if (hooks) {
-            const model = geminiClient.getCurrentSequenceModel() ?? config.getModel();
-            logSessionCompleted(hooks, session.id, message, responseText, turnCount, toolCalls, skillsActivated, status, errorMessage, sessionStartMs, model, tokens);
-        }
-    }
-}
-/**
- * Stream a message through the agentic loop, yielding SSE events.
- */
-export async function* streamMessage(session, message, signal, hooks, sessionManager) {
-    const { geminiClient, scheduler, config } = session;
-    const promptId = `msg-${Date.now()}`;
-    const sessionStartMs = Date.now();
-    let currentMessages = [
-        { role: 'user', parts: [{ text: message }] },
-    ];
-    // Accumulators for the consolidated audit event
-    const auditToolCalls = [];
-    const skillsActivated = [];
-    const widgetEvents = [];
-    let responseText = '';
-    let auditStatus = 'completed';
-    const tokens = { inputTokens: 0, outputTokens: 0, cachedTokens: 0 };
-    // Track content block ordering so history can reconstruct the correct interleave
-    const contentBlockOrder = [];
-    function trackText(text) {
-        const last = contentBlockOrder[contentBlockOrder.length - 1];
-        if (last && last['type'] === 'text') {
-            last['text'] = String(last['text'] ?? '') + text;
-        }
-        else {
-            contentBlockOrder.push({ type: 'text', text });
-        }
-    }
-    function trackToolCall(callId) {
-        const last = contentBlockOrder[contentBlockOrder.length - 1];
-        if (last && last['type'] === 'tool_calls') {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- extending callIds array
-            last['callIds'].push(callId);
-        }
-        else {
-            contentBlockOrder.push({ type: 'tool_calls', callIds: [callId] });
-        }
-    }
-    let auditError;
-    // Accumulate user message for session history
-    const userMsg = {
-        type: 'user',
-        id: `msg-${Date.now()}`,
-        text: message,
-        timestamp: new Date().toISOString(),
-    };
-    session.accumulatedMessages.push(userMsg);
-    yield {
-        type: SSEEventType.Init,
-        session_id: session.id,
-        timestamp: new Date().toISOString(),
-    };
-    let turnCount = 0;
-    while (true) {
-        turnCount++;
-        if (turnCount > MAX_TURNS) {
-            auditStatus = 'max_turns';
-            auditError = 'Maximum turns exceeded';
-            yield {
-                type: SSEEventType.Error,
-                message: 'Maximum turns exceeded',
-                timestamp: new Date().toISOString(),
-            };
-            break;
-        }
-        if (signal.aborted)
-            break;
-        const toolCallRequests = [];
-        const responseStream = geminiClient.sendMessageStream(currentMessages[0]?.parts ?? [], signal, promptId, undefined, false, turnCount === 1 ? message : undefined);
-        for await (const event of responseStream) {
-            if (signal.aborted)
-                break;
-            if (event.type === GeminiEventType.Content) {
-                responseText += event.value;
-                trackText(event.value);
-                yield {
-                    type: SSEEventType.TextDelta,
-                    content: event.value,
-                    timestamp: new Date().toISOString(),
-                };
-            }
-            else if (event.type === GeminiEventType.ToolCallRequest) {
-                // Suppress tool_call_start for present (widget events replace it) and ask_user (intercepted below)
-                if (event.value.name !== PRESENT_TOOL_NAME && event.value.name !== ASK_USER_TOOL_NAME) {
-                    yield {
-                        type: SSEEventType.ToolCallStart,
-                        tool_name: event.value.name,
-                        tool_id: event.value.callId,
-                        parameters: event.value.args,
-                        timestamp: new Date().toISOString(),
-                    };
-                }
-                toolCallRequests.push(event.value);
-            }
-            else if (event.type === GeminiEventType.Finished) {
-                const meta = event.value.usageMetadata;
-                if (meta) {
-                    tokens.inputTokens += meta.promptTokenCount ?? 0;
-                    tokens.outputTokens += meta.candidatesTokenCount ?? 0;
-                    tokens.cachedTokens += meta.cachedContentTokenCount ?? 0;
-                }
-            }
-            else if (event.type === GeminiEventType.Error) {
-                auditStatus = 'error';
-                const errObj = event.value.error;
-                const errMsg = errObj instanceof Error ? errObj.message : (typeof errObj === 'object' && errObj !== null && 'message' in errObj) ? String(errObj['message']) : String(errObj);
-                auditError = errMsg;
-                yield {
-                    type: SSEEventType.Error,
-                    message: errMsg,
-                    timestamp: new Date().toISOString(),
-                };
-                logSessionCompleted(hooks, session.id, message, responseText, turnCount, auditToolCalls, skillsActivated, auditStatus, auditError, sessionStartMs, geminiClient.getCurrentSequenceModel() ?? config.getModel(), tokens);
-                accumulateAssistantAndSave(session, hooks, responseText, auditToolCalls, skillsActivated, widgetEvents, contentBlockOrder, 'error');
-                yield {
-                    type: SSEEventType.Done,
-                    timestamp: new Date().toISOString(),
-                    usage: {
-                        input_tokens: tokens.inputTokens,
-                        output_tokens: tokens.outputTokens,
-                        cached_tokens: tokens.cachedTokens,
-                        total_tokens: tokens.inputTokens + tokens.outputTokens,
-                    },
-                };
-                return;
-            }
-            else if (event.type === GeminiEventType.AgentExecutionStopped) {
-                logSessionCompleted(hooks, session.id, message, responseText, turnCount, auditToolCalls, skillsActivated, auditStatus, auditError, sessionStartMs, geminiClient.getCurrentSequenceModel() ?? config.getModel(), tokens);
-                accumulateAssistantAndSave(session, hooks, responseText, auditToolCalls, skillsActivated, widgetEvents, contentBlockOrder, 'completed');
-                yield {
-                    type: SSEEventType.Done,
-                    timestamp: new Date().toISOString(),
-                    usage: {
-                        input_tokens: tokens.inputTokens,
-                        output_tokens: tokens.outputTokens,
-                        cached_tokens: tokens.cachedTokens,
-                        total_tokens: tokens.inputTokens + tokens.outputTokens,
-                    },
-                };
-                return;
-            }
-        }
-        if (toolCallRequests.length > 0) {
-            // Partition: separate ask_user requests from regular tool calls
-            const askUserRequests = toolCallRequests.filter((req) => req.name === ASK_USER_TOOL_NAME);
-            const otherRequests = toolCallRequests.filter((req) => req.name !== ASK_USER_TOOL_NAME);
-            const toolResponseParts = [];
-            // Handle ask_user requests: yield SSE event, wait for user response
-            if (askUserRequests.length > 0 && sessionManager) {
-                for (const askReq of askUserRequests) {
-                    const askId = askReq.callId;
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- LLM-provided questions array
-                    const questions = askReq.args['questions'] ?? [];
-                    const askStartMs = Date.now();
-                    // Emit tool_call_start for the ask_user tool
-                    yield {
-                        type: SSEEventType.ToolCallStart,
-                        tool_name: askReq.name,
-                        tool_id: askId,
-                        parameters: askReq.args,
-                        timestamp: new Date().toISOString(),
-                    };
-                    // Track ask_user in content block ordering
-                    contentBlockOrder.push({ type: 'ask_user', askId });
-                    // Emit ask_user SSE event
-                    yield {
-                        type: SSEEventType.AskUser,
-                        ask_id: askId,
-                        questions,
-                        timestamp: new Date().toISOString(),
-                    };
-                    try {
-                        const answers = await sessionManager.waitForAskUserResponse(session, askId, signal);
-                        const askDuration = Date.now() - askStartMs;
-                        const resultOutput = JSON.stringify({ answers });
-                        // Audit
-                        auditToolCalls.push({
-                            tool_name: askReq.name,
-                            tool_id: askId,
-                            args: askReq.args,
-                            status: 'success',
-                            duration_ms: askDuration,
-                        });
-                        // Emit tool_call_result
-                        yield {
-                            type: SSEEventType.ToolCallResult,
-                            tool_id: askId,
-                            status: 'success',
-                            result: resultOutput,
-                            duration_ms: askDuration,
-                            timestamp: new Date().toISOString(),
-                        };
-                        // Build function response part
-                        toolResponseParts.push({
-                            functionResponse: {
-                                id: askId,
-                                name: ASK_USER_TOOL_NAME,
-                                response: { output: resultOutput },
-                            },
-                        });
-                    }
-                    catch (err) {
-                        const askDuration = Date.now() - askStartMs;
-                        const errorMsg = err instanceof Error ? err.message : 'ask_user failed';
-                        auditToolCalls.push({
-                            tool_name: askReq.name,
-                            tool_id: askId,
-                            args: askReq.args,
-                            status: 'error',
-                            duration_ms: askDuration,
-                            error: errorMsg,
-                        });
-                        yield {
-                            type: SSEEventType.ToolCallResult,
-                            tool_id: askId,
-                            status: 'error',
-                            error: errorMsg,
-                            duration_ms: askDuration,
-                            timestamp: new Date().toISOString(),
-                        };
-                        toolResponseParts.push({
-                            functionResponse: {
-                                id: askId,
-                                name: ASK_USER_TOOL_NAME,
-                                response: { output: JSON.stringify({ error: errorMsg }) },
-                            },
-                        });
-                    }
-                }
-            }
-            else if (askUserRequests.length > 0) {
-                // No sessionManager — return fallback response
-                for (const askReq of askUserRequests) {
-                    auditToolCalls.push({
-                        tool_name: askReq.name,
-                        tool_id: askReq.callId,
-                        args: askReq.args,
-                        status: 'error',
-                        error: 'ask_user not supported in this session mode',
-                    });
-                    toolResponseParts.push({
-                        functionResponse: {
-                            id: askReq.callId,
-                            name: ASK_USER_TOOL_NAME,
-                            response: { output: JSON.stringify({ error: 'ask_user not supported in this session mode' }) },
-                        },
-                    });
-                }
-            }
-            // Handle other tool calls through the scheduler normally
-            if (otherRequests.length > 0) {
-                // --- Real-time subagent event streaming ---
-                // Subscribe to SUBAGENT_ACTIVITY on the message bus so we can yield
-                // subagent events as they happen (instead of waiting for dispatch to finish).
-                const messageBus = config.getMessageBus();
-                const subagentEventQueue = [];
-                let notifyNewEvent = null;
-                // Track dispatch tool call IDs for correlation
-                const unmatchedDispatchCallIds = new Set();
-                const dispatchIdToCallId = new Map();
-                for (const req of otherRequests) {
-                    if (req.name === 'dispatch') {
-                        unmatchedDispatchCallIds.add(req.callId);
-                    }
-                }
-                const hasDispatchCalls = unmatchedDispatchCallIds.size > 0;
-                const subagentListener = (msg) => {
-                    // Map dispatchId to the parent tool callId
-                    let parentToolId = dispatchIdToCallId.get(msg.dispatchId);
-                    if (!parentToolId && unmatchedDispatchCallIds.size > 0) {
-                        // Assign to the first unmatched dispatch call
-                        const firstUnmatched = unmatchedDispatchCallIds.values().next().value;
-                        if (firstUnmatched) {
-                            unmatchedDispatchCallIds.delete(firstUnmatched);
-                            dispatchIdToCallId.set(msg.dispatchId, firstUnmatched);
-                            parentToolId = firstUnmatched;
-                        }
-                    }
-                    if (!parentToolId)
-                        return;
-                    subagentEventQueue.push(subagentMessageToSSE(msg, parentToolId));
-                    // Wake up the yield loop
-                    notifyNewEvent?.();
-                    notifyNewEvent = null;
-                };
-                if (hasDispatchCalls) {
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion, @typescript-eslint/no-explicit-any -- custom event not in upstream Message union; EventEmitter accepts any string
-                    messageBus.subscribe(SUBAGENT_ACTIVITY_EVENT, subagentListener);
-                }
-                // Start the scheduler (don't await yet — we'll yield events concurrently)
-                let completedToolCalls;
-                const schedulerPromise = scheduler.schedule(otherRequests, signal).then((result) => {
-                    completedToolCalls = result;
-                    // Wake up the yield loop so it can exit
-                    notifyNewEvent?.();
-                    notifyNewEvent = null;
-                });
-                // Yield subagent events in real-time while the scheduler is running
-                if (hasDispatchCalls) {
-                    while (completedToolCalls === undefined || subagentEventQueue.length > 0) {
-                        // Drain any pending events
-                        while (subagentEventQueue.length > 0) {
-                            yield subagentEventQueue.shift();
-                        }
-                        // If scheduler isn't done, wait for a new event or completion
-                        if (completedToolCalls === undefined) {
-                            await new Promise((resolve) => {
-                                notifyNewEvent = resolve;
-                                // Also resolve if the scheduler finishes while we're waiting
-                                schedulerPromise.then(() => {
-                                    resolve();
-                                    return;
-                                }, () => {
-                                    resolve();
-                                    return;
-                                });
-                            });
-                        }
-                    }
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion, @typescript-eslint/no-explicit-any -- custom event not in upstream Message union; EventEmitter accepts any string
-                    messageBus.unsubscribe(SUBAGENT_ACTIVITY_EVENT, subagentListener);
-                }
-                // Ensure scheduler has completed (no-op if already resolved)
-                await schedulerPromise;
-                // Process completed tool calls
-                for (const completed of completedToolCalls) {
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- accessing optional field on CompletedToolCall union
-                    const duration = 'durationMs' in completed ? completed['durationMs'] : undefined;
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- inner_tool_calls from subagent data
-                    const innerCalls = completed.response.data?.['inner_tool_calls'];
-                    // Accumulate tool call summary for audit
-                    auditToolCalls.push({
-                        tool_name: completed.request.name,
-                        tool_id: completed.request.callId,
-                        args: completed.request.args,
-                        status: completed.response.error ? 'error' : 'success',
-                        duration_ms: duration,
-                        error: completed.response.error?.message,
-                        result: extractResultText(completed.response.responseParts),
-                        inner_tool_calls: innerCalls,
-                    });
-                    // Most subagent events were streamed in real-time above.
-                    // The COMPLETE event (agent's final summary) may be missed due to race
-                    // conditions, so emit it from the batch data as a fallback.
-                    if (completed.request.name === 'dispatch' && completed.response.data) {
-                        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- subagent_events from dispatch tool data
-                        const batchEvents = completed.response.data['subagent_events'];
-                        if (batchEvents) {
-                            for (const evt of batchEvents) {
-                                if (evt.type === 'COMPLETE' && typeof evt.data['text'] === 'string') {
-                                    yield {
-                                        type: SSEEventType.SubagentEvent,
-                                        parent_tool_id: completed.request.callId,
-                                        agent_name: evt.agentName,
-                                        event_type: 'complete',
-                                        text: evt.data['text'],
-                                        timestamp: new Date().toISOString(),
-                                    };
-                                }
-                            }
-                        }
-                    }
-                    if (completed.request.name === PRESENT_TOOL_NAME && !completed.response.error) {
-                        // Emit a widget event instead of tool_call_result for the present tool
-                        const args = completed.request.args;
-                        const widgetType = String(args['widget'] ?? 'unknown');
-                        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- LLM-provided data object
-                        const widgetData = args['data'] ?? {};
-                        widgetEvents.push({ widgetType, data: widgetData });
-                        contentBlockOrder.push({ type: 'widget', widgetType, data: widgetData });
-                        yield {
-                            type: SSEEventType.Widget,
-                            widget_type: widgetType,
-                            data: widgetData,
-                            timestamp: new Date().toISOString(),
-                        };
-                    }
-                    else {
-                        trackToolCall(completed.request.callId);
-                        yield {
-                            type: SSEEventType.ToolCallResult,
-                            tool_id: completed.request.callId,
-                            status: completed.response.error ? 'error' : 'success',
-                            result: extractResultText(completed.response.responseParts),
-                            duration_ms: duration,
-                            error: completed.response.error?.message,
-                            timestamp: new Date().toISOString(),
-                        };
-                    }
-                    // Track skill activations
-                    if (completed.request.name === ACTIVATE_SKILL_TOOL_NAME &&
-                        !completed.response.error) {
-                        const skillName = String(completed.request.args['name'] ?? '');
-                        if (skillName) {
-                            skillsActivated.push(skillName);
-                            yield {
-                                type: SSEEventType.SkillActivated,
-                                skill_name: skillName,
-                                timestamp: new Date().toISOString(),
-                            };
-                        }
-                    }
-                    if (completed.response.responseParts) {
-                        toolResponseParts.push(...completed.response.responseParts);
-                    }
-                }
-                // Record tool calls
-                try {
-                    const currentModel = geminiClient.getCurrentSequenceModel() ?? config.getModel();
-                    geminiClient
-                        .getChat()
-                        .recordCompletedToolCalls(currentModel, completedToolCalls);
-                }
-                catch {
-                    // Non-critical
-                }
-                const stopTool = completedToolCalls.find((tc) => tc.response.errorType === ToolErrorType.STOP_EXECUTION);
-                if (stopTool) {
-                    logSessionCompleted(hooks, session.id, message, responseText, turnCount, auditToolCalls, skillsActivated, auditStatus, auditError, sessionStartMs, geminiClient.getCurrentSequenceModel() ?? config.getModel(), tokens);
-                    accumulateAssistantAndSave(session, hooks, responseText, auditToolCalls, skillsActivated, widgetEvents, contentBlockOrder, 'completed');
-                    yield {
-                        type: SSEEventType.Done,
-                        timestamp: new Date().toISOString(),
-                        usage: {
-                            input_tokens: tokens.inputTokens,
-                            output_tokens: tokens.outputTokens,
-                            cached_tokens: tokens.cachedTokens,
-                            total_tokens: tokens.inputTokens + tokens.outputTokens,
-                        },
-                    };
-                    return;
-                }
-            }
-            currentMessages = [{ role: 'user', parts: toolResponseParts }];
-        }
-        else {
-            break;
-        }
-    }
-    logSessionCompleted(hooks, session.id, message, responseText, turnCount, auditToolCalls, skillsActivated, auditStatus, auditError, sessionStartMs, geminiClient.getCurrentSequenceModel() ?? config.getModel(), tokens);
-    accumulateAssistantAndSave(session, hooks, responseText, auditToolCalls, skillsActivated, widgetEvents, contentBlockOrder, auditStatus === 'completed' ? 'completed' : 'error');
-    yield {
-        type: SSEEventType.Done,
-        timestamp: new Date().toISOString(),
-        usage: {
-            input_tokens: tokens.inputTokens,
-            output_tokens: tokens.outputTokens,
-            cached_tokens: tokens.cachedTokens,
-            total_tokens: tokens.inputTokens + tokens.outputTokens,
-        },
-    };
-}
-/**
- * Accumulate the assistant response message and fire-and-forget save to platform-api.
- */
-function accumulateAssistantAndSave(session, hooks, responseText, toolCalls, skillsActivated, widgetEvents, contentBlocks, status) {
-    const assistantMsg = {
-        type: 'assistant_text',
-        id: `msg-${Date.now()}`,
-        text: responseText,
-        timestamp: new Date().toISOString(),
-        toolCalls: toolCalls.map((tc) => ({
-            toolName: tc.tool_name,
-            toolId: tc.tool_id,
-            args: tc.args,
-            status: tc.status,
-            duration_ms: tc.duration_ms,
-            error: tc.error,
-            result: tc.result,
-            inner_tool_calls: tc.inner_tool_calls,
-        })),
-        skillActivations: skillsActivated,
-        widgets: widgetEvents.map((w) => ({
-            widgetType: w.widgetType,
-            data: w.data,
-        })),
-        contentBlocks,
-    };
-    session.accumulatedMessages.push(assistantMsg);
-    hooks?.onSessionPersist?.(session.id, session.accumulatedMessages, status, {
-        model: session.model,
-        provider: session.provider,
-    });
-}
-function logSessionCompleted(hooks, sessionId, message, response, turns, toolCalls, skillsActivated, status, error, startMs, model, tokens) {
-    if (!hooks)
-        return;
-    const details = {
-        message,
-        response,
-        turns,
-        duration_ms: Date.now() - startMs,
-        status,
-        tool_calls: toolCalls,
-        skills_activated: skillsActivated,
-    };
-    if (error) {
-        details['error'] = error;
-    }
-    hooks.onAuditLog?.({
-        event: 'session_completed',
-        resource_name: sessionId,
-        details,
-    });
-    const taskAgentRuns = toolCalls.filter((tc) => tc.tool_name === 'dispatch').length;
-    hooks.onUsageReport?.({
-        model: model ?? 'unknown',
-        taskAgentRuns,
-        tokens: tokens ?? { inputTokens: 0, outputTokens: 0, cachedTokens: 0 },
-    });
-}
-//# sourceMappingURL=session-runner.js.map