@andorra-labs/code 0.0.0-stage → 0.1.5

package/dist/vendor/engine/runtime/agent/agent-loop.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Agent loop that works with AgentMessage throughout.
+ * Transforms to Message[] only at the LLM call boundary.
+ */
+import { AndorraEventStream } from "../ai/index.js";
+import type { AgentContext, AgentEvent, AgentLoopConfig, AgentMessage, StreamFn } from "./types.js";
+export type AgentEventSink = (event: AgentEvent) => Promise<void> | void;
+/**
+ * Start an agent loop with a new prompt message.
+ * The prompt is added to the context and events are emitted for it.
+ */
+export declare function andorraAgentLoop(prompts: AgentMessage[], context: AgentContext, config: AgentLoopConfig, signal: AbortSignal | undefined, streamFn: StreamFn): AndorraEventStream<AgentEvent, AgentMessage[]>;
+/**
+ * Continue an agent loop from the current context without adding a new message.
+ * Used for retries - context already has user message or tool results.
+ *
+ * **Important:** The last message in context must convert to a `user` or `toolResult` message
+ * via `convertToLlm`. If it doesn't, the LLM provider will reject the request.
+ * This cannot be validated here since `convertToLlm` is only called once per turn.
+ */
+export declare function andorraAgentLoopContinue(context: AgentContext, config: AgentLoopConfig, signal: AbortSignal | undefined, streamFn: StreamFn): AndorraEventStream<AgentEvent, AgentMessage[]>;
+export declare function andorraRunAgentLoop(prompts: AgentMessage[], context: AgentContext, config: AgentLoopConfig, emit: AgentEventSink, signal: AbortSignal | undefined, streamFn: StreamFn): Promise<AgentMessage[]>;
+export declare function andorraRunAgentLoopContinue(context: AgentContext, config: AgentLoopConfig, emit: AgentEventSink, signal: AbortSignal | undefined, streamFn: StreamFn): Promise<AgentMessage[]>;

package/dist/vendor/engine/runtime/agent/agent-loop.js

@@ -0,0 +1,601 @@
+/**
+ * Agent loop that works with AgentMessage throughout.
+ * Transforms to Message[] only at the LLM call boundary.
+ */
+import { AndorraEventStream, andorraGetCurrentTools, andorraGetToolStateChanges, andorraNormalizeContext, andorraToToolDeclaration, andorraValidateToolArguments, } from "../ai/index.js";
+import { andorraGetDefaultStreamFn } from "./stream-fn.js";
+/**
+ * Start an agent loop with a new prompt message.
+ * The prompt is added to the context and events are emitted for it.
+ */
+export function andorraAgentLoop(prompts, context, config, signal, streamFn) {
+    const stream = andorraCreateAgentStream();
+    void andorraRunAgentLoop(prompts, context, config, async (event) => {
+        stream.push(event);
+    }, signal, streamFn).then((messages) => {
+        stream.end(messages);
+    });
+    return stream;
+}
+/**
+ * Continue an agent loop from the current context without adding a new message.
+ * Used for retries - context already has user message or tool results.
+ *
+ * **Important:** The last message in context must convert to a `user` or `toolResult` message
+ * via `convertToLlm`. If it doesn't, the LLM provider will reject the request.
+ * This cannot be validated here since `convertToLlm` is only called once per turn.
+ */
+export function andorraAgentLoopContinue(context, config, signal, streamFn) {
+    if (context.messages.length === 0) {
+        throw new Error("Cannot continue: no messages in context");
+    }
+    if (context.messages[context.messages.length - 1].role === "assistant") {
+        throw new Error("Cannot continue from message role: assistant");
+    }
+    const stream = andorraCreateAgentStream();
+    void andorraRunAgentLoopContinue(context, config, async (event) => {
+        stream.push(event);
+    }, signal, streamFn).then((messages) => {
+        stream.end(messages);
+    });
+    return stream;
+}
+export async function andorraRunAgentLoop(prompts, context, config, emit, signal, streamFn) {
+    const initialMessages = andorraDeclareToolChanges(context, prompts);
+    const newMessages = [...initialMessages];
+    const currentContext = {
+        ...context,
+        messages: [...context.messages, ...initialMessages],
+    };
+    await emit({ type: "agent_start" });
+    await emit({ type: "turn_start" });
+    for (const message of initialMessages) {
+        await emit({ type: "message_start", message });
+        await emit({ type: "message_end", message });
+    }
+    await andorraRunLoop(currentContext, newMessages, config, signal, emit, streamFn ?? andorraGetDefaultStreamFn());
+    return newMessages;
+}
+export async function andorraRunAgentLoopContinue(context, config, emit, signal, streamFn) {
+    if (context.messages.length === 0) {
+        throw new Error("Cannot continue: no messages in context");
+    }
+    if (context.messages[context.messages.length - 1].role === "assistant") {
+        throw new Error("Cannot continue from message role: assistant");
+    }
+    const newMessages = [];
+    const currentContext = { ...context };
+    await emit({ type: "agent_start" });
+    await emit({ type: "turn_start" });
+    await andorraRunLoop(currentContext, newMessages, config, signal, emit, streamFn ?? andorraGetDefaultStreamFn());
+    return newMessages;
+}
+function andorraCreateAgentStream() {
+    return new AndorraEventStream((event) => event.type === "agent_end", (event) => (event.type === "agent_end" ? event.messages : []));
+}
+/**
+ * Main loop logic shared by agentLoop and agentLoopContinue.
+ */
+async function andorraRunLoop(initialContext, newMessages, initialConfig, signal, emit, streamFunction) {
+    let currentContext = initialContext;
+    let config = initialConfig;
+    let lastCompletedTurn;
+    // Check for steering messages at start (user may have typed while waiting)
+    let pendingMessages = (await config.getSteeringMessages?.()) || [];
+    // Outer loop: continues when queued follow-up messages arrive after agent would stop
+    while (true) {
+        let hasMoreToolCalls = true;
+        // Inner loop: process tool calls and steering messages
+        while (hasMoreToolCalls || pendingMessages.length > 0) {
+            let preparedMessages = [];
+            if (lastCompletedTurn) {
+                const nextTurnSnapshot = await config.prepareNextTurn?.(lastCompletedTurn);
+                if (nextTurnSnapshot) {
+                    currentContext = nextTurnSnapshot.context ?? currentContext;
+                    preparedMessages = nextTurnSnapshot.messages ?? [];
+                    config = {
+                        ...config,
+                        model: nextTurnSnapshot.model ?? config.model,
+                        reasoning: nextTurnSnapshot.thinkingLevel === undefined
+                            ? config.reasoning
+                            : nextTurnSnapshot.thinkingLevel === "off"
+                                ? undefined
+                                : nextTurnSnapshot.thinkingLevel,
+                    };
+                }
+                // Preparation can be long-running (for example, compaction). Pick up steering
+                // queued while it ran. Only poll again if the earlier poll returned nothing;
+                // otherwise one-at-a-time mode would deliver two messages in this turn.
+                if (pendingMessages.length === 0) {
+                    pendingMessages = (await config.getSteeringMessages?.()) || [];
+                }
+                await emit({ type: "turn_start" });
+            }
+            // Process prepared and queued messages before the next assistant response.
+            for (const message of andorraDeclareToolChanges(currentContext, [...preparedMessages, ...pendingMessages])) {
+                await emit({ type: "message_start", message });
+                await emit({ type: "message_end", message });
+                currentContext.messages.push(message);
+                newMessages.push(message);
+            }
+            pendingMessages = [];
+            // Stream assistant response
+            const message = await andorraStreamAssistantResponse(currentContext, config, signal, emit, streamFunction);
+            newMessages.push(message);
+            if (message.stopReason === "error" || message.stopReason === "aborted") {
+                await emit({ type: "turn_end", message, toolResults: [] });
+                await emit({ type: "agent_end", messages: newMessages });
+                return;
+            }
+            // Check for tool calls
+            const toolCalls = message.content.filter((c) => c.type === "toolCall");
+            const toolResults = [];
+            hasMoreToolCalls = false;
+            if (toolCalls.length > 0) {
+                // A "length" stop means the output was cut off by the token limit, so
+                // every tool call in the message may carry truncated arguments. Fail
+                // them all instead of executing potentially borked calls.
+                const executedToolBatch = message.stopReason === "length"
+                    ? await andorraFailToolCallsFromTruncatedMessage(toolCalls, emit)
+                    : await andorraExecuteToolCalls(currentContext, message, config, signal, emit);
+                toolResults.push(...executedToolBatch.messages);
+                hasMoreToolCalls = !executedToolBatch.terminate;
+                for (const result of toolResults) {
+                    currentContext.messages.push(result);
+                    newMessages.push(result);
+                }
+            }
+            await emit({ type: "turn_end", message, toolResults });
+            lastCompletedTurn = {
+                message,
+                toolResults,
+                context: currentContext,
+                newMessages,
+            };
+            if (await config.shouldStopAfterTurn?.(lastCompletedTurn)) {
+                await emit({ type: "agent_end", messages: newMessages });
+                return;
+            }
+            pendingMessages = (await config.getSteeringMessages?.()) || [];
+        }
+        // Agent would stop here. Check for follow-up messages.
+        const followUpMessages = (await config.getFollowUpMessages?.()) || [];
+        if (followUpMessages.length > 0) {
+            // Set as pending so inner loop processes them
+            pendingMessages = followUpMessages;
+            continue;
+        }
+        // No more messages, exit
+        break;
+    }
+    await emit({ type: "agent_end", messages: newMessages });
+}
+/**
+ * Declare tool loadout changes to the model.
+ *
+ * `context.tools` is what the runtime can execute; the transcript's system messages declare
+ * what the model may call. Before each request the difference becomes `toolsAdded` and
+ * `toolsRemoved` on a system message. When a pending system message exists, its tool fields
+ * are treated as intent and replaced with the delta between the committed transcript and
+ * the executable set, so replay always yields exactly `context.tools`. Otherwise a new
+ * system message is inserted before the first non-system pending message.
+ */
+function andorraDeclareToolChanges(context, pendingMessages) {
+    let systemIndex = -1;
+    for (let i = pendingMessages.length - 1; i >= 0; i--) {
+        if (pendingMessages[i].role === "system") {
+            systemIndex = i;
+            break;
+        }
+    }
+    const pending = pendingMessages[systemIndex];
+    const baseline = pending
+        ? pendingMessages.map((message, index) => index === systemIndex ? andorraWithToolChanges(pending, NO_CHANGES) : message)
+        : pendingMessages;
+    const changes = andorraGetToolStateChanges(andorraGetCurrentTools([...context.messages, ...baseline]), (context.tools ?? []).map(andorraToToolDeclaration));
+    const unchanged = changes.toolsAdded.length === 0 && changes.toolsRemoved.length === 0;
+    if (pending) {
+        // Keep the caller's message object when it already declares no tool changes.
+        if (unchanged && !pending.toolsAdded?.length && !pending.toolsRemoved?.length)
+            return pendingMessages;
+        return baseline.map((message, index) => (index === systemIndex ? andorraWithToolChanges(pending, changes) : message));
+    }
+    if (unchanged)
+        return pendingMessages;
+    const update = andorraWithToolChanges({ role: "system", content: "", timestamp: Date.now() }, changes);
+    const insertIndex = pendingMessages.findIndex((message) => message.role !== "system");
+    const index = insertIndex === -1 ? pendingMessages.length : insertIndex;
+    return [...pendingMessages.slice(0, index), update, ...pendingMessages.slice(index)];
+}
+const NO_CHANGES = { toolsAdded: [], toolsRemoved: [] };
+/** Copy a system message with its tool fields replaced by `changes`; empty lists omit the field. */
+function andorraWithToolChanges(message, { toolsAdded, toolsRemoved }) {
+    const { toolsAdded: _added, toolsRemoved: _removed, ...rest } = message;
+    return {
+        ...rest,
+        ...(toolsAdded.length > 0 ? { toolsAdded } : {}),
+        ...(toolsRemoved.length > 0 ? { toolsRemoved } : {}),
+    };
+}
+/**
+ * Stream an assistant response from the LLM.
+ * This is where AgentMessage[] gets transformed to Message[] for the LLM.
+ */
+async function andorraStreamAssistantResponse(context, config, signal, emit, streamFunction) {
+    // Apply context transform if configured (AgentMessage[] → AgentMessage[])
+    let messages = context.messages;
+    if (config.transformContext) {
+        messages = await config.transformContext(messages, signal);
+    }
+    // Convert to LLM-compatible messages (AgentMessage[] → Message[])
+    const llmMessages = await config.convertToLlm(messages);
+    const llmContext = andorraNormalizeContext({ messages: llmMessages });
+    // Resolve API key (important for expiring tokens)
+    const resolvedApiKey = (config.getApiKey ? await config.getApiKey(config.model.provider) : undefined) || config.apiKey;
+    const response = await streamFunction(config.model, llmContext, {
+        ...config,
+        apiKey: resolvedApiKey,
+        signal,
+    });
+    let partialMessage = null;
+    let addedPartial = false;
+    for await (const event of response) {
+        switch (event.type) {
+            case "start":
+                partialMessage = event.partial;
+                context.messages.push(partialMessage);
+                addedPartial = true;
+                await emit({ type: "message_start", message: { ...partialMessage } });
+                break;
+            case "text_start":
+            case "text_delta":
+            case "text_end":
+            case "thinking_start":
+            case "thinking_delta":
+            case "thinking_end":
+            case "toolcall_start":
+            case "toolcall_delta":
+            case "toolcall_end":
+                if (partialMessage) {
+                    partialMessage = event.partial;
+                    context.messages[context.messages.length - 1] = partialMessage;
+                    await emit({
+                        type: "message_update",
+                        assistantMessageEvent: event,
+                        message: { ...partialMessage },
+                    });
+                }
+                break;
+            case "done":
+            case "error": {
+                const finalMessage = await response.result();
+                if (addedPartial) {
+                    context.messages[context.messages.length - 1] = finalMessage;
+                }
+                else {
+                    context.messages.push(finalMessage);
+                }
+                if (!addedPartial) {
+                    await emit({ type: "message_start", message: { ...finalMessage } });
+                }
+                await emit({ type: "message_end", message: finalMessage });
+                return finalMessage;
+            }
+        }
+    }
+    const finalMessage = await response.result();
+    if (addedPartial) {
+        context.messages[context.messages.length - 1] = finalMessage;
+    }
+    else {
+        context.messages.push(finalMessage);
+        await emit({ type: "message_start", message: { ...finalMessage } });
+    }
+    await emit({ type: "message_end", message: finalMessage });
+    return finalMessage;
+}
+/**
+ * Fail all tool calls from an assistant message that was truncated by the
+ * output token limit. Streamed tool-call arguments are finalized with a
+ * best-effort JSON salvage parser, so a truncated message can yield tool calls
+ * whose arguments parse and validate but are silently incomplete. None of them
+ * are safe to execute; report each as an error so the model can re-issue them.
+ */
+async function andorraFailToolCallsFromTruncatedMessage(toolCalls, emit) {
+    const messages = [];
+    for (const toolCall of toolCalls) {
+        await emit({
+            type: "tool_execution_start",
+            toolCallId: toolCall.id,
+            toolName: toolCall.name,
+            args: toolCall.arguments,
+        });
+        const finalized = {
+            toolCall,
+            result: andorraCreateErrorToolResult(`Tool call "${toolCall.name}" was not executed: the response hit the output token limit, so its arguments may be truncated. Re-issue the tool call with complete arguments.`),
+            isError: true,
+        };
+        await andorraEmitToolExecutionEnd(finalized, emit);
+        const toolResultMessage = andorraCreateToolResultMessage(finalized);
+        await andorraEmitToolResultMessage(toolResultMessage, emit);
+        messages.push(toolResultMessage);
+    }
+    return { messages, terminate: false };
+}
+/**
+ * Execute tool calls from an assistant message.
+ */
+async function andorraExecuteToolCalls(currentContext, assistantMessage, config, signal, emit) {
+    const toolCalls = assistantMessage.content.filter((c) => c.type === "toolCall");
+    const hasSequentialToolCall = toolCalls.some((tc) => currentContext.tools?.find((t) => t.name === tc.name)?.executionMode === "sequential");
+    if (config.toolExecution === "sequential" || hasSequentialToolCall) {
+        return andorraExecuteToolCallsSequential(currentContext, assistantMessage, toolCalls, config, signal, emit);
+    }
+    return andorraExecuteToolCallsParallel(currentContext, assistantMessage, toolCalls, config, signal, emit);
+}
+async function andorraExecuteToolCallsSequential(currentContext, assistantMessage, toolCalls, config, signal, emit) {
+    const finalizedCalls = [];
+    const messages = [];
+    for (const toolCall of toolCalls) {
+        await emit({
+            type: "tool_execution_start",
+            toolCallId: toolCall.id,
+            toolName: toolCall.name,
+            args: toolCall.arguments,
+        });
+        const preparation = await andorraPrepareToolCall(currentContext, assistantMessage, toolCall, config, signal);
+        let finalized;
+        if (preparation.kind === "immediate") {
+            finalized = {
+                toolCall,
+                result: preparation.result,
+                isError: preparation.isError,
+            };
+        }
+        else {
+            const executed = await andorraExecutePreparedToolCall(preparation, signal, emit);
+            finalized = await andorraFinalizeExecutedToolCall(currentContext, assistantMessage, preparation, executed, config, signal);
+        }
+        await andorraEmitToolExecutionEnd(finalized, emit);
+        const toolResultMessage = andorraCreateToolResultMessage(finalized);
+        await andorraEmitToolResultMessage(toolResultMessage, emit);
+        finalizedCalls.push(finalized);
+        messages.push(toolResultMessage);
+        if (signal?.aborted) {
+            break;
+        }
+    }
+    return {
+        messages,
+        terminate: andorraShouldTerminateToolBatch(finalizedCalls),
+    };
+}
+async function andorraExecuteToolCallsParallel(currentContext, assistantMessage, toolCalls, config, signal, emit) {
+    const finalizedCalls = [];
+    for (const toolCall of toolCalls) {
+        await emit({
+            type: "tool_execution_start",
+            toolCallId: toolCall.id,
+            toolName: toolCall.name,
+            args: toolCall.arguments,
+        });
+        const preparation = await andorraPrepareToolCall(currentContext, assistantMessage, toolCall, config, signal);
+        if (preparation.kind === "immediate") {
+            const finalized = {
+                toolCall,
+                result: preparation.result,
+                isError: preparation.isError,
+            };
+            await andorraEmitToolExecutionEnd(finalized, emit);
+            finalizedCalls.push(finalized);
+            if (signal?.aborted) {
+                break;
+            }
+            continue;
+        }
+        finalizedCalls.push(async () => {
+            if (signal?.aborted) {
+                const finalized = {
+                    toolCall,
+                    result: andorraCreateErrorToolResult("Operation aborted"),
+                    isError: true,
+                };
+                await andorraEmitToolExecutionEnd(finalized, emit);
+                return finalized;
+            }
+            const executed = await andorraExecutePreparedToolCall(preparation, signal, emit);
+            const finalized = await andorraFinalizeExecutedToolCall(currentContext, assistantMessage, preparation, executed, config, signal);
+            await andorraEmitToolExecutionEnd(finalized, emit);
+            return finalized;
+        });
+        if (signal?.aborted) {
+            break;
+        }
+    }
+    const orderedFinalizedCalls = await Promise.all(finalizedCalls.map((entry) => (typeof entry === "function" ? entry() : Promise.resolve(entry))));
+    const messages = [];
+    for (const finalized of orderedFinalizedCalls) {
+        const toolResultMessage = andorraCreateToolResultMessage(finalized);
+        await andorraEmitToolResultMessage(toolResultMessage, emit);
+        messages.push(toolResultMessage);
+    }
+    return {
+        messages,
+        terminate: andorraShouldTerminateToolBatch(orderedFinalizedCalls),
+    };
+}
+function andorraShouldTerminateToolBatch(finalizedCalls) {
+    return finalizedCalls.length > 0 && finalizedCalls.every((finalized) => finalized.result.terminate === true);
+}
+function andorraPrepareToolCallArguments(tool, toolCall) {
+    if (!tool.prepareArguments) {
+        return toolCall;
+    }
+    const preparedArguments = tool.prepareArguments(toolCall.arguments);
+    if (preparedArguments === toolCall.arguments) {
+        return toolCall;
+    }
+    return {
+        ...toolCall,
+        arguments: preparedArguments,
+    };
+}
+async function andorraPrepareToolCall(currentContext, assistantMessage, toolCall, config, signal) {
+    const tool = currentContext.tools?.find((t) => t.name === toolCall.name);
+    if (!tool) {
+        return {
+            kind: "immediate",
+            result: andorraCreateErrorToolResult(`Tool ${toolCall.name} not found`),
+            isError: true,
+        };
+    }
+    try {
+        const preparedToolCall = andorraPrepareToolCallArguments(tool, toolCall);
+        const validatedArgs = andorraValidateToolArguments(tool, preparedToolCall);
+        if (config.beforeToolCall) {
+            const beforeResult = await config.beforeToolCall({
+                assistantMessage,
+                toolCall,
+                args: validatedArgs,
+                context: currentContext,
+            }, signal);
+            if (signal?.aborted) {
+                return {
+                    kind: "immediate",
+                    result: andorraCreateErrorToolResult("Operation aborted"),
+                    isError: true,
+                };
+            }
+            if (beforeResult?.block) {
+                const result = andorraCreateErrorToolResult(beforeResult.reason || "Tool execution was blocked");
+                if (beforeResult.terminate === true) {
+                    result.terminate = true;
+                }
+                return {
+                    kind: "immediate",
+                    result,
+                    isError: true,
+                };
+            }
+        }
+        if (signal?.aborted) {
+            return {
+                kind: "immediate",
+                result: andorraCreateErrorToolResult("Operation aborted"),
+                isError: true,
+            };
+        }
+        return {
+            kind: "prepared",
+            toolCall,
+            tool,
+            args: validatedArgs,
+        };
+    }
+    catch (error) {
+        return {
+            kind: "immediate",
+            result: andorraCreateErrorToolResult(error instanceof Error ? error.message : String(error)),
+            isError: true,
+        };
+    }
+}
+async function andorraExecutePreparedToolCall(prepared, signal, emit) {
+    const updateEvents = [];
+    let acceptingUpdates = true;
+    try {
+        const result = await prepared.tool.execute(prepared.toolCall.id, prepared.args, signal, (partialResult) => {
+            if (!acceptingUpdates)
+                return;
+            updateEvents.push(Promise.resolve(emit({
+                type: "tool_execution_update",
+                toolCallId: prepared.toolCall.id,
+                toolName: prepared.toolCall.name,
+                args: prepared.toolCall.arguments,
+                partialResult,
+            })));
+        });
+        acceptingUpdates = false;
+        await Promise.all(updateEvents);
+        return { result, isError: false };
+    }
+    catch (error) {
+        acceptingUpdates = false;
+        await Promise.all(updateEvents);
+        return {
+            result: andorraCreateErrorToolResult(error instanceof Error ? error.message : String(error)),
+            isError: true,
+        };
+    }
+    finally {
+        acceptingUpdates = false;
+    }
+}
+async function andorraFinalizeExecutedToolCall(currentContext, assistantMessage, prepared, executed, config, signal) {
+    let result = executed.result;
+    let isError = executed.isError;
+    if (config.afterToolCall) {
+        try {
+            const afterResult = await config.afterToolCall({
+                assistantMessage,
+                toolCall: prepared.toolCall,
+                args: prepared.args,
+                result,
+                isError,
+                context: currentContext,
+            }, signal);
+            if (afterResult) {
+                result = {
+                    ...result,
+                    content: afterResult.content ?? result.content,
+                    details: afterResult.details ?? result.details,
+                    usage: afterResult.usage ?? result.usage,
+                    terminate: afterResult.terminate ?? result.terminate,
+                };
+                isError = afterResult.isError ?? isError;
+            }
+        }
+        catch (error) {
+            result = andorraCreateErrorToolResult(error instanceof Error ? error.message : String(error));
+            isError = true;
+        }
+    }
+    return {
+        toolCall: prepared.toolCall,
+        result,
+        isError,
+    };
+}
+function andorraCreateErrorToolResult(message) {
+    return {
+        content: [{ type: "text", text: message }],
+        details: {},
+    };
+}
+async function andorraEmitToolExecutionEnd(finalized, emit) {
+    await emit({
+        type: "tool_execution_end",
+        toolCallId: finalized.toolCall.id,
+        toolName: finalized.toolCall.name,
+        result: finalized.result,
+        isError: finalized.isError,
+    });
+}
+function andorraCreateToolResultMessage(finalized) {
+    return {
+        role: "toolResult",
+        toolCallId: finalized.toolCall.id,
+        toolName: finalized.toolCall.name,
+        // Untyped tools (JS extensions) can return results without content; normalize
+        // so the null never enters session history or provider payloads.
+        content: finalized.result.content ?? [],
+        details: finalized.result.details,
+        usage: finalized.result.usage,
+        isError: finalized.isError,
+        timestamp: Date.now(),
+    };
+}
+async function andorraEmitToolResultMessage(toolResultMessage, emit) {
+    await emit({ type: "message_start", message: toolResultMessage });
+    await emit({ type: "message_end", message: toolResultMessage });
+}