/// <reference types="webmcp-types" />
import { MaybeRefOrGetter, Ref, ShallowRef, ComputedRef, InjectionKey } from 'vue';
import { W as WebMCPToolAnnotations, a as WebMCPToolExecuteOptions, R as RegisteredTool, b as WebMCPToolResponse } from './shared/vue-webmcp.BUJ4eDiy.mjs';
export { E as ExecuteToolOptions, G as GetToolsOptions, M as ModelContext, c as RegisterToolOptions, d as WebMCPContentBlock, e as WebMCPToolDescriptor } from './shared/vue-webmcp.BUJ4eDiy.mjs';

interface UseWebMCPToolOptions<Args = Record<string, unknown>, Result = unknown> {
    /**
     * Tool identifier the agent sees. 1–128 characters of `[a-zA-Z0-9_.-]`;
     * Chrome's guidance is at most 30.
     */
    name: MaybeRefOrGetter<string>;
    /** Human-readable label for user-agent UI. Agents reason over `name` and `description`. */
    title?: MaybeRefOrGetter<string | null | undefined>;
    /** Natural-language description for the agent. Chrome's guidance: keep under 500 characters. */
    description: MaybeRefOrGetter<string>;
    /** JSON Schema for the tool arguments. Compared by content, not identity. */
    inputSchema?: MaybeRefOrGetter<object | undefined>;
    annotations?: MaybeRefOrGetter<WebMCPToolAnnotations | undefined>;
    /**
     * Secure origins (for example an iframe-hosted agent) that may discover and
     * call the tool, in addition to the registering page, its same-origin
     * frames, and the browser's own agent.
     */
    exposedTo?: MaybeRefOrGetter<readonly string[] | undefined>;
    /**
     * Runs when the agent invokes the tool. Reads reactive state live at call
     * time; swapping the function never re-registers the tool.
     *
     * `options.signal` aborts when the caller cancels the execution or goes
     * away: hand it to `fetch` and other cancellable work.
     */
    execute: (args: Args, options: WebMCPToolExecuteOptions) => Result | Promise<Result>;
    /** Register only while true. May be a ref or getter — the tool follows it reactively. */
    enabled?: MaybeRefOrGetter<boolean>;
    /** Optional shaper applied to the result before MCP normalization. */
    formatOutput?: (result: Result, args: Args) => unknown;
    /**
     * Side effect when `execute` throws or returns an `Error`. The agent still
     * receives an `isError` response afterwards.
     */
    onError?: (error: unknown) => void;
}
interface UseWebMCPToolReturn {
    /** A modelContext API exists in this environment. Flips reactively if injected late. */
    isSupported: Readonly<Ref<boolean>>;
    /** The tool is currently registered with the browser. */
    isRegistered: Readonly<Ref<boolean>>;
    /** Registration failure, e.g. `NotAllowedError` from a `tools` Permissions Policy. */
    error: Readonly<Ref<Error | null>>;
}
/**
 * Registers a WebMCP tool with the browser and ties its lifetime to the
 * current component or effect scope, so the set of tools an agent sees stays
 * in lockstep with what is actually on screen.
 *
 * Feature-detects `document.modelContext` and degrades to a no-op everywhere
 * the API is absent, including during SSR.
 */
declare function useWebMCPTool<Args = Record<string, unknown>, Result = unknown>(options: UseWebMCPToolOptions<Args, Result>): UseWebMCPToolReturn;

/**
 * Typed identity helper, so a tool definition can live in a plain module
 * (importable, testable, no component needed to write it) and keep the
 * inferred `Args` and `Result` types, and its literal name, when it is
 * registered later.
 */
declare function defineWebMCPTool<Args = Record<string, unknown>, Result = unknown, const Name extends MaybeRefOrGetter<string> = string>(definition: Omit<UseWebMCPToolOptions<Args, Result>, 'name'> & {
    name: Name;
}): Omit<UseWebMCPToolOptions<Args, Result>, 'name'> & {
    name: Name;
};
type AnyToolOptions = UseWebMCPToolOptions<any, any>;
/** Options applied to every tool in the group unless the tool sets its own. */
interface UseWebMCPToolsSharedOptions {
    enabled?: MaybeRefOrGetter<boolean>;
    annotations?: MaybeRefOrGetter<WebMCPToolAnnotations | undefined>;
    exposedTo?: MaybeRefOrGetter<readonly string[] | undefined>;
    /** Receives the failing tool's name as well, since one handler serves the group. */
    onError?: (error: unknown, name: string) => void;
}
/** Static tool names in a definitions tuple; reactive names fall back to `string`. */
type ToolNames<T extends readonly AnyToolOptions[]> = T[number]['name'] extends string ? T[number]['name'] : string;
interface UseWebMCPToolsReturn<Names extends string = string> {
    /** A modelContext API exists in this environment. */
    isSupported: Readonly<Ref<boolean>>;
    /**
     * Every enabled tool in the group is registered. Tools switched off through
     * `enabled` are left out, so a group with its read tools on and its write
     * tools off still counts as registered; `false` while no tool is enabled.
     */
    isRegistered: Readonly<Ref<boolean>>;
    /** The first registration failure in the group, if any. */
    error: Readonly<Ref<Error | null>>;
    /** Per-tool state, keyed by each tool's name at setup time. */
    byName: Readonly<Record<Names, UseWebMCPToolReturn>>;
}
/**
 * Registers a group of tools from one component or scope, with options
 * shared across the group. Each tool still goes through `useWebMCPTool`, so
 * per-tool `enabled`, `annotations`, `exposedTo` and `onError` win over the
 * shared ones, the per-tool state stays reachable through `byName`, and one
 * tool failing to register leaves the others registered.
 */
declare function useWebMCPTools<const T extends readonly AnyToolOptions[]>(definitions: T, shared?: UseWebMCPToolsSharedOptions): UseWebMCPToolsReturn<ToolNames<T>>;

interface UseRegisteredToolsOptions {
    /**
     * Origins whose tools to include on top of the same-origin default. Each
     * must be a secure origin whose document listed this page in `exposedTo`.
     */
    fromOrigins?: MaybeRefOrGetter<readonly string[] | undefined>;
    /**
     * How to hand arguments to `executeTool()`. Leave unset to detect it: the
     * JSON string Chrome shipped with is tried first, and the object form the
     * spec adopted in PR #246 (2026-08-17) is used from then on if the browser
     * rejects the string with a `TypeError`. Set it to skip the detection.
     */
    argumentFormat?: 'object' | 'json';
}
/**
 * Options for the composable's `execute`; the browser-level counterpart is
 * `ExecuteToolOptions`.
 */
interface ExecuteRegisteredToolOptions {
    /** Aborts the execution; the tool's `execute` sees it through its own signal. */
    signal?: AbortSignal;
}
interface UseRegisteredToolsReturn {
    /** `getTools()` and `executeTool()` exist here. Flips reactively if injected late. */
    isSupported: Readonly<Ref<boolean>>;
    /** Tools this document may call, sorted by name, refreshed on `toolchange`. */
    tools: Readonly<ShallowRef<readonly RegisteredTool[]>>;
    /** Failure of the last `getTools()` call. */
    error: Readonly<Ref<Error | null>>;
    /** Query `getTools()` again. Runs by itself on every `toolchange` event. */
    refresh: () => Promise<void>;
    /**
     * Run a discovered tool in its owner's document. Resolves with the tool's
     * result parsed from the JSON the browser returns, so an MCP-shaped result
     * comes back as `{ content: [...] }`. Rejects with the browser's
     * `DOMException` when the tool or the browser fails, and with a
     * `NotSupportedError` when the API is absent.
     */
    execute: (tool: RegisteredTool, args?: object, options?: ExecuteRegisteredToolOptions) => Promise<unknown>;
}
/**
 * Lists the WebMCP tools this document may call and lets it run them, for
 * in-page agents, dev panels, or an iframe-hosted agent reading a partner
 * page's tools. Follows the `toolchange` event, so the list stays current as
 * components register and unregister tools.
 *
 * Feature-detects `document.modelContext.getTools` and stays empty where the
 * consumer side of the API is absent, including during SSR.
 */
declare function useRegisteredTools(options?: UseRegisteredToolsOptions): UseRegisteredToolsReturn;

declare global {
    interface SubmitEvent {
        /** True when an agent submitted the form through its WebMCP tool. */
        readonly agentInvoked: boolean;
        /**
         * Hands the agent the tool result: the resolved value is serialized and
         * returned to the model. Call `preventDefault()` first, and call it while
         * the event is being dispatched.
         */
        respondWith(agentResponse: Promise<any>): void;
    }
    /** `toolactivated` / `toolcancel` on `window`; neither bubbles nor cancels. */
    interface WebMCPEvent extends Event {
        readonly toolName: string;
    }
    interface WindowEventMap {
        toolactivated: WebMCPEvent;
        toolcancel: WebMCPEvent;
    }
}
/** One entry, or every entry when a name repeats (a checkbox group, `<select multiple>`). */
type FormFieldValue = FormDataEntryValue | FormDataEntryValue[];
type FormFields = Record<string, FormFieldValue>;
interface UseWebMCPFormOptions<Fields extends FormFields = FormFields, Result = unknown> {
    /** The form's `toolname`. */
    name: MaybeRefOrGetter<string>;
    /** The form's `tooldescription`. */
    description: MaybeRefOrGetter<string>;
    /** Let the agent submit without a click (`toolautosubmit`). */
    autosubmit?: MaybeRefOrGetter<boolean>;
    /**
     * Handles a submission, by a person or by an agent, with the form's fields
     * as `FormData` entries. The return value is normalized like a
     * `useWebMCPTool` result and handed to the agent when one asked.
     */
    execute: (fields: Fields, event: SubmitEvent) => Result | Promise<Result>;
    /** Optional shaper applied to the result before normalization. */
    formatOutput?: (result: Result, fields: Fields) => unknown;
    /** Side effect when `execute` throws; the failure also lands in `error`. */
    onError?: (error: unknown) => void;
}
interface WebMCPFormAttrs {
    toolname: string;
    tooldescription: string;
    toolautosubmit?: '';
    onSubmit: (event: Event) => Promise<void>;
}
interface UseWebMCPFormReturn {
    /** Spread onto the form: `<form v-bind="attrs">`. */
    attrs: ComputedRef<WebMCPFormAttrs>;
    /** The submit handler on its own, for a form that sets the attributes itself. */
    onSubmit: (event: Event) => Promise<void>;
    /**
     * An agent is filling the form in (`toolactivated` until `toolcancel` or
     * submit). Stays `false` for an autosubmit form, which the browser submits
     * before it activates; `isSubmitting` covers that call.
     */
    isAgentActive: Readonly<Ref<boolean>>;
    isSubmitting: Readonly<Ref<boolean>>;
    /** What the last submission threw, until the next one. */
    error: Readonly<Ref<Error | null>>;
}
/**
 * Wires a declarative WebMCP form: sets `toolname` / `tooldescription`,
 * answers an agent's submission through `respondWith()`, and tracks whether
 * an agent is currently filling the form in. The same handler serves a
 * person clicking Submit, so the form's `action` never navigates.
 */
declare function useWebMCPForm<Fields extends FormFields = FormFields, Result = unknown>(options: UseWebMCPFormOptions<Fields, Result>): UseWebMCPFormReturn;

interface WebMCPToolCallEvent {
    name: string;
    /** Present only with `includeArgs: true`. The same object `execute` receives; do not mutate it. */
    args?: unknown;
}
interface WebMCPToolResultEvent {
    name: string;
    /** `false` when `execute` threw or returned an `isError` result. */
    ok: boolean;
    /** Wall-clock duration of the call in milliseconds. */
    ms: number;
    /** What the agent receives, after normalization. */
    response: WebMCPToolResponse;
    /**
     * What `execute` threw or returned as an `Error`, when `ok` is false for
     * that reason; in `'error'` budget mode also the oversized-result failure.
     */
    error?: unknown;
    /** Present only with `includeArgs: true`. */
    args?: unknown;
}
/**
 * App-level settings for every `useWebMCPTool` call below the provider,
 * read once when each tool is set up. Provide it once at the root:
 * `app.provide(WEBMCP_CONFIG, ...)` reaches everything, including tools
 * registered from Pinia stores or under `app.runWithContext`;
 * `provideWebMCPConfig()` in a root component's setup reaches that
 * component's subtree only.
 */
interface WebMCPConfig {
    /**
     * What happens when a name, description, parameter or result is over
     * Chrome's character budgets. `'warn'` logs (the default in development).
     * `'error'` fails setup for an over-budget initial definition (a thrown
     * error in a dev or test build; the server never validates), records a
     * later over-budget change in `error` without registering, and turns an
     * oversized result into an `isError` response. `false` skips the checks
     * (the default in production). An explicit `'warn'` is honoured in
     * production too, so leave it unset outside test runs.
     */
    budgets?: 'warn' | 'error' | false;
    /**
     * Include the call arguments in hook payloads. Off by default: arguments
     * often carry personal data that should not reach an analytics tool.
     */
    includeArgs?: boolean;
    /** Runs before `execute`. */
    onToolCall?: (event: WebMCPToolCallEvent) => void;
    /** Runs after the result is normalized, for success and failure alike. */
    onToolResult?: (event: WebMCPToolResultEvent) => void;
}
declare const WEBMCP_CONFIG: InjectionKey<WebMCPConfig>;
/**
 * Call in a component's `setup()` to configure its subtree. For the whole
 * app, including Pinia stores, use `app.provide(WEBMCP_CONFIG, config)`.
 */
declare function provideWebMCPConfig(config: WebMCPConfig): void;

/**
 * MCP result normalization.
 *
 * Derived from use-webmcp-tool (https://github.com/GoogleChromeLabs/use-webmcp-tool),
 * Copyright 2026 Google LLC, Apache-2.0. See the NOTICE file at the repository root.
 * The normalization matrix is kept in behavioral lockstep with that project so
 * agents observe identical results from the React and Vue integrations.
 */

declare function toToolResponse(value: unknown): WebMCPToolResponse;
declare function toErrorResponse(error: unknown): WebMCPToolResponse;

export { RegisteredTool, WEBMCP_CONFIG, WebMCPToolAnnotations, WebMCPToolExecuteOptions, WebMCPToolResponse, defineWebMCPTool, provideWebMCPConfig, toErrorResponse, toToolResponse, useRegisteredTools, useWebMCPForm, useWebMCPTool, useWebMCPTools };
export type { ExecuteRegisteredToolOptions, FormFieldValue, FormFields, UseRegisteredToolsOptions, UseRegisteredToolsReturn, UseWebMCPFormOptions, UseWebMCPFormReturn, UseWebMCPToolOptions, UseWebMCPToolReturn, UseWebMCPToolsReturn, UseWebMCPToolsSharedOptions, WebMCPConfig, WebMCPFormAttrs, WebMCPToolCallEvent, WebMCPToolResultEvent };