lua-cli 3.48.0 → 3.49.0

package/dist/api-exports.d.ts

@@ -199,6 +199,9 @@ declare interface AgentInvocationEffects {
     /** Set once per run when the agent reported it could not finish. Trusted
      *  side channel: the run's own account of why, not a regex over its prose. */
     blocker?: TaskRunBlocker;
+    /** BAC-1974: set when an unattended task run reported it had nothing to tell
+     *  the user. Same vocabulary as a workflow's declared `neutral` outcome (BAC-1949). */
+    declaredOutcome?: 'neutral';
 }
 
 export declare interface AgentInvocationInput {
@@ -388,6 +391,11 @@ declare interface AgentInvocationMeter {
      * that advertises no reasoning) — a non-effort turn's meter is byte-identical to today's.
      */
     effortApplied?: ReasoningEffort;
+    /**
+     * BAC-1976 — how many model steps the turn ran (`fullOutput.steps.length`), so the workflow worker can tell a
+     * step that hit the agent step cap from a clean finish. Server-owned like `effortApplied`; absent when unknown.
+     */
+    modelSteps?: number;
 }
 
 declare interface AgentInvocationOutput {
@@ -1935,23 +1943,542 @@ export declare interface BatchingConfig {
     serializeProcessing?: boolean;
 }
 
+export declare const Browser: BrowserApi;
+
+/**
+ * The full command surface (mirrors the desktop bridge's registry). Grouped the
+ * way the agent-browser CLI groups them so the surface is complete without
+ * 50+ near-duplicate names.
+ */
+declare const BROWSER_COMMANDS: readonly [{
+    readonly name: "health";
+    readonly description: "Check the local browser engine is installed and responsive.";
+}, {
+    readonly name: "session_open";
+    readonly description: "Open/attach a browser session (its own cookies/auth). Args: url?, headed?, profile?, confirmActions?. Only use the browser when the user explicitly asked for it, or said yes when you asked.";
+}, {
+    readonly name: "navigate";
+    readonly description: "Navigate the session to a URL. Args: url, waitUntil?. Only use the browser when the user explicitly asked for it, or said yes when you asked.";
+}, {
+    readonly name: "back";
+    readonly description: "Go back in history.";
+}, {
+    readonly name: "forward";
+    readonly description: "Go forward in history.";
+}, {
+    readonly name: "reload";
+    readonly description: "Reload the current page.";
+}, {
+    readonly name: "pushstate";
+    readonly description: "SPA client-side navigation. Args: url.";
+}, {
+    readonly name: "close";
+    readonly description: "Close the session’s browser.";
+}, {
+    readonly name: "read";
+    readonly description: "Read one page in a fresh session that is closed afterwards: open the URL, wait, return its title and content. Args: url, waitFor?(load|networkidle|selector), selector?, format?(text|html|markdown), timeoutMs?.";
+}, {
+    readonly name: "snapshot";
+    readonly description: "Accessibility-tree snapshot with element refs (@e1…) — see what to click/fill. Args: interactiveOnly?, selector?, urls?, compact?, depth?.";
+}, {
+    readonly name: "get";
+    readonly description: "Read from the page. Args: what(text|html|value|attr|title|url|count|box|styles), selector?, attr?.";
+}, {
+    readonly name: "is";
+    readonly description: "Check element state. Args: check(visible|enabled|checked), selector.";
+}, {
+    readonly name: "click";
+    readonly description: "Click an element. Args: selector(@eN or CSS), newTab?.";
+}, {
+    readonly name: "dblclick";
+    readonly description: "Double-click an element. Args: selector.";
+}, {
+    readonly name: "fill";
+    readonly description: "Clear and fill a field. Args: selector, text.";
+}, {
+    readonly name: "type";
+    readonly description: "Type into an element. Args: selector, text.";
+}, {
+    readonly name: "press";
+    readonly description: "Press a key/chord (Enter, Control+a). Args: key.";
+}, {
+    readonly name: "hover";
+    readonly description: "Hover an element. Args: selector.";
+}, {
+    readonly name: "focus";
+    readonly description: "Focus an element. Args: selector.";
+}, {
+    readonly name: "select";
+    readonly description: "Select a dropdown option. Args: selector, value.";
+}, {
+    readonly name: "check";
+    readonly description: "Check a checkbox. Args: selector.";
+}, {
+    readonly name: "uncheck";
+    readonly description: "Uncheck a checkbox. Args: selector.";
+}, {
+    readonly name: "scroll";
+    readonly description: "Scroll. Args: direction(up|down|left|right), px?, selector?.";
+}, {
+    readonly name: "scrollintoview";
+    readonly description: "Scroll an element into view. Args: selector.";
+}, {
+    readonly name: "drag";
+    readonly description: "Drag and drop. Args: source, target.";
+}, {
+    readonly name: "upload";
+    readonly description: "Upload local file(s) to a file input. Args: selector, files[].";
+}, {
+    readonly name: "find";
+    readonly description: "Act by semantic locator. Args: by(role|text|label|placeholder|alt|title|testid), query, action(click|fill|type|hover|focus|check|uncheck|text), value?, name?, exact?.";
+}, {
+    readonly name: "act";
+    readonly description: "Act on the page: ref+action (deterministic) or natural-language instruction (engine AI). Args: ref?, action?, value?, instruction?.";
+}, {
+    readonly name: "extract";
+    readonly description: "Extract data by natural-language instruction (engine AI). Args: instruction.";
+}, {
+    readonly name: "wait";
+    readonly description: "Wait for a condition. Provide one of: selector(+state), ms, text, url, load, fn.";
+}, {
+    readonly name: "tab";
+    readonly description: "Manage tabs. Args: action(list|new|switch|close), target?, url?, label?.";
+}, {
+    readonly name: "window_new";
+    readonly description: "Open a new browser window. Args: url?.";
+}, {
+    readonly name: "frame";
+    readonly description: "Switch frame context. Args: target(@eN | CSS | \"main\").";
+}, {
+    readonly name: "screenshot";
+    readonly description: "Screenshot the page. Args: fullPage?, path?.";
+}, {
+    readonly name: "pdf";
+    readonly description: "Save the page as PDF. Args: path.";
+}, {
+    readonly name: "cookies";
+    readonly description: "Manage cookies. Args: action(get|set|clear), name?, value?.";
+}, {
+    readonly name: "storage";
+    readonly description: "Manage web storage. Args: area(local|session), action(get|set|clear), key?, value?.";
+}, {
+    readonly name: "set";
+    readonly description: "Configure the browser. Args: setting(viewport|device|geo|headers|credentials|media), args[].";
+}, {
+    readonly name: "download";
+    readonly description: "Download a file (click a selector to trigger, or wait for one). Args: selector?, path?.";
+}, {
+    readonly name: "clipboard";
+    readonly description: "Clipboard. Args: action(read|write|copy|paste), text?.";
+}, {
+    readonly name: "auth";
+    readonly description: "Use a saved login profile. Args: action(login|list|show), name?. (Credentials are saved via the desktop, never the agent.)";
+}, {
+    readonly name: "confirm";
+    readonly description: "Approve a pending confirmation_required action. Args: id.";
+}, {
+    readonly name: "deny";
+    readonly description: "Reject a pending confirmation_required action. Args: id.";
+}, {
+    readonly name: "network";
+    readonly description: "Inspect/control network. Args: action(route|unroute|requests|har) + relevant fields.";
+}, {
+    readonly name: "console";
+    readonly description: "View browser console messages. Args: clear?.";
+}, {
+    readonly name: "errors";
+    readonly description: "View uncaught page JS errors. Args: clear?.";
+}, {
+    readonly name: "mouse";
+    readonly description: "Low-level mouse. Args: action(move|down|up|wheel), x?, y?, button?, dy?, dx?.";
+}, {
+    readonly name: "keyboard";
+    readonly description: "Low-level keyboard at focus. Args: action(type|inserttext|keydown|keyup), text?, key?.";
+}, {
+    readonly name: "state";
+    readonly description: "Persist/restore storage+auth state to a file. Args: action(save|load|list|clear), path?.";
+}];
+
+declare const BROWSER_ERROR_NAME = "BrowserError";
+
+declare const BROWSER_EXECUTE_STATUSES: readonly ["completed", "failed", "stopped"];
+
+declare const BROWSER_EXECUTE_STOP_REASONS: readonly ["done", "model_failed", "max_steps", "cost_cap", "timeout", "confirmation_required", "invalid_action", "repeated_action", "schema_mismatch", "browser_error", "cancelled", "error"];
+
+declare const BROWSER_FALLBACKS: readonly ["browser-use", "none"];
+
+declare const BROWSER_LOG_CONTENT_MODES: readonly ["summary", "full", "none"];
+
+declare const BROWSER_READ_FORMATS: readonly ["text", "html", "markdown"];
+
+declare const BROWSER_READ_LOAD_STATES: readonly ["load", "networkidle"];
+
+declare const BROWSER_READ_LOGIN_BLOCKER = "login_required";
+
+declare const BROWSER_SCREENSHOT_POLICIES: readonly ["always", "onError", "never"];
+
+export declare interface BrowserApi extends BrowserStepwiseApi {
+    read(url: string, options?: BrowserApiReadOptions): Promise<BrowserReadResult>;
+    execute(input: BrowserExecuteInput): Promise<BrowserExecuteResult>;
+}
+
+export declare type BrowserApiReadOptions = BrowserReadOptions & BrowserProfileOption;
+
+export declare interface BrowserCommandInputs {
+    health: BrowserSessionInput;
+    session_open: BrowserSessionInput & {
+        url?: string;
+        headed?: boolean;
+        profile?: string;
+        confirmActions?: string[];
+    };
+    navigate: UrlInput & {
+        waitUntil?: LoadState;
+    };
+    back: BrowserSessionInput;
+    forward: BrowserSessionInput;
+    reload: BrowserSessionInput;
+    pushstate: UrlInput;
+    close: BrowserSessionInput;
+    snapshot: BrowserSessionInput & {
+        interactiveOnly?: boolean;
+        selector?: string;
+        urls?: boolean;
+        compact?: boolean;
+        depth?: number;
+    };
+    get: BrowserSessionInput & {
+        what: 'text' | 'html' | 'value' | 'attr' | 'title' | 'url' | 'count' | 'box' | 'styles';
+        selector?: string;
+        attr?: string;
+    };
+    is: SelectorInput & {
+        check: 'visible' | 'enabled' | 'checked';
+    };
+    click: SelectorInput & {
+        newTab?: boolean;
+    };
+    dblclick: SelectorInput;
+    fill: SelectorTextInput;
+    type: SelectorTextInput;
+    press: BrowserSessionInput & {
+        key: string;
+    };
+    hover: SelectorInput;
+    focus: SelectorInput;
+    select: SelectorInput & {
+        value: string;
+    };
+    check: SelectorInput;
+    uncheck: SelectorInput;
+    scroll: BrowserSessionInput & {
+        direction: 'up' | 'down' | 'left' | 'right';
+        px?: number;
+        selector?: string;
+    };
+    scrollintoview: SelectorInput;
+    drag: BrowserSessionInput & {
+        source: string;
+        target: string;
+    };
+    upload: SelectorInput & {
+        files: string[];
+    };
+    find: BrowserSessionInput & {
+        by: 'role' | 'text' | 'label' | 'placeholder' | 'alt' | 'title' | 'testid';
+        query: string;
+        action: 'click' | 'fill' | 'type' | 'hover' | 'focus' | 'check' | 'uncheck' | 'text';
+        value?: string;
+        name?: string;
+        exact?: boolean;
+    };
+    act: BrowserSessionInput & {
+        ref?: string;
+        action?: string;
+        value?: string;
+        instruction?: string;
+    };
+    extract: BrowserSessionInput & {
+        instruction: string;
+    };
+    wait: BrowserSessionInput & {
+        selector?: string;
+        state?: 'visible' | 'hidden';
+        ms?: number;
+        text?: string;
+        url?: string;
+        load?: LoadState;
+        fn?: string;
+    };
+    tab: BrowserSessionInput & {
+        action: 'list' | 'new' | 'switch' | 'close';
+        target?: string;
+        url?: string;
+        label?: string;
+    };
+    window_new: BrowserSessionInput & {
+        url?: string;
+    };
+    frame: BrowserSessionInput & {
+        target: string;
+    };
+    screenshot: BrowserSessionInput & {
+        fullPage?: boolean;
+        path?: string;
+    };
+    pdf: BrowserSessionInput & {
+        path: string;
+    };
+    cookies: BrowserSessionInput & {
+        action: 'get' | 'set' | 'clear';
+        name?: string;
+        value?: string;
+    };
+    storage: BrowserSessionInput & {
+        area: 'local' | 'session';
+        action: 'get' | 'set' | 'clear';
+        key?: string;
+        value?: string;
+    };
+    set: BrowserSessionInput & {
+        setting: 'viewport' | 'device' | 'geo' | 'headers' | 'credentials' | 'media' | 'offline';
+        args: Array<string | number>;
+    };
+    download: BrowserSessionInput & {
+        selector?: string;
+        path?: string;
+    };
+    clipboard: BrowserSessionInput & {
+        action: 'read' | 'write' | 'copy' | 'paste';
+        text?: string;
+    };
+    auth: BrowserSessionInput & {
+        action: 'login' | 'list' | 'show';
+        name?: string;
+    };
+    confirm: IdInput;
+    deny: IdInput;
+    network: BrowserSessionInput & {
+        action: 'route' | 'unroute' | 'requests' | 'har';
+        url?: string;
+        abort?: boolean;
+        body?: string;
+        resourceType?: string;
+        filter?: string;
+        type?: string;
+        method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
+        status?: string;
+        requestId?: string;
+    };
+    console: ClearInput;
+    errors: ClearInput;
+    mouse: BrowserSessionInput & {
+        action: 'move' | 'down' | 'up' | 'wheel';
+        x?: number;
+        y?: number;
+        button?: 'left' | 'right' | 'middle';
+        dy?: number;
+        dx?: number;
+    };
+    keyboard: BrowserSessionInput & {
+        action: 'type' | 'inserttext' | 'keydown' | 'keyup';
+        text?: string;
+        key?: string;
+    };
+    state: BrowserSessionInput & {
+        action: 'save' | 'load' | 'list' | 'clear';
+        path?: string;
+    };
+}
+
+declare type BrowserCommandMethod<I> = {} extends I ? (input?: I) => Promise<BrowserCommandResult> : (input: I) => Promise<BrowserCommandResult>;
+
+/** Union of every command name. */
+declare type BrowserCommandName = (typeof BROWSER_COMMANDS)[number]['name'];
+
+declare interface BrowserCommandOutput {
+    /**
+     * Which engine served the command. `none` = a precondition failed before any
+     * engine ran (e.g. missing agentId, or a local-only policy with no device) —
+     * so callers don't mistake it for a failed cloud attempt.
+     */
+    engine: 'local' | 'cloud-agent-browser' | 'cloud' | 'none';
+    data?: unknown;
+    error?: string;
+    code?: string;
+}
+
+export declare interface BrowserCommandResult extends BrowserCommandOutput {
+    code?: BrowserErrorCode | (string & {});
+}
+
+/**
+ * Which engine a browser command may run on. `auto` (default) prefers the local
+ * desktop Device and falls back to the cloud; `agent-browser` is local-only (no
+ * paid cloud fallback); `browser-use` is cloud-only. Mirrors
+ * `BrowserSwitchConfig.engine` on the dev-facing switch.
+ */
+declare type BrowserEngine = 'auto' | 'agent-browser' | 'browser-use';
+
+export declare type BrowserErrorCode = 'BROWSER_DISABLED' | 'BROWSER_UNAVAILABLE' | 'BROWSER_RUN_SCOPE_MISSING' | 'BROWSER_WORKER_NOT_CONFIGURED' | 'BROWSER_DOMAIN_NOT_ALLOWED' | 'BROWSER_PROFILE_NOT_FOUND' | 'session_lost' | 'unreachable' | BrowserWorkerErrorCode;
+
+export declare interface BrowserErrorFields {
+    name: typeof BROWSER_ERROR_NAME;
+    /** `'http_error'`: the page answered an HTTP error status with nothing to read; see `status`. */
+    code: BrowserErrorCode;
+    /** HTTP status of the page's main document, when the error is an `'http_error'` and the status is known. */
+    status?: number;
+}
+
+export declare interface BrowserExecuteInput {
+    task: string;
+    sessionKey?: string;
+    url?: string;
+    startUrl?: string;
+    schema?: Record<string, unknown>;
+    maxSteps?: number;
+    maxCostUsd?: number;
+    model?: string;
+    timeoutMs?: number;
+    allowAnyDomain?: boolean;
+    allowedDomains?: string[];
+    browser?: string;
+}
+
+export declare interface BrowserExecutePendingAction {
+    category: string;
+    action: string;
+    url?: string;
+    confirmationId?: string;
+}
+
+export declare interface BrowserExecuteResult {
+    status: BrowserExecuteStatus;
+    output: unknown;
+    steps: number;
+    stopReason?: BrowserExecuteStopReason;
+    costUsd?: number;
+    finalUrl?: string;
+    engine: BrowserCommandOutput['engine'];
+    error?: string;
+    code?: string;
+    pendingAction?: BrowserExecutePendingAction;
+    history?: BrowserExecuteStep[];
+    liveUrl?: string;
+    sessionKey?: string;
+    detail?: string;
+    navigationScope?: string[];
+}
+
+export declare type BrowserExecuteStatus = (typeof BROWSER_EXECUTE_STATUSES)[number];
+
+export declare interface BrowserExecuteStep {
+    step: number;
+    intent: string;
+    action: string;
+    url?: string;
+    ok: boolean;
+    error?: string;
+}
+
+export declare type BrowserExecuteStopReason = (typeof BROWSER_EXECUTE_STOP_REASONS)[number];
+
+declare type BrowserFallback = (typeof BROWSER_FALLBACKS)[number];
+
+declare type BrowserLogContent = (typeof BROWSER_LOG_CONTENT_MODES)[number];
+
+export declare interface BrowserProfileOption {
+    browser?: string;
+}
+
+export declare type BrowserReadFormat = (typeof BROWSER_READ_FORMATS)[number];
+
+export declare type BrowserReadLoadState = (typeof BROWSER_READ_LOAD_STATES)[number];
+
+export declare interface BrowserReadOptions {
+    /** Wait before reading: `'load'`, `'networkidle'`, or a CSS selector that must appear. */
+    waitFor?: BrowserReadLoadState | (string & {});
+    /**
+     * CSS selector to read (default `'body'`). Every match is read, in document order, with matches joined by a
+     * blank line and empty matches skipped, up to the content cap. On the Lua cloud browser this holds for
+     * `'text'` and `'markdown'`; `'html'` returns the inner HTML of the first match. On the desktop browser every
+     * format reads the first match. `matches` on the result says how many elements matched.
+     */
+    selector?: string;
+    /**
+     * `'text'` (default) or `'html'`. `'markdown'` is accepted but returns plain text for now, and the result
+     * says `format: 'text'`.
+     */
+    format?: BrowserReadFormat;
+    /** Budget for the whole read in ms (1000 to 100000, default 60000). */
+    timeoutMs?: number;
+    sessionKey?: string;
+}
+
+export declare interface BrowserReadResult {
+    /** The URL you asked for. */
+    url: string;
+    /** The URL the page ended on after redirects. */
+    finalUrl: string;
+    title: string;
+    content: string;
+    format: 'text' | 'html';
+    /** True when `content` hit the content cap or not every match was read. */
+    truncated: boolean;
+    /**
+     * HTTP status of the page's main document, e.g. `200` or `404`. A 404 page that has a body is still read, so
+     * check this before trusting `content`. Absent when the browser could not observe the response.
+     */
+    status?: number;
+    /** How many elements matched `selector`, when a selector other than `'body'` was given. */
+    matches?: number;
+    /** Set when the page is a wall rather than the content you asked for. */
+    blocked?: true;
+    /** `'login_required'`: the URL redirected to a sign-in page, so the content needs a signed-in session. */
+    blocker?: typeof BROWSER_READ_LOGIN_BLOCKER;
+    blockerKind?: 'login';
+    /** What to do about the wall. */
+    blockerGuidance?: string;
+}
+
+declare type BrowserScreenshotPolicy = (typeof BROWSER_SCREENSHOT_POLICIES)[number];
+
+export declare interface BrowserSessionInput extends BrowserProfileOption {
+    sessionKey?: string;
+}
+
+export declare type BrowserStepwiseApi = {
+    [K in BrowserStepwiseCommandName]: BrowserCommandMethod<BrowserCommandInputs[K]>;
+};
+
+export declare type BrowserStepwiseCommandName = Exclude<BrowserCommandName, 'read'>;
+
 /**
  * Browser switch config (LuaBrowser). `browser: true` is the zero-code form —
- * the agent gets browser tools injected, like `searchWeb`, routed to the user's
- * local browser (desktop) or the Browser-Use cloud fallback. The object form
- * adds optional policy.
+ * the agent gets browser tools and the `Browser` global, routed to the user's
+ * desktop browser when it is online, else the Lua cloud browser. The object
+ * form adds optional policy.
  */
 export declare interface BrowserSwitchConfig {
-    /** Preferred engine; 'auto' lets the platform pick local (desktop) vs cloud. */
+    /** 'auto' (default): desktop when online, else the Lua cloud browser. 'agent-browser': desktop or Lua cloud, never Browser-Use. 'browser-use': Browser-Use only. */
     engine?: 'auto' | 'browser-use' | 'agent-browser';
-    /** Egress allowlist — domains the browser may navigate/sub-request. */
+    fallback?: 'browser-use' | 'none';
+    proxyCountry?: string;
+    /** Hosts the browser may open; checked before every command that opens a URL. On the Lua cloud browser it also applies to redirects and everything a page loads. */
     allowedDomains?: string[];
-    /** Names of vault credential entries the agent may use (never raw secrets). */
+    confirmActions?: string[];
+    logContent?: BrowserLogContent;
+    screenshots?: BrowserScreenshotPolicy;
+    /** Accepted but not enforced yet. */
     credentials?: string[];
-    /** Hard cap on a single browser session's duration (cost control). */
+    /** Lua cloud browser session length in minutes: default 10, at most 60 (a larger value is cut to 60). */
     maxSessionMinutes?: number;
+    /** Lua cloud browser idle timeout in seconds: default 120, at most 900 (a larger value is cut to 900). */
+    idleTimeoutSeconds?: number;
 }
 
+declare type BrowserWorkerErrorCode = 'unauthorized' | 'invalid_request' | 'invalid_argument' | 'policy_mismatch' | 'unsupported' | 'blocked_scheme' | 'blocked_private_host' | 'blocked_domain' | 'session_cap' | 'session_not_on_this_pod' | 'no_page' | 'draining' | 'timeout' | 'engine_unavailable' | 'engine_error' | 'http_error';
+
 /** What `.commit()` hands to `LuaWorkflow` — internal; never `new LuaWorkflow({...})` by users. */
 declare interface BuiltWorkflow {
     config: LuaWorkflowConfig;
@@ -2437,6 +2964,10 @@ export declare interface ChoiceQuestion<L extends string = string> {
     options: Record<L, string>;
 }
 
+declare interface ClearInput extends BrowserSessionInput {
+    clear?: boolean;
+}
+
 /**
  * U6 (wave 2) — connection inspection, account pinning and capability checks; U33 — the same checks run
  * with the CONVERSATION USER's principal. Owner: U6 (catalogue, list, pin, check, cleanup); U33 owns only
@@ -3063,6 +3594,7 @@ export declare interface DecisionError extends Error {
     readonly code: DecisionErrorFields['code'];
     readonly provider?: DecisionProvider;
     readonly upstreamStatus?: number;
+    readonly decisionId?: string;
 }
 
 export declare const DecisionError: new (message: string, fields: DecisionErrorFields) => DecisionError;
@@ -3073,6 +3605,7 @@ export declare interface DecisionErrorFields {
     code: DecisionErrorCode | (string & {});
     provider?: DecisionProvider;
     upstreamStatus?: number;
+    decisionId?: string;
 }
 
 declare type DecisionFallback = DecisionProvider | 'none';
@@ -3129,6 +3662,8 @@ export declare interface DecisionResult<Q extends DecisionQuestions = DecisionQu
     durationMs: number;
     cached: boolean;
     fallback?: DecisionFallbackInfo;
+    decisionName?: string;
+    decisionVersion?: string;
 }
 
 declare type DecisionRoutingRule = (typeof DECISION_ROUTING_RULES)[number];
@@ -3160,6 +3695,8 @@ declare interface DecisionUsage {
     inputTokens: number | null;
 }
 
+export declare function defineBrowser(config: LuaBrowserConfig): LuaBrowser;
+
 export declare function defineDecision<Q extends DecisionQuestions>(config: LuaDecisionConfig<Q>): LuaDecision<Q>;
 
 /**
@@ -4143,6 +4680,10 @@ declare interface IdentifiedEntity {
     _id?: string;
 }
 
+declare interface IdInput extends BrowserSessionInput {
+    id: string;
+}
+
 export declare interface ImageMessage {
     type: 'image';
     image: string;
@@ -5056,8 +5597,16 @@ declare interface LlmContextStep {
     cacheCreationTokens?: number;
     cacheCreationTokens5m?: number;
     cacheCreationTokens1h?: number;
+    /** The step's output tokens. Cost only: settlement never reads it. */
+    outputTokens?: number;
+    /** As the provider reported them: outside `outputTokens` on Gemini, a subset of it on OpenAI. Cost only. */
+    reasoningTokens?: number;
+    /** The model id the provider says served the step (a fallback leg names itself here). Cost only. */
+    model?: string;
 }
 
+declare type LoadState = 'load' | 'domcontentloaded' | 'networkidle';
+
 /**
  * Structured logging: `log.debug/info/warn/error(message, fields?)`.
  *
@@ -5189,6 +5738,7 @@ export declare class LuaAgent {
     private readonly batching?;
     private readonly governance?;
     private readonly browser?;
+    private readonly browsers?;
     /**
      * Creates a new LuaAgent instance.
      *
@@ -5226,6 +5776,7 @@ export declare class LuaAgent {
     getBatching(): BatchingConfig | undefined;
     getDevices(): LuaDevice[];
     getVoices(): LuaVoice[] | undefined;
+    getBrowsers(): LuaBrowser[] | undefined;
     getDecisions(): LuaDecision[];
 }
 
@@ -5290,12 +5841,13 @@ export declare interface LuaAgentConfig {
     /** Governance policy configuration. When set, tool calls, preprocessors, and postprocessors are governed. */
     governance?: GovernanceConfig;
     /**
-     * Browser switch (LuaBrowser). `true` turns on browser tools with platform
-     * defaults; an object adds policy (engine, allowedDomains, credentials,
-     * maxSessionMinutes). Off by default — a browser session costs money and
+     * Browser switch (LuaBrowser). `true` turns on browser tools and the
+     * `Browser` global with platform defaults; an object adds policy (see
+     * `BrowserSwitchConfig`). Off by default — a browser session costs money and
      * carries risk, so it's opt-in (unlike always-on searchWeb).
      */
     browser?: boolean | BrowserSwitchConfig;
+    browsers?: LuaBrowser[];
 }
 
 /**
@@ -5323,6 +5875,44 @@ export declare type LuaAgentModel = string | ((request: LuaRequest) => string |
 /** The signed-in person a route runs for (never an API key, never anonymous). */
 export declare type LuaAuth = WebRouteAuth;
 
+export declare class LuaBrowser {
+    readonly name: string;
+    readonly description?: string;
+    readonly engine: LuaBrowserSettings['engine'];
+    readonly fallback: LuaBrowserSettings['fallback'];
+    readonly proxyCountry: LuaBrowserSettings['proxyCountry'];
+    readonly allowedDomains: LuaBrowserSettings['allowedDomains'];
+    readonly confirmActions: LuaBrowserSettings['confirmActions'];
+    readonly maxSessionMinutes: LuaBrowserSettings['maxSessionMinutes'];
+    readonly idleTimeoutSeconds: LuaBrowserSettings['idleTimeoutSeconds'];
+    readonly maxConcurrentSessions: LuaBrowserSettings['maxConcurrentSessions'];
+    readonly screenshots: LuaBrowserSettings['screenshots'];
+    readonly logContent: LuaBrowserSettings['logContent'];
+    readonly persist: LuaBrowserSettings['persist'];
+    readonly credentials: LuaBrowserSettings['credentials'];
+    constructor(config: LuaBrowserConfig);
+}
+
+export declare interface LuaBrowserConfig extends LuaBrowserSettings {
+    name: string;
+    description?: string;
+}
+
+export declare interface LuaBrowserSettings {
+    engine?: BrowserEngine;
+    fallback?: BrowserFallback;
+    proxyCountry?: string;
+    allowedDomains?: string[];
+    confirmActions?: string[];
+    maxSessionMinutes?: number;
+    idleTimeoutSeconds?: number;
+    maxConcurrentSessions?: number;
+    screenshots?: BrowserScreenshotPolicy;
+    logContent?: BrowserLogContent;
+    persist?: boolean;
+    credentials?: string[];
+}
+
 export declare class LuaDecision<Q extends DecisionQuestions = DecisionQuestions> {
     readonly name: string;
     readonly description?: string;
@@ -6070,7 +6660,7 @@ export declare interface LuaTriggerConfig<T = any> {
  *
  * export default new LuaVoice({
  *   name: 'support-line',
- *   llm: 'openai/gpt-5.2-chat-latest',
+ *   llm: 'openai/chat-latest',
  *   stt: 'deepgram/nova-3',
  *   tts: { model: 'cartesia/sonic-3', voice: '9626c31c-bec5-4cca-baa8-f8ba9e84c8bc' },
  *   vad: 'silero',
@@ -6170,7 +6760,7 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
     llm: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
         kind: z.ZodLiteral<"inference">;
-        /** Provider-prefixed model id (e.g. `'openai/gpt-5.2-chat-latest'`). */
+        /** Provider-prefixed model id (e.g. `'openai/chat-latest'`). */
         model: z.ZodString;
         /**
          * TTS-only — provider voice id. Inference's TTS API takes voice
@@ -6236,7 +6826,7 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     }>]>;
     stt: z.ZodOptional<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
         kind: z.ZodLiteral<"inference">;
-        /** Provider-prefixed model id (e.g. `'openai/gpt-5.2-chat-latest'`). */
+        /** Provider-prefixed model id (e.g. `'openai/chat-latest'`). */
         model: z.ZodString;
         /**
          * TTS-only — provider voice id. Inference's TTS API takes voice
@@ -6302,7 +6892,7 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     }>]>>;
     tts: z.ZodOptional<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
         kind: z.ZodLiteral<"inference">;
-        /** Provider-prefixed model id (e.g. `'openai/gpt-5.2-chat-latest'`). */
+        /** Provider-prefixed model id (e.g. `'openai/chat-latest'`). */
         model: z.ZodString;
         /**
          * TTS-only — provider voice id. Inference's TTS API takes voice
@@ -7305,7 +7895,9 @@ export declare type LuaWorkflowBuildCode = 'duplicate-step-id' | 'unknown-step-r
 /** BAC-2062: the builder mirror of the BAC-619 validator codes: a `waitForSignal` name a delivery refuses. */
 | 'signal-name-invalid'
 /** BAC-2062: a numeric approval / waitForSignal `timeoutHours` outside 1..720. */
-| 'timeout-hours-out-of-range' | 'editable-path-invalid' | 'env-template-secret-key' | 'invalid-envelope' | 'invalid-step' | 'invalid-step-id' | 'invalid-workflow-name' | 'schedule-input-required' | 'schedule-input-invalid' | 'hitl-duration-defaulted' | 'WORKFLOW_UNPLACED_STEP';
+| 'timeout-hours-out-of-range' | 'editable-path-invalid' | 'env-template-secret-key' | 'invalid-envelope'
+/** BAC-2341: a `concurrencyKey` declared without `concurrencyPolicy:'forbid'` (the server's 400 twin). */
+| 'concurrency-key-requires-forbid' | 'invalid-step' | 'invalid-step-id' | 'invalid-workflow-name' | 'schedule-input-required' | 'schedule-input-invalid' | 'hitl-duration-defaulted' | 'WORKFLOW_UNPLACED_STEP';
 
 export declare interface LuaWorkflowBuilder {
     then(step: StepRef): this;
@@ -7372,6 +7964,11 @@ export declare interface LuaWorkflowConfig {
     stateSchema?: ZodType;
     /** 'forbid' = jobs-style overlap guard per workflow (D21-r1) — every start path gets 409 `RUNS_IN_FLIGHT`. */
     concurrencyPolicy?: 'allow' | 'forbid';
+    /**
+     * Scope the `forbid` overlap guard per correlation key instead of workflow-wide. Requires `concurrencyPolicy:'forbid'`;
+     * absent means workflow-wide. Rides the manifest and the push body, not the graph envelope or `graphHash`.
+     */
+    concurrencyKey?: 'correlationKey';
     /** Who may READ this workflow's run outputs beyond `workflows:read-outputs` holders (B44). Envelope member outside `graphHash`. */
     outputVisibility?: WorkflowOutputVisibility;
     /**
@@ -9029,6 +9626,14 @@ export declare interface SecretTestOutcome {
 
 export declare type SecretTestResult = (typeof SECRET_TEST_RESULTS)[number];
 
+declare interface SelectorInput extends BrowserSessionInput {
+    selector: string;
+}
+
+declare interface SelectorTextInput extends SelectorInput {
+    text: string;
+}
+
 declare interface SendTemplateButtonValue {
     sub_type: WhatsAppTemplateButtonType;
     index: string;
@@ -10000,6 +10605,10 @@ declare interface UpdateJobVersionDTO {
     metadata?: Record<string, any>;
 }
 
+declare interface UrlInput extends BrowserSessionInput {
+    url: string;
+}
+
 /**
  * Function type for resolving URL at runtime.
  * Use env() inside to access agent environment variables.