@ponythewhite/base-context-agent 1.0.0

package/dist/agent-loop.js

@@ -0,0 +1,897 @@
+/**
+ * Agent loop that works with AgentMessage throughout.
+ * Transforms to Message[] only at the LLM call boundary.
+ */
+import { EventStream, isLocalRequestPreparationError, markLocalRequestPreparationError, streamSimple, validateToolArguments, } from "@ponythewhite/base-context-ai";
+import { AgentOutputLimitError, InvocationOutput } from "./invocation-output.js";
+const ABORT_ERROR_MESSAGE = "Request was aborted";
+const EMPTY_USAGE = {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    totalTokens: 0,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+};
+function createAbortError() {
+    return new Error(ABORT_ERROR_MESSAGE);
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted) {
+        throw createAbortError();
+    }
+}
+function raceWithAbort(operation, signal, onAbort) {
+    if (!signal) {
+        return operation;
+    }
+    if (signal.aborted) {
+        onAbort?.();
+        void operation.catch(() => undefined);
+        return Promise.reject(createAbortError());
+    }
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const cleanup = () => {
+            signal.removeEventListener("abort", abort);
+        };
+        const abort = () => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            cleanup();
+            onAbort?.();
+            reject(createAbortError());
+        };
+        signal.addEventListener("abort", abort, { once: true });
+        operation.then((value) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            cleanup();
+            resolve(value);
+        }, (error) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            cleanup();
+            reject(error);
+        });
+    });
+}
+function maybePromiseWithAbort(operation, signal, onAbort) {
+    return raceWithAbort(Promise.resolve(operation), signal, onAbort);
+}
+function isAbortError(error) {
+    return error instanceof Error && (error.message === ABORT_ERROR_MESSAGE || error.name === "AbortError");
+}
+async function settlePostTurn(operation, signal) {
+    try {
+        return { status: "completed", value: await operation };
+    }
+    catch (error) {
+        if (signal?.aborted && isAbortError(error)) {
+            return { status: "aborted" };
+        }
+        throw error;
+    }
+}
+function cloneAssistantContent(content) {
+    return content.map((part) => {
+        if (part.type === "toolCall") {
+            return { ...part, arguments: { ...part.arguments } };
+        }
+        return { ...part };
+    });
+}
+function cloneUsage(usage) {
+    return { ...usage, cost: { ...usage.cost } };
+}
+function createAbortedAssistantMessage(config, partialMessage) {
+    return {
+        role: "assistant",
+        content: partialMessage ? cloneAssistantContent(partialMessage.content) : [{ type: "text", text: "" }],
+        api: partialMessage?.api ?? config.model.api,
+        provider: partialMessage?.provider ?? config.model.provider,
+        model: partialMessage?.model ?? config.model.id,
+        usage: cloneUsage(partialMessage?.usage ?? EMPTY_USAGE),
+        stopReason: "aborted",
+        errorMessage: ABORT_ERROR_MESSAGE,
+        timestamp: Date.now(),
+    };
+}
+function getTerminalMessage(event) {
+    return event.type === "done" ? event.message : event.error;
+}
+function endAgentStreamOnError(stream, promise) {
+    void promise.then((messages) => {
+        stream.end(messages);
+    }, (error) => {
+        if (error instanceof AgentOutputLimitError)
+            stream.fail(error);
+        else
+            stream.end([]);
+    });
+}
+async function pollMessagesUnlessAborted(poll, signal) {
+    if (!poll || signal?.aborted) {
+        return [];
+    }
+    return (await maybePromiseWithAbort(poll(), signal)) || [];
+}
+/**
+ * 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();
+    endAgentStreamOnError(stream, runAgentLoop(prompts, context, config, async (event) => {
+        stream.push(event);
+    }, signal, streamFn));
+    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();
+    endAgentStreamOnError(stream, runAgentLoopContinue(context, config, async (event) => {
+        stream.push(event);
+    }, signal, streamFn));
+    return stream;
+}
+async function withInvocationOutput(messages, config, emit, run) {
+    const output = config.outputPolicy ? new InvocationOutput(config.outputPolicy, messages) : undefined;
+    let releaseUpdates = output ? output.policy.bindUpdates?.(output.refresh.bind(output)) : undefined;
+    const stopUpdates = () => {
+        const release = releaseUpdates;
+        releaseUpdates = undefined;
+        release?.();
+    };
+    let updateSettlement;
+    const settleUpdates = () => {
+        if (!updateSettlement) {
+            try {
+                updateSettlement = output?.policy.settleUpdates?.() ?? Promise.resolve();
+            }
+            catch (error) {
+                updateSettlement = Promise.reject(error);
+            }
+        }
+        return updateSettlement;
+    };
+    const ownedEmit = output
+        ? async (event) => {
+            if (event.type === "agent_end") {
+                await settleUpdates();
+                output.throwIfRefused();
+                const finalizedMessages = output.copy();
+                stopUpdates();
+                await emit({ type: "agent_end", messages: finalizedMessages });
+            }
+            else {
+                await emit(event);
+                // The native sink joins this message's replacement/persistence job. Keep its original subject.
+                if (event.type === "message_end")
+                    output.capture(event.message);
+            }
+        }
+        : emit;
+    try {
+        await run(ownedEmit, output);
+        return messages;
+    }
+    catch (error) {
+        if (!output)
+            throw error;
+        let failure = error;
+        try {
+            await settleUpdates();
+        }
+        catch (settlementError) {
+            if (settlementError !== failure)
+                failure = new AggregateError([failure, settlementError], "Invocation and accepted update settlement failed", { cause: failure });
+        }
+        if (!output.refusal)
+            throw failure;
+        let cause = failure instanceof AgentOutputLimitError ? failure.cause : failure;
+        stopUpdates();
+        try {
+            await emit({ type: "agent_end", refusal: { ...output.refusal } });
+        }
+        catch (notificationError) {
+            cause =
+                cause === undefined
+                    ? notificationError
+                    : new AggregateError([cause, notificationError], "Output refusal and terminal notification failed");
+        }
+        throw new AgentOutputLimitError({ ...output.refusal }, cause === undefined ? undefined : { cause });
+    }
+    finally {
+        try {
+            stopUpdates();
+        }
+        finally {
+            output?.dispose();
+        }
+    }
+}
+export async function runAgentLoop(prompts, context, config, emit, signal, streamFn) {
+    const newMessages = config.outputPolicy ? [] : [...prompts];
+    return withInvocationOutput(newMessages, config, emit, async (ownedEmit, output) => {
+        if (output) {
+            output.checkRoom(prompts.length);
+            prompts = [...prompts];
+        }
+        // Keep only the working wrapper across awaits, not the initial snapshot.
+        context = { ...context, messages: [...context.messages, ...prompts] };
+        await ownedEmit({ type: "agent_start" });
+        await ownedEmit({ type: "turn_start" });
+        for (const prompt of prompts) {
+            await ownedEmit({ type: "message_start", message: prompt });
+            await ownedEmit({ type: "message_end", message: prompt });
+            output?.throwIfRefused();
+        }
+        await runLoop(context, newMessages, config, signal, ownedEmit, streamFn, output);
+    });
+}
+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 = [];
+    return withInvocationOutput(newMessages, config, emit, async (ownedEmit, output) => {
+        context = { ...context };
+        await ownedEmit({ type: "agent_start" });
+        output?.throwIfRefused();
+        await ownedEmit({ type: "turn_start" });
+        await runLoop(context, newMessages, config, signal, ownedEmit, streamFn, output);
+    });
+}
+function createAgentStream() {
+    return new EventStream((event) => event.type === "agent_end" && !event.refusal, (event) => (event.type === "agent_end" && !event.refusal ? event.messages : []));
+}
+async function runLoop(currentContext, newMessages, config, signal, emit, streamFn, output) {
+    let firstTurn = true;
+    let lastTurn;
+    let pendingMessages = await pollMessagesUnlessAborted(config.getSteeringMessages, signal);
+    const shouldStopBeforeTurn = () => !firstTurn && (config.shouldStopBeforeTurn?.() ?? false);
+    while (true) {
+        throwIfAborted(signal);
+        let hasMoreToolCalls = true;
+        while (hasMoreToolCalls || pendingMessages.length > 0) {
+            throwIfAborted(signal);
+            if (!firstTurn) {
+                await emit({ type: "turn_start" });
+            }
+            else {
+                firstTurn = false;
+            }
+            if (pendingMessages.length > 0) {
+                output?.checkRoom(pendingMessages.length);
+                if (output)
+                    pendingMessages = [...pendingMessages];
+                for (const message of pendingMessages) {
+                    await emit({ type: "message_start", message });
+                    await emit({ type: "message_end", message });
+                    currentContext.messages.push(message);
+                    if (!output)
+                        newMessages.push(message);
+                    output?.throwIfRefused();
+                }
+                pendingMessages = [];
+            }
+            output?.checkRoom(1);
+            const message = await streamAssistantResponse(currentContext, config, signal, emit, streamFn);
+            if (!output)
+                newMessages.push(message);
+            output?.throwIfRefused();
+            if (message.stopReason === "error" || message.stopReason === "aborted") {
+                await emit({
+                    type: "turn_end",
+                    message,
+                    toolResults: [],
+                    toolExecution: config.toolExecution ?? "parallel",
+                    exchanges: [],
+                });
+                output?.refresh(message);
+                if (message.stopReason === "error" &&
+                    config.recoverProviderFailure &&
+                    (await maybePromiseWithAbort(config.recoverProviderFailure(message, signal), signal))) {
+                    // Retain and charge the failed output; only omit it from the next request.
+                    currentContext.messages = currentContext.messages.filter((candidate) => candidate !== message);
+                    hasMoreToolCalls = true;
+                    continue;
+                }
+                await emit({ type: "agent_end", messages: newMessages });
+                return;
+            }
+            const toolCalls = message.content.filter((c) => c.type === "toolCall");
+            const toolResults = [];
+            const exchanges = [];
+            let toolExecution = config.toolExecution ?? "parallel";
+            hasMoreToolCalls = false;
+            if (toolCalls.length > 0) {
+                output?.checkRoom(toolCalls.length);
+                const executedToolBatch = await executeToolCalls(currentContext, message, config, signal, emit, output);
+                toolResults.push(...executedToolBatch.messages);
+                exchanges.push(...executedToolBatch.exchanges);
+                toolExecution = executedToolBatch.toolExecution;
+                hasMoreToolCalls = !executedToolBatch.terminate;
+                for (const result of toolResults) {
+                    currentContext.messages.push(result);
+                    if (!output)
+                        newMessages.push(result);
+                }
+            }
+            output?.throwIfRefused();
+            await emit({ type: "turn_end", message, toolResults, toolExecution, exchanges });
+            output?.refresh(message);
+            for (const result of toolResults)
+                output?.refresh(result);
+            output?.throwIfRefused();
+            if (signal?.aborted) {
+                await emit({ type: "agent_end", messages: newMessages });
+                return;
+            }
+            lastTurn = {
+                message,
+                toolResults,
+                context: currentContext,
+                newMessages,
+            };
+            const turnContext = { ...lastTurn, newMessages: output?.copy() ?? newMessages };
+            const shouldStopResult = await settlePostTurn(maybePromiseWithAbort(config.getTurnOutcome
+                ? config.getTurnOutcome({ ...turnContext, hasMoreToolCalls }, signal)
+                : Promise.resolve(config.shouldStopAfterTurn?.(turnContext) ?? false).then((stop) => ({
+                    kind: stop ? "finish" : "proceed",
+                })), signal), signal);
+            output?.refresh(message);
+            for (const result of toolResults)
+                output?.refresh(result);
+            output?.throwIfRefused();
+            if (shouldStopResult.status === "aborted") {
+                await emit({ type: "agent_end", messages: newMessages });
+                return;
+            }
+            if (shouldStopResult.value.kind !== "proceed" || shouldStopBeforeTurn()) {
+                await emit({ type: "agent_end", messages: newMessages });
+                return;
+            }
+            const steeringMessagesResult = await settlePostTurn(pollMessagesUnlessAborted(config.getSteeringMessages, signal), signal);
+            if (steeringMessagesResult.status === "aborted") {
+                await emit({ type: "agent_end", messages: newMessages });
+                return;
+            }
+            pendingMessages = steeringMessagesResult.value;
+            // Steering drained by this poll owns the turn boundary; stop only when it was empty.
+            if (pendingMessages.length === 0 && shouldStopBeforeTurn()) {
+                await emit({ type: "agent_end", messages: newMessages });
+                return;
+            }
+        }
+        if (shouldStopBeforeTurn())
+            break;
+        const followUpMessagesResult = await settlePostTurn(pollMessagesUnlessAborted(config.getFollowUpMessages, signal), signal);
+        if (followUpMessagesResult.status === "aborted") {
+            await emit({ type: "agent_end", messages: newMessages });
+            return;
+        }
+        const followUpMessages = followUpMessagesResult.value;
+        if (followUpMessages.length > 0) {
+            pendingMessages = followUpMessages;
+            continue;
+        }
+        if (shouldStopBeforeTurn())
+            break;
+        if (lastTurn && config.getContinuationOutcome) {
+            const outcome = await settlePostTurn(maybePromiseWithAbort(config.getContinuationOutcome(output ? { ...lastTurn, newMessages: output.copy() } : lastTurn, signal), signal), signal);
+            if (outcome.status === "completed" && outcome.value.kind === "continue") {
+                pendingMessages = outcome.value.messages;
+                continue;
+            }
+            break;
+        }
+        const continuationMessagesResult = lastTurn
+            ? await settlePostTurn(maybePromiseWithAbort(config.getContinuationMessages?.(output ? { ...lastTurn, newMessages: output.copy() } : lastTurn, signal) ?? [], signal), signal)
+            : { status: "completed", value: [] };
+        if (continuationMessagesResult.status === "aborted") {
+            await emit({ type: "agent_end", messages: newMessages });
+            return;
+        }
+        const continuationMessages = continuationMessagesResult.value || [];
+        if (continuationMessages.length > 0) {
+            pendingMessages = continuationMessages;
+            continue;
+        }
+        break;
+    }
+    await emit({ type: "agent_end", messages: newMessages });
+}
+async function streamAssistantResponse(context, config, signal, emit, streamFn, allowRecovery = true) {
+    const build = { projection: undefined };
+    let addedPartial = false;
+    const runResponse = async () => {
+        let partialMessage = null;
+        const finishAbortedMessage = async () => {
+            const finalMessage = createAbortedAssistantMessage(config, partialMessage);
+            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;
+        };
+        try {
+            throwIfAborted(signal);
+            // Do not race source persistence against cancellation; drain it before leaving this build.
+            const projection = await config.beforeContextBuild?.();
+            build.projection = projection;
+            if (projection && projection.adoptMessages === true) {
+                context.messages = projection.messages.slice();
+                await config.onContextAdopted?.(context.messages);
+            }
+            throwIfAborted(signal);
+            let messages = projection ? projection.messages.slice() : context.messages;
+            if (config.transformContext) {
+                messages = await maybePromiseWithAbort(config.transformContext(messages, signal), signal);
+            }
+            const llmMessages = await maybePromiseWithAbort(config.convertToLlm(messages), signal);
+            const streamFunction = streamFn || streamSimple;
+            const resolvedApiKey = (config.getApiKey
+                ? await maybePromiseWithAbort(config.getApiKey(config.model.provider), signal)
+                : undefined) || config.apiKey;
+            const llmContext = {
+                systemPrompt: config.getSystemPrompt?.() ?? context.systemPrompt,
+                messages: llmMessages,
+                tools: context.tools,
+            };
+            const { beforeContextBuild: _beforeContextBuild, onContextAdopted: _onContextAdopted, recoverRequestPreparation: _recoverRequestPreparation, recoverProviderFailure: _recoverProviderFailure, outputPolicy: _outputPolicy, ownedStreamFn, ...streamOptions } = config;
+            const options = { ...streamOptions, apiKey: resolvedApiKey, signal };
+            const response = await maybePromiseWithAbort(ownedStreamFn
+                ? ownedStreamFn(config.model, llmContext, options, projection ? projection.streamContext : undefined)
+                : streamFunction(config.model, llmContext, options), signal);
+            const iterator = response[Symbol.asyncIterator]();
+            const closeIterator = () => {
+                void Promise.resolve(iterator.return?.()).catch(() => undefined);
+            };
+            while (true) {
+                const next = await raceWithAbort(iterator.next(), signal, closeIterator);
+                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;
+                            context.messages[context.messages.length - 1] = partialMessage;
+                            await emit({
+                                type: "message_update",
+                                assistantMessageEvent: event,
+                                message: { ...partialMessage },
+                            });
+                        }
+                        break;
+                    case "done":
+                    case "error": {
+                        let finalMessage = getTerminalMessage(event);
+                        try {
+                            finalMessage = await maybePromiseWithAbort(response.result(), signal);
+                        }
+                        catch (error) {
+                            if (!signal?.aborted || !isAbortError(error)) {
+                                throw error;
+                            }
+                        }
+                        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 maybePromiseWithAbort(response.result(), signal);
+            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) {
+            if (signal?.aborted && isAbortError(error)) {
+                return await finishAbortedMessage();
+            }
+            throw error;
+        }
+    };
+    let outcome;
+    try {
+        outcome = { message: await runResponse() };
+    }
+    catch (error) {
+        outcome = { error };
+    }
+    try {
+        if (build.projection)
+            await build.projection.release?.();
+    }
+    catch (error) {
+        if ("error" in outcome) {
+            throw new AggregateError([outcome.error, error], `Agent inference and context cleanup failed: ${String(outcome.error)}`);
+        }
+        throw error;
+    }
+    if ("error" in outcome) {
+        if (allowRecovery &&
+            !addedPartial &&
+            isLocalRequestPreparationError(outcome.error) &&
+            config.recoverRequestPreparation) {
+            let recovered;
+            try {
+                recovered = await config.recoverRequestPreparation(outcome.error, signal);
+            }
+            catch (error) {
+                // Preserve the real owner error, including a post-ACK compaction failure.
+                markLocalRequestPreparationError(error);
+                throw error;
+            }
+            if (recovered) {
+                // Rebuild/adopt the committed owner view. Keep this invocation's output collector,
+                // completed tools and emitted messages; only this unsent request gets one reprepare.
+                return streamAssistantResponse(context, config, signal, emit, streamFn, false);
+            }
+        }
+        throw outcome.error;
+    }
+    return outcome.message;
+}
+async function executeToolCalls(currentContext, assistantMessage, config, signal, emit, output) {
+    const toolCalls = assistantMessage.content
+        .filter((c) => c.type === "toolCall")
+        .map((toolCall, sourceOrder) => ({
+        toolCall,
+        sourceOrder,
+        executionId: crypto.randomUUID(),
+        assistantMessage,
+        originalInput: structuredClone(toolCall.arguments),
+    }));
+    const hasSequentialToolCall = toolCalls.some(({ toolCall }) => currentContext.tools?.find((t) => t.name === toolCall.name)?.executionMode === "sequential");
+    if (config.toolExecution === "sequential" || hasSequentialToolCall) {
+        return executeToolCallsSequential(currentContext, assistantMessage, toolCalls, config, signal, emit, output);
+    }
+    return executeToolCallsParallel(currentContext, assistantMessage, toolCalls, config, signal, emit);
+}
+async function executeToolCallsSequential(currentContext, assistantMessage, toolCalls, config, signal, emit, output) {
+    const finalizedCalls = [];
+    const messages = [];
+    const exchanges = [];
+    for (const source of toolCalls) {
+        const { toolCall } = source;
+        if (signal?.aborted) {
+            break;
+        }
+        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,
+                executionOutcome: "not_started",
+            };
+        }
+        else {
+            const executed = await executePreparedToolCall(preparation, source, "sequential", config, signal, emit);
+            finalized = await finalizeExecutedToolCall(currentContext, assistantMessage, preparation, executed, config, signal);
+        }
+        const published = await publishToolExchange(finalized, source, "sequential", config, signal, emit);
+        await emitToolResultMessage(published.exchange.result, emit);
+        finalizedCalls.push(finalized);
+        messages.push(published.exchange.result);
+        exchanges.push(published.exchange);
+        if (signal?.aborted || output?.refusal) {
+            break;
+        }
+    }
+    return {
+        messages,
+        exchanges,
+        toolExecution: "sequential",
+        terminate: shouldTerminateToolBatch(finalizedCalls),
+    };
+}
+async function executeToolCallsParallel(currentContext, assistantMessage, toolCalls, config, signal, emit) {
+    const finalizedCalls = [];
+    for (const source of toolCalls) {
+        const { toolCall } = source;
+        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,
+                executionOutcome: "not_started",
+            };
+            finalizedCalls.push(await publishToolExchange(finalized, source, "parallel", config, signal, emit));
+            continue;
+        }
+        finalizedCalls.push(async () => {
+            const executed = await executePreparedToolCall(preparation, source, "parallel", config, signal, emit);
+            const finalized = await finalizeExecutedToolCall(currentContext, assistantMessage, preparation, executed, config, signal);
+            return publishToolExchange(finalized, source, "parallel", config, signal, emit);
+        });
+    }
+    // An owner/publication failure must not abandon other invocations already started.
+    const settledCalls = await Promise.allSettled(finalizedCalls.map((entry) => (typeof entry === "function" ? entry() : Promise.resolve(entry))));
+    const orderedFinalizedCalls = settledCalls.flatMap((settled) => settled.status === "fulfilled" ? [settled.value] : []);
+    const failure = settledCalls.find((settled) => settled.status === "rejected");
+    const messages = [];
+    for (const finalized of orderedFinalizedCalls) {
+        const toolResultMessage = finalized.exchange.result;
+        await emitToolResultMessage(toolResultMessage, emit);
+        messages.push(toolResultMessage);
+    }
+    if (failure?.status === "rejected")
+        throw failure.reason;
+    return {
+        messages,
+        exchanges: orderedFinalizedCalls.map((finalized) => finalized.exchange),
+        toolExecution: "parallel",
+        terminate: shouldTerminateToolBatch(orderedFinalizedCalls),
+    };
+}
+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 = currentContext.tools?.find((t) => t.name === toolCall.name);
+    if (!tool) {
+        return {
+            kind: "immediate",
+            result: createErrorToolResult(`Tool ${toolCall.name} not found`),
+            isError: true,
+        };
+    }
+    try {
+        const preparedToolCall = prepareToolCallArguments(tool, toolCall);
+        const validatedArgs = validateToolArguments(tool, preparedToolCall);
+        if (config.beforeToolCall) {
+            const beforeResult = await maybePromiseWithAbort(config.beforeToolCall({
+                assistantMessage,
+                toolCall,
+                args: validatedArgs,
+                context: currentContext,
+            }, signal), signal);
+            if (beforeResult?.block) {
+                return {
+                    kind: "immediate",
+                    result: createErrorToolResult(beforeResult.reason || "Tool execution was blocked"),
+                    isError: true,
+                };
+            }
+        }
+        return {
+            kind: "prepared",
+            toolCall,
+            tool,
+            args: validatedArgs,
+        };
+    }
+    catch (error) {
+        return {
+            kind: "immediate",
+            result: createErrorToolResult(error instanceof Error ? error.message : String(error)),
+            isError: true,
+        };
+    }
+}
+async function executePreparedToolCall(prepared, source, toolExecution, config, signal, emit) {
+    const invocationArgs = structuredClone(prepared.args);
+    const executedInput = structuredClone(invocationArgs);
+    const execute = prepared.tool.execute;
+    if (!signal?.aborted) {
+        // Admission failures must not become synthetic tool results or fall through to effects.
+        const owner = await config.onToolInvocationStarting?.({
+            executionId: source.executionId,
+            sourceOrder: source.sourceOrder,
+            toolCallId: prepared.toolCall.id,
+            toolName: prepared.toolCall.name,
+            originalInput: source.originalInput,
+            executedInput,
+            toolExecution,
+        }, signal, prepared.tool, execute, source.assistantMessage);
+        if (owner)
+            source.owner = owner;
+    }
+    const updateEvents = [];
+    let acceptingUpdates = true;
+    let executionStarted = false;
+    try {
+        throwIfAborted(signal);
+        executionStarted = true;
+        const run = () => execute.call(prepared.tool, prepared.toolCall.id, invocationArgs, signal, (partialResult) => {
+            if (!acceptingUpdates || signal?.aborted) {
+                return;
+            }
+            updateEvents.push(Promise.resolve(emit({
+                type: "tool_execution_update",
+                toolCallId: prepared.toolCall.id,
+                toolName: prepared.toolCall.name,
+                args: prepared.toolCall.arguments,
+                partialResult,
+            })));
+        });
+        const result = await raceWithAbort(source.owner ? source.owner.run(run) : run(), signal);
+        acceptingUpdates = false;
+        try {
+            await raceWithAbort(Promise.all(updateEvents).then(() => undefined), signal);
+        }
+        catch (error) {
+            if (!signal?.aborted || !isAbortError(error)) {
+                throw error;
+            }
+        }
+        return { result, isError: false, executedInput, executionOutcome: "completed" };
+    }
+    catch (error) {
+        acceptingUpdates = false;
+        await raceWithAbort(Promise.all(updateEvents).then(() => undefined), signal).catch(() => undefined);
+        return {
+            result: createErrorToolResult(signal?.aborted ? "Tool execution aborted" : error instanceof Error ? error.message : String(error)),
+            isError: true,
+            ...(executionStarted ? { executedInput } : {}),
+            executionOutcome: !executionStarted ? "not_started" : signal?.aborted ? "outcome_unknown" : "failed",
+        };
+    }
+}
+async function finalizeExecutedToolCall(currentContext, assistantMessage, prepared, executed, config, signal) {
+    let result = executed.result;
+    let isError = executed.isError;
+    if (config.afterToolCall) {
+        try {
+            const afterResult = await maybePromiseWithAbort(config.afterToolCall({
+                assistantMessage,
+                toolCall: prepared.toolCall,
+                args: prepared.args,
+                result,
+                isError,
+                context: currentContext,
+            }, signal), 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) {
+            result = createErrorToolResult(error instanceof Error ? error.message : String(error));
+            isError = true;
+        }
+    }
+    return {
+        ...executed,
+        toolCall: prepared.toolCall,
+        result,
+        isError,
+    };
+}
+function createErrorToolResult(message) {
+    return {
+        content: [{ type: "text", text: message }],
+        details: {},
+    };
+}
+async function publishToolExchange(finalized, source, toolExecution, config, signal, emit) {
+    const exchange = {
+        executionId: source.executionId,
+        sourceOrder: source.sourceOrder,
+        toolCallId: finalized.toolCall.id,
+        toolName: finalized.toolCall.name,
+        originalInput: source.originalInput,
+        ...(finalized.executionOutcome === "not_started" ? {} : { executedInput: finalized.executedInput }),
+        toolExecution,
+        executionOutcome: finalized.executionOutcome,
+        cancellationRequested: signal?.aborted ?? false,
+        result: createToolResultMessage(finalized),
+    };
+    await config.onToolExchangeFinalized?.(exchange, signal, source.owner);
+    await emit({
+        type: "tool_execution_end",
+        toolCallId: finalized.toolCall.id,
+        toolName: finalized.toolCall.name,
+        result: finalized.result,
+        isError: finalized.isError,
+        exchange,
+    });
+    return { ...finalized, exchange };
+}
+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