@nexface/tools 0.1.15-alpha.0 → 0.1.15-alpha.2

package/dist/registration.d.ts

@@ -9,9 +9,6 @@ export declare function registerAgentTool<TInput, TResult>(definition: AgentTool
     execute: RegisteredAgentTool<TInput, TResult>["execute"];
     requiresConfirmation?: never;
 }): RegisteredAgentTool<TInput, TResult>;
-export declare function createAgentToolRegistry(): {
-    register<TInput, TResult>(definition: AgentToolDefinition<TInput, TResult>, options: {
-        execute: RegisteredAgentTool<TInput, TResult>["execute"];
-        requiresConfirmation?: never;
-    }): () => void;
-};
+export declare function assertAgentToolRegistration(definition: AgentToolDefinition<any, any>, options: {
+    execute: unknown;
+}): void;

package/dist/registration.js

@@ -1,35 +1,16 @@
-import { defineAgentTool } from "./definition.js";
-import { toolRegistrySymbol } from "./shared/tool-registry.js";
 import { assertAgentToolInputSchema } from "./shared/schema.js";
 export function registerAgentTool(definition, options) {
-    if (!definition || typeof definition.name !== "string" || typeof options?.execute !== "function") {
+    assertAgentToolRegistration(definition, options);
+    assertAgentToolInputSchema(definition.inputSchema, `Tool "${definition.name}" was not registered: inputSchema`);
+    return Object.freeze({ definition, execute: options.execute });
+}
+export function assertAgentToolRegistration(definition, options) {
+    if (!definition ||
+        typeof definition.name !== "string" ||
+        typeof options?.execute !== "function") {
         throw new TypeError("registerAgentTool requires a definition and execute function.");
     }
     if ("requiresConfirmation" in options) {
         throw new TypeError("Registered Agent tools do not support requiresConfirmation.");
     }
-    assertAgentToolInputSchema(definition.inputSchema, `Tool "${definition.name}".inputSchema`);
-    return Object.freeze({ definition, execute: options.execute });
-}
-export function createAgentToolRegistry() {
-    const tools = new Map();
-    const registry = {
-        register(definition, options) {
-            const validated = registerAgentTool(definition, options);
-            if (tools.has(definition.name))
-                throw new TypeError(`Tool "${definition.name}" is already registered.`);
-            const copied = defineAgentTool(validated.definition);
-            const tool = Object.freeze({ definition: copied, execute: validated.execute });
-            tools.set(copied.name, tool);
-            return () => {
-                if (tools.get(copied.name) === tool)
-                    tools.delete(copied.name);
-            };
-        },
-    };
-    Object.defineProperty(registry, toolRegistrySymbol, {
-        value: Object.freeze({ getTools: () => [...tools.values()] }),
-    });
-    return Object.freeze(registry);
 }
-//# sourceMappingURL=registration.js.map

package/dist/runtime.d.ts

@@ -2,18 +2,20 @@ import { type InternalExecutionOptions } from "./shared/runtime-execution.js";
 import type { PageActionFeedback } from "./browser/feedback.js";
 import { type TaskProgress } from "./shared/runtime-controller.js";
 export { AgentToolError } from "./shared/errors.js";
+import { type RegisteredAgentTool } from "./registration.js";
 import { OperationTracker, type RuntimeActivitySnapshot } from "./operation-runtime.js";
 import type { AgentContextEntry, AgentContextInput, AgentContextRegistration, AgentToolDefinition, AgentToolExecutor } from "./types.js";
 import type { AgentToolExecutionEvent } from "./internal-types.js";
 export interface ToolRuntimeOptions {
     readonly pageAutomation?: boolean;
+    readonly routeSearch?: boolean;
 }
 export interface ToolRuntimeToolChangeEvent {
     readonly toolName: string;
-    readonly change: "registered" | "unregistered";
+    readonly change: "registered" | "unregistered" | "visibility";
 }
 declare const CONTEXT_ERROR_CODES: readonly ["CONTEXT_DISPOSED", "CONTEXT_NAME_MISMATCH", "DUPLICATE_CONTEXT", "INVALID_CONTEXT"];
-type AgentContextErrorCode = typeof CONTEXT_ERROR_CODES[number];
+type AgentContextErrorCode = (typeof CONTEXT_ERROR_CODES)[number];
 export declare function isToolRuntimeError(error: unknown): error is {
     readonly type: "tool_runtime_error";
     readonly domain: "tool" | "context";
@@ -51,6 +53,14 @@ export interface ToolRuntime {
     beginOperation(options?: {
         onCancel?: () => void;
     }): ToolOperation;
+    /**
+     * Register a business tool outside React and return an idempotent unregister function.
+     * @remarks Copies the definition. Unregistration invalidates unstarted calls; running calls use their execution signal.
+     */
+    register<TInput, TResult>(definition: AgentToolDefinition<TInput, TResult>, options: {
+        execute: RegisteredAgentTool<TInput, TResult>["execute"];
+        requiresConfirmation?: never;
+    }): () => void;
     getTools(): readonly RuntimeAgentTool[];
     getContexts(options?: {
         signal?: AbortSignal;
@@ -121,7 +131,7 @@ export interface InternalToolRuntime extends ToolRuntime, EventTarget {
     requestOperationCancel(id: string): void;
     resolveTarget(tool: RuntimeAgentTool, input: unknown): HTMLElement | undefined;
     setPageActionFeedback(listener: (event: AgentToolExecutionEvent, feedback: PageActionFeedback, signal?: AbortSignal) => void | Promise<void>): () => void;
-    register<TInput, TResult>(definition: AgentToolDefinition<TInput, TResult>, execute: AgentToolExecutor<TInput, TResult>, options?: {
+    bindTool<TInput, TResult>(definition: AgentToolDefinition<TInput, TResult>, execute: AgentToolExecutor<TInput, TResult>, options?: {
         signal?: AbortSignal;
         getConfirmation?: () => AgentToolConfirmationConfig | undefined;
         resolveTarget?: (input: unknown) => HTMLElement | undefined;
@@ -157,7 +167,11 @@ export declare class ToolRuntimeImplementation extends EventTarget implements To
     constructor(options?: ToolRuntimeOptions);
     on(eventName: "toolchange", listener: (event: ToolRuntimeToolChangeEvent) => void): () => void;
     on(eventName: "toolexecution", listener: (event: AgentToolExecutionEvent) => void): () => void;
-    register<TInput, TResult>(definition: AgentToolDefinition<TInput, TResult>, execute: AgentToolExecutor<TInput, TResult>, options?: {
+    register<TInput, TResult>(definition: AgentToolDefinition<TInput, TResult>, options: {
+        execute: RegisteredAgentTool<TInput, TResult>["execute"];
+        requiresConfirmation?: never;
+    }): () => void;
+    bindTool<TInput, TResult>(definition: AgentToolDefinition<TInput, TResult>, execute: AgentToolExecutor<TInput, TResult>, options?: {
         signal?: AbortSignal;
         getConfirmation?: () => AgentToolConfirmationConfig | undefined;
         resolveTarget?: (input: unknown) => HTMLElement | undefined;
@@ -170,6 +184,7 @@ export declare class ToolRuntimeImplementation extends EventTarget implements To
     getContexts(options?: {
         signal?: AbortSignal;
     }): Promise<readonly AgentContextEntry[]>;
+    getRegisteredTools(): readonly RuntimeAgentTool[];
     getWebMcpTools(): readonly RuntimeAgentTool[];
     isRegistered(name: string): boolean;
     getTools(): readonly RuntimeAgentTool[];

package/dist/runtime.js

@@ -1,13 +1,15 @@
+import { searchNavigationTools, searchToolDefinition } from "./tool-search.js";
 import { pageDecisionSymbol } from "./shared/runtime-execution.js";
 import { PageCommandError } from "./browser/locator.js";
 import { measurePagePhase } from "./browser/diagnostics.js";
-import { runtimeControllerSymbol } from "./shared/runtime-controller.js";
+import { runtimeControllerSymbol, } from "./shared/runtime-controller.js";
 import { AgentToolError, TOOL_ERROR_CODES } from "./shared/errors.js";
 export { AgentToolError } from "./shared/errors.js";
+import { assertAgentToolRegistration } from "./registration.js";
 import { OperationTracker } from "./operation-runtime.js";
-import { isValidAgentContextName } from "./definition.js";
+import { defineAgentTool, isValidAgentContextName } from "./definition.js";
 import { assertAgentToolInputSchema, validateAgentToolInput } from "./shared/schema.js";
-import { createBrowserToolset, } from "./browser/toolset.js";
+import { createBrowserToolset } from "./browser/toolset.js";
 const CONTEXT_ERROR_CODES = [
     "CONTEXT_DISPOSED",
     "CONTEXT_NAME_MISMATCH",
@@ -20,9 +22,9 @@ export function isToolRuntimeError(error) {
     if (!error || typeof error !== "object")
         return false;
     const candidate = error;
-    if (candidate.type !== "tool_runtime_error"
-        || typeof candidate.message !== "string"
-        || typeof candidate.code !== "string") {
+    if (candidate.type !== "tool_runtime_error" ||
+        typeof candidate.message !== "string" ||
+        typeof candidate.code !== "string") {
         return false;
     }
     if (candidate.domain === "tool") {
@@ -43,9 +45,7 @@ function assertContextName(name) {
     }
 }
 function normalizeContextValue(value, path = "value", seen = new WeakSet()) {
-    if (value === null
-        || typeof value === "string"
-        || typeof value === "boolean") {
+    if (value === null || typeof value === "string" || typeof value === "boolean") {
         return value;
     }
     if (typeof value === "number") {
@@ -82,8 +82,8 @@ function normalizeContextValue(value, path = "value", seen = new WeakSet()) {
 }
 function normalizeContext(context) {
     assertContextName(context.name);
-    if (context.description !== undefined
-        && (typeof context.description !== "string" || !context.description.trim())) {
+    if (context.description !== undefined &&
+        (typeof context.description !== "string" || !context.description.trim())) {
         throw new AgentContextError("INVALID_CONTEXT", "Context description must be a non-empty string when provided.");
     }
     return {
@@ -123,6 +123,8 @@ export function getInternalToolRuntime(runtime) {
 export class ToolRuntimeImplementation extends EventTarget {
     [toolRuntimeBrand] = true;
     #bindings = new Map();
+    #routeSearch;
+    #visibleNavigation = new Set();
     #contexts = new Map();
     #contextRevision = 0;
     #browserToolset;
@@ -136,16 +138,22 @@ export class ToolRuntimeImplementation extends EventTarget {
     beginInternalOperation(options = {}) {
         return this.#operations.begin(options);
     }
-    endBridgeOperation(handle) { return this.#operations.disposeBridge(handle); }
+    endBridgeOperation(handle) {
+        return this.#operations.disposeBridge(handle);
+    }
     setTaskProgress = (handle, progress) => this.#operations.setTaskProgress(handle, progress);
     setOperationWaiting = (handle, waiting) => this.#operations.setWaitingForUser(handle, waiting);
     getActivitySnapshot = () => this.#operations.getSnapshot();
     subscribeActivity = (listener) => this.#operations.subscribe(listener);
-    requestOperationCancel(id) { this.#operations.requestCancel(id); }
+    requestOperationCancel(id) {
+        this.#operations.requestCancel(id);
+    }
     setPageActionFeedback(listener) {
         this.#pageActionFeedback = listener;
-        return () => { if (this.#pageActionFeedback === listener)
-            this.#pageActionFeedback = undefined; };
+        return () => {
+            if (this.#pageActionFeedback === listener)
+                this.#pageActionFeedback = undefined;
+        };
     }
     #emitExecution(event) {
         this.#operations.observe(event);
@@ -153,10 +161,40 @@ export class ToolRuntimeImplementation extends EventTarget {
     }
     constructor(options = {}) {
         super();
-        if (options.pageAutomation !== undefined &&
-            typeof options.pageAutomation !== "boolean") {
+        if (options.pageAutomation !== undefined && typeof options.pageAutomation !== "boolean") {
             throw new AgentToolError("INVALID_INPUT", "pageAutomation must be a boolean.");
         }
+        if (options.routeSearch !== undefined && typeof options.routeSearch !== "boolean") {
+            throw new AgentToolError("INVALID_INPUT", "routeSearch must be a boolean.");
+        }
+        this.#routeSearch = options.routeSearch ?? false;
+        if (this.#routeSearch)
+            this.bindTool(searchToolDefinition, ({ query, queries }) => {
+                if (query !== undefined && queries !== undefined)
+                    throw new AgentToolError("INVALID_INPUT", "Use either query or queries, not both.");
+                const searchQueries = queries === undefined ? (query === undefined ? undefined : [query]) : [...queries];
+                if (searchQueries?.some((phrase) => typeof phrase !== "string" || !phrase.trim()))
+                    throw new AgentToolError("INVALID_INPUT", "Search queries must contain nonblank strings.");
+                const navigation = this.getRegisteredTools().filter(({ definition }) => definition.effect === "navigate");
+                const candidates = searchQueries === undefined
+                    ? navigation
+                    : searchNavigationTools(navigation, searchQueries.map((phrase) => phrase.trim()));
+                if (searchQueries !== undefined) {
+                    const previous = this.#visibleNavigation;
+                    this.#visibleNavigation = new Set(candidates);
+                    for (const tool of new Set([...previous, ...candidates])) {
+                        if (previous.has(tool) === this.#visibleNavigation.has(tool))
+                            continue;
+                        this.dispatchEvent(new DetailEvent("toolchange", Object.freeze({
+                            toolName: tool.definition.name,
+                            change: "visibility",
+                        })));
+                    }
+                }
+                return {
+                    tools: candidates.map(({ definition: { name, description } }) => ({ name, description })),
+                };
+            });
         this.#browserToolset = options.pageAutomation ? createBrowserToolset() : undefined;
         runtimeInternals.set(this, this);
         const controller = Object.freeze({
@@ -165,6 +203,7 @@ export class ToolRuntimeImplementation extends EventTarget {
             setTaskProgress: this.setTaskProgress,
             getOperationSnapshot: () => this.getActivitySnapshot().operation,
             subscribeOperation: this.subscribeActivity,
+            getRegisteredTools: () => this.getRegisteredTools(),
         });
         Object.defineProperty(this, runtimeControllerSymbol, { value: controller });
     }
@@ -186,8 +225,26 @@ export class ToolRuntimeImplementation extends EventTarget {
             this.removeEventListener(eventName, handleEvent);
         };
     }
-    register(definition, execute, options = {}) {
-        assertAgentToolInputSchema(definition.inputSchema, `Tool "${definition.name}".inputSchema`);
+    register(definition, options) {
+        assertAgentToolRegistration(definition, options);
+        const execute = options.execute;
+        if (definition.inputSchema?.type !== "object") {
+            throw new TypeError(`Tool "${definition.name}" was not registered: inputSchema root type must be object.`);
+        }
+        let copied;
+        try {
+            copied = defineAgentTool(definition);
+        }
+        catch (cause) {
+            throw new TypeError(`Tool "${definition.name}" was not registered: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
+        }
+        return this.#bindTool(copied, (input, { signal }) => execute(input, { signal }));
+    }
+    bindTool(definition, execute, options = {}) {
+        assertAgentToolInputSchema(definition.inputSchema, `Tool "${definition.name}" was not registered: inputSchema`);
+        return this.#bindTool(definition, execute, options);
+    }
+    #bindTool(definition, execute, options = {}) {
         if (this.#bindings.has(definition.name)) {
             throw new AgentToolError("DUPLICATE_BINDING", `Tool "${definition.name}" already has an active binding.`);
         }
@@ -196,9 +253,7 @@ export class ToolRuntimeImplementation extends EventTarget {
             definition,
             get confirmation() {
                 const confirmation = options.getConfirmation?.();
-                return confirmation === undefined
-                    ? undefined
-                    : Object.freeze({ ...confirmation });
+                return confirmation === undefined ? undefined : Object.freeze({ ...confirmation });
             },
             lifecycleSignal: lifecycleController.signal,
         });
@@ -207,9 +262,7 @@ export class ToolRuntimeImplementation extends EventTarget {
             definition,
             runtimeTool,
             execute,
-            ...(options.getConfirmation
-                ? { getConfirmation: options.getConfirmation }
-                : {}),
+            ...(options.getConfirmation ? { getConfirmation: options.getConfirmation } : {}),
             lifecycleController,
         };
         this.#bindings.set(definition.name, binding);
@@ -224,6 +277,7 @@ export class ToolRuntimeImplementation extends EventTarget {
             disposed = true;
             options.signal?.removeEventListener("abort", dispose);
             this.#bindings.delete(definition.name);
+            this.#visibleNavigation.delete(runtimeTool);
             lifecycleController.abort();
             this.dispatchEvent(new DetailEvent("toolchange", Object.freeze({
                 toolName: definition.name,
@@ -337,21 +391,27 @@ export class ToolRuntimeImplementation extends EventTarget {
             revision: this.#contextRevision,
         }));
     }
+    getRegisteredTools() {
+        return [...this.#bindings.values()]
+            .map(({ runtimeTool }) => runtimeTool)
+            .filter(({ definition }) => !this.#routeSearch || definition !== searchToolDefinition)
+            .sort((left, right) => compareStrings(left.definition.name, right.definition.name));
+    }
     getWebMcpTools() {
         return [...this.#bindings.values()]
             .map(({ runtimeTool }) => runtimeTool)
+            .filter((tool) => !this.#routeSearch ||
+            tool.definition.effect !== "navigate" ||
+            this.#visibleNavigation.has(tool))
             .sort((left, right) => compareStrings(left.definition.name, right.definition.name));
     }
     isRegistered(name) {
         return this.#bindings.has(name);
     }
     getTools() {
-        const applicationTools = [...this.#bindings.values()]
-            .map(({ runtimeTool }) => runtimeTool);
-        const browserTools = (this.#browserToolset?.definitions ?? [])
-            .map((definition) => this.#getBrowserRuntimeTool(definition));
-        return [...applicationTools, ...browserTools]
-            .sort((left, right) => compareStrings(left.definition.name, right.definition.name));
+        const applicationTools = this.getWebMcpTools();
+        const browserTools = (this.#browserToolset?.definitions ?? []).map((definition) => this.#getBrowserRuntimeTool(definition));
+        return [...applicationTools, ...browserTools].sort((left, right) => compareStrings(left.definition.name, right.definition.name));
     }
     waitForTool(definition, options = {}) {
         const isTargetRegistered = () => this.#bindings.has(definition.name);
@@ -374,8 +434,7 @@ export class ToolRuntimeImplementation extends EventTarget {
             };
             const onToolChange = (event) => {
                 const detail = event.detail;
-                if (detail?.toolName !== definition.name
-                    || detail.change !== "registered")
+                if (detail?.toolName !== definition.name || detail.change !== "registered")
                     return;
                 if (isTargetRegistered())
                     settle(resolve);
@@ -401,7 +460,11 @@ export class ToolRuntimeImplementation extends EventTarget {
     }
     execute(tool, input, options = {}) {
         const label = options.progressLabel?.trim().replace(/\s+/g, " ").slice(0, 48);
-        options = { ...(options.signal ? { signal: options.signal } : {}), ...(label ? { progressLabel: label } : {}), ...(options[pageDecisionSymbol] ? { [pageDecisionSymbol]: true } : {}) };
+        options = {
+            ...(options.signal ? { signal: options.signal } : {}),
+            ...(label ? { progressLabel: label } : {}),
+            ...(options[pageDecisionSymbol] ? { [pageDecisionSymbol]: true } : {}),
+        };
         const definition = tool.definition;
         const name = definition.name;
         const binding = this.#bindings.get(name);
@@ -417,8 +480,8 @@ export class ToolRuntimeImplementation extends EventTarget {
             if (!browserHandler) {
                 return Promise.reject(new AgentToolError("UNKNOWN_TOOL", `Unknown tool: ${name}.`));
             }
-            if (!browserToolset?.definitions.some((candidate) => candidate === definition)
-                || this.#getBrowserRuntimeTool(definition) !== tool) {
+            if (!browserToolset?.definitions.some((candidate) => candidate === definition) ||
+                this.#getBrowserRuntimeTool(definition) !== tool) {
                 return Promise.reject(new AgentToolError("CONTRACT_MISMATCH", `Tool "${name}" is registered with a different Definition.`));
             }
             return this.#enqueue((operationId) => this.#observeExecution(tool, input, options.signal, async (onFeedback, assertActive) => {
@@ -460,7 +523,9 @@ export class ToolRuntimeImplementation extends EventTarget {
         };
         // Reserve the tail before invoking executors or notifying synchronous listeners.
         let settleTail;
-        const tail = new Promise((resolve) => { settleTail = resolve; });
+        const tail = new Promise((resolve) => {
+            settleTail = resolve;
+        });
         this.#executionTail = tail;
         const queuedExecution = previous ? previous.then(start) : start();
         let execution = queuedExecution;
@@ -492,9 +557,13 @@ export class ToolRuntimeImplementation extends EventTarget {
             const target = binding.resolveTarget?.(input);
             return target?.isConnected ? target : undefined;
         }
-        if (this.#browserRuntimeTools.get(tool.definition) !== tool || !input || typeof input !== "object")
+        if (this.#browserRuntimeTools.get(tool.definition) !== tool ||
+            !input ||
+            typeof input !== "object")
             return undefined;
-        return this.#browserToolset?.handlers.get(tool.definition.name)?.resolveTarget?.(input);
+        return this.#browserToolset?.handlers
+            .get(tool.definition.name)
+            ?.resolveTarget?.(input);
     }
     async #observeExecution(tool, input, signal, execute, progressLabel, operationId) {
         const running = {
@@ -511,7 +580,10 @@ export class ToolRuntimeImplementation extends EventTarget {
         const assertActive = () => {
             signal?.throwIfAborted();
             if (presentation && this.#pageActionFeedback !== presentation) {
-                throw new PageCommandError({ code: "EXECUTION_CANCELLED", message: "Page action presentation was detached." });
+                throw new PageCommandError({
+                    code: "EXECUTION_CANCELLED",
+                    message: "Page action presentation was detached.",
+                });
             }
         };
         this.#emitExecution(running);
@@ -520,26 +592,33 @@ export class ToolRuntimeImplementation extends EventTarget {
             const result = await execute(async (feedback) => {
                 assertActive();
                 if (presentation)
-                    await measurePagePhase("presentation", async () => { await presentation(running, feedback, signal); });
+                    await measurePagePhase("presentation", async () => {
+                        await presentation(running, feedback, signal);
+                    });
                 assertActive();
             }, assertActive);
             signal?.throwIfAborted();
             this.#emitExecution({
-                ...running, status: "success", finishedAt: Date.now(), result,
+                ...running,
+                status: "success",
+                finishedAt: Date.now(),
+                result,
             });
             return result;
         }
         catch (error) {
             this.#emitExecution({
-                ...running, status: "error", cancelled: signal?.aborted === true,
-                finishedAt: Date.now(), error,
+                ...running,
+                status: "error",
+                cancelled: signal?.aborted === true,
+                finishedAt: Date.now(),
+                error,
             });
             throw error;
         }
     }
     async #executeApplication(name, input, options, binding, operationId) {
-        const id = globalThis.crypto?.randomUUID?.()
-            ?? `${Date.now()}-${Math.random()}`;
+        const id = globalThis.crypto?.randomUUID?.() ?? `${Date.now()}-${Math.random()}`;
         const startedAt = Date.now();
         const running = {
             ...(operationId ? { operationId } : {}),
@@ -599,4 +678,3 @@ export class ToolRuntimeImplementation extends EventTarget {
         return runtimeTool;
     }
 }
-//# sourceMappingURL=runtime.js.map

package/dist/shared/definition.js

@@ -2,14 +2,14 @@
 import { assertAgentToolInputSchema } from "./schema.js";
 export function createAgentToolDefinition(metadata) {
     if (!metadata.description.trim())
-        throw new Error("Tool description is required.");
+        throw new Error(`Tool "${metadata.name}": Tool description is required.`);
     if (metadata.inputSchema?.type !== "object") {
         throw new TypeError(`Tool inputSchema root type must be object. Tool "${metadata.name}".inputSchema.type is invalid.`);
     }
     assertAgentToolInputSchema(metadata.inputSchema, `Tool "${metadata.name}".inputSchema`);
     const effect = metadata.effect ?? "action";
     if (!["read", "action", "navigate"].includes(effect)) {
-        throw new Error(`Invalid agent tool effect: ${String(effect)}.`);
+        throw new Error(`Tool "${metadata.name}": Invalid agent tool effect: ${String(effect)}.`);
     }
     return Object.freeze({
         name: metadata.name,
@@ -30,4 +30,3 @@ function cloneAndFreeze(value) {
     }
     return value;
 }
-//# sourceMappingURL=definition.js.map

package/dist/shared/errors.d.ts

@@ -1,5 +1,5 @@
 export declare const TOOL_ERROR_CODES: readonly ["EXECUTION_OUTCOME_UNKNOWN", "ACTION_IN_FLIGHT", "ACTION_NOT_HANDLED", "ACTION_TARGET_UNAVAILABLE", "BROWSER_EXECUTION_FAILED", "BROWSER_SNAPSHOT_REQUIRED", "BROWSER_TOOLS_UNAVAILABLE", "CONTRACT_MISMATCH", "DUPLICATE_BINDING", "INVALID_INPUT", "INVALID_TOOL_RUNTIME", "OPERATION_BUSY", "TOOL_CANCELLED", "TOOL_CONFIRMATION_INVALIDATED", "TOOL_CONFIRMATION_REJECTED", "TOOL_ERROR", "TOOL_REGISTRATION_TIMEOUT", "TOOL_SKIPPED", "TOOL_UNAVAILABLE", "UNKNOWN_TOOL"];
-type AgentToolErrorCode = typeof TOOL_ERROR_CODES[number];
+type AgentToolErrorCode = (typeof TOOL_ERROR_CODES)[number];
 export declare class AgentToolError extends Error {
     readonly code: AgentToolErrorCode;
     readonly details?: unknown | undefined;

package/dist/shared/errors.js

@@ -33,4 +33,3 @@ export class AgentToolError extends Error {
         this.name = "ToolRuntimeError";
     }
 }
-//# sourceMappingURL=errors.js.map

package/dist/shared/page-protocol.js

@@ -1,3 +1,2 @@
 // Generated from shared/page-protocol.ts. Do not edit manually.
 export {};
-//# sourceMappingURL=page-protocol.js.map

package/dist/shared/page-tools.js

@@ -40,4 +40,3 @@ export const applyActionTool = createAgentToolDefinition({
         additionalProperties: false,
     },
 });
-//# sourceMappingURL=page-tools.js.map

package/dist/shared/runtime-controller.d.ts

@@ -12,6 +12,7 @@ interface OperationSnapshot {
     readonly taskProgress?: TaskProgress;
 }
 export interface RuntimeController {
+    getRegisteredTools(): ReturnType<ToolRuntime["getTools"]>;
     beginInternalOperation(options?: {
         signal?: AbortSignal;
         onCancel?: () => void;

package/dist/shared/runtime-controller.js

@@ -8,4 +8,3 @@ export function getRuntimeController(runtime) {
     }
     return controller;
 }
-//# sourceMappingURL=runtime-controller.js.map

package/dist/shared/runtime-execution.js

@@ -1,3 +1,2 @@
 // Generated from shared/runtime-execution.ts. Do not edit manually.
 export const pageDecisionSymbol = Symbol.for("@nexface/tools/page-decision");
-//# sourceMappingURL=runtime-execution.js.map