@sema-agent/core 1.279.0

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

@@ -0,0 +1,1087 @@
+import { EventStream as LlmEventStream } from "../llm/index.js";
+import { findToolByName, validateToolArguments } from "../llm/index.js";
+import { TOMBSTONED_TOOLS } from "../../core/tool-name-aliases.js";
+import { resolveAgentCoreStreamFn } from "./runtime-deps.js";
+const EMPTY_USAGE = {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    totalTokens: 0,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+};
+const EventStreamConstructor = LlmEventStream;
+function appendTextDeltaToAssistantMessage(message, contentIndex, delta) {
+    const content = [...message.content];
+    const currentContent = content[contentIndex];
+    content[contentIndex] =
+        currentContent?.type === "text"
+            ? { ...currentContent, text: currentContent.text + delta }
+            : { type: "text", text: delta };
+    return { ...message, content };
+}
+function resolveAssistantMessageUpdate(event, currentMessage) {
+    if ("partial" in event && event.partial) {
+        return event.partial;
+    }
+    if (event.type === "text_delta") {
+        return appendTextDeltaToAssistantMessage(currentMessage, event.contentIndex, event.delta);
+    }
+    return currentMessage;
+}
+export function agentLoop(prompts, context, config, signal, streamFn, runtime) {
+    const stream = createAgentStream();
+    void runAgentLoop(prompts, context, config, async (event) => {
+        stream.push(event);
+    }, signal, streamFn, runtime)
+        .then((messages) => {
+        stream.end(messages);
+    })
+        .catch((error) => {
+        pushLoopFailure(stream, config, error, signal?.aborted === true);
+    });
+    return stream;
+}
+export function agentLoopContinue(context, config, signal, streamFn, runtime) {
+    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, runtime)
+        .then((messages) => {
+        stream.end(messages);
+    })
+        .catch((error) => {
+        pushLoopFailure(stream, config, error, signal?.aborted === true);
+    });
+    return stream;
+}
+export async function runAgentLoop(prompts, context, config, emit, signal, streamFn, runtime, trace) {
+    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, runtime, trace);
+    return newMessages;
+}
+export async function runAgentLoopContinue(context, config, emit, signal, streamFn, runtime, trace) {
+    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, runtime, trace);
+    return newMessages;
+}
+function createAgentStream() {
+    return new EventStreamConstructor((event) => event.type === "agent_end", (event) => (event.type === "agent_end" ? event.messages : []));
+}
+function createLoopFailureMessage(config, error, aborted) {
+    return {
+        role: "assistant",
+        content: [{ type: "text", text: "" }],
+        api: config.model.api,
+        provider: config.model.provider,
+        model: config.model.id,
+        usage: EMPTY_USAGE,
+        stopReason: aborted ? "aborted" : "error",
+        errorMessage: error instanceof Error ? error.message : String(error),
+        timestamp: Date.now(),
+    };
+}
+function pushLoopFailure(stream, config, error, aborted) {
+    const failureMessage = createLoopFailureMessage(config, error, aborted);
+    stream.push({ type: "message_start", message: failureMessage });
+    stream.push({ type: "message_end", message: failureMessage });
+    stream.push({ type: "turn_end", message: failureMessage, toolResults: [] });
+    stream.push({ type: "agent_end", messages: [failureMessage] });
+}
+const PROMPT_TOO_LONG_RE = /context.{0,3}length|context_length|context window (?:limit|exceeded)|reached its context window|prompt is too long|too many tokens|maximum context|exceeds? .{0,30}(?:context|token)|input is too long|\b413\b/i;
+function isBlankFailureContent(message) {
+    return message.content.every((c) => c.type === "text" ? c.text.trim() === "" : c.type === "thinking" ? c.thinking.trim() === "" : false);
+}
+function defaultDetectPromptTooLong(message) {
+    return message.stopReason === "error" && PROMPT_TOO_LONG_RE.test(message.errorMessage ?? "");
+}
+function createPtlWithholdBuffer(emit, detect) {
+    const held = [];
+    let liveStartEmitted = false;
+    const isCandidate = (message) => message.role === "assistant" &&
+        message.stopReason === "error" &&
+        detect(message) &&
+        isBlankFailureContent(message);
+    return {
+        sink: async (event) => {
+            if (event.type === "message_start" && isCandidate(event.message)) {
+                held.push(event);
+                return;
+            }
+            if (event.type === "message_end" && !liveStartEmitted && isCandidate(event.message)) {
+                held.push(event);
+                return;
+            }
+            if (event.type === "message_start")
+                liveStartEmitted = true;
+            await emit(event);
+        },
+        async flush() {
+            for (const event of held.splice(0))
+                await emit(event);
+        },
+        discard() {
+            held.length = 0;
+        },
+    };
+}
+function createMalformedToolUseNudge() {
+    return {
+        role: "custom",
+        customType: "loop:malformed-tool-use-retry",
+        content: "Your previous response indicated tool use but contained no valid tool call. Re-issue the tool call(s) now, with complete and valid JSON arguments — provide exactly one JSON value per parameter, and do not truncate.",
+        display: false,
+        timestamp: Date.now(),
+    };
+}
+function createThinkingOnlyNudge() {
+    return {
+        role: "custom",
+        customType: "loop:thinking-only-retry",
+        content: "Your previous response had no visible output — it contained only internal reasoning. Respond now with your answer as visible text (or make the required tool calls); do not end the turn with reasoning alone.",
+        display: false,
+        timestamp: Date.now(),
+    };
+}
+function createMidstreamPartialContinueNudge() {
+    return {
+        role: "custom",
+        customType: "loop:midstream-partial-continue",
+        content: "Your previous response was cut off mid-stream by a connection failure — the content above may be incomplete. Continue EXACTLY where you left off; do not repeat any content you already produced, do not re-introduce or summarize.",
+        display: false,
+        timestamp: Date.now(),
+    };
+}
+function createDegenerateRecoveryNudge() {
+    return {
+        role: "custom",
+        customType: "loop:degenerate-output-recovery",
+        content: "Your previous reply degenerated into repetition and was cut off. Do NOT repeat or continue that text. " +
+            "Take a DIFFERENT approach: state your next concrete step or conclusion in one short sentence, then proceed normally.",
+        display: false,
+        timestamp: Date.now(),
+    };
+}
+function createWalltimeCutoffRecoveryNudge() {
+    return {
+        role: "custom",
+        customType: "loop:walltime-cutoff-recovery",
+        content: "Your previous response crossed the task's wall-clock deadline and was cut off (the partial text above is preserved). " +
+            "This is the FINAL turn: write your best current answer / deliverables NOW in one short response — no new work, no long commands.",
+        display: false,
+        timestamp: Date.now(),
+    };
+}
+function createReasoningCutContinueNudge() {
+    return {
+        role: "custom",
+        customType: "loop:truncated-output-continue",
+        content: "Your previous response hit the output-token limit before producing any visible text (the budget went to internal reasoning). " +
+            "Do NOT restart the long reasoning: state your current best answer or next concrete action directly as visible text (or make the required tool call) now.",
+        display: false,
+        timestamp: Date.now(),
+    };
+}
+function createContinueNudge() {
+    return {
+        role: "custom",
+        customType: "loop:truncated-output-continue",
+        content: "Your previous response was cut off because it hit the output-token limit. Continue EXACTLY where you left off — do not repeat any content you already produced, do not re-introduce or summarize.",
+        display: false,
+        timestamp: Date.now(),
+    };
+}
+async function runLoop(initialContext, newMessages, initialConfig, signal, emit, streamFn, runtime, trace) {
+    const state = {
+        context: initialContext,
+        config: initialConfig,
+        newMessages,
+        firstTurn: true,
+        pendingMessages: (await initialConfig.getSteeringMessages?.()) || [],
+        hasMoreToolCalls: true,
+        truncatedOutputContinues: 0,
+        staticReasoningCutRecoveries: initialContext.messages.filter((m) => m.role === "assistant" && m.staticReasoningCut === true).length,
+        degenerateContinues: 0,
+        walltimeCutoffContinues: 0,
+        malformedToolUseRetries: 0,
+        thinkingOnlyRetries: 0,
+        midstreamPartialContinues: 0,
+    };
+    while (true) {
+        if (!state.hasMoreToolCalls && state.pendingMessages.length === 0) {
+            const followUpMessages = (await state.config.getFollowUpMessages?.()) || [];
+            if (followUpMessages.length === 0) {
+                trace?.({ kind: "terminal", reason: "completed" });
+                break;
+            }
+            state.pendingMessages = followUpMessages;
+            trace?.({ kind: "continue", reason: "follow_up_injected" });
+        }
+        const outcome = await runSingleTurn(state, signal, emit, streamFn, runtime, trace);
+        if (outcome.kind === "terminal") {
+            trace?.({ kind: "terminal", reason: outcome.reason });
+            return;
+        }
+        if (outcome.recovered) {
+            trace?.({ kind: "continue", reason: outcome.recovered });
+        }
+        else if (state.pendingMessages.length > 0) {
+            trace?.({ kind: "continue", reason: "steer_injected" });
+        }
+        else if (state.hasMoreToolCalls) {
+            trace?.({ kind: "continue", reason: "next_turn" });
+        }
+    }
+    await emit({ type: "agent_end", messages: state.newMessages });
+}
+const MAX_STATIC_REASONING_CUT_RECOVERIES = 2;
+async function runSingleTurn(state, signal, emit, streamFn, runtime, trace) {
+    if (signal?.aborted) {
+        await emit({ type: "agent_end", messages: state.newMessages });
+        return { kind: "terminal", reason: "aborted_before_stream" };
+    }
+    if (!state.firstTurn) {
+        await emit({ type: "turn_start" });
+    }
+    else {
+        state.firstTurn = false;
+    }
+    if (state.pendingMessages.length > 0) {
+        for (const message of state.pendingMessages) {
+            await emit({ type: "message_start", message });
+            await emit({ type: "message_end", message });
+            state.context.messages.push(message);
+            state.newMessages.push(message);
+        }
+    }
+    let executor = new StreamToolExecutor(state.context, state.config, signal, emit);
+    const staticReasoningCutDowngrade = state.config.recovery?.truncatedOutput !== undefined &&
+        state.staticReasoningCutRecoveries < MAX_STATIC_REASONING_CUT_RECOVERIES;
+    const ptl = state.config.recovery?.promptTooLong;
+    const ptlDetect = ptl?.detect ?? defaultDetectPromptTooLong;
+    const withholdEnabled = ptl !== undefined && (ptl.withholdErrorEvents ?? true);
+    let withhold = withholdEnabled ? createPtlWithholdBuffer(emit, ptlDetect) : undefined;
+    let message;
+    try {
+        message = await streamAssistantResponse(state.context, state.config, signal, withhold?.sink ?? emit, streamFn, runtime, executor, staticReasoningCutDowngrade);
+    }
+    finally {
+        await executor.settle();
+    }
+    {
+        if (ptl) {
+            const detect = ptlDetect;
+            const maxRetries = ptl.maxRetries ?? 2;
+            let attempt = 0;
+            while (message.stopReason === "error" &&
+                !signal?.aborted &&
+                detect(message) &&
+                isBlankFailureContent(message) &&
+                executor.admittedCount === 0 &&
+                attempt < maxRetries) {
+                attempt++;
+                if (state.context.messages[state.context.messages.length - 1] === message) {
+                    state.context.messages.pop();
+                }
+                let replaced;
+                try {
+                    replaced = await ptl.recover(state.context.messages, attempt);
+                }
+                catch {
+                    replaced = undefined;
+                }
+                if (!replaced) {
+                    state.context.messages.push(message);
+                    break;
+                }
+                withhold?.discard();
+                withhold = withholdEnabled ? createPtlWithholdBuffer(emit, ptlDetect) : undefined;
+                state.context.messages = replaced;
+                trace?.({ kind: "continue", reason: "reactive_compact_retry" });
+                executor = new StreamToolExecutor(state.context, state.config, signal, emit);
+                try {
+                    message = await streamAssistantResponse(state.context, state.config, signal, withhold?.sink ?? emit, streamFn, runtime, executor, staticReasoningCutDowngrade);
+                }
+                finally {
+                    await executor.settle();
+                }
+            }
+        }
+    }
+    await withhold?.flush();
+    state.newMessages.push(message);
+    if (message.staticReasoningCut === true)
+        state.staticReasoningCutRecoveries++;
+    {
+        const degen = state.config.recovery?.degenerateOutput;
+        if (degen &&
+            message.stopReason === "error" &&
+            !signal?.aborted &&
+            degen.detect(message) &&
+            executor.admittedCount === 0 &&
+            message.content.every((b) => b.type !== "toolCall") &&
+            state.degenerateContinues < (degen.maxContinues ?? 2)) {
+            state.degenerateContinues++;
+            await emit({ type: "turn_end", message, toolResults: [] });
+            const drained = (await state.config.getSteeringMessages?.()) || [];
+            state.pendingMessages = drained.length > 0 ? drained : [createDegenerateRecoveryNudge()];
+            return { kind: "ran", recovered: "degenerate_output_recovery" };
+        }
+        if (message.stopReason !== "error")
+            state.degenerateContinues = 0;
+    }
+    {
+        const wc = state.config.recovery?.walltimeCutoff;
+        if (wc &&
+            message.stopReason === "error" &&
+            !signal?.aborted &&
+            wc.detect(message) &&
+            executor.admittedCount === 0 &&
+            message.content.every((b) => b.type !== "toolCall") &&
+            state.walltimeCutoffContinues < (wc.maxContinues ?? 1)) {
+            state.walltimeCutoffContinues++;
+            await emit({ type: "turn_end", message, toolResults: [] });
+            const drained = (await state.config.getSteeringMessages?.()) || [];
+            state.pendingMessages = drained.length > 0 ? drained : [createWalltimeCutoffRecoveryNudge()];
+            return { kind: "ran", recovered: "walltime_cutoff_recovery" };
+        }
+    }
+    if (message.stopReason === "error" || message.stopReason === "aborted") {
+        const errorFinalResults = await harvestExecutorOnErrorFinal(executor, state, message, signal, emit);
+        if (state.config.recovery?.walltimeCutoff?.detect(message)) {
+            const covered = new Set(errorFinalResults.map((r) => r.toolCallId));
+            for (const tc of message.content.filter((c) => c.type === "toolCall")) {
+                if (covered.has(tc.id))
+                    continue;
+                const synthetic = {
+                    role: "toolResult",
+                    toolCallId: tc.id,
+                    toolName: tc.name,
+                    content: [{ type: "text", text: "[call aborted by walltime cutoff — never executed]" }],
+                    isError: true,
+                    timestamp: Date.now(),
+                };
+                await emitToolResultMessage(synthetic, emit);
+                state.context.messages.push(synthetic);
+                state.newMessages.push(synthetic);
+                errorFinalResults.push(synthetic);
+            }
+        }
+        await emit({ type: "turn_end", message, toolResults: errorFinalResults });
+        await emit({ type: "agent_end", messages: state.newMessages });
+        return { kind: "terminal", reason: "assistant_error" };
+    }
+    const toolCalls = message.content.filter((c) => c.type === "toolCall");
+    const toolResults = [];
+    state.hasMoreToolCalls = false;
+    if (toolCalls.length > 0) {
+        const executedToolBatch = await executeToolCalls(state.context, message, state.config, signal, emit, executor);
+        toolResults.push(...executedToolBatch.messages);
+        state.hasMoreToolCalls = !executedToolBatch.terminate;
+        for (const result of toolResults) {
+            state.context.messages.push(result);
+            state.newMessages.push(result);
+        }
+    }
+    else {
+        for (const orphan of executor.remaining()) {
+            executor.take(orphan.toolCall.id);
+            await closeOrphanedStreamEntry(orphan, emit);
+        }
+    }
+    await emit({ type: "turn_end", message, toolResults });
+    const nextTurnContext = {
+        message,
+        toolResults,
+        context: state.context,
+        newMessages: state.newMessages,
+    };
+    const nextTurnSnapshot = await state.config.prepareNextTurn?.(nextTurnContext);
+    if (nextTurnSnapshot) {
+        state.context = nextTurnSnapshot.context ?? state.context;
+        state.config = Object.assign({}, state.config, {
+            model: nextTurnSnapshot.model ?? state.config.model,
+            reasoning: nextTurnSnapshot.thinkingLevel === undefined
+                ? state.config.reasoning
+                : nextTurnSnapshot.thinkingLevel === "off"
+                    ? undefined
+                    : nextTurnSnapshot.thinkingLevel,
+        });
+    }
+    if (await state.config.shouldStopAfterTurn?.({
+        message,
+        toolResults,
+        context: state.context,
+        newMessages: state.newMessages,
+    })) {
+        await emit({ type: "agent_end", messages: state.newMessages });
+        return { kind: "terminal", reason: "stop_requested" };
+    }
+    state.pendingMessages = (await state.config.getSteeringMessages?.()) || [];
+    const truncated = state.config.recovery?.truncatedOutput;
+    if (message.stopReason === "length") {
+        if (truncated &&
+            toolCalls.length === 0 &&
+            state.pendingMessages.length === 0 &&
+            state.truncatedOutputContinues < (truncated.maxContinues ?? 3)) {
+            state.truncatedOutputContinues++;
+            state.midstreamPartialContinues = 0;
+            const noVisibleText = !message.content.some((c) => c.type === "text" && c.text.trim() !== "");
+            state.pendingMessages = [...state.pendingMessages, noVisibleText ? createReasoningCutContinueNudge() : createContinueNudge()];
+            return { kind: "ran", recovered: "max_output_tokens_recovery" };
+        }
+    }
+    else {
+        state.truncatedOutputContinues = 0;
+    }
+    if (message.stopReason === "stop" && message.partialFinalized === true) {
+        if (toolCalls.length === 0 &&
+            state.pendingMessages.length === 0 &&
+            state.midstreamPartialContinues < 3) {
+            state.midstreamPartialContinues++;
+            state.pendingMessages = [createMidstreamPartialContinueNudge()];
+            return { kind: "ran", recovered: "midstream_partial_recovery" };
+        }
+    }
+    else {
+        state.midstreamPartialContinues = 0;
+    }
+    const malformed = state.config.recovery?.malformedToolUse;
+    if (malformed &&
+        message.stopReason === "toolUse" &&
+        toolCalls.length === 0 &&
+        state.pendingMessages.length === 0 &&
+        state.malformedToolUseRetries < (malformed.maxRetries ?? 1)) {
+        state.malformedToolUseRetries++;
+        state.pendingMessages = [createMalformedToolUseNudge()];
+        return { kind: "ran", recovered: "malformed_tool_use_retry" };
+    }
+    const thinkingOnly = state.config.recovery?.thinkingOnly;
+    if (thinkingOnly &&
+        message.stopReason === "stop" &&
+        toolCalls.length === 0 &&
+        state.pendingMessages.length === 0 &&
+        state.thinkingOnlyRetries < (thinkingOnly.maxRetries ?? 1) &&
+        message.content.some((c) => c.type === "thinking") &&
+        !message.content.some((c) => c.type === "text" && c.text.trim() !== "")) {
+        state.thinkingOnlyRetries++;
+        state.pendingMessages = [createThinkingOnlyNudge()];
+        return { kind: "ran", recovered: "thinking_only_retry" };
+    }
+    return { kind: "ran" };
+}
+async function streamAssistantResponse(context, config, signal, emit, streamFn, runtime, executor, staticReasoningCutDowngrade) {
+    let messages = context.messages;
+    if (config.transformContext) {
+        messages = await config.transformContext(messages, signal);
+    }
+    const llmMessages = await config.convertToLlm(messages);
+    const llmContext = {
+        systemPrompt: context.systemPrompt,
+        messages: llmMessages,
+        tools: context.tools,
+    };
+    const streamFunction = resolveAgentCoreStreamFn(runtime, streamFn);
+    const resolvedApiKey = (config.getApiKey ? await config.getApiKey(config.model.provider) : undefined) || config.apiKey;
+    const perCallMaxTokens = config.maxTokensPerCall?.();
+    const perCallDeadlineMs = config.callDeadlineMsPerCall?.();
+    const response = await streamFunction(config.model, llmContext, {
+        ...config,
+        ...(perCallMaxTokens !== undefined ? { maxTokens: perCallMaxTokens, maxTokensDynamic: true } : {}),
+        ...(perCallDeadlineMs !== undefined ? { callDeadlineMs: perCallDeadlineMs } : {}),
+        ...(staticReasoningCutDowngrade === true ? { staticReasoningCutDowngrade: true } : {}),
+        apiKey: resolvedApiKey,
+        signal,
+    });
+    let partialMessage = null;
+    let addedPartial = false;
+    for await (const event of response) {
+        switch (event.type) {
+            case "start": {
+                const message = event.partial;
+                partialMessage = message;
+                context.messages.push(message);
+                addedPartial = true;
+                await emit({ type: "message_start", message: { ...message } });
+                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) {
+                    const message = resolveAssistantMessageUpdate(event, partialMessage);
+                    partialMessage = message;
+                    context.messages[context.messages.length - 1] = message;
+                    await emit({
+                        type: "message_update",
+                        assistantMessageEvent: event,
+                        message: { ...message },
+                    });
+                }
+                if (event.type === "toolcall_end" && executor) {
+                    executor.maybeAdmit(event.toolCall, partialMessage);
+                }
+                break;
+            case "done":
+            case "error": {
+                const finalMessage = await response.result();
+                if (executor && (finalMessage.stopReason === "error" || finalMessage.stopReason === "aborted")) {
+                    mergeBackAdmittedCalls(finalMessage, executor);
+                }
+                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 (executor && (finalMessage.stopReason === "error" || finalMessage.stopReason === "aborted")) {
+        mergeBackAdmittedCalls(finalMessage, executor);
+    }
+    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;
+}
+async function executeToolCalls(currentContext, assistantMessage, config, signal, emit, executor) {
+    const toolCalls = assistantMessage.content.filter((c) => c.type === "toolCall");
+    if (config.toolExecution === "sequential") {
+        return executeToolCallsSequential(currentContext, assistantMessage, toolCalls, config, signal, emit);
+    }
+    return executeToolCallsPartitioned(currentContext, assistantMessage, toolCalls, config, signal, emit, executor);
+}
+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),
+    };
+}
+function isCallConcurrencySafe(tool, args) {
+    if (!tool)
+        return false;
+    if (tool.executionMode === "parallel")
+        return true;
+    if (!tool.isConcurrencySafe)
+        return false;
+    try {
+        return tool.isConcurrencySafe(args) === true;
+    }
+    catch {
+        return false;
+    }
+}
+function isBatchSafeToolCall(tool, toolCall) {
+    if (!tool)
+        return false;
+    let args;
+    try {
+        args = validateToolArguments(tool, prepareToolCallArguments(tool, toolCall));
+    }
+    catch {
+        return false;
+    }
+    return isCallConcurrencySafe(tool, args);
+}
+function partitionToolCalls(toolCalls, tools) {
+    const batches = [];
+    for (const tc of toolCalls) {
+        const safe = isBatchSafeToolCall(findToolByName(tools, tc.name), tc);
+        const last = batches[batches.length - 1];
+        if (safe && last?.safe) {
+            last.calls.push(tc);
+        }
+        else {
+            batches.push({ safe, calls: [tc] });
+        }
+    }
+    return batches;
+}
+async function runCapped(thunks, limit) {
+    const results = new Array(thunks.length);
+    let next = 0;
+    const workers = Array.from({ length: Math.max(1, Math.min(limit, thunks.length)) }, async () => {
+        while (next < thunks.length) {
+            const i = next++;
+            results[i] = await thunks[i]();
+        }
+    });
+    await Promise.all(workers);
+    return results;
+}
+async function executeToolCallsPartitioned(currentContext, assistantMessage, toolCalls, config, signal, emit, executor) {
+    const cap = config.maxToolConcurrency ?? 10;
+    const allFinalized = [];
+    const messages = [];
+    const remainingCalls = [];
+    for (const toolCall of toolCalls) {
+        const held = executor?.take(toolCall.id);
+        if (!held) {
+            remainingCalls.push(toolCall);
+            continue;
+        }
+        const finalized = await finalizeStreamEntry(currentContext, assistantMessage, held, config, signal);
+        await emitToolExecutionEnd(finalized, emit);
+        const toolResultMessage = createToolResultMessage(finalized);
+        await emitToolResultMessage(toolResultMessage, emit);
+        allFinalized.push(finalized);
+        messages.push(toolResultMessage);
+    }
+    if (executor) {
+        for (const orphan of executor.remaining()) {
+            executor.take(orphan.toolCall.id);
+            await closeOrphanedStreamEntry(orphan, emit);
+        }
+    }
+    const batches = partitionToolCalls(remainingCalls, currentContext.tools);
+    outer: for (const batch of batches) {
+        if (signal?.aborted)
+            break;
+        const entries = [];
+        for (const toolCall of batch.calls) {
+            await emit({
+                type: "tool_execution_start",
+                toolCallId: toolCall.id,
+                toolName: toolCall.name,
+                args: toolCall.arguments,
+            });
+            const preparation = await prepareToolCall(currentContext, assistantMessage, toolCall, config, signal);
+            if (preparation.kind === "immediate") {
+                const finalized = { toolCall, result: preparation.result, isError: preparation.isError };
+                await emitToolExecutionEnd(finalized, emit);
+                entries.push({ finalized, toolCall });
+            }
+            else {
+                entries.push({ prepared: preparation, toolCall });
+            }
+            if (signal?.aborted) {
+                await settleBatch(entries, true);
+                break outer;
+            }
+        }
+        await settleBatch(entries, batch.safe);
+    }
+    return { messages, terminate: shouldTerminateToolBatch(allFinalized) };
+    async function settleBatch(entries, concurrent) {
+        const runOne = (prepared) => async () => {
+            const executed = await executePreparedToolCall(prepared, signal, emit);
+            const finalized = await finalizeExecutedToolCall(currentContext, assistantMessage, prepared, executed, config, signal);
+            await emitToolExecutionEnd(finalized, emit);
+            return finalized;
+        };
+        const preparedEntries = entries.filter((e) => e.prepared);
+        let executedResults;
+        if (concurrent && preparedEntries.length > 1) {
+            executedResults = await runCapped(preparedEntries.map((e) => runOne(e.prepared)), cap);
+        }
+        else {
+            executedResults = [];
+            for (const e of preparedEntries) {
+                executedResults.push(await runOne(e.prepared)());
+            }
+        }
+        let idx = 0;
+        for (const e of entries) {
+            const finalized = e.finalized ?? executedResults[idx++];
+            if (!finalized)
+                continue;
+            allFinalized.push(finalized);
+            const toolResultMessage = createToolResultMessage(finalized);
+            await emitToolResultMessage(toolResultMessage, emit);
+            messages.push(toolResultMessage);
+        }
+    }
+}
+class StreamToolExecutor {
+    context;
+    config;
+    signal;
+    emit;
+    entries = new Map();
+    admittedOrder = [];
+    barrier = false;
+    inFlight = 0;
+    constructor(context, config, signal, emit) {
+        this.context = context;
+        this.config = config;
+        this.signal = signal;
+        this.emit = emit;
+    }
+    get admittedCount() {
+        return this.admittedOrder.length;
+    }
+    admittedToolCalls() {
+        return this.admittedOrder.map((id) => this.entries.get(id)?.toolCall).filter((tc) => tc !== undefined);
+    }
+    maybeAdmit(toolCall, partialAssistant) {
+        if (this.barrier)
+            return;
+        if (this.config.streamingToolExecution !== true ||
+            this.config.toolExecution === "sequential" ||
+            this.signal?.aborted ||
+            partialAssistant === null ||
+            !isBatchSafeToolCall(findToolByName(this.context.tools, toolCall.name), toolCall) ||
+            this.inFlight >= (this.config.maxToolConcurrency ?? 10) ||
+            this.entries.has(toolCall.id)) {
+            this.barrier = true;
+            return;
+        }
+        const entry = { toolCall, promise: Promise.resolve() };
+        this.entries.set(toolCall.id, entry);
+        this.admittedOrder.push(toolCall.id);
+        entry.promise = this.runOne(entry, partialAssistant);
+    }
+    async runOne(entry, partialAssistant) {
+        this.inFlight++;
+        try {
+            await this.emit({
+                type: "tool_execution_start",
+                toolCallId: entry.toolCall.id,
+                toolName: entry.toolCall.name,
+                args: entry.toolCall.arguments,
+            });
+            const preparation = await prepareToolCall(this.context, partialAssistant, entry.toolCall, this.config, this.signal);
+            if (preparation.kind === "immediate") {
+                entry.immediate = preparation;
+                return;
+            }
+            entry.prepared = preparation;
+            entry.executed = await executePreparedToolCall(preparation, this.signal, this.emit);
+        }
+        catch (error) {
+            entry.immediate = {
+                kind: "immediate",
+                result: createErrorToolResult(error instanceof Error ? error.message : String(error)),
+                isError: true,
+            };
+        }
+        finally {
+            this.inFlight--;
+        }
+    }
+    async settle() {
+        this.barrier = true;
+        await Promise.all([...this.entries.values()].map((e) => e.promise));
+    }
+    take(id) {
+        const entry = this.entries.get(id);
+        if (entry)
+            this.entries.delete(id);
+        return entry;
+    }
+    remaining() {
+        return this.admittedOrder
+            .map((id) => this.entries.get(id))
+            .filter((e) => e !== undefined);
+    }
+}
+async function finalizeStreamEntry(currentContext, assistantMessage, entry, config, signal) {
+    if (entry.prepared && entry.executed) {
+        return finalizeExecutedToolCall(currentContext, assistantMessage, entry.prepared, entry.executed, config, signal);
+    }
+    const immediate = entry.immediate ?? {
+        kind: "immediate",
+        result: createErrorToolResult("in-stream execution produced no outcome"),
+        isError: true,
+    };
+    return { toolCall: entry.toolCall, result: immediate.result, isError: immediate.isError };
+}
+async function closeOrphanedStreamEntry(entry, emit) {
+    await emit({
+        type: "tool_execution_end",
+        toolCallId: entry.toolCall.id,
+        toolName: entry.toolCall.name,
+        result: createErrorToolResult("in-stream result dropped: the call is missing from the final assistant content (provider contract breach)"),
+        isError: true,
+    });
+}
+async function harvestExecutorOnErrorFinal(executor, state, finalMessage, signal, emit) {
+    const held = executor.remaining();
+    if (held.length === 0)
+        return [];
+    const results = [];
+    const persistedCallIds = new Set(finalMessage.content.filter((c) => c.type === "toolCall").map((c) => c.id));
+    for (const entry of held) {
+        executor.take(entry.toolCall.id);
+        if (!persistedCallIds.has(entry.toolCall.id)) {
+            await closeOrphanedStreamEntry(entry, emit);
+            continue;
+        }
+        const finalized = await finalizeStreamEntry(state.context, finalMessage, entry, state.config, signal);
+        await emitToolExecutionEnd(finalized, emit);
+        const toolResultMessage = createToolResultMessage(finalized);
+        await emitToolResultMessage(toolResultMessage, emit);
+        state.context.messages.push(toolResultMessage);
+        state.newMessages.push(toolResultMessage);
+        results.push(toolResultMessage);
+    }
+    return results;
+}
+function mergeBackAdmittedCalls(finalMessage, executor) {
+    const admitted = executor.admittedToolCalls();
+    if (admitted.length === 0)
+        return;
+    const present = new Set(finalMessage.content.filter((c) => c.type === "toolCall").map((c) => c.id));
+    const missing = admitted.filter((tc) => !present.has(tc.id));
+    if (missing.length === 0)
+        return;
+    finalMessage.content = [...finalMessage.content, ...missing];
+}
+function shouldTerminateToolBatch(finalizedCalls) {
+    return (finalizedCalls.length > 0 &&
+        finalizedCalls.every((finalized) => finalized.result.terminate === true));
+}
+function prepareToolCallArguments(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 prepareToolCall(currentContext, assistantMessage, toolCall, config, signal) {
+    const tool = findToolByName(currentContext.tools, toolCall.name);
+    if (!tool) {
+        const tombstone = TOMBSTONED_TOOLS[toolCall.name];
+        if (tombstone !== undefined) {
+            return {
+                kind: "immediate",
+                result: createErrorToolResult(tombstone),
+                isError: true,
+            };
+        }
+        const available = (currentContext.tools ?? []).map((t) => t.name).join(", ");
+        return {
+            kind: "immediate",
+            result: createErrorToolResult(`Tool ${toolCall.name} not found.${available ? ` Available tools: ${available}` : ""}`),
+            isError: true,
+        };
+    }
+    try {
+        const preparedToolCall = prepareToolCallArguments(tool, toolCall);
+        let finalArgs = validateToolArguments(tool, preparedToolCall);
+        if (config.beforeToolCall) {
+            const beforeResult = await config.beforeToolCall({
+                assistantMessage,
+                toolCall,
+                args: finalArgs,
+                context: currentContext,
+            }, signal);
+            if (signal?.aborted) {
+                return {
+                    kind: "immediate",
+                    result: createErrorToolResult("Operation aborted"),
+                    isError: true,
+                };
+            }
+            if (beforeResult?.block) {
+                return {
+                    kind: "immediate",
+                    result: createErrorToolResult(beforeResult.reason || "Tool execution was blocked"),
+                    isError: true,
+                };
+            }
+            if (beforeResult?.updatedInput !== undefined) {
+                finalArgs = validateToolArguments(tool, {
+                    ...preparedToolCall,
+                    arguments: beforeResult.updatedInput,
+                });
+            }
+        }
+        if (signal?.aborted) {
+            return {
+                kind: "immediate",
+                result: createErrorToolResult("Operation aborted"),
+                isError: true,
+            };
+        }
+        return {
+            kind: "prepared",
+            toolCall,
+            tool,
+            args: finalArgs,
+        };
+    }
+    catch (error) {
+        return {
+            kind: "immediate",
+            result: createErrorToolResult(error instanceof Error ? error.message : String(error)),
+            isError: true,
+        };
+    }
+}
+async function executePreparedToolCall(prepared, signal, emit) {
+    const updateEvents = [];
+    let acceptingUpdates = true;
+    if (signal?.aborted) {
+        return { result: createErrorToolResult("operation aborted before execution"), isError: 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,
+        };
+    }
+}
+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 = {
+                    content: afterResult.content ?? result.content,
+                    details: afterResult.details ?? result.details,
+                    terminate: afterResult.terminate ?? result.terminate,
+                };
+                isError = afterResult.isError ?? isError;
+            }
+        }
+        catch (error) {
+            const note = `[post-tool processing failed (the tool already executed): ${error instanceof Error ? error.message : String(error)}]`;
+            result = { ...result, content: [...result.content, { type: "text", text: note }] };
+        }
+    }
+    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,
+        content: finalized.result.content,
+        details: finalized.result.details,
+        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