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

package/dist/agent.d.ts

@@ -1,19 +1,2 @@
-import type { ToolRuntime } from "@nexface/tools";
-import type { Agent, AgentSkill } from "./types.js";
-import type { AgentModelConfig } from "./model/types.js";
-import { type ToolBridge } from "./tool-bridge.js";
-export declare function createAgent(options: {
-    model: AgentModelConfig;
-    skills?: readonly AgentSkill[];
-    maxSteps?: number;
-    maxRetries?: number;
-    applicationContext?: {
-        maxSizeBytes?: number;
-    };
-} & ({
-    toolRuntime: ToolRuntime;
-    toolBridge?: never;
-} | {
-    toolBridge: ToolBridge;
-    toolRuntime?: never;
-})): Agent;
+import type { Agent, CreateAgentOptions } from "./types.js";
+export declare function createAgent(options: CreateAgentOptions): Agent;

package/dist/agent.js

@@ -1,3 +1,4 @@
+import { decodeRequest, 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";
@@ -5,7 +6,7 @@ import { EventType, TextInputContentSchema, ImageInputContentSchema, ResumeEntry
 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,14 +610,9 @@ 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 }), ...(result.checkpoint ? { checkpoint: result.checkpoint } : {}) },
                 });
                 return result;
             }
@@ -637,6 +630,7 @@ class AgentRunStream {
             this.#notify();
         });
     }
+    toResponse() { return runResponse(this); }
     cancel() {
         this.onCancel?.();
         if (!this.#controller.signal.aborted) {
@@ -672,7 +666,13 @@ class Nexface {
     id = createId();
     #toolBridge;
     #toolRuntime;
-    #externalToolBridge;
+    #registered = new Map();
+    #request;
+    #requestIdentity;
+    #requestMessages = [];
+    #requestPending;
+    #requestResult;
+    #requestUsed = false;
     #pendingModelConfig;
     #modelBinding;
     #modelInfo;
@@ -690,8 +690,6 @@ class Nexface {
     #browserSkillLoaded = false;
     #activeRun;
     #operation;
-    #terminalToolBridgeError;
-    #bridgeExecutionOccurredInRun = false;
     #pendingInterrupt;
     #authorizedPageResponses = new WeakSet();
     #hasPageConfirmation = (_toolName) => false;
@@ -703,25 +701,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);
@@ -773,14 +783,14 @@ class Nexface {
         }
     }
     run(input, options = {}) {
+        if ("messages" in input)
+            return this.#runRequest(input, options);
         if (this.#activeRun) {
             throw new AgentError("AGENT_RUN_ACTIVE", "An agent run is already active.");
         }
         if (this.#modelSwitch) {
             throw new AgentModelError("AGENT_RUN_BLOCKED", "An agent run cannot start while the model is switching.");
         }
-        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.");
@@ -824,6 +834,7 @@ class Nexface {
             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) {
@@ -841,8 +852,7 @@ class Nexface {
         else if (this.#pendingInterrupt) {
             this.#invalidateInterrupt("A new user message started.", "new_message");
         }
-        const inputMessage = { role: "user", content };
-        this.#bridgeExecutionOccurredInRun = false;
+        const inputMessage = { id: input.message.id ?? createId(), role: "user", content };
         const runId = createId();
         const pendingModelConfig = this.#pendingModelConfig;
         const existingBinding = this.#modelBinding;
@@ -865,12 +875,6 @@ class Nexface {
                 return await this.#execute(emit, signal, binding, definitions, runId);
             }
             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();
@@ -887,20 +891,172 @@ class Nexface {
         });
         return run;
     }
+    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" } });
+        }
+    }
+    #checkpoint(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: 1, 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 { continuation: JSON.stringify(continuation) };
+    }
+    #runRequest(wire, options) {
+        let input;
+        try {
+            input = decodeRequest(wire);
+        }
+        catch (error) {
+            throw new AgentError("INVALID_RUN_INPUT", error instanceof Error ? error.message : "Invalid request.");
+        }
+        this.#requestIdentity = { threadId: wire.threadId, runId: wire.runId };
+        this.#requestMessages = wire.messages;
+        if (this.#requestUsed || this.#activeRun || this.#messages.length || this.#toolRuntime)
+            throw new AgentError("INVALID_RUN_INPUT", "Request input requires a new server Agent.");
+        if (!Array.isArray(input.messages) || !Array.isArray(input.tools) || !Array.isArray(input.contexts))
+            throw new AgentError("INVALID_RUN_INPUT", "Invalid request input.");
+        validateBridgeTools(input.tools);
+        validateBridgeContexts(input.contexts);
+        this.#requestUsed = true;
+        this.#request = structuredClone(input);
+        let continuation;
+        try {
+            continuation = input.continuation ? JSON.parse(input.continuation) : undefined;
+            if (continuation && (continuation.version !== 1 || JSON.stringify(continuation.model) !== JSON.stringify(this.model) || !Array.isArray(continuation.loadedSkills) || !Number.isInteger(continuation.contextRevision)))
+                throw new Error("Invalid continuation.");
+            if (continuation?.pending) {
+                const pending = continuation.pending;
+                if (!Array.isArray(pending.calls) || !pending.calls.length || !Number.isInteger(pending.step) || pending.step < 0 || !Number.isInteger(pending.recoverableFailures) || pending.recoverableFailures < 0 || !Array.isArray(pending.unresolvedToolFailures))
+                    throw new Error("Invalid pending batch.");
+                validateToolCallIds(pending.calls);
+                if (input.toolResult?.toolCallId !== pending.calls[0]?.id)
+                    throw new Error("Missing or mismatched browser result.");
+                const batchIndex = input.messages.reduce((last, message, index) => message.role === "assistant" ? index : last, -1);
+                const batch = input.messages[batchIndex];
+                const outstanding = batch?.role === "assistant" ? batch.toolCalls : [];
+                for (const call of pending.calls) {
+                    if (!outstanding.some((item) => item.id === call.id && item.name === call.name && item.arguments === call.arguments) || input.messages.slice(batchIndex + 1).some((message) => message.role === "tool" && message.toolCallId === call.id))
+                        throw new Error("Pending call does not match history.");
+                }
+                const first = pending.calls[0];
+                const target = first.name === "callAppTool" ? JSON.parse(first.arguments).name : first.name;
+                if (target && this.#registered.has(target))
+                    throw new Error("A browser result cannot settle a server tool.");
+                if (typeof input.toolResult?.confirmed !== "undefined" && typeof input.toolResult.confirmed !== "boolean")
+                    throw new Error("Invalid confirmation result.");
+                if (input.toolResult?.error && (typeof input.toolResult.error.code !== "string" || typeof input.toolResult.error.message !== "string"))
+                    throw new Error("Invalid browser error.");
+                this.#requestPending = structuredClone(pending);
+                this.#requestResult = structuredClone(input.toolResult);
+            }
+            else if (input.toolResult)
+                throw new Error("Unexpected browser result.");
+            for (const name of continuation?.loadedSkills ?? []) {
+                if (!this.#skillsByName.has(name))
+                    throw new Error("A restored Skill is unavailable.");
+                this.#loadedSkills.add(name);
+            }
+            this.#browserSkillLoaded = continuation?.browserSkillLoaded ?? false;
+            this.#contextRevision = continuation?.contextRevision ?? -1;
+            this.#lastContextSerialized = continuation?.lastContextSerialized;
+            const catalog = serializeRuntimeCatalog([...input.tools, ...[...this.#registered.values()].map((tool) => tool.definition)].filter((tool) => !NATIVE_TOOL_NAMES.has(tool.name)));
+            for (const message of input.messages) {
+                if (!message || !["system", "user", "assistant", "tool", "application_context"].includes(message.role))
+                    throw new Error("Invalid history message.");
+                if (message.role === "system") {
+                    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.");
+                    this.#messages.push({ role: "system", content });
+                }
+                else {
+                    if (message.role === "assistant")
+                        validateToolCallIds(message.toolCalls);
+                    if (message.role === "user" && typeof message.content !== "string") {
+                        if (!Array.isArray(message.content))
+                            throw new Error("Invalid user content.");
+                        message.content.forEach((part) => part.type === "text" ? TextInputContentSchema.parse(part) : ImageInputContentSchema.parse(part));
+                    }
+                    else if (message.role !== "assistant" && typeof message.content !== "string")
+                        throw new Error("Invalid history content.");
+                    this.#messages.push(structuredClone(message));
+                }
+            }
+        }
+        catch (error) {
+            throw new AgentError("INVALID_RUN_INPUT", error instanceof Error ? error.message : "Invalid request.");
+        }
+        const run = this.#createRun(wire.runId, options, async (emit, signal) => {
+            const binding = await resolveModelBinding(this.#pendingModelConfig, signal);
+            this.#modelBinding = binding;
+            if (continuation?.replay !== undefined)
+                binding.restoreReplay?.(continuation.replay, this.#messages);
+            this.#appendContextCheckpoint(validateBridgeContexts(input.contexts));
+            const definitions = validateBridgeTools(await this.#toolBridge.getTools({ signal }));
+            const pending = this.#requestPending;
+            const result = await this.#execute(emit, signal, binding, definitions, run.id, pending ? { step: pending.step, recoverableFailures: pending.recoverableFailures, unresolvedToolFailures: new Set(pending.unresolvedToolFailures) } : undefined);
+            return result.outcome.type === "success" ? { ...result, checkpoint: this.#checkpoint(binding) } : result;
+        });
+        this.#activeRun = run;
+        void run.result.then(() => { this.#activeRun = undefined; }, () => { this.#activeRun = undefined; });
+        return run;
+    }
     #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) => {
+        let resumedResultId = this.#request?.toolResultMessageId;
+        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 previous = this.#requestMessages.find((item) => item.id === resumedResultId && item.role === "tool" && item.toolCallId === event.toolCallId);
+                        if (previous) {
+                            event = { ...event, messageId: previous.id };
+                            resumedResultId = undefined;
+                        }
+                        const message = this.#messages.at(-1);
+                        if (message?.role === "tool" && message.toolCallId === event.toolCallId)
+                            message.id = event.messageId;
+                    }
+                    emit(event);
+                }, signal);
+                emit({ type: EventType.MESSAGES_SNAPSHOT, messages: mergeProtocolMessages(toProtocolMessages(this.#messages), this.#requestMessages) });
+                return result;
             }
             finally {
                 signal.removeEventListener("abort", onAbort);
@@ -915,7 +1071,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 +1114,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 +1148,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 +1181,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 +1197,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 +1221,7 @@ class Nexface {
             }
             if (!call) {
                 return {
-                    status: "completed",
+                    outcome: { type: "success" },
                     output,
                 };
             }
@@ -1127,11 +1282,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 +1310,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 +1350,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 +1362,10 @@ class Nexface {
                         if (inputErrors.length) {
                             throw new AgentToolError("INVALID_INPUT", inputErrors.join(" "), { errors: inputErrors });
                         }
+                        if (this.#request && !registered) {
+                            this.#requestPending = { 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, metadata: { nexface: { kind: "client-tool-execution", action: { toolCallId: prepared.call.id, definition: expectedDefinition, input: toolInput, ...(prepared.progressLabel ? { progressLabel: prepared.progressLabel } : {}) } } } }] }, checkpoint: this.#checkpoint(binding) };
+                        }
                         const confirmation = runtimeTool?.confirmation;
                         if (runtimeTool && confirmation) {
                             if (confirmation.mode === "page"
@@ -1244,15 +1415,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, metadata: { nexface: { kind: "tool-approval", 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 +1437,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 = { 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, metadata: { nexface: { kind: "client-tool-execution", action: { toolCallId: prepared.call.id, definition: expectedDefinition, input: toolInput, ...(progressLabel ? { progressLabel } : {}) } } } }] }, checkpoint: this.#checkpoint(binding) };
+                        }
                         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 +1455,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 +1497,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);