@useago/sdk 1.9.0 → 1.13.0

package/dist/index.d.cts

@@ -92,6 +92,7 @@ export declare class AgoClient {
     private contextRegistry;
     private eventEmitter;
     private activityLedger;
+    private errorWatcher;
     private lastSentPageState;
     private config;
     /** Conversations already warned about an empty reply (one warning each). */
@@ -130,7 +131,10 @@ export declare class AgoClient {
      * `null` otherwise.
      */
     proactive: ProactiveController | null;
+    /** Removes the mirrored WebMCP tools; `null` when the bridge is off. */
+    private detachWebMCP;
     constructor(config: AgoConfig);
+    private attachWebMCPBridge;
     /**
      * Send a message and receive a streaming response
      */
@@ -242,6 +246,7 @@ export declare class AgoClient {
      * (the agent decides what to do next). No-op if the invocation is unknown.
      */
     rejectFunction(invocationId: string): Promise<void>;
+    /* Excluded from this release type: runExternalFunction */
     /**
      * Get a page of conversations, newest-first. `pageSize` is capped at 100 by
      * the backend (default 50). Returns the `{ data, has_more, total }` envelope
@@ -261,6 +266,35 @@ export declare class AgoClient {
      * `SSEHandler.parseToolCall` so persisted and streamed tool calls match.
      */
     private static mapPersistedToolCalls;
+    /**
+     * Transcribe an audio file into editable text (`POST /api/sdk/v1/audio/transcriptions`).
+     * Requires speech to text to be enabled for the tenant. Supports FLAC, MP3,
+     * MP4, MPEG, MPGA, M4A, OGG, WAV and WebM files up to 25 MB.
+     * The filename must include the matching extension. For a MediaRecorder blob,
+     * wrap it in a File with the recording's extension and MIME type.
+     * Show the returned text as a draft; call `sendMessage` when the user sends it.
+     */
+    transcribeAudio(file: File, options?: TranscribeAudioOptions): Promise<AudioTranscription>;
+    /**
+     * The tenant's SDK configuration (`GET /api/sdk/v1/config`): per-permission
+     * agents, the ticket form the agent's `ago_ticketing` tool opens, and the
+     * file-attachment and speech-to-text flags. The vanilla widget fetches it
+     * once, when a ticket form first appears in a conversation.
+     */
+    getConfig(): Promise<SdkConfig>;
+    /**
+     * The dashboard's home screen content. A starter card shows its
+     * `description` and sends its `initial_message`; one with neither is
+     * unusable and is dropped rather than rendered as an empty card.
+     */
+    private static mapHomePage;
+    private static mapTicketForm;
+    /**
+     * Create a support ticket (`POST /api/sdk/v1/tickets`, multipart). This is
+     * what the ticket form in the conversation does before it completes the
+     * `form` tool call with {@link submitToolCallForm}.
+     */
+    createTicket(input: CreateTicketInput): Promise<CreateTicketResult>;
     /**
      * Get messages for a conversation
      */
@@ -382,6 +416,9 @@ export declare class AgoClient {
      * Get all registered function schemas
      */
     getRegisteredFunctions(): ClientFunctionSchema[];
+    /** The callback form of `functions:changed`. Returns an unsubscribe. */
+    onFunctionsChanged(listener: () => void): () => void;
+    /* Excluded from this release type: getFunctionRegistrations */
     /**
      * Execute a registered client function locally, through the same
      * FunctionRegistry path (result-size guard, error wrapping) as agent-invoked
@@ -519,6 +556,15 @@ export declare class AgoClient {
     /* Excluded from this release type: emitProactiveEvent */
     /* Excluded from this release type: getHttp */
     /* Excluded from this release type: getConfiguredAgent */
+    /**
+     * How the SDK identifies the visitor: the configured `userEmail`, and
+     * whether a `userJwt` is set. The ticket form asks for an email when it has
+     * neither.
+     */
+    getUserIdentity(): {
+        email?: string;
+        hasJwt: boolean;
+    };
     /**
      * Enable automatic capture of the current browser page (URL + title).
      * Injected as a dynamic context entry named `browser-page`.
@@ -541,6 +587,26 @@ export declare class AgoClient {
     private addActivity;
     private recordAgentAction;
     private registerActivityContext;
+    /**
+     * Start capturing the page's JavaScript errors (uncaught exceptions,
+     * unhandled rejections, `console.error` calls, {@link reportError}) and send
+     * the recent ones as the `errors:recent` context entry on every message.
+     * Same as setting `errorWatcher` in the config. Calling it again replaces
+     * the watcher (and its options); the captured errors are not kept.
+     */
+    enableErrorWatcher(options?: ErrorWatcherOptions): void;
+    /** Stop capturing errors and drop the `errors:recent` context entry. */
+    disableErrorWatcher(): void;
+    /**
+     * Record an error the app caught itself (React error boundary, Vue
+     * `errorHandler`, Angular `ErrorHandler`, a try/catch) so the agent sees it
+     * like an uncaught one. No-op unless the error watcher is enabled. `context`
+     * is size-clamped before it is stored; keep it small and free of secrets.
+     */
+    reportError(error: unknown, context?: Record<string, unknown>): void;
+    /** Errors the watcher currently holds, oldest first (a copy). Empty when disabled. */
+    getRecentErrors(): CapturedError[];
+    clearErrors(): void;
     /**
      * Subscribe to an event
      */
@@ -685,6 +751,8 @@ export declare interface AgoClientEvents {
      * call running immediately.
      */
     "function:awaiting-approval": ClientFunctionInvocation;
+    /** A function was registered or unregistered, or the registry cleared. */
+    "functions:changed": ClientFunctionSchema[];
     "function:result": {
         invocationId: string;
         result: unknown;
@@ -735,6 +803,12 @@ export declare interface AgoClientEvents {
     };
     /** A user- or agent-action was recorded into the activity ledger. */
     "activity:recorded": ActivityEntry;
+    /**
+     * The error watcher captured a JavaScript error (uncaught exception,
+     * unhandled rejection, `console.error` call, or `reportError`). Fires on
+     * repeats too, with the updated `count`. Requires `errorWatcher` in the config.
+     */
+    "error:captured": CapturedError;
 }
 
 /**
@@ -751,10 +825,14 @@ export declare interface AgoConfig {
     defaultAgentId?: string;
     /** Permission name to apply to all requests (sent as `X-Widget-Permission`). Mirrors the widget's `window.AGO.permission`. */
     permission?: string;
+    /** Interface locale selected by the host app, sent as Accept-Language. Null clears the override. */
+    language?: string | null;
     /** User email for identification */
     userEmail?: string;
     /** JWT token for authenticated users */
     userJwt?: string;
+    /** User metadata sent with messages. Use null to stop sending defaults. Not an authentication credential. */
+    metadata?: Record<string, unknown> | null;
     /** Enable debug logging */
     debug?: boolean;
     /**
@@ -814,6 +892,27 @@ export declare interface AgoConfig {
      * default otherwise.
      */
     proactive?: ProactiveOptions;
+    /**
+     * Capture the page's JavaScript errors as agent context. When set, the SDK
+     * listens for uncaught exceptions and unhandled promise rejections, wraps
+     * `console.error` (calling through; restored on `destroy`), and sends the
+     * recent errors (deduplicated, capped, pruned after 10 min) as the
+     * `errors:recent` context entry on every message. `true` uses the defaults;
+     * pass {@link ErrorWatcherOptions} to tune the caps or add a `filter` that
+     * redacts messages. Off by default: error messages can carry PII or internal
+     * URLs, so enabling it is the host's call. Errors also feed the proactive
+     * mode's `jsErrors` signal. See `client.reportError()` for caught errors.
+     */
+    errorWatcher?: boolean | ErrorWatcherOptions;
+    /** Mirror every registered client function into the browser's WebMCP registry
+     * (`document.modelContext`), so an external agent can call the same functions
+     * the in-app agent calls. Off by default; no-ops without WebMCP.
+     *
+     * A mirrored function runs immediately: the approval gate
+     * ({@link approvalPolicy}, `requiresApproval`) covers the agent loop only.
+     * Use `webmcp: false` on a definition to keep it out.
+     */
+    webmcp?: boolean;
 }
 
 /**
@@ -1130,6 +1229,11 @@ declare interface ApiErrorResponse {
  */
 export declare function attachAutoContinueAfterNavigation(client: AgoClient, options?: AgoAutoContinueOptions | (() => AgoAutoContinueOptions | undefined)): () => void;
 
+/** Editable text returned by `AgoClient.transcribeAudio`. */
+export declare interface AudioTranscription {
+    text: string;
+}
+
 /**
  * Auto-detect AGO configuration from the DOM environment.
  *
@@ -1151,6 +1255,32 @@ export declare function autoDetectConfig(overrides?: Partial<AgoConfig>): AgoCon
  */
 export declare function canInlineImage(attachment: AgoAttachment): boolean;
 
+/** One JavaScript error captured on the page (deduplicated, see `count`). */
+export declare interface CapturedError {
+    type: CapturedErrorType;
+    /** Error message, truncated to 500 chars. */
+    message: string;
+    /** Script URL the error came from, without its query string. */
+    source?: string;
+    line?: number;
+    col?: number;
+    /** Leading stack frames, truncated (see `maxStackChars`). */
+    stack?: string;
+    /** Pathname at capture time. */
+    route: string;
+    /** Epoch ms of the first occurrence. */
+    firstAt: number;
+    /** Epoch ms of the most recent occurrence. */
+    lastAt: number;
+    /** How many times this same error (type + message + source + line) fired. */
+    count: number;
+    /** App-provided context, manual reports only (size-clamped). */
+    context?: Record<string, unknown>;
+}
+
+/** How an error reached the watcher. */
+export declare type CapturedErrorType = "error" | "unhandledrejection" | "console" | "manual";
+
 /**
  * Registry that collects client-side context from across the component tree.
  *
@@ -1207,22 +1337,11 @@ export declare type ClientFunction = (args: Record<string, unknown>) => Promise<
  * client.registerFunction(fn);
  * ```
  */
-export declare interface ClientFunctionDefinition {
+export declare interface ClientFunctionDefinition extends ClientFunctionSettings {
     name: string;
     description: string;
     parameters: ClientFunctionSchema["parameters"];
     handler: ClientFunctionHandler;
-    /**
-     * Max serialized result size in bytes before the SDK truncates it to a
-     * flagged preview (default: `AgoConfig.maxFunctionResultBytes`, 50 000).
-     * `Infinity` disables the guard for this function.
-     */
-    maxResultBytes?: number;
-    /**
-     * Require explicit user approval before this function runs. See
-     * {@link AgoConfig.approvalPolicy} — pause mode only. ORs with the policy.
-     */
-    requiresApproval?: boolean;
 }
 
 /**
@@ -1241,20 +1360,7 @@ export declare interface ClientFunctionInvocation {
  * Schema-plus-settings object accepted when registering a function: the schema
  * (minus `name`) and SDK-side options that are NOT sent to the backend.
  */
-export declare type ClientFunctionRegisterOptions = Omit<ClientFunctionSchema, "name"> & {
-    /**
-     * Max serialized result size in bytes before the SDK truncates it to a
-     * flagged preview. Overrides the client-level default
-     * (`AgoConfig.maxFunctionResultBytes`, 50 000 by default). `Infinity`
-     * disables the guard for this function.
-     */
-    maxResultBytes?: number;
-    /**
-     * Require explicit user approval before this function runs. See
-     * {@link AgoConfig.approvalPolicy} — pause mode only. ORs with the policy.
-     */
-    requiresApproval?: boolean;
-};
+export declare type ClientFunctionRegisterOptions = Omit<ClientFunctionSchema, "name"> & ClientFunctionSettings;
 
 /**
  * Schema for a client-side function that AGO can call
@@ -1281,6 +1387,28 @@ export declare interface ClientFunctionSchema {
     };
 }
 
+/** SDK-side function settings that are never sent to the backend. */
+declare interface ClientFunctionSettings {
+    /**
+     * Max serialized result size in bytes before the SDK truncates it to a
+     * flagged preview. Overrides the client-level default
+     * (`AgoConfig.maxFunctionResultBytes`, 50 000 by default). `Infinity`
+     * disables the guard for this function.
+     */
+    maxResultBytes?: number;
+    /**
+     * Require explicit user approval before this function runs. See
+     * {@link AgoConfig.approvalPolicy} — pause mode only. ORs with the policy.
+     */
+    requiresApproval?: boolean;
+    /**
+     * WebMCP metadata, read only when the bridge is on (`AgoConfig.webmcp`).
+     * `false` keeps this function out of WebMCP while leaving it available to the
+     * in-app agent.
+     */
+    webmcp?: WebMCPToolMeta | false;
+}
+
 /** See {@link AgoConfig.clientFunctionsMode}. */
 export declare type ClientFunctionsMode = "placeholder" | "pause";
 
@@ -1559,8 +1687,36 @@ export declare function createMockClient(options?: MockAgoClientOptions): MockAg
 
 export declare function createStore<T>(initial: T, persist?: PersistOptions): Store<T>;
 
+/** Input of `AgoClient.createTicket` (`POST /api/sdk/v1/tickets`). */
+declare interface CreateTicketInput {
+    subject: string;
+    body: string;
+    priority?: string;
+    typology?: string;
+    /** Conversation the ticket is filed from. */
+    conversationId?: string;
+    /** Reporter email, for a visitor the SDK does not otherwise identify. */
+    email?: string;
+    customFields?: Array<{
+        id: string;
+        value: string;
+    }>;
+    files?: File[];
+    ticketFormId?: string;
+}
+
+/** Response of `AgoClient.createTicket`. */
+declare interface CreateTicketResult {
+    id: string;
+    url?: string;
+}
+
 export declare const DEFAULT_MAX_ACTIVITY_ENTRIES = 10;
 
+export declare const DEFAULT_MAX_ERROR_AGE_MS = 600000;
+
+export declare const DEFAULT_MAX_ERRORS = 10;
+
 /**
  * Create a reusable function definition.
  * Returns the same object — this is an identity function for discoverability and type-checking.
@@ -1603,6 +1759,83 @@ export declare function deriveFormStatus(schema: FormCollectorSchema, values: Pa
  */
 export declare type DynamicContextProvider = () => ContextEntry | null | undefined;
 
+/**
+ * Captures the page's JavaScript errors so they can ride along as agent
+ * context: uncaught exceptions (`window` `error` event), unhandled promise
+ * rejections, every `console.error` call, and errors the app reports itself
+ * via {@link report}.
+ *
+ * Errors are deduplicated by type + message + source + line (a repeat bumps
+ * `count` and `lastAt`), capped at `maxErrors`, and pruned after `maxAgeMs`
+ * when read. Messages and stacks are truncated so one error cannot bloat the
+ * context.
+ *
+ * `console.error` capture wraps the console method. This is the one sanctioned
+ * exception to the SDK's no-global-mutation rule: the wrapper always calls the
+ * original, ignores the SDK's own `[AGO SDK]` lines, and is restored by
+ * {@link destroy} when it is still installed (another library may have
+ * wrapped it after us; in that case ours stays in the chain and keeps calling
+ * through).
+ *
+ * Attached by `AgoClient` when `errorWatcher` is set in the config; usable
+ * standalone. Listeners are attached only by `start()` and removed by
+ * `destroy()`. No-op outside a browser (SSR).
+ */
+export declare class ErrorWatcher {
+    private readonly maxErrors;
+    private readonly maxAgeMs;
+    private readonly maxStackChars;
+    private readonly filter?;
+    private started;
+    private teardowns;
+    private errors;
+    private listeners;
+    /** True while a capture is being processed (a throw inside must not recurse). */
+    private capturing;
+    constructor(options?: ErrorWatcherOptions);
+    /** Attach the listeners and wrap `console.error`. Idempotent; no-op in SSR. */
+    start(): void;
+    /** Remove the listeners, restore `console.error`, drop subscribers. */
+    destroy(): void;
+    /**
+     * Record an error the app caught itself (error boundary, framework error
+     * handler, try/catch). `context` is size-clamped before it is stored.
+     */
+    report(error: unknown, context?: Record<string, unknown>): void;
+    /** Subscribe to captures (fires once per capture, repeats included). */
+    subscribe(listener: (error: CapturedError) => void): () => void;
+    /** Errors still within `maxAgeMs`, oldest first (a copy). */
+    getErrors(): CapturedError[];
+    clear(): void;
+    private onErrorEvent;
+    private onRejectionEvent;
+    private wrapConsoleError;
+    private onConsoleError;
+    private capture;
+    private notify;
+    private prune;
+    /** Drop the leading "Name: message" line stacks repeat, then cap the length. */
+    private trimStack;
+    private currentPathname;
+}
+
+export declare interface ErrorWatcherOptions {
+    /** Max distinct errors kept. Oldest dropped first. Default 10. */
+    maxErrors?: number;
+    /**
+     * Errors older than this are pruned when the buffer is read, so a crash from
+     * an hour ago does not confuse the agent. Default 600 000 (10 min).
+     */
+    maxAgeMs?: number;
+    /** Max chars of stack kept per error. Default 2000. */
+    maxStackChars?: number;
+    /**
+     * Redact or drop an error before it is stored. Return the (possibly edited)
+     * error to keep it, `null` to drop it. Runs on every capture, so keep it cheap.
+     */
+    filter?: (error: CapturedError) => CapturedError | null;
+}
+
 /**
  * Simple typed event emitter
  */
@@ -1844,7 +2077,11 @@ export declare interface FunctionDefinition {
 export declare class FunctionRegistry {
     private functions;
     private defaultMaxResultBytes;
+    private changeListeners;
     constructor(options?: FunctionRegistryOptions);
+    /** Fires on registrations, unregistrations and clears. */
+    onChange(listener: () => void): () => void;
+    private emitChange;
     /** Update the client-level result-size ceiling at runtime. */
     setDefaultMaxResultBytes(bytes: number): void;
     /**
@@ -1875,6 +2112,13 @@ export declare class FunctionRegistry {
      * Get all registered function schemas (for sending to backend)
      */
     getSchemas(): ClientFunctionSchema[];
+    /**
+     * Every registration, name included, with the SDK-side settings
+     * {@link getSchemas} drops.
+     */
+    getAll(): Array<RegisteredFunction & {
+        name: string;
+    }>;
     /**
      * Execute a registered function
      */
@@ -2371,6 +2615,12 @@ export declare interface ProactiveTriggerWhen {
     pageState?: Partial<Record<string, unknown>>;
     /** Min rage-click bursts on the current route. */
     rageClicks?: number;
+    /**
+     * Min JavaScript errors captured on the current route. Needs the client's
+     * `errorWatcher` enabled; without it the count stays at 0 and the matcher
+     * never passes.
+     */
+    jsErrors?: number;
     /** Min A→B→A→B route oscillations this session. */
     routeBounces?: number;
     /** Per-field minimum error counts (field NAME → min count). */
@@ -2380,13 +2630,9 @@ export declare interface ProactiveTriggerWhen {
 /**
  * Registered function with handler
  */
-export declare interface RegisteredFunction {
+export declare interface RegisteredFunction extends ClientFunctionSettings {
     schema: ClientFunctionSchema;
     handler: ClientFunctionHandler;
-    /** Per-function result-size ceiling; falls back to the registry default. */
-    maxResultBytes?: number;
-    /** Require explicit user approval before running (pause mode only). */
-    requiresApproval?: boolean;
 }
 
 /**
@@ -2414,10 +2660,71 @@ export declare function safeAttachmentUrl(url?: string): string | undefined;
  */
 export declare const scrollToElement: ClientFunctionDefinition;
 
+/** Response of `GET /api/sdk/v1/config` (see `AgoClient.getConfig`). */
+export declare interface SdkConfig {
+    permissions: SdkPermissionConfig[];
+    proactive: {
+        enabled: boolean;
+    };
+}
+
+/** The dashboard's home screen content (title, subtitle, starter cards). */
+declare interface SdkHomePageConfig {
+    title?: string;
+    /** Markdown. */
+    subtitle?: string;
+    starters: SdkHomeStarter[];
+    widgetStarter?: SdkWidgetStarter;
+}
+
+/**
+ * A conversation starter card configured in the AGO dashboard. `label` is what
+ * the card shows; clicking it sends `message`.
+ */
+declare interface SdkHomeStarter {
+    id: string;
+    /** The card's text (the starter's `description` in the dashboard). */
+    label: string;
+    /** What is sent when the card is clicked. */
+    message: string;
+    /** Answer with this agent instead of the configured default. */
+    agentId?: string;
+}
+
+/** One permission's configuration in {@link SdkConfig}. */
+export declare interface SdkPermissionConfig {
+    id?: string;
+    name?: string;
+    displayName?: string;
+    agents: Array<{
+        id: string;
+        name?: string;
+    }>;
+    ticketForm?: TicketForm;
+    /** Home screen content, when the tenant configured one. */
+    homePage?: SdkHomePageConfig;
+    fileAttachmentsEnabled: boolean;
+    voiceEnabled: boolean;
+    /** Whether audio uploads can be transcribed. Defaults to false on older backends. */
+    speechToTextEnabled: boolean;
+}
+
+/**
+ * The starter the dashboard sends by itself on a fresh visit, before the
+ * visitor types anything.
+ */
+declare interface SdkWidgetStarter {
+    id: string;
+    message: string;
+    agentId?: string;
+}
+
 /**
  * Options for sending a message
  */
 export declare interface SendMessageOptions {
+    /** Replaces config.metadata for this message; null omits metadata for this message. */
+    metadata?: Record<string, unknown> | null;
     /** Existing conversation ID */
     conversationId?: string;
     /** Override default agent */
@@ -2483,8 +2790,9 @@ export declare interface Signal {
 
 /**
  * Framework-agnostic collector of client-side friction signals: per-route
- * dwell time, idle time, route bounces (A→B→A→B), rage clicks, and app-pushed
- * field error counters. Attached to an `AgoClient` by `createAgoProactive`,
+ * dwell time, idle time, route bounces (A→B→A→B), rage clicks, app-pushed
+ * field error counters, and JavaScript error counts (pushed by the client's
+ * `ErrorWatcher` through `createAgoProactive`). Attached to an `AgoClient` by `createAgoProactive`,
  * the same way `ClientContextRegistry` is attached.
  *
  * Route observation is poll-on-demand rather than a `history.pushState` patch:
@@ -2516,6 +2824,7 @@ export declare class SignalCollector {
     private recentRoutes;
     private routeBounces;
     private rageClicks;
+    private jsErrors;
     private fieldErrors;
     private recentClicks;
     private signals;
@@ -2533,9 +2842,15 @@ export declare class SignalCollector {
      * Pass the field NAME only — values are never read, so no PII is collected.
      */
     signalFieldError(fieldName: string): void;
+    /**
+     * Pushed signal: a JavaScript error was captured on the page. Counter only;
+     * `kind` says how it was caught (`error`, `unhandledrejection`, `console`,
+     * `manual`). The message itself never enters the signals channel.
+     */
+    signalJsError(kind: string): void;
     /**
      * Subscribe to raw signals (route changes, bounces, rage clicks, field
-     * errors). Returns an unsubscribe function. Used by the proactive engine to
+     * errors, JS errors). Returns an unsubscribe function. Used by the proactive engine to
      * evaluate promptly instead of waiting for the next tick.
      */
     subscribe(listener: (signal: Signal) => void): () => void;
@@ -2605,6 +2920,12 @@ export declare interface SignalsSnapshot {
     idleMs: number;
     /** Rage-click bursts detected on the current route. */
     rageClicks: number;
+    /**
+     * JavaScript errors captured on the current route (count only; the messages
+     * travel in `client_context` under `errors:recent`). Always `0` unless the
+     * client has `errorWatcher` enabled.
+     */
+    jsErrors: number;
     /**
      * A→B→A→B route oscillations detected in the recent route sequence. Rolling
      * session counter (cross-route by nature); trigger cooldowns and dismissal
@@ -2628,7 +2949,7 @@ export declare interface SignalsSnapshot {
  * Privacy rule: signals carry **enums, counters, and paths only** — never field
  * values or free text — so no PII ever leaves the page through this channel.
  */
-export declare type SignalType = "route_change" | "route_bounce" | "rage_click" | "field_error";
+export declare type SignalType = "route_change" | "route_bounce" | "rage_click" | "field_error" | "js_error";
 
 /**
  * SSE stream chunk data
@@ -2671,6 +2992,13 @@ export declare interface SSEChunkData {
     follow_up_replies?: string[];
     satisfaction_feedback?: unknown;
     ask_to_talk_to_human?: boolean;
+    allowed_to_create_ticket?: boolean;
+    ticket?: ToolCallTicketPrefill;
+    mode?: "form" | "embed";
+    ticket_form_id?: string;
+    embed_html?: string;
+    embed_description?: string;
+    display_mode?: "collapsible" | "display" | "both";
     /** Tool call ids still awaiting a client result, sent with the final `WAITING_CLIENT` event. */
     waiting_tool_call_ids?: string[];
 }
@@ -2839,12 +3167,82 @@ export declare const submitForm: ClientFunctionDefinition;
 export declare interface SubmitToolCallResult {
     status: string;
     result?: unknown;
+    /** Set when `status` is `"error"`. */
+    error?: string;
+    /** The ticket a ticketing `form` tool call resolved to, when it did. */
+    ticket?: {
+        ticket_id: string;
+        ticket_url?: string;
+        [key: string]: unknown;
+    };
     resume?: {
         message_id: string;
         ready: boolean;
     };
 }
 
+/** A custom field of a ticket form. */
+declare interface TicketField {
+    id: string;
+    /** The key the ticketing backend expects; used as the submit key when set. */
+    externalId?: string;
+    title?: string;
+    /** Field kind, e.g. `"text"`, `"checkbox"`, `"tagger"`. */
+    type?: string;
+    required: boolean;
+    /** Carried in the submission but never shown. */
+    hidden: boolean;
+    active?: boolean;
+    /** Bypass progressive disclosure, while still respecting conditions. */
+    alwaysVisible?: boolean;
+    regexpForValidation?: string;
+    position: number;
+    /** Non-empty turns the field into a select. */
+    options: TicketFieldOption[];
+    /** Show this field only when the parent field holds `conditionalFieldValue`. */
+    conditionalFieldId?: string;
+    /** Legacy comma-separated condition values. */
+    conditionalFieldValue?: string;
+    /** Takes precedence over conditionalFieldValue when non-empty. */
+    conditionalFieldValues?: string[];
+}
+
+/** An option of a ticket form field (`GET /config` → `ticket_form.fields[].options[]`). */
+declare interface TicketFieldOption {
+    id: string;
+    /** Label shown to the user. */
+    name?: string;
+    /** Value submitted. Falls back to `name` when absent. */
+    value?: string;
+    /** Preselected when the form opens. */
+    default: boolean;
+    /** A note shown under the field once this option is picked. */
+    message?: string;
+    messageType: "info" | "warning" | "danger";
+    position?: number;
+    group?: string;
+    noDisplay?: boolean;
+    conditionalFieldId?: string;
+    /** Available when the parent matches any of these values. */
+    conditionalFieldValues?: string[];
+}
+
+/** The ticket form an agent's `ago_ticketing` tool opens in the conversation. */
+declare interface TicketForm {
+    id: string;
+    name?: string;
+    /** `"form"` renders the SDK's own fields; `"embed"` hosts third-party HTML. */
+    mode: "form" | "embed";
+    showSubject: boolean;
+    showBody: boolean;
+    showPriority: boolean;
+    showTypology: boolean;
+    priorityTypologies?: string[];
+    successMessageText?: string;
+    successMessageUrlLabel?: string;
+    fields: TicketField[];
+}
+
 /**
  * Tool call data from SSE stream
  */
@@ -2859,6 +3257,34 @@ export declare interface ToolCallData {
     data?: Record<string, unknown>;
     functionName?: string;
     arguments?: Record<string, unknown>;
+    /**
+     * Where the hosted widget shows the call: in the collapsible "reasoning"
+     * section, in the message body, or both. Absent means collapsible only.
+     */
+    displayMode?: "collapsible" | "display" | "both";
+    /** The user asked to talk to a human. */
+    askToTalkToHuman?: boolean;
+    /** `false` when the tenant blocks ticket creation for this visitor. */
+    allowedToCreateTicket?: boolean;
+    /** Fields the agent pre-filled from the conversation. */
+    ticket?: ToolCallTicketPrefill;
+    /** `"embed"` hosts third-party HTML (`embedHtml`); otherwise the SDK's form. */
+    mode?: "form" | "embed";
+    ticketFormId?: string;
+    embedHtml?: string;
+    embedDescription?: string;
+}
+
+/** The ticket the agent pre-filled on a ticketing `form` tool call. */
+declare interface ToolCallTicketPrefill {
+    subject?: string;
+    body?: string;
+    typology?: string;
+    priority?: string;
+    tag?: string;
+    products?: string[];
+    /** Keyed by the field's external id, or a lowercased, underscored title. */
+    custom_fields?: Record<string, string>;
 }
 
 export declare type ToolCallType = "form" | "confirmation_input" | "status_message" | "progress_indicator" | "client_function" | "reasoning" | "mcp_ui_resource";
@@ -2869,6 +3295,12 @@ export declare type ToolCallType = "form" | "confirmation_input" | "status_messa
  */
 export declare const trackEvent: ClientFunctionDefinition;
 
+/** Options for `AgoClient.transcribeAudio`. */
+export declare interface TranscribeAudioOptions {
+    /** Cancel the upload or stop waiting for its transcription. */
+    signal?: AbortSignal;
+}
+
 /**
  * Validate an AgoConfig at the public API boundary.
  *
@@ -2892,6 +3324,25 @@ export declare const trackEvent: ClientFunctionDefinition;
  */
 export declare function validateConfig(config: unknown, context?: string): asserts config is AgoConfig;
 
+/** The MCP behavior hints AGO has no equivalent for. */
+export declare interface WebMCPToolMeta {
+    /**
+     * Both default to `false`, so only set what is true: `readOnlyHint` marks a
+     * function that changes nothing, `untrustedContentHint` one whose result may
+     * carry third-party text.
+     */
+    annotations?: {
+        readOnlyHint?: boolean;
+        untrustedContentHint?: boolean;
+    };
+    /**
+     * This function navigates. The WebMCP call is held open until the function
+     * registry goes quiet, so the caller sees the destination page's tools rather
+     * than the departing page's. Already set on the built-in `navigateToPage`.
+     */
+    navigates?: boolean;
+}
+
 /**
  * Attach a handler to a pre-built function definition.
  *