@code-yeongyu/senpi-agent-core 2026.7.25-2

package/dist/agent-loop.js

@@ -0,0 +1,851 @@
+/**
+ * Agent loop that works with AgentMessage throughout.
+ * Transforms to Message[] only at the LLM call boundary.
+ */
+import { EventStream, validateToolArguments, } from "@earendil-works/pi-ai";
+import { getDefaultStreamFn } 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 agentLoop(prompts, context, config, signal, streamFn) {
+    const stream = createAgentStream();
+    void runAgentLoop(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 agentLoopContinue(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 = createAgentStream();
+    void runAgentLoopContinue(context, config, async (event) => {
+        stream.push(event);
+    }, signal, streamFn).then((messages) => {
+        stream.end(messages);
+    });
+    return stream;
+}
+export async function runAgentLoop(prompts, context, config, emit, signal, streamFn) {
+    const newMessages = [...prompts];
+    const currentContext = {
+        ...context,
+        messages: [...context.messages, ...prompts],
+    };
+    await emit({ type: "agent_start" });
+    await emit({ type: "turn_start" });
+    for (const prompt of prompts) {
+        await emit({ type: "message_start", message: prompt });
+        await emit({ type: "message_end", message: prompt });
+    }
+    await runLoop(currentContext, newMessages, config, signal, emit, streamFn ?? getDefaultStreamFn());
+    return newMessages;
+}
+export async function runAgentLoopContinue(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 runLoop(currentContext, newMessages, config, signal, emit, streamFn ?? getDefaultStreamFn());
+    return newMessages;
+}
+function createAgentStream() {
+    return new EventStream((event) => event.type === "agent_end", (event) => (event.type === "agent_end" ? event.messages : []));
+}
+const EMPTY_USAGE = {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    totalTokens: 0,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+};
+class StreamIdleTimeoutError extends Error {
+    constructor(timeoutMs) {
+        super(`Idle timeout waiting for provider stream after ${timeoutMs}ms`);
+        this.name = "StreamIdleTimeoutError";
+    }
+}
+/**
+ * Main loop logic shared by agentLoop and agentLoopContinue.
+ */
+async function runLoop(initialContext, newMessages, initialConfig, signal, emit, streamFunction) {
+    let currentContext = initialContext;
+    let config = initialConfig;
+    let firstTurn = true;
+    // Check for steering messages at start (user may have typed while waiting)
+    let pendingMessages = (await config.getSteeringMessages?.()) || [];
+    let drainedTerminatingQueue;
+    const refreshTerminatingQueueDrain = async () => {
+        if (!drainedTerminatingQueue || !config.restorePendingMessages)
+            return;
+        await config.restorePendingMessages(drainedTerminatingQueue, pendingMessages);
+        pendingMessages = (await config.getSteeringMessages?.()) || [];
+        drainedTerminatingQueue = pendingMessages.length > 0 ? "steering" : undefined;
+        if (pendingMessages.length === 0) {
+            pendingMessages = (await config.getFollowUpMessages?.()) || [];
+            drainedTerminatingQueue = pendingMessages.length > 0 ? "followUp" : undefined;
+        }
+    };
+    // 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) {
+            if (!firstTurn) {
+                await emit({ type: "turn_start" });
+            }
+            else {
+                firstTurn = false;
+            }
+            if (drainedTerminatingQueue) {
+                await refreshTerminatingQueueDrain();
+                if (pendingMessages.length === 0) {
+                    await emit({ type: "agent_end", messages: newMessages });
+                    return;
+                }
+                drainedTerminatingQueue = undefined;
+            }
+            // Process pending messages (inject before next assistant response)
+            if (pendingMessages.length > 0) {
+                for (const message of 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 streamAssistantResponse(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;
+            let toolBatchTerminated = false;
+            if (toolCalls.length > 0) {
+                // A native "length" stop means the output was cut off by the token limit,
+                // so every tool call in the message may carry truncated arguments. Text
+                // tool-call middleware finalizes its calls as "toolUse", leaving only
+                // native, unwrapped length responses for this message-wide safeguard.
+                const executedToolBatch = message.stopReason === "length"
+                    ? await failToolCallsFromTruncatedMessage(toolCalls, emit)
+                    : await executeToolCalls(currentContext, message, config, signal, emit);
+                toolResults.push(...executedToolBatch.messages);
+                toolBatchTerminated = executedToolBatch.terminate;
+                hasMoreToolCalls = !executedToolBatch.terminate;
+                for (const result of toolResults) {
+                    currentContext.messages.push(result);
+                    newMessages.push(result);
+                }
+            }
+            await emit({ type: "turn_end", message, toolResults });
+            if (signal?.aborted) {
+                await emit({ type: "agent_end", messages: newMessages });
+                return;
+            }
+            const nextTurnContext = {
+                message,
+                toolResults,
+                context: currentContext,
+                newMessages,
+            };
+            if (toolBatchTerminated) {
+                if (await config.shouldStopAfterTurn?.(nextTurnContext)) {
+                    await emit({ type: "agent_end", messages: newMessages });
+                    return;
+                }
+                pendingMessages = (await config.getSteeringMessages?.()) || [];
+                if (pendingMessages.length > 0) {
+                    drainedTerminatingQueue = "steering";
+                }
+                if (pendingMessages.length === 0) {
+                    pendingMessages = (await config.getFollowUpMessages?.()) || [];
+                    if (pendingMessages.length > 0) {
+                        drainedTerminatingQueue = "followUp";
+                    }
+                }
+                if (pendingMessages.length === 0) {
+                    await emit({ type: "agent_end", messages: newMessages });
+                    return;
+                }
+            }
+            let nextTurnSnapshot;
+            try {
+                nextTurnSnapshot = await config.prepareNextTurn?.(nextTurnContext);
+            }
+            catch (error) {
+                if (drainedTerminatingQueue) {
+                    await config.restorePendingMessages?.(drainedTerminatingQueue, pendingMessages);
+                }
+                throw error;
+            }
+            if (nextTurnSnapshot) {
+                currentContext = nextTurnSnapshot.context ?? currentContext;
+                config = {
+                    ...config,
+                    model: nextTurnSnapshot.model ?? config.model,
+                    reasoning: nextTurnSnapshot.thinkingLevel === undefined
+                        ? config.reasoning
+                        : nextTurnSnapshot.thinkingLevel === "off"
+                            ? undefined
+                            : nextTurnSnapshot.thinkingLevel,
+                };
+            }
+            if (signal?.aborted) {
+                if (drainedTerminatingQueue) {
+                    await config.restorePendingMessages?.(drainedTerminatingQueue, pendingMessages);
+                }
+                await emit({ type: "agent_end", messages: newMessages });
+                return;
+            }
+            if (drainedTerminatingQueue) {
+                await refreshTerminatingQueueDrain();
+                if (pendingMessages.length === 0) {
+                    await emit({ type: "agent_end", messages: newMessages });
+                    return;
+                }
+            }
+            if (!toolBatchTerminated &&
+                (await config.shouldStopAfterTurn?.({
+                    message,
+                    toolResults,
+                    context: currentContext,
+                    newMessages,
+                }))) {
+                await emit({ type: "agent_end", messages: newMessages });
+                return;
+            }
+            if (!toolBatchTerminated) {
+                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 });
+}
+/**
+ * Stream an assistant response from the LLM.
+ * This is where AgentMessage[] gets transformed to Message[] for the LLM.
+ */
+async function streamAssistantResponse(context, config, signal, emit, streamFunction) {
+    let partialMessage = null;
+    let addedPartial = false;
+    const thinkingTiming = new Map();
+    function propagateThinkingTiming(finalMessage) {
+        for (const timing of thinkingTiming.values()) {
+            if (timing.endedAt === undefined)
+                timing.endedAt = Date.now();
+        }
+        for (const [contentIndex, timing] of thinkingTiming) {
+            const block = finalMessage.content[contentIndex];
+            if (block?.type !== "thinking")
+                continue;
+            block.startedAt = timing.startedAt;
+            block.endedAt = timing.endedAt;
+        }
+    }
+    // Dedicated controller for the provider request so the loop can tear the
+    // request down itself (idle timeout), not only when the caller aborts.
+    const requestAbortController = new AbortController();
+    let detachCallerAbort;
+    if (signal !== undefined) {
+        if (signal.aborted) {
+            requestAbortController.abort(signal.reason);
+        }
+        else {
+            const onCallerAbort = () => requestAbortController.abort(signal.reason);
+            signal.addEventListener("abort", onCallerAbort, { once: true });
+            detachCallerAbort = () => signal.removeEventListener("abort", onCallerAbort);
+        }
+    }
+    try {
+        // 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);
+        // Build LLM context
+        const llmContext = {
+            systemPrompt: context.systemPrompt,
+            messages: llmMessages,
+            tools: context.tools,
+        };
+        // 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: requestAbortController.signal,
+        });
+        const iterator = response[Symbol.asyncIterator]();
+        const eventReader = createAssistantEventReader(iterator, config.timeoutMs, requestAbortController.signal, (error) => requestAbortController.abort(error));
+        try {
+            while (true) {
+                const next = await eventReader.next();
+                if (next.done)
+                    break;
+                const event = next.value;
+                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;
+                            if (event.type === "thinking_start" ||
+                                event.type === "thinking_delta" ||
+                                event.type === "thinking_end") {
+                                let timing = thinkingTiming.get(event.contentIndex);
+                                if (event.type === "thinking_start" && timing === undefined) {
+                                    timing = { startedAt: Date.now() };
+                                    thinkingTiming.set(event.contentIndex, timing);
+                                }
+                                if (event.type === "thinking_end" && timing !== undefined)
+                                    timing.endedAt = Date.now();
+                                const block = partialMessage.content[event.contentIndex];
+                                if (block?.type === "thinking" && timing !== undefined) {
+                                    block.startedAt = timing.startedAt;
+                                    if (timing.endedAt !== undefined)
+                                        block.endedAt = timing.endedAt;
+                                }
+                            }
+                            context.messages[context.messages.length - 1] = partialMessage;
+                            await emit({
+                                type: "message_update",
+                                assistantMessageEvent: event,
+                                message: { ...partialMessage },
+                            });
+                        }
+                        break;
+                    case "done":
+                    case "error": {
+                        const finalMessage = normalizeTerminalAssistantMessage(await response.result(), event);
+                        propagateThinkingTiming(finalMessage);
+                        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;
+                    }
+                }
+            }
+        }
+        finally {
+            eventReader.dispose();
+        }
+        const finalMessage = await response.result();
+        propagateThinkingTiming(finalMessage);
+        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;
+    }
+    catch (error) {
+        const finalMessage = createTerminalFailureAssistantMessage(config.model, signal?.aborted ? "aborted" : "error", error, partialMessage);
+        propagateThinkingTiming(finalMessage);
+        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;
+    }
+    finally {
+        detachCallerAbort?.();
+    }
+}
+const ABORTED = Symbol("aborted");
+function createAssistantEventReader(iterator, timeoutMs, signal, onIdleTimeout) {
+    const idleTimeoutMs = typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : undefined;
+    let removeAbortListener;
+    let abortPromise;
+    if (signal !== undefined) {
+        if (signal.aborted) {
+            abortPromise = Promise.resolve(ABORTED);
+        }
+        else {
+            abortPromise = new Promise((resolve) => {
+                const abortHandler = () => resolve(ABORTED);
+                signal.addEventListener("abort", abortHandler, { once: true });
+                removeAbortListener = () => signal.removeEventListener("abort", abortHandler);
+            });
+        }
+    }
+    return {
+        next: () => {
+            if (signal?.aborted) {
+                void iterator.return?.();
+                return Promise.reject(new Error("Request was aborted"));
+            }
+            return readNextAssistantEvent(iterator, idleTimeoutMs, abortPromise, onIdleTimeout);
+        },
+        dispose: () => removeAbortListener?.(),
+    };
+}
+async function readNextAssistantEvent(iterator, idleTimeoutMs, abortPromise, onIdleTimeout) {
+    if (idleTimeoutMs === undefined && abortPromise === undefined) {
+        return iterator.next();
+    }
+    let timeout;
+    let settled = false;
+    return new Promise((resolve, reject) => {
+        const settle = (complete) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timeout !== undefined) {
+                clearTimeout(timeout);
+            }
+            complete();
+        };
+        if (idleTimeoutMs !== undefined) {
+            timeout = setTimeout(() => {
+                const error = new StreamIdleTimeoutError(idleTimeoutMs);
+                void iterator.return?.();
+                settle(() => reject(error));
+                // Abort after settling so the failure surfaces as an idle timeout,
+                // not as a generic abort, while the dead request still gets torn down.
+                onIdleTimeout?.(error);
+            }, idleTimeoutMs);
+        }
+        const next = abortPromise ? Promise.race([iterator.next(), abortPromise]) : iterator.next();
+        void next.then((result) => {
+            if (result === ABORTED) {
+                void iterator.return?.();
+                settle(() => reject(new Error("Request was aborted")));
+                return;
+            }
+            settle(() => resolve(result));
+        }, (error) => settle(() => reject(error)));
+    });
+}
+function createIncompleteToolCallErrorMessage(toolName, errorMessage) {
+    if (errorMessage !== undefined) {
+        return `${errorMessage}${errorMessage.endsWith(".") ? "" : "."} Re-issue the tool call with complete arguments.`;
+    }
+    return `Tool call "${toolName}" was not executed: the response ended before the tool call was complete because it hit the output token limit. Re-issue the tool call with complete arguments.`;
+}
+/**
+ * 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 failToolCallsFromTruncatedMessage(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: createErrorToolResult(createIncompleteToolCallErrorMessage(toolCall.name)),
+            isError: true,
+        };
+        await emitToolExecutionEnd(finalized, emit);
+        const toolResultMessage = createToolResultMessage(finalized);
+        await emitToolResultMessage(toolResultMessage, emit);
+        messages.push(toolResultMessage);
+    }
+    return { messages, terminate: false };
+}
+/**
+ * Execute tool calls from an assistant message.
+ */
+async function executeToolCalls(currentContext, assistantMessage, config, signal, emit) {
+    const toolCalls = assistantMessage.content.filter((c) => c.type === "toolCall");
+    if (config.toolExecution === "sequential") {
+        return executeToolCallsSequential(currentContext, assistantMessage, toolCalls, config, signal, emit);
+    }
+    return executeToolCallsParallel(currentContext, assistantMessage, toolCalls, config, signal, emit);
+}
+function createTerminalFailureAssistantMessage(model, reason, error, partialMessage) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+        role: "assistant",
+        content: partialMessage?.content ?? [{ type: "text", text: "" }],
+        api: partialMessage?.api ?? model.api,
+        provider: partialMessage?.provider ?? model.provider,
+        model: partialMessage?.model ?? model.id,
+        responseModel: partialMessage?.responseModel,
+        responseId: partialMessage?.responseId,
+        diagnostics: partialMessage?.diagnostics,
+        usage: partialMessage?.usage ?? EMPTY_USAGE,
+        stopReason: reason,
+        errorMessage: errorMessage || (reason === "aborted" ? "Request was aborted" : "Error"),
+        timestamp: partialMessage?.timestamp ?? Date.now(),
+    };
+}
+function normalizeTerminalAssistantMessage(message, event) {
+    if (event.type === "done") {
+        return message;
+    }
+    const errorMessage = message.errorMessage ?? (event.reason === "aborted" ? "Request was aborted" : "Error");
+    if (message.stopReason === event.reason && message.errorMessage === errorMessage) {
+        return message;
+    }
+    return {
+        ...message,
+        stopReason: event.reason,
+        errorMessage,
+    };
+}
+async function executeToolCallsSequential(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 prepareToolCall(currentContext, assistantMessage, toolCall, config, signal);
+        let finalized;
+        if (preparation.kind === "immediate") {
+            finalized = {
+                toolCall,
+                result: preparation.result,
+                isError: preparation.isError,
+            };
+        }
+        else {
+            const executed = await executePreparedToolCall(preparation, signal, emit);
+            finalized = await finalizeExecutedToolCall(currentContext, assistantMessage, preparation, executed, config, signal);
+        }
+        await emitToolExecutionEnd(finalized, emit);
+        const toolResultMessage = createToolResultMessage(finalized);
+        await emitToolResultMessage(toolResultMessage, emit);
+        finalizedCalls.push(finalized);
+        messages.push(toolResultMessage);
+        if (signal?.aborted) {
+            break;
+        }
+    }
+    return {
+        messages,
+        terminate: shouldTerminateToolBatch(finalizedCalls),
+    };
+}
+async function executeToolCallsParallel(currentContext, assistantMessage, toolCalls, config, signal, emit) {
+    const finalizedCalls = [];
+    let lastSequentialCall;
+    let currentParallelWave = [];
+    for (const toolCall of toolCalls) {
+        await emit({
+            type: "tool_execution_start",
+            toolCallId: toolCall.id,
+            toolName: toolCall.name,
+            args: toolCall.arguments,
+        });
+        const preparation = await prepareToolCall(currentContext, assistantMessage, toolCall, config, signal);
+        const isSequential = isSequentialToolCall(currentContext, toolCall);
+        const dependencies = isSequential
+            ? [...(lastSequentialCall ? [lastSequentialCall] : []), ...currentParallelWave]
+            : lastSequentialCall
+                ? [lastSequentialCall]
+                : [];
+        const finalizedCall = (async () => {
+            await Promise.all(dependencies);
+            const finalized = await runPreparedToolCall(currentContext, assistantMessage, preparation, config, signal, emit);
+            await emitToolExecutionEnd(finalized, emit);
+            return finalized;
+        })();
+        finalizedCalls.push(finalizedCall);
+        if (isSequential) {
+            lastSequentialCall = finalizedCall;
+            currentParallelWave = [];
+        }
+        else {
+            currentParallelWave.push(finalizedCall);
+        }
+        if (signal?.aborted) {
+            break;
+        }
+    }
+    const orderedFinalizedCalls = await Promise.all(finalizedCalls);
+    const messages = [];
+    for (const finalized of orderedFinalizedCalls) {
+        const toolResultMessage = createToolResultMessage(finalized);
+        await emitToolResultMessage(toolResultMessage, emit);
+        messages.push(toolResultMessage);
+    }
+    return {
+        messages,
+        terminate: shouldTerminateToolBatch(orderedFinalizedCalls),
+    };
+}
+async function runPreparedToolCall(currentContext, assistantMessage, preparation, config, signal, emit) {
+    if (preparation.kind === "immediate") {
+        return {
+            toolCall: preparation.toolCall,
+            result: preparation.result,
+            isError: preparation.isError,
+        };
+    }
+    const executed = await executePreparedToolCall(preparation, signal, emit);
+    return finalizeExecutedToolCall(currentContext, assistantMessage, preparation, executed, config, signal);
+}
+function isSequentialToolCall(currentContext, toolCall) {
+    return currentContext.tools?.find((tool) => tool.name === toolCall.name)?.executionMode === "sequential";
+}
+function shouldTerminateToolBatch(finalizedCalls) {
+    return finalizedCalls.length > 0 && finalizedCalls.every((finalized) => finalized.result.terminate === true);
+}
+export function prepareAgentToolCallArguments(tool, toolCall) {
+    if (!tool.prepareArguments) {
+        return toolCall;
+    }
+    const preparedArguments = tool.prepareArguments(toolCall.arguments);
+    if (preparedArguments === toolCall.arguments) {
+        return toolCall;
+    }
+    return {
+        ...toolCall,
+        arguments: preparedArguments,
+    };
+}
+export function prepareAgentToolCall(tool, toolCall) {
+    const preparedToolCall = prepareAgentToolCallArguments(tool, toolCall);
+    return {
+        toolCall: preparedToolCall,
+        tool,
+        args: validateToolArguments(tool, preparedToolCall),
+    };
+}
+async function prepareToolCall(currentContext, assistantMessage, toolCall, config, signal) {
+    if (toolCall.incomplete === true) {
+        return {
+            kind: "immediate",
+            toolCall,
+            result: createErrorToolResult(createIncompleteToolCallErrorMessage(toolCall.name, toolCall.errorMessage)),
+            isError: true,
+        };
+    }
+    const tool = currentContext.tools?.find((t) => t.name === toolCall.name);
+    if (!tool) {
+        return {
+            kind: "immediate",
+            toolCall,
+            result: createErrorToolResult(`Tool ${toolCall.name} not found`),
+            isError: true,
+        };
+    }
+    try {
+        const preparedToolCall = prepareAgentToolCall(tool, toolCall);
+        const validatedArgs = preparedToolCall.args;
+        if (config.beforeToolCall) {
+            const beforeResult = await config.beforeToolCall({
+                assistantMessage,
+                toolCall: preparedToolCall.toolCall,
+                args: validatedArgs,
+                context: currentContext,
+            }, signal);
+            if (signal?.aborted) {
+                return {
+                    kind: "immediate",
+                    toolCall,
+                    result: createErrorToolResult("Operation aborted"),
+                    isError: true,
+                };
+            }
+            if (beforeResult?.block) {
+                return {
+                    kind: "immediate",
+                    toolCall,
+                    result: createErrorToolResult(beforeResult.reason || "Tool execution was blocked"),
+                    isError: true,
+                };
+            }
+        }
+        if (signal?.aborted) {
+            return {
+                kind: "immediate",
+                toolCall,
+                result: createErrorToolResult("Operation aborted"),
+                isError: true,
+            };
+        }
+        return {
+            kind: "prepared",
+            toolCall: preparedToolCall.toolCall,
+            tool,
+            args: validatedArgs,
+        };
+    }
+    catch (error) {
+        return {
+            kind: "immediate",
+            toolCall,
+            result: createErrorToolResult(error instanceof Error ? error.message : String(error)),
+            isError: true,
+        };
+    }
+}
+async function executePreparedToolCall(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: createErrorToolResult(error instanceof Error ? error.message : String(error)),
+            isError: true,
+        };
+    }
+    finally {
+        acceptingUpdates = false;
+    }
+}
+async function finalizeExecutedToolCall(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 = createErrorToolResult(error instanceof Error ? error.message : String(error));
+            isError = true;
+        }
+    }
+    return {
+        toolCall: prepared.toolCall,
+        result,
+        isError,
+    };
+}
+function createErrorToolResult(message) {
+    return {
+        content: [{ type: "text", text: message }],
+        details: {},
+    };
+}
+async function emitToolExecutionEnd(finalized, emit) {
+    await emit({
+        type: "tool_execution_end",
+        toolCallId: finalized.toolCall.id,
+        toolName: finalized.toolCall.name,
+        result: finalized.result,
+        isError: finalized.isError,
+    });
+}
+function createToolResultMessage(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,
+        ...(finalized.result.addedToolNames?.length ? { addedToolNames: finalized.result.addedToolNames } : {}),
+        isError: finalized.isError,
+        timestamp: Date.now(),
+    };
+}
+async function emitToolResultMessage(toolResultMessage, emit) {
+    await emit({ type: "message_start", message: toolResultMessage });
+    await emit({ type: "message_end", message: toolResultMessage });
+}
+//# sourceMappingURL=agent-loop.js.map