@nexface/agent 0.1.1-alpha.5 → 0.1.1-alpha.7

package/dist/agent.js

@@ -1,11 +1,12 @@
+import { decodeRequest, convertMessages, parseResume, approvalResponseSchema, toolResultResponseSchema, toProtocolMessages, mergeProtocolMessages, runResponse } from "./request.js";
 import { getInternalToolRuntime } from "@nexface/tools/internal";
 import { BROWSER_TOOLS_SKILL, serializeBrowserToolsSkill, } from "./browser-prompt.js";
 import { AgentError, isAgentError } from "./errors.js";
-import { EventType, TextInputContentSchema, ImageInputContentSchema, ResumeEntrySchema } from "@ag-ui/core";
+import { EventType, RunAgentInputSchema } from "@ag-ui/core";
 import { agentBrand } from "./types.js";
 import { describeModelConfig, prepareModelConfig, resolveModelBinding, } from "./model/binding.js";
 import { AgentModelError } from "./model/error.js";
-import { createLocalToolBridge, isToolBridgeError, ToolBridgeError, validateBridgeContexts, validateBridgeResult, validateBridgeTools, } from "./tool-bridge.js";
+import { createLocalToolBridge, validateBridgeContexts, validateBridgeTools, } from "./tool-bridge.js";
 const SYSTEM_PROMPT = "You are an application agent. Handle the latest user request.\n\n"
     + "Decision:\n"
     + "- Reply directly when the request needs no application data or action.\n"
@@ -18,7 +19,7 @@ const SYSTEM_PROMPT = "You are an application agent. Handle the latest user requ
     + "- Use only the provided function tools. Call cataloged application tools through callAppTool.\n"
     + "- If the user repeats or changes an action, execute the calls required for the latest request even if the same tool ran earlier.\n"
     + "- Before a state-changing call, use the latest context or a current read or navigation call to confirm any required state and identifiers.\n"
-    + "- The catalog may change after navigation or opening UI. Do not batch those calls with operations that depend on newly available tools.\n"
+    + "- The catalog changes with the page. If a needed tool is missing and navigation to the relevant page is available, navigate there and inspect the updated catalog before declaring the task unsupported. Do not batch navigation or opening UI with operations that depend on newly available tools.\n"
     + "- Batch only independent calls. The host executes them in order and skips remaining calls after a failure.\n"
     + "- Provide a concise progressLabel in the user's language for every application or page automation call. Do not expose tool names, internal identifiers, or parameters.\n\n"
     + "Completion:\n"
@@ -341,8 +342,8 @@ function validateToolCallIds(toolCalls) {
 }
 function eventFields(prepared) {
     return {
-        name: prepared.displayName,
-        arguments: prepared.displayArguments,
+        name: prepared.call.name,
+        arguments: prepared.call.arguments,
         ...(prepared.displayInput === undefined ? {} : { input: prepared.displayInput }),
         ...(prepared.parseError === undefined ? {} : { parseError: prepared.parseError }),
     };
@@ -577,9 +578,6 @@ function createTextEmitter(emit) {
                 emit({ type: EventType.TEXT_MESSAGE_END, messageId: id });
         } };
 }
-function emitText(emit, content) {
-    createTextEmitter(emit).finish(content);
-}
 class AgentRunStream {
     id;
     threadId;
@@ -612,16 +610,13 @@ class AgentRunStream {
                 await this.onResult?.(result, false);
                 this.#controller.signal.throwIfAborted();
                 this.#emit({
-                    type: EventType.RUN_FINISHED, threadId, runId: id, result,
-                    outcome: result.status === "completed" ? { type: "success" } : {
-                        type: "interrupt", interrupts: [{
-                                id: result.interrupt.id, reason: "tool_call",
-                                toolCallId: result.interrupt.toolCallId,
-                                metadata: { nexface: result.interrupt },
-                            }],
-                    },
+                    type: EventType.RUN_FINISHED, threadId, runId: id,
+                    outcome: result.outcome,
+                    result: { ...(result.output === undefined ? {} : { output: result.output }) },
                 });
-                return result;
+                return result.outcome.type === "success"
+                    ? { outcome: result.outcome, output: result.output }
+                    : { outcome: result.outcome };
             }
             catch (error) {
                 await this.onResult?.(undefined, this.#controller.signal.aborted);
@@ -637,6 +632,7 @@ class AgentRunStream {
             this.#notify();
         });
     }
+    toResponse() { return runResponse(this); }
     cancel() {
         this.onCancel?.();
         if (!this.#controller.signal.aborted) {
@@ -672,7 +668,15 @@ class Nexface {
     id = createId();
     #toolBridge;
     #toolRuntime;
-    #externalToolBridge;
+    #registered = new Map();
+    #request;
+    #requestIdentity;
+    #requestMessages = [];
+    #requestPending;
+    #requestResult;
+    #requestUsed = false;
+    #hasRun = false;
+    #receiptQueue = [];
     #pendingModelConfig;
     #modelBinding;
     #modelInfo;
@@ -690,8 +694,6 @@ class Nexface {
     #browserSkillLoaded = false;
     #activeRun;
     #operation;
-    #terminalToolBridgeError;
-    #bridgeExecutionOccurredInRun = false;
     #pendingInterrupt;
     #authorizedPageResponses = new WeakSet();
     #hasPageConfirmation = (_toolName) => false;
@@ -703,25 +705,37 @@ class Nexface {
             : SYSTEM_PROMPT;
         const hasToolRuntime = "toolRuntime" in options
             && options.toolRuntime !== undefined;
-        const hasToolBridge = "toolBridge" in options
-            && options.toolBridge !== undefined;
-        if (hasToolRuntime === hasToolBridge) {
-            throw new AgentError("AGENT_TOOL_RUNTIME_UNAVAILABLE", "createAgent requires exactly one toolRuntime or toolBridge.");
+        if ("toolBridge" in options) {
+            throw new AgentError("AGENT_TOOL_RUNTIME_UNAVAILABLE", "toolBridge is no longer supported. Use toolRuntime locally or ChatClient with HTTP + SSE.");
         }
         if (hasToolRuntime) {
             assertToolRuntime(options.toolRuntime);
             this.#toolRuntime = options.toolRuntime;
             this.#toolBridge = createLocalToolBridge(options.toolRuntime);
-            this.#externalToolBridge = false;
         }
-        else if (hasToolBridge) {
-            this.#toolBridge = options.toolBridge;
-            this.#externalToolBridge = true;
+        else {
             this.#toolRuntime = undefined;
+            this.#toolBridge = {
+                getTools: async () => this.#request?.tools ?? [],
+                getContexts: async () => this.#request?.contexts ?? [],
+                execute: async () => { throw new Error("No browser transport is available."); },
+            };
         }
-        else {
-            throw new Error("Unreachable Agent Tool transport state.");
+        for (const tool of options.tools ?? []) {
+            if (!tool?.definition || typeof tool.execute !== "function" || "requiresConfirmation" in tool || this.#registered.has(tool.definition.name) || NATIVE_TOOL_NAMES.has(tool.definition.name)) {
+                throw new AgentError("INVALID_RUN_INPUT", "Invalid or duplicate registered Agent tool.");
+            }
+            this.#registered.set(tool.definition.name, tool);
         }
+        const bridge = this.#toolBridge;
+        this.#toolBridge = {
+            getTools: async (options) => validateBridgeTools([
+                ...await bridge.getTools(options),
+                ...[...this.#registered.values()].map((tool) => tool.definition),
+            ]),
+            getContexts: (options) => bridge.getContexts(options),
+            execute: (definition, input, options) => bridge.execute(definition, input, options),
+        };
         const model = prepareModelConfig(options.model);
         this.#pendingModelConfig = model;
         this.#modelInfo = describeModelConfig(model);
@@ -735,7 +749,12 @@ class Nexface {
                     throw new Error("Conversation can only be restored into a new Agent.");
                 this.#messages.push(...structuredClone(messages));
             },
-            settle: (interruptId, settlement) => this.#settleInterrupt(interruptId, settlement),
+            settle: (interruptId, settlement, receipts) => {
+                const settled = this.#settleInterrupt(interruptId, settlement);
+                if (receipts)
+                    this.#alignCancellationReceipts(receipts);
+                return settled;
+            },
             authorizePageResponse: (response) => {
                 this.#authorizedPageResponses.add(response);
             },
@@ -773,134 +792,336 @@ class Nexface {
         }
     }
     run(input, options = {}) {
-        if (this.#activeRun) {
+        this.#assertAvailable();
+        let messages;
+        let resume;
+        try {
+            if (!input || typeof input !== "object" || Array.isArray(input) || Object.keys(input).some((key) => key !== "messages" && key !== "resume"))
+                throw new Error("run accepts only messages and resume.");
+            if (input.messages !== undefined && !Array.isArray(input.messages))
+                throw new Error("messages must be an array.");
+            if (input.resume !== undefined && (!Array.isArray(input.resume) || input.resume.length !== 1))
+                throw new Error("Exactly one resume entry is required.");
+            resume = input.resume?.[0] ? parseResume(input.resume[0]) : undefined;
+            if (!input.messages?.length && !resume)
+                throw new Error("Provide messages or resume.");
+            const previous = mergeProtocolMessages(toProtocolMessages(this.#messages), this.#requestMessages);
+            const incomingIds = new Set(input.messages?.map((message) => message.id));
+            messages = convertMessages([...previous, ...input.messages ?? []]).filter((message) => incomingIds.has(message.id));
+            for (const message of messages)
+                if (message.role === "assistant")
+                    validateToolCallIds(message.toolCalls);
+            if (resume) {
+                if (!this.#pendingInterrupt || resume.interruptId !== this.#pendingInterrupt.descriptor.id)
+                    throw new Error("The interrupt is no longer pending.");
+                if (resume.status === "resolved") {
+                    if (!("approved" in resume.payload))
+                        throw new Error("This pending approval requires an approval response.");
+                    if (messages.length)
+                        throw new Error("A resolved approval cannot start a new task.");
+                    if (!resume.payload.approved && this.#pendingInterrupt.descriptor.mode === "page")
+                        throw new Error("A page confirmation cannot be rejected through run.");
+                    if (resume.payload.approved && this.#pendingInterrupt.descriptor.mode === "page" && !this.#authorizedPageResponses.delete(input.resume[0]))
+                        throw new Error("Page confirmation must be submitted through its registered usePageConfirmation Hook.");
+                }
+            }
+        }
+        catch (error) {
+            throw new AgentError("INVALID_RUN_INPUT", error instanceof Error ? error.message : "Invalid Agent input.");
+        }
+        return this.#start({ kind: "local", messages, protocolMessages: structuredClone(input.messages ?? []), ...(resume ? { resume } : {}) }, options);
+    }
+    runRequest(input, options = {}) {
+        let wire;
+        try {
+            wire = RunAgentInputSchema.parse(input);
+        }
+        catch (error) {
+            throw new AgentError("INVALID_RUN_INPUT", error instanceof Error ? error.message : "Invalid request shape.");
+        }
+        if (this.#hasRun || this.#activeRun || this.#modelSwitch || this.#messages.length || this.#toolRuntime)
+            throw new AgentError("AGENT_REQUEST_REQUIRES_NEW_AGENT", "runRequest requires a new Agent without a local ToolRuntime.");
+        return this.#start({ kind: "request", wire: structuredClone(wire) }, options);
+    }
+    #assertAvailable() {
+        if (this.#activeRun)
             throw new AgentError("AGENT_RUN_ACTIVE", "An agent run is already active.");
+        if (this.#modelSwitch)
+            throw new AgentModelError("AGENT_RUN_BLOCKED", "The model cannot be switched while the Agent is busy.");
+        if (this.#requestUsed)
+            throw new AgentError("AGENT_REQUEST_REQUIRES_NEW_AGENT", "A request Agent cannot be reused.");
+    }
+    #start(source, options) {
+        const runId = source.kind === "request" ? source.wire.runId : createId();
+        if (source.kind === "local" && !options.signal?.aborted) {
+            if (this.#toolRuntime && !source.resume) {
+                const previousOperation = this.#operation;
+                const abort = new AbortController();
+                const handle = getInternalToolRuntime(this.#toolRuntime).beginInternalOperation({
+                    signal: abort.signal,
+                    taskProgress: { phase: "processing" },
+                    onCancel: () => {
+                        abort.abort(new DOMException("Agent operation cancelled.", "AbortError"));
+                        if (this.#operation?.abort === abort && this.#pendingInterrupt)
+                            this.#settleInterrupt(this.#pendingInterrupt.descriptor.id, { type: "cancel" });
+                    },
+                    ...(previousOperation ? { replaceWaiting: previousOperation.handle } : {}),
+                });
+                this.#operation = { handle, abort };
+            }
+            if (!source.resume && this.#pendingInterrupt) {
+                const previous = this.#takeInterrupt(this.#pendingInterrupt.descriptor.id);
+                this.#appendInterruptedBatch(previous, errorPayload(new AgentToolError("TOOL_CANCELLED", "A new user message replaced the pending task.", { toolExecuted: false })));
+            }
+            else if (source.resume && this.#pendingInterrupt) {
+                // Transfer ownership before exposing the resumed Run to cancellation.
+                this.#pendingInterrupt.descriptor = Object.freeze({ ...this.#pendingInterrupt.descriptor, runId });
+            }
         }
-        if (this.#modelSwitch) {
-            throw new AgentModelError("AGENT_RUN_BLOCKED", "An agent run cannot start while the model is switching.");
+        if (source.kind === "request") {
+            this.#requestUsed = true;
+            this.#requestIdentity = { threadId: source.wire.threadId, runId };
         }
-        if (this.#terminalToolBridgeError)
-            throw this.#terminalToolBridgeError;
-        if ("resume" in input) {
-            if (!Array.isArray(input.resume) || input.resume.length !== 1) {
-                throw new AgentError("INVALID_RUN_INPUT", "Nexface currently requires exactly one resume entry.");
+        this.#hasRun = true;
+        const run = this.#createRun(runId, options, async (emit, signal) => {
+            signal.throwIfAborted();
+            let incoming;
+            let resume;
+            let restored;
+            let requestInput;
+            let history = [];
+            if (source.kind === "request") {
+                try {
+                    requestInput = decodeRequest(source.wire);
+                    history = this.#prepareRequestHistory(requestInput);
+                    restored = requestInput.continuation;
+                }
+                catch (error) {
+                    throw new AgentError("INVALID_RUN_INPUT", error instanceof Error ? error.message : "Invalid request recovery.");
+                }
+                incoming = requestInput.newMessages;
+                resume = requestInput.resume;
             }
-            const parsedEntry = ResumeEntrySchema.safeParse(input.resume[0]);
-            if (!parsedEntry.success) {
-                throw new AgentError("INVALID_RUN_INPUT", "The resume entry does not match the AG-UI interrupt response schema.");
+            else {
+                incoming = source.messages;
+                resume = source.resume;
             }
-            const entry = parsedEntry.data;
-            if (entry.status === "cancelled") {
-                throw new AgentError("INVALID_RUN_INPUT", "Cancelling a pending interrupt does not create an Agent Run.");
+            const binding = this.#modelBinding ?? await resolveModelBinding(this.#pendingModelConfig, signal);
+            signal.throwIfAborted();
+            if (restored?.replay !== undefined) {
+                if (!binding.restoreReplay)
+                    throw new AgentError("INVALID_RUN_INPUT", "The model cannot restore native replay data.");
+                binding.restoreReplay(restored.replay, history);
             }
-            if (typeof entry.payload?.approved !== "boolean") {
-                throw new AgentError("INVALID_RUN_INPUT", "Approval response requires a boolean approved field.");
+            // Commit only after recovery and native replay have both been validated.
+            this.#modelBinding = binding;
+            this.#modelInfo = binding.info;
+            this.#pendingModelConfig = undefined;
+            if (requestInput && source.kind === "request") {
+                this.#request = requestInput;
+                this.#requestMessages = source.wire.messages;
+                this.#receiptQueue = [...requestInput.receipts];
+                this.#messages.push(...history);
+                for (const skill of restored?.loadedSkills ?? [])
+                    this.#loadedSkills.add(skill);
+                this.#browserSkillLoaded = restored?.browserSkillLoaded ?? false;
+                this.#contextRevision = restored?.contextRevision ?? -1;
+                this.#lastContextSerialized = restored?.lastContextSerialized;
+                const pending = restored?.pending;
+                if (pending) {
+                    this.#requestPending = structuredClone(pending);
+                    this.#requestResult = requestInput.toolResult;
+                }
             }
-            const pending = this.#pendingInterrupt;
-            if (entry.payload.approved
-                && pending?.descriptor.id === entry.interruptId
-                && pending.descriptor.mode === "page"
-                && !this.#authorizedPageResponses.delete(input.resume[0])) {
-                throw new AgentError("INVALID_RUN_INPUT", "Page confirmation must be submitted through its registered usePageConfirmation Hook.");
+            const rememberLocalInput = () => {
+                if (source.kind === "local")
+                    this.#requestMessages = [...mergeProtocolMessages(toProtocolMessages(this.#messages), this.#requestMessages), ...source.protocolMessages];
+            };
+            if (resume?.status === "cancelled") {
+                if (this.#pendingInterrupt) {
+                    const pending = this.#takeInterrupt(resume.interruptId);
+                    this.#appendInterruptedBatch(pending, errorPayload(new AgentToolError("TOOL_CANCELLED", "The pending task was cancelled.", { toolExecuted: false })), emit);
+                }
+                else if (this.#requestPending) {
+                    this.#cancelRequestPending(emit);
+                }
+                if (!incoming.length) {
+                    rememberLocalInput();
+                    return { outcome: { type: "success" }, output: "" };
+                }
             }
-            const continuation = this.#resolveInterrupt(entry.interruptId, entry.payload.approved ? "confirm" : "reject", options);
-            if (!continuation) {
-                throw new AgentError("INVALID_RUN_INPUT", "The interrupt is no longer pending or cannot accept this response.");
+            else if (resume?.status === "resolved" && "approved" in resume.payload) {
+                rememberLocalInput();
+                return this.#continueApproval(resume.interruptId, resume.payload.approved ? "confirm" : "reject", emit, signal, runId);
             }
-            return continuation;
-        }
-        const raw = input.message.content;
-        const content = typeof raw === "string" ? raw.trim() : raw.map((part) => part.type === "text" ? TextInputContentSchema.parse(part) : ImageInputContentSchema.parse(part));
-        if (!content.length) {
-            throw new AgentError("INVALID_RUN_INPUT", "Agent message content is required.");
-        }
-        if (options.signal?.aborted) {
-            return new AgentRunStream(createId(), this.id, options, async (_emit, signal) => {
-                signal.throwIfAborted();
-                throw new Error("An aborted Run cannot execute.");
-            });
-        }
-        if (this.#toolRuntime) {
-            const abort = new AbortController();
-            const handle = getInternalToolRuntime(this.#toolRuntime).beginInternalOperation({
-                signal: abort.signal,
-                onCancel: () => {
-                    abort.abort(new DOMException("Agent operation cancelled.", "AbortError"));
-                    if (this.#operation?.abort === abort && this.#pendingInterrupt) {
-                        this.#settleInterrupt(this.#pendingInterrupt.descriptor.id, { type: "cancel" });
-                    }
-                },
-                ...(this.#pendingInterrupt && this.#operation ? { replaceWaiting: this.#operation.handle } : {}),
-            });
-            // The old handle has been replaced atomically; invalidation cannot close the new one.
-            this.#operation = undefined;
-            if (this.#pendingInterrupt)
-                this.#invalidateInterrupt("A new user message started.", "new_message");
-            this.#operation = { handle, abort };
-        }
-        else if (this.#pendingInterrupt) {
-            this.#invalidateInterrupt("A new user message started.", "new_message");
-        }
-        const inputMessage = { role: "user", content };
-        this.#bridgeExecutionOccurredInRun = false;
-        const runId = createId();
-        const pendingModelConfig = this.#pendingModelConfig;
-        const existingBinding = this.#modelBinding;
-        const run = this.#createRun(runId, options, async (emit, signal) => {
+            rememberLocalInput();
+            const contexts = validateBridgeContexts(await this.#toolBridge.getContexts({ signal }));
+            this.#appendContextCheckpoint(contexts);
+            const definitions = validateBridgeTools(await this.#toolBridge.getTools({ signal }));
+            appendRuntimeCatalogCheckpoint(this.#messages, definitions.filter(({ name }) => !NATIVE_TOOL_NAMES.has(name)));
+            const previousLength = this.#messages.length;
+            this.#messages.push(...structuredClone(incoming));
             try {
-                const binding = existingBinding ?? await resolveModelBinding(pendingModelConfig, signal);
-                signal.throwIfAborted();
-                if (!this.#modelBinding && this.#pendingModelConfig === pendingModelConfig) {
-                    this.#modelBinding = binding;
-                    this.#modelInfo = binding.info;
-                    this.#pendingModelConfig = undefined;
-                }
-                const contexts = validateBridgeContexts(await this.#toolBridge.getContexts({ signal }));
-                this.#appendContextCheckpoint(contexts);
-                const definitions = validateBridgeTools(await this.#toolBridge.getTools({ signal }));
-                const applicationDefinitions = definitions
-                    .filter(({ name }) => !NATIVE_TOOL_NAMES.has(name));
-                appendRuntimeCatalogCheckpoint(this.#messages, applicationDefinitions);
-                this.#messages.push(inputMessage);
-                return await this.#execute(emit, signal, binding, definitions, runId);
+                const pending = this.#requestPending;
+                return await this.#execute(emit, signal, binding, definitions, runId, pending ? { step: pending.step, recoverableFailures: pending.recoverableFailures, unresolvedToolFailures: new Set(pending.unresolvedToolFailures) } : undefined);
             }
             catch (error) {
-                if (this.#externalToolBridge
-                    && isToolBridgeError(error)
-                    && (this.#bridgeExecutionOccurredInRun
-                        || error.code === "EXECUTION_OUTCOME_UNKNOWN")) {
-                    this.#terminalToolBridgeError = error;
-                }
-                // Preserve history after a Tool may have caused application side effects.
-                if (this.#messages.at(-1) === inputMessage)
-                    this.#messages.pop();
+                // Roll back untouched input, but keep history after a tool may have executed.
+                if (this.#messages.length === previousLength + incoming.length)
+                    this.#messages.splice(previousLength);
                 throw error;
             }
         });
         this.#activeRun = run;
-        void run.result.then(() => {
-            if (this.#activeRun === run)
-                this.#activeRun = undefined;
-        }, () => {
-            if (this.#activeRun === run)
-                this.#activeRun = undefined;
-        });
+        if (source.kind === "local" && source.resume)
+            this.#operation?.handle.setWaitingForUser(false);
+        void run.result.then(() => { if (this.#activeRun === run)
+            this.#activeRun = undefined; }, () => { if (this.#activeRun === run)
+            this.#activeRun = undefined; });
         return run;
     }
+    #prepareRequestHistory(input) {
+        validateBridgeTools(input.tools);
+        validateBridgeContexts(input.contexts);
+        const definitions = [...input.tools, ...[...this.#registered.values()].map((tool) => tool.definition)];
+        validateBridgeTools(definitions);
+        const restored = input.continuation;
+        if (restored && (JSON.stringify(restored.model) !== JSON.stringify(this.model) || !Array.isArray(restored.loadedSkills) || !Number.isInteger(restored.contextRevision) || typeof restored.browserSkillLoaded !== "boolean"))
+            throw new Error("Invalid Agent state.");
+        for (const name of restored?.loadedSkills ?? [])
+            if (!this.#skillsByName.has(name))
+                throw new Error("A restored Skill is unavailable.");
+        const catalog = serializeRuntimeCatalog(definitions.filter(({ name }) => !NATIVE_TOOL_NAMES.has(name)));
+        const history = input.messages.map((message) => {
+            if (message.role !== "system") {
+                if (message.role === "assistant")
+                    validateToolCallIds(message.toolCalls);
+                return structuredClone(message);
+            }
+            const skill = message.content.startsWith("nexface:skill:") ? this.#skillsByName.get(message.content.slice(14)) : undefined;
+            const content = skill ? serializeSkill(skill) : message.content === "nexface:browser" ? serializeBrowserToolsSkill() : message.content === "nexface:catalog" ? catalog : undefined;
+            if (!content)
+                throw new Error("Untrusted system message.");
+            return { role: "system", content };
+        });
+        for (const message of input.newMessages)
+            if (message.role === "assistant")
+                validateToolCallIds(message.toolCalls);
+        const pending = restored?.pending;
+        if (pending) {
+            if (!Number.isInteger(pending.step) || pending.step < 0 || !Number.isInteger(pending.recoverableFailures) || pending.recoverableFailures < 0 || !Array.isArray(pending.unresolvedToolFailures) || pending.unresolvedToolFailures.some((name) => typeof name !== "string") || typeof pending.browserSkillAvailable !== "boolean" || typeof pending.loadBrowserSkill !== "boolean")
+                throw new Error("Invalid pending budget.");
+            validateToolCallIds(pending.calls);
+            const batchIndex = history.reduce((last, message, index) => message.role === "assistant" ? index : last, -1);
+            const batch = history[batchIndex];
+            if (batch?.role !== "assistant")
+                throw new Error("Pending call has no assistant message.");
+            const firstIndex = batch.toolCalls.findIndex((call) => call.id === pending.calls[0].id);
+            if (firstIndex < 0 || JSON.stringify(batch.toolCalls.slice(firstIndex)) !== JSON.stringify(pending.calls))
+                throw new Error("Pending calls do not match their original batch.");
+            if (history.slice(batchIndex + 1).some((message) => message.role === "tool" && pending.calls.some((call) => call.id === message.toolCallId)))
+                throw new Error("Pending call already has a result.");
+            const first = pending.calls[0];
+            const prepared = prepareToolCall(first, new Set(NATIVE_TOOL_NAMES), this.#skills.length > 0);
+            if (prepared.preparationError)
+                throw prepared.preparationError;
+            // Client receipts settle the original call even if its Binding has since changed.
+            const definition = validateBridgeTools([pending.definition])[0];
+            if (!definition || definition.name !== prepared.displayName)
+                throw new Error("Pending tool definition changed.");
+            const pendingInput = prepared.kind === "application" ? prepared.input : Object.fromEntries(Object.entries(parseArguments(first)).filter(([key]) => key !== "progressLabel"));
+            const inputErrors = validateToolInput(definition.inputSchema, pendingInput);
+            if (inputErrors.length)
+                throw new Error(`Invalid pending tool input: ${inputErrors.join(" ")}`);
+            if (this.#registered.has(prepared.displayName))
+                throw new Error("A client result cannot settle a registered tool.");
+        }
+        return history;
+    }
+    #cancelRequestPending(emit) {
+        const pending = this.#requestPending;
+        this.#requestPending = undefined;
+        this.#requestResult = undefined;
+        for (const [index, call] of pending.calls.entries()) {
+            const prepared = prepareToolCall(call, new Set(NATIVE_TOOL_NAMES), this.#skills.length > 0);
+            const payload = errorPayload(new AgentToolError(index === 0 ? "TOOL_CANCELLED" : "TOOL_SKIPPED", "The pending task was cancelled.", { toolExecuted: false }));
+            this.#messages.push({ role: "tool", toolCallId: call.id, name: call.name, content: modelToolPayload(prepared, payload) });
+            emit({ type: EventType.TOOL_CALL_RESULT, messageId: createId(), role: "tool", toolCallId: call.id, content: serializeToolPayload(payload) });
+        }
+        this.#loadPendingBrowserSkill(pending);
+    }
+    async #executeRegistered(tool, input, toolCallId, progressLabel, emit, signal) {
+        const progress = { phase: "tool", toolCallId, ...(progressLabel ? { progressLabel } : {}) };
+        const runtime = this.#toolRuntime && getInternalToolRuntime(this.#toolRuntime);
+        if (runtime && this.#operation)
+            runtime.setTaskProgress(this.#operation.handle, progress);
+        emit({ type: EventType.CUSTOM, name: "nexface.tool-execution", value: { ...progress, status: "running" } });
+        try {
+            return await tool.execute(input, { signal, toolCallId });
+        }
+        finally {
+            if (runtime && this.#operation)
+                runtime.setTaskProgress(this.#operation.handle, { phase: "processing" });
+            emit({ type: EventType.CUSTOM, name: "nexface.tool-execution", value: { toolCallId, status: "finished" } });
+        }
+    }
+    #exportState(binding) {
+        toProtocolMessages(this.#messages);
+        const messages = this.#messages.map((message) => {
+            if (message.role !== "system")
+                return structuredClone(message);
+            if (message.content === serializeBrowserToolsSkill())
+                return { role: "system", content: "nexface:browser" };
+            for (const skill of this.#skills) {
+                if (message.content === serializeSkill(skill))
+                    return { role: "system", content: `nexface:skill:${skill.name}` };
+            }
+            return { role: "system", content: "nexface:catalog" };
+        });
+        const continuation = {
+            version: 2, threadId: this.#requestIdentity.threadId, timeline: messages.map((message) => message.role === "system" || message.role === "application_context" ? { internal: message } : { messageId: message.id }), model: this.model, loadedSkills: [...this.#loadedSkills], browserSkillLoaded: this.#browserSkillLoaded,
+            contextRevision: this.#contextRevision, ...(this.#lastContextSerialized === undefined ? {} : { lastContextSerialized: this.#lastContextSerialized }),
+            ...(binding.exportReplay ? { replay: binding.exportReplay(this.#messages) } : {}),
+            ...(this.#requestPending ? { pending: this.#requestPending } : {}),
+        };
+        return structuredClone({ nexface: continuation });
+    }
     #createRun(id, options, execute) {
         const operation = this.#operation;
         const runOptions = operation ? {
             ...options,
             signal: AbortSignal.any([operation.abort.signal, ...(options.signal ? [options.signal] : [])]),
         } : options;
-        return new AgentRunStream(id, this.id, runOptions, async (emit, signal) => {
+        return new AgentRunStream(id, this.#requestIdentity?.threadId ?? this.id, runOptions, async (emit, signal) => {
             const onAbort = () => operation?.abort.abort(signal.reason);
             if (signal.aborted)
                 onAbort();
             else
                 signal.addEventListener("abort", onAbort, { once: true });
             try {
-                return await execute(emit, signal);
+                const result = await execute((event) => {
+                    if (event.type === EventType.TOOL_CALL_RESULT) {
+                        const receiptIndex = this.#receiptQueue.findIndex((item) => item.role === "tool" && item.toolCallId === event.toolCallId);
+                        const previous = receiptIndex < 0 ? undefined : this.#receiptQueue.splice(receiptIndex, 1)[0];
+                        if (previous?.role === "tool")
+                            event = { ...event, messageId: previous.id, ...(this.#request?.resume?.status === "cancelled" ? { content: previous.content } : {}) };
+                        const message = this.#messages.at(-1);
+                        if (message?.role === "tool" && message.toolCallId === event.toolCallId) {
+                            message.id = event.messageId;
+                            if (previous?.role === "tool" && this.#request?.resume?.status === "cancelled") {
+                                const original = JSON.parse(message.content);
+                                message.content = JSON.stringify({ ...(original.toolName ? { toolName: original.toolName } : {}), ...JSON.parse(previous.content) });
+                            }
+                        }
+                    }
+                    emit(event);
+                }, signal);
+                const messages = mergeProtocolMessages(toProtocolMessages(this.#messages), this.#requestMessages);
+                this.#requestMessages = structuredClone(messages);
+                emit({ type: EventType.MESSAGES_SNAPSHOT, messages });
+                if (this.#requestIdentity)
+                    emit({ type: EventType.STATE_SNAPSHOT, snapshot: this.#exportState(this.#modelBinding) });
+                return result;
             }
             finally {
                 signal.removeEventListener("abort", onAbort);
@@ -915,7 +1136,7 @@ class Nexface {
         }, async (result, aborted) => {
             if (!operation || this.#operation !== operation)
                 return;
-            if (result?.status === "interrupted" && this.#pendingInterrupt) {
+            if (result?.outcome.type === "interrupt" && this.#pendingInterrupt) {
                 operation.handle.setWaitingForUser(true);
             }
             else {
@@ -958,13 +1179,13 @@ class Nexface {
                 throw new AgentError("AGENT_RUN_LIMIT_REACHED", "Agent step limit reached before completion.");
             }
             this.#messages.push({
-                role: "assistant",
+                id: text.id, role: "assistant",
                 content: response.content,
                 toolCalls: [],
             });
             response.accept?.();
             text.finish(response.content);
-            return { status: "completed", output };
+            return { outcome: { type: "success" }, output };
         }
         for (let step = startStep; step < this.#maxSteps; step += 1) {
             signal.throwIfAborted();
@@ -992,14 +1213,16 @@ class Nexface {
                 finishTool,
             ];
             let response;
-            const browserSkillAvailableForRequest = this.#browserSkillLoaded;
+            const resumed = this.#requestPending;
+            this.#requestPending = undefined;
+            const browserSkillAvailableForRequest = resumed?.browserSkillAvailable ?? this.#browserSkillLoaded;
             appendRuntimeCatalogCheckpoint(this.#messages, applicationDefinitions);
             const messages = [
                 { role: "system", content: this.#systemPrompt },
                 ...this.#messages,
             ];
             const text = createTextEmitter(emit);
-            response = await binding.complete({
+            response = resumed ? { content: null, toolCalls: resumed.calls } : await binding.complete({
                 onTextDelta: text.delta,
                 messages,
                 tools,
@@ -1023,8 +1246,10 @@ class Nexface {
                 if (!output) {
                     throw new AgentError("INVALID_MODEL_RESPONSE", "finish needs non-empty output.");
                 }
+                if (!response.content)
+                    text.finish(output);
                 this.#messages.push({
-                    role: "assistant",
+                    id: text.id, role: "assistant",
                     content: output,
                     toolCalls: response.toolCalls,
                 });
@@ -1037,25 +1262,20 @@ class Nexface {
                         result: { status: finishInput.status, output },
                     }),
                 });
-                if (output !== response.content?.trim())
-                    emitText(emit, output);
-                return { status: "completed", output };
+                return { outcome: { type: "success" }, output };
             }
             const call = response.toolCalls[0];
             const output = response.content?.trim() ?? "";
             if (!call && !output) {
                 throw new AgentError("INVALID_MODEL_RESPONSE", "Model returned neither a message nor a tool call.");
             }
-            const batchHistoryStart = this.#messages.length;
-            this.#messages.push({
-                role: "assistant",
-                content: response.content,
-                toolCalls: response.toolCalls,
-            });
-            response.accept?.();
+            if (!resumed) {
+                this.#messages.push({ id: text.id, role: "assistant", content: response.content, toolCalls: response.toolCalls });
+                response.accept?.();
+            }
             const preparedCalls = response.toolCalls.map((modelCall) => prepareToolCall(modelCall, nativeToolNames, this.#skills.length > 0));
             const publicCalls = preparedCalls.filter(({ kind }) => kind !== "finish");
-            for (const prepared of publicCalls) {
+            for (const prepared of resumed ? [] : publicCalls) {
                 const fields = eventFields(prepared);
                 emit({ type: EventType.TOOL_CALL_START, toolCallId: prepared.call.id,
                     toolCallName: fields.name, parentMessageId: text.id });
@@ -1066,7 +1286,7 @@ class Nexface {
             }
             if (!call) {
                 return {
-                    status: "completed",
+                    outcome: { type: "success" },
                     output,
                 };
             }
@@ -1127,11 +1347,12 @@ class Nexface {
                 continue;
             }
             let failedCallId;
-            let shouldLoadBrowserSkill = false;
+            let shouldLoadBrowserSkill = resumed?.loadBrowserSkill ?? false;
+            let confirmedCallId;
             let skillToLoad;
             for (let index = 0; index < preparedCalls.length; index += 1) {
                 const prepared = preparedCalls[index];
-                if (failedCallId) {
+                if (failedCallId || confirmedCallId) {
                     const skipped = new AgentToolError("TOOL_SKIPPED", "Skipped because an earlier tool call failed.", { failedToolCallId: failedCallId });
                     const payload = errorPayload(skipped);
                     this.#messages.push({
@@ -1154,12 +1375,22 @@ class Nexface {
                 let modelContent;
                 let eventContent;
                 let failed = false;
-                let bridgeExecutionConfirmed = false;
                 try {
                     if (prepared.preparationError)
                         throw prepared.preparationError;
                     let output;
-                    if (prepared.kind === "skill") {
+                    const browserResult = this.#requestResult?.toolCallId === prepared.call.id ? this.#requestResult : undefined;
+                    if (browserResult) {
+                        this.#requestResult = undefined;
+                        if (browserResult.confirmed)
+                            confirmedCallId = prepared.call.id;
+                        if (browserResult.error)
+                            throw new AgentToolError(browserResult.error.code, browserResult.error.message);
+                        output = browserResult.result;
+                        if (prepared.call.name === "getSnapshot")
+                            shouldLoadBrowserSkill = true;
+                    }
+                    else if (prepared.kind === "skill") {
                         toolInput = parseArguments(prepared.call);
                         const unexpectedKeys = Object.keys(toolInput)
                             .filter((key) => key !== "name");
@@ -1184,8 +1415,9 @@ class Nexface {
                         if (!expectedDefinition) {
                             throw new AgentToolError("UNKNOWN_TOOL", `Tool "${prepared.displayName}" was not available when this model request was sent.`);
                         }
+                        const registered = this.#registered.get(prepared.displayName);
                         const runtimeTool = this.#toolRuntime?.getTools().find((candidate) => candidate.definition === expectedDefinition);
-                        if (this.#toolRuntime && !runtimeTool) {
+                        if (this.#toolRuntime && !runtimeTool && !registered) {
                             const replacement = this.#toolRuntime.getTools().find(({ definition }) => definition.name === expectedDefinition.name);
                             throw new AgentToolError(replacement ? "CONTRACT_MISMATCH" : "UNKNOWN_TOOL", replacement
                                 ? `Tool "${expectedDefinition.name}" changed after the model request was sent.`
@@ -1195,6 +1427,10 @@ class Nexface {
                         if (inputErrors.length) {
                             throw new AgentToolError("INVALID_INPUT", inputErrors.join(" "), { errors: inputErrors });
                         }
+                        if (this.#request && !registered) {
+                            this.#requestPending = { kind: "client-tool-execution", definition: expectedDefinition, interruptId: createId(), calls: preparedCalls.slice(index).map((item) => item.call), step, recoverableFailures, unresolvedToolFailures: [...unresolvedToolFailures], browserSkillAvailable: browserSkillAvailableForRequest, loadBrowserSkill: shouldLoadBrowserSkill };
+                            return { outcome: { type: "interrupt", interrupts: [{ id: this.#requestPending.interruptId, reason: "tool_call", toolCallId: prepared.call.id, responseSchema: toolResultResponseSchema, metadata: { nexface: { kind: "client-tool-execution", action: { toolCallId: prepared.call.id, definition: expectedDefinition, input: toolInput, ...(prepared.progressLabel ? { progressLabel: prepared.progressLabel } : {}) } } } }] } };
+                        }
                         const confirmation = runtimeTool?.confirmation;
                         if (runtimeTool && confirmation) {
                             if (confirmation.mode === "page"
@@ -1232,6 +1468,7 @@ class Nexface {
                                 remaining: preparedCalls.slice(index + 1),
                                 modelBinding: binding,
                                 nextStep: step + 1,
+                                loadBrowserSkill: shouldLoadBrowserSkill,
                                 recoverableFailures,
                                 unresolvedToolFailures: new Set(unresolvedToolFailures),
                                 removeInvalidationListener: () => { },
@@ -1244,15 +1481,11 @@ class Nexface {
                             runtimeTool.lifecycleSignal.addEventListener("abort", onRuntimeToolDisposed, { once: true });
                             pending.removeInvalidationListener = () => runtimeTool.lifecycleSignal.removeEventListener("abort", onRuntimeToolDisposed);
                             this.#pendingInterrupt = pending;
-                            return { status: "interrupted", interrupt: descriptor };
+                            return { outcome: { type: "interrupt", interrupts: [{ id: descriptor.id, reason: "tool_call", toolCallId: descriptor.toolCallId, responseSchema: approvalResponseSchema, metadata: { nexface: { kind: "tool-approval", source: "runtime", approval: descriptor } } }] } };
                         }
-                        output = runtimeTool && this.#toolRuntime
+                        output = registered ? await this.#executeRegistered(registered, toolInput, prepared.call.id, prepared.progressLabel, emit, signal) : runtimeTool && this.#toolRuntime
                             ? await getInternalToolRuntime(this.#toolRuntime).executeWithProgress(runtimeTool, toolInput, { signal, ...(prepared.progressLabel ? { progressLabel: prepared.progressLabel } : {}) })
                             : await this.#toolBridge.execute(expectedDefinition, toolInput, { signal });
-                        if (this.#externalToolBridge) {
-                            bridgeExecutionConfirmed = true;
-                            this.#bridgeExecutionOccurredInRun = true;
-                        }
                     }
                     else if (prepared.kind === "native") {
                         const expectedDefinition = nativeDefinitionsByName.get(prepared.call.name);
@@ -1270,14 +1503,17 @@ class Nexface {
                         toolInput = parseArguments(prepared.call);
                         const progressLabel = normalizeProgressLabel(toolInput.progressLabel);
                         delete toolInput.progressLabel;
+                        if (this.#request) {
+                            const inputErrors = validateToolInput(expectedDefinition.inputSchema, toolInput);
+                            if (inputErrors.length)
+                                throw new AgentToolError("INVALID_INPUT", inputErrors.join(" "));
+                            this.#requestPending = { kind: "client-tool-execution", definition: expectedDefinition, interruptId: createId(), calls: preparedCalls.slice(index).map((item) => item.call), step, recoverableFailures, unresolvedToolFailures: [...unresolvedToolFailures], browserSkillAvailable: browserSkillAvailableForRequest, loadBrowserSkill: shouldLoadBrowserSkill };
+                            return { outcome: { type: "interrupt", interrupts: [{ id: this.#requestPending.interruptId, reason: "tool_call", toolCallId: prepared.call.id, responseSchema: toolResultResponseSchema, metadata: { nexface: { kind: "client-tool-execution", action: { toolCallId: prepared.call.id, definition: expectedDefinition, input: toolInput, ...(progressLabel ? { progressLabel } : {}) } } } }] } };
+                        }
                         const nativeRuntimeTool = this.#toolRuntime?.getTools().find((tool) => tool.definition === expectedDefinition);
                         output = nativeRuntimeTool && this.#toolRuntime
                             ? await getInternalToolRuntime(this.#toolRuntime).executeWithProgress(nativeRuntimeTool, toolInput, { signal, ...(progressLabel ? { progressLabel } : {}) })
                             : await this.#toolBridge.execute(expectedDefinition, toolInput, { signal });
-                        if (this.#externalToolBridge) {
-                            bridgeExecutionConfirmed = true;
-                            this.#bridgeExecutionOccurredInRun = true;
-                        }
                         if (prepared.call.name === "getSnapshot") {
                             shouldLoadBrowserSkill = true;
                         }
@@ -1285,27 +1521,12 @@ class Nexface {
                     else {
                         throw new AgentError("UNKNOWN_MODEL_TOOL", `Unknown model tool: ${prepared.call.name}.`);
                     }
-                    if (this.#externalToolBridge)
-                        validateBridgeResult(output);
                     const payload = { result: output ?? null };
                     modelContent = modelToolPayload(prepared, payload);
                     eventContent = serializeToolPayload(payload);
                 }
                 catch (error) {
-                    if (this.#externalToolBridge
-                        && isToolBridgeError(error)
-                        && error.code === "EXECUTION_OUTCOME_UNKNOWN") {
-                        this.#bridgeExecutionOccurredInRun = true;
-                        this.#messages.splice(batchHistoryStart);
-                        throw error;
-                    }
                     if (signal.aborted) {
-                        if (this.#externalToolBridge) {
-                            this.#terminalToolBridgeError = new ToolBridgeError("EXECUTION_OUTCOME_UNKNOWN", `Tool "${prepared.displayName}" was cancelled before its outcome was confirmed.`, {
-                                toolCallId: prepared.call.id,
-                                toolName: prepared.displayName,
-                            });
-                        }
                         const cancelled = new AgentToolError("TOOL_CANCELLED", `Tool "${prepared.displayName}" was cancelled with the Agent run.`, prepared.call.name === "executeCode"
                             ? { refsExpired: true }
                             : undefined);
@@ -1342,14 +1563,6 @@ class Nexface {
                         }
                         throw signal.reason;
                     }
-                    if (this.#externalToolBridge && isToolBridgeError(error)) {
-                        this.#messages.splice(batchHistoryStart);
-                        if (bridgeExecutionConfirmed
-                            || error.code === "EXECUTION_OUTCOME_UNKNOWN") {
-                            this.#bridgeExecutionOccurredInRun = true;
-                        }
-                        throw error;
-                    }
                     failed = true;
                     failedCallId = prepared.call.id;
                     const payload = errorPayload(error);
@@ -1444,6 +1657,37 @@ class Nexface {
                 });
             }
         }
+        this.#loadPendingBrowserSkill(pending);
+    }
+    #loadPendingBrowserSkill(pending) {
+        if (pending.loadBrowserSkill && !this.#browserSkillLoaded) {
+            this.#messages.push({ role: "system", content: serializeBrowserToolsSkill() });
+            this.#browserSkillLoaded = true;
+        }
+    }
+    #alignCancellationReceipts(protocol) {
+        const ownerIndex = protocol.reduce((last, message, index) => message.role === "assistant" && message.toolCalls?.length ? index : last, -1);
+        const owner = protocol[ownerIndex];
+        if (!owner)
+            return;
+        const historyIndex = this.#messages.findIndex((message) => message.id === owner.id && message.role === "assistant");
+        if (historyIndex < 0)
+            return;
+        const codes = new Set(["TOOL_CANCELLED", "TOOL_CONFIRMATION_INVALIDATED", "TOOL_SKIPPED"]);
+        for (const receipt of protocol.slice(ownerIndex + 1)) {
+            if (receipt.role === "user" || (receipt.role === "assistant" && receipt.toolCalls?.length))
+                break;
+            if (receipt.role !== "tool")
+                continue;
+            const current = this.#messages.slice(historyIndex + 1).find((message) => message.role === "tool" && message.toolCallId === receipt.toolCallId);
+            if (current?.role !== "tool")
+                continue;
+            try {
+                if (codes.has(JSON.parse(current.content)?.error?.code) && codes.has(JSON.parse(receipt.content)?.error?.code))
+                    current.id = receipt.id;
+            }
+            catch { /* Only known cancellation receipts are aligned. */ }
+        }
     }
     #invalidateInterrupt(message, reason) {
         const pending = this.#pendingInterrupt;
@@ -1468,103 +1712,85 @@ class Nexface {
         this.#appendInterruptedBatch(pending, errorPayload(new AgentToolError("TOOL_CONFIRMATION_INVALIDATED", settlement.message, { reason: settlement.reason, toolExecuted: false })));
         return true;
     }
-    #resolveInterrupt(id, decision, options = {}) {
-        const current = this.#pendingInterrupt;
-        if (!current || current.descriptor.id !== id)
-            return undefined;
-        if (decision === "reject" && current.descriptor.mode !== "chat") {
-            return undefined;
-        }
-        options.signal?.throwIfAborted();
+    async #continueApproval(id, decision, emit, signal, runId) {
         const pending = this.#takeInterrupt(id);
         if (!pending)
-            return undefined;
+            throw new AgentError("INVALID_RUN_INPUT", "The interrupt is no longer pending.");
         this.#operation?.handle.setWaitingForUser(false);
-        const runId = createId();
-        const run = this.#createRun(runId, options, async (emit, signal) => {
-            let currentFailed = decision === "reject";
-            if (decision === "reject") {
-                this.#appendInterruptedBatch(pending, errorPayload(new AgentToolError("TOOL_CONFIRMATION_REJECTED", `Tool "${pending.descriptor.toolName}" was rejected by the user.`, { toolExecuted: false })), emit);
+        let currentFailed = decision === "reject";
+        if (decision === "reject") {
+            this.#appendInterruptedBatch(pending, errorPayload(new AgentToolError("TOOL_CONFIRMATION_REJECTED", `Tool "${pending.descriptor.toolName}" was rejected by the user.`, { toolExecuted: false })), emit);
+        }
+        else {
+            let payload;
+            try {
+                const output = await getInternalToolRuntime(this.#toolRuntime).executeWithProgress(pending.runtimeTool, pending.input, { signal, ...(pending.prepared.progressLabel ? { progressLabel: pending.prepared.progressLabel } : {}) });
+                payload = { result: output ?? null };
             }
-            else {
-                let payload;
-                try {
-                    if (!this.#toolRuntime) {
-                        throw new AgentToolError("TOOL_CONFIRMATION_INVALIDATED", `Tool "${pending.descriptor.toolName}" no longer has a local Runtime.`, { toolExecuted: false });
-                    }
-                    const output = await getInternalToolRuntime(this.#toolRuntime).executeWithProgress(pending.runtimeTool, pending.input, { signal, ...(pending.prepared.progressLabel ? { progressLabel: pending.prepared.progressLabel } : {}) });
-                    payload = { result: output ?? null };
-                }
-                catch (error) {
-                    currentFailed = true;
-                    const normalized = signal.aborted
-                        ? new AgentToolError("TOOL_CANCELLED", `Tool "${pending.descriptor.toolName}" was cancelled with the Agent run.`)
-                        : error;
-                    payload = errorPayload(normalized);
-                }
-                const eventContent = serializeToolPayload(payload);
+            catch (error) {
+                currentFailed = true;
+                const normalized = signal.aborted
+                    ? new AgentToolError("TOOL_CANCELLED", `Tool "${pending.descriptor.toolName}" was cancelled with the Agent run.`)
+                    : error;
+                payload = errorPayload(normalized);
+            }
+            const eventContent = serializeToolPayload(payload);
+            this.#messages.push({
+                role: "tool",
+                toolCallId: pending.prepared.call.id,
+                name: pending.prepared.call.name,
+                content: modelToolPayload(pending.prepared, payload),
+            });
+            emit({
+                type: EventType.TOOL_CALL_RESULT,
+                messageId: createId(),
+                role: "tool",
+                toolCallId: pending.prepared.call.id,
+                content: eventContent,
+            });
+            for (const prepared of pending.remaining) {
+                const skipped = new AgentToolError("TOOL_SKIPPED", "Skipped because an earlier tool call required confirmation.", { failedToolCallId: pending.prepared.call.id });
+                const skippedPayload = errorPayload(skipped);
                 this.#messages.push({
                     role: "tool",
-                    toolCallId: pending.prepared.call.id,
-                    name: pending.prepared.call.name,
-                    content: modelToolPayload(pending.prepared, payload),
+                    toolCallId: prepared.call.id,
+                    name: prepared.call.name,
+                    content: modelToolPayload(prepared, skippedPayload),
                 });
                 emit({
                     type: EventType.TOOL_CALL_RESULT,
                     messageId: createId(),
                     role: "tool",
-                    toolCallId: pending.prepared.call.id,
-                    content: eventContent,
+                    toolCallId: prepared.call.id,
+                    content: serializeToolPayload(skippedPayload),
                 });
-                for (const prepared of pending.remaining) {
-                    const skipped = new AgentToolError("TOOL_SKIPPED", "Skipped because an earlier tool call required confirmation.", { failedToolCallId: pending.prepared.call.id });
-                    const skippedPayload = errorPayload(skipped);
-                    this.#messages.push({
-                        role: "tool",
-                        toolCallId: prepared.call.id,
-                        name: prepared.call.name,
-                        content: modelToolPayload(prepared, skippedPayload),
-                    });
-                    emit({
-                        type: EventType.TOOL_CALL_RESULT,
-                        messageId: createId(),
-                        role: "tool",
-                        toolCallId: prepared.call.id,
-                        content: serializeToolPayload(skippedPayload),
-                    });
-                }
-            }
-            signal.throwIfAborted();
-            const unresolved = new Set(pending.unresolvedToolFailures);
-            if (currentFailed)
-                unresolved.add(pending.prepared.displayName);
-            else
-                unresolved.delete(pending.prepared.displayName);
-            for (const prepared of pending.remaining) {
-                unresolved.add(prepared.displayName);
-            }
-            const contexts = validateBridgeContexts(await this.#toolBridge.getContexts({ signal }));
-            this.#appendContextCheckpoint(contexts);
-            const nextRecoverableFailures = pending.recoverableFailures
-                + (currentFailed ? 1 : 0);
-            if (decision === "confirm"
-                && currentFailed
-                && nextRecoverableFailures > this.#maxRetries) {
-                throw new AgentError("AGENT_RUN_LIMIT_REACHED", "Agent recovery attempt limit reached.");
             }
-            const definitions = validateBridgeTools(await this.#toolBridge.getTools({ signal }));
-            return this.#execute(emit, signal, pending.modelBinding, definitions, runId, {
-                step: pending.nextStep,
-                recoverableFailures: nextRecoverableFailures,
-                unresolvedToolFailures: unresolved,
-            });
+        }
+        signal.throwIfAborted();
+        this.#loadPendingBrowserSkill(pending);
+        const unresolved = new Set(pending.unresolvedToolFailures);
+        if (currentFailed)
+            unresolved.add(pending.prepared.displayName);
+        else
+            unresolved.delete(pending.prepared.displayName);
+        for (const prepared of pending.remaining) {
+            unresolved.add(prepared.displayName);
+        }
+        const contexts = validateBridgeContexts(await this.#toolBridge.getContexts({ signal }));
+        this.#appendContextCheckpoint(contexts);
+        const nextRecoverableFailures = pending.recoverableFailures
+            + (currentFailed ? 1 : 0);
+        if (decision === "confirm"
+            && currentFailed
+            && nextRecoverableFailures > this.#maxRetries) {
+            throw new AgentError("AGENT_RUN_LIMIT_REACHED", "Agent recovery attempt limit reached.");
+        }
+        const definitions = validateBridgeTools(await this.#toolBridge.getTools({ signal }));
+        return this.#execute(emit, signal, pending.modelBinding, definitions, runId, {
+            step: pending.nextStep,
+            recoverableFailures: nextRecoverableFailures,
+            unresolvedToolFailures: unresolved,
         });
-        this.#activeRun = run;
-        void run.result.finally(() => {
-            if (this.#activeRun === run)
-                this.#activeRun = undefined;
-        }).catch(() => undefined);
-        return run;
     }
     #appendContextCheckpoint(entries) {
         const serializedEntries = JSON.stringify(entries);