@boxline/sdk 1.1.0

package/dist/client.d.ts

@@ -0,0 +1,529 @@
+import { type CoreConfig, type Query, type RequestOptions, type SendInit } from "./core.js";
+import { Page, PagePromise } from "./pagination.js";
+import { Session } from "./session.js";
+import type { ActionItem, ActionResult, AgentMessageSent, AgentModelCatalog, AgentRun, AgentRunEvent, AgentRunParams, AgentRunStarted, ContinueRunParams, ApiKeyInfo, BulkResult, ComputerAction, ComputerOptions, ComputerResult, ContextInfo, LoginDetails, LoginDetailsUpdate, MoveShell, Secret, SecretAuditEntry, SecretAuditParams, SecretCreateParams, SecretUpdateParams, CrawlGetParams, CrawlJob, CrawlPage, CrawlParams, CreateSessionParams, ExecExit, ExecOptions, ExecResult, ExtensionInfo, ExtractParams, ExtractResult, FetchParams, FetchResult, FileList, FileRef, ListParams, LoginResponse, Me, MoveTimings, NewApiKey, NewWebhookEndpoint, ProjectSettings as ProjectSettingsData, AgentProvider, ModelKey, ModelKeyParams, CaptchaMode, WebhookCreateParams, WebhookDelivery, WebhookDeliveryListParams, WebhookEndpoint, WebhookEventType, WebhookEventTypeList, WebhookUpdateParams, PdfParams, PlanFeature, Pricing, Recording, RunScriptOptions, ScreenshotParams, ScriptResult, SearchParams, SearchResponse, SessionEvent, SessionEventsParams, SessionListParams, SessionUrls, SignupResponse, Stats, Task, TaskCreateParams, TaskRun, TaskRunListParams, TaskRunParams, TaskUpdateParams, TrajectoriesSetting, UpdateSessionParams, Usage, VisitedPage } from "./types.js";
+export interface BoxlineOptions {
+    /** Defaults to the BOXLINE_API_KEY environment variable. */
+    apiKey?: string;
+    /** Defaults to BOXLINE_API_URL, then https://api.boxline.dev (a local API: http://localhost:8080). */
+    baseUrl?: string;
+    /** Send the dashboard cookie instead of an API key (browser apps on the same site). */
+    credentials?: RequestCredentials;
+    /** A fetch implementation (default: the global fetch). */
+    fetch?: typeof fetch;
+    /** Retries after network errors, 429 and 5xx, for GETs and for POSTs with an Idempotency-Key (default 2). */
+    maxRetries?: number;
+    /** Time limit per request in ms (default 120 000; streams: until the response starts). */
+    timeoutMs?: number;
+    /** Headers sent with every request. */
+    headers?: Record<string, string>;
+}
+/** Where the SDK goes without baseUrl or BOXLINE_API_URL (the same default as the CLI). */
+export declare const DEFAULT_BASE_URL = "https://api.boxline.dev";
+/**
+ * Client for the Boxline API: isolated cloud sessions with a Chrome browser, a bash shell and a shared disk, plus
+ * the web APIs and the AI agent. Works in Node 18+ and modern browsers (it uses the global fetch).
+ *
+ *   const bx = new Boxline();                    // BOXLINE_API_KEY; BOXLINE_API_URL (default https://api.boxline.dev)
+ *   const s = await bx.sessions.create();
+ *   const browser = await chromium.connectOverCDP(s.connectUrl!);
+ */
+export declare class Boxline {
+    readonly baseUrl: string;
+    readonly auth: Auth;
+    readonly project: ProjectSettings;
+    readonly apiKeys: ApiKeys;
+    readonly sessions: Sessions;
+    readonly contexts: Contexts;
+    readonly crawl: Crawl;
+    readonly agent: Agent;
+    readonly tasks: Tasks;
+    readonly secrets: Secrets;
+    readonly webhooks: Webhooks;
+    readonly extensions: Extensions;
+    /** @internal */
+    readonly cfg: CoreConfig;
+    private readonly options;
+    constructor(opts?: BoxlineOptions);
+    /** What JSON.stringify shows: where the client points, never its key. */
+    toJSON(): {
+        baseUrl: string;
+        maxRetries: number;
+        timeoutMs: number;
+    };
+    /** A client like this one with some options changed, e.g. `bx.withOptions({ maxRetries: 5 })`. */
+    withOptions(opts: BoxlineOptions): Boxline;
+    /** The calling user/project, its plan's limits and features, and whether it is suspended. */
+    me(options?: RequestOptions): Promise<Me>;
+    /** True when the project's plan includes `feature` (calls using a missing feature fail with 402 feature_not_in_plan). */
+    hasFeature(feature: PlanFeature, options?: RequestOptions): Promise<boolean>;
+    /** Fetch API: open a URL in a real browser (inside a sandbox) and get Markdown, HTML or text back. */
+    fetch(url: string, params?: FetchParams, options?: RequestOptions): Promise<FetchResult>;
+    /** A screenshot of any URL (fresh browser context each time). Returns the image bytes. */
+    screenshot(url: string, params?: ScreenshotParams, options?: RequestOptions): Promise<Uint8Array>;
+    /** A PDF of any URL, printed like Chrome's "Save as PDF". Returns the PDF bytes. */
+    pdf(url: string, params?: PdfParams, options?: RequestOptions): Promise<Uint8Array>;
+    /**
+     * Structured data from one or more pages: they are rendered in a real browser, then a model fills `schema`
+     * (JSON Schema) and/or follows `prompt`. Defaults to a fast, low-cost model.
+     */
+    extract<T = unknown>(params: ExtractParams, options?: RequestOptions): Promise<ExtractResult<T>>;
+    /**
+     * Web search (the platform's provider, Brave): titles, URLs, snippets and dates. With `fetch`, the top pages are
+     * also opened in a sandboxed browser and returned as Markdown (`content`). The same search within an hour is
+     * answered from the cache (`cached: true`, not counted). The query text goes to the provider: keep secrets and
+     * personal data out of it. 503 `search_unavailable` (SearchUnavailableError) when search is not set up.
+     */
+    search(params: SearchParams, options?: RequestOptions): Promise<SearchResponse>;
+    /** Usage and cost of the sessions created in a period (default: this month so far). */
+    usage(params?: {
+        from?: string;
+        to?: string;
+    }, options?: RequestOptions): Promise<Usage>;
+    /** Totals and per-day numbers for the last `days` days (UTC, including today). */
+    stats(days?: number, options?: RequestOptions): Promise<Stats>;
+    /** The public price table and plans (no API key needed). */
+    pricing(options?: RequestOptions): Promise<Pricing>;
+    /** The OpenAPI 3.1 description of the API. */
+    openapi(options?: RequestOptions): Promise<Record<string, unknown>>;
+    /** `{ok: true}` when the API is up. */
+    health(options?: RequestOptions): Promise<{
+        ok: true;
+    }>;
+    /** Low-level request: parsed JSON (undefined for 204). The SDK's retry and error rules apply. */
+    request<T>(method: string, path: string, body?: unknown, options?: RequestOptions & Omit<SendInit, "as" | "body">): Promise<T>;
+    /** Low-level request returning the Response with its body unread (after checking for errors). */
+    send(method: string, path: string, body?: unknown, options?: RequestOptions & Omit<SendInit, "as" | "body">): Promise<Response>;
+    /** @internal */
+    bytes(method: string, path: string, body?: unknown, options?: RequestOptions): Promise<Uint8Array>;
+    /** @internal A list whose pages follow `next`; `map` turns each raw item into what the list yields. */
+    list<T, E extends object = object>(path: string, query: Query, map: (raw: any) => T, options?: RequestOptions): PagePromise<T, Page<T> & E>;
+}
+/** Sign-up and console logins. Server-side code uses an API key instead of logging in. */
+export declare class Auth {
+    private readonly client;
+    constructor(client: Boxline);
+    /**
+     * Creates a user, a project on the Free plan and a first API key (in the response only). No API key needed.
+     * `acceptTerms: true` says the user accepts the terms of service and acceptable use policy (400
+     * `terms_not_accepted` without it); `name` is optional.
+     */
+    signup(params: {
+        email: string;
+        password: string;
+        acceptTerms: true;
+        name?: string;
+    }, options?: RequestOptions): Promise<SignupResponse>;
+    /** Starts a console login (cookie `bx_session`): for browser apps with `credentials: "include"`. */
+    login(params: {
+        email: string;
+        password: string;
+    }, options?: RequestOptions): Promise<LoginResponse>;
+    /** Ends the console login. */
+    logout(options?: RequestOptions): Promise<void>;
+}
+/** Project settings. */
+export declare class ProjectSettings {
+    private readonly client;
+    constructor(client: Boxline);
+    /** The Trajectories program setting: on by default; see the Terms of Service and Privacy Policy. */
+    trajectories(options?: RequestOptions): Promise<TrajectoriesSetting>;
+    /** Turns the Trajectories program on or off for this project (logged). */
+    setTrajectories(enabled: boolean, opts?: {
+        source?: "notice" | "settings";
+    }, options?: RequestOptions): Promise<TrajectoriesSetting>;
+    /**
+     * The project's settings: `captchaDefault` is what new sessions and agent runs without a `captcha` option get;
+     * `captchaDefaultEffective` what they get now (the plan may no longer include solving).
+     */
+    settings(options?: RequestOptions): Promise<ProjectSettingsData>;
+    /**
+     * Changes the fields you send (`captchaDefault: "solve"` needs a plan with CAPTCHA solving: 402 otherwise).
+     * `defaultModel` is the model used when a request names none; `null` clears it.
+     */
+    setSettings(params: {
+        captchaDefault?: CaptchaMode;
+        defaultModel?: {
+            provider: AgentProvider;
+            model?: string;
+        } | null;
+    }, options?: RequestOptions): Promise<ProjectSettingsData>;
+    /** The four providers with the project's own-key state (never a key: `preview` is its last 4 characters). */
+    modelKeys(options?: RequestOptions): Promise<{
+        keys: ModelKey[];
+    }>;
+    /**
+     * Saves a provider key and/or the choice of whose key calls use. The provider checks the key first (400
+     * `invalid_model_key` when it refuses it). Runs on your own key have no model charge from Boxline.
+     */
+    setModelKey(provider: AgentProvider, params: ModelKeyParams, options?: RequestOptions): Promise<ModelKey>;
+    /** Deletes the provider's key; calls go back to the platform's key where the plan includes it. */
+    deleteModelKey(provider: AgentProvider, options?: RequestOptions): Promise<void>;
+}
+/** The project's API keys. */
+export declare class ApiKeys {
+    private readonly client;
+    constructor(client: Boxline);
+    /** Active keys, oldest first (the keys themselves are never shown again; `prefix` identifies them). */
+    list(params?: ListParams, options?: RequestOptions): PagePromise<ApiKeyInfo>;
+    /** A new key; `key` is in this response only. */
+    create(params?: {
+        name?: string;
+    }, options?: RequestOptions): Promise<NewApiKey>;
+    revoke(id: string, options?: RequestOptions): Promise<void>;
+}
+export type SessionPage = Page<Session> & {
+    total: number;
+    limit: number;
+    offset: number;
+};
+export declare class Sessions {
+    private readonly client;
+    readonly files: SessionFiles;
+    constructor(client: Boxline);
+    private wrap;
+    private one;
+    /** Starts a session (an Idempotency-Key is sent, so a retry never starts a second one). */
+    create(params?: CreateSessionParams, options?: RequestOptions): Promise<Session>;
+    get(id: string, options?: RequestOptions): Promise<Session>;
+    /**
+     * Sessions, newest first unless `sort` says otherwise. Await it for one page (`total` counts every match), or
+     * `for await (const s of bx.sessions.list())` for all of them.
+     */
+    list(params?: SessionListParams, options?: RequestOptions): PagePromise<Session, SessionPage>;
+    /** @deprecated Use list(): its first page has `total` too. */
+    page(params?: SessionListParams, options?: RequestOptions): Promise<SessionPage>;
+    /** Pause, resume or release 1 to 100 sessions at once (session ids; 30 calls per minute per project). */
+    bulk(action: "release" | "pause" | "resume", ids: string[], options?: RequestOptions): Promise<BulkResult>;
+    /** Changes keepAlive, userMetadata, the proxy, the captcha option or the browser settings. */
+    update(id: string, patch: UpdateSessionParams, options?: RequestOptions): Promise<Session>;
+    /** Ends the session and deletes its machine. */
+    release(id: string, options?: RequestOptions): Promise<Session>;
+    /** Saves browser state and files, frees the machine and stops billing. Touching the session resumes it. */
+    pause(id: string, options?: RequestOptions): Promise<Session>;
+    resume(id: string, options?: RequestOptions): Promise<Session>;
+    /** Moves the live session to a fresh machine; clients reconnect to the same connectUrl. */
+    move(id: string, options?: RequestOptions): Promise<{
+        session: Session;
+        timings: MoveTimings;
+        shell: MoveShell | null;
+    }>;
+    /** Adds time (60–3600 s), up to the plan's maximum session length. */
+    extend(id: string, seconds: number, options?: RequestOptions): Promise<Session>;
+    /** A new IP for the session's proxy. */
+    rotateProxy(id: string, options?: RequestOptions): Promise<Session>;
+    /** Revokes the session's connect, live and terminal URLs and returns the session with fresh ones. */
+    rotateUrls(id: string, options?: RequestOptions): Promise<Session>;
+    /** Fresh signed URLs (treat them like passwords). */
+    live(id: string, options?: RequestOptions): Promise<SessionUrls>;
+    /**
+     * Runs browser actions in order, next to the browser; stops at the first failure. A bare string is a plain-English
+     * step: `["click Sign in", {action: "fill", selector: "#q", value: "x"}]`. Each result's `text` says what happened.
+     */
+    actions(id: string, actions: ActionItem[] | ActionItem, opts?: {
+        timeoutMs?: number;
+    }, options?: RequestOptions): Promise<ActionResult[]>;
+    /**
+     * Runs ONE computer-use action exactly as the model's tool gave it (Anthropic `computer` tool input, or one OpenAI
+     * `computer_call` action) on the session's page, and returns the screen after it. With `maxWidth` the screenshot is
+     * scaled down and the action's coordinates are read in its pixels. A failure in the page is `ok: false`; input that
+     * cannot be mapped, or a point off the screen, throws (400 `invalid_request` / `out_of_viewport`).
+     */
+    computer(id: string, action: ComputerAction, opts?: ComputerOptions, options?: RequestOptions): Promise<ComputerResult>;
+    /** Runs a shell command (persistent bash by default: cd/export survive between calls). */
+    /**
+     * Runs a command and returns its output. It is read as a stream (headers at once, the API keeps the connection
+     * alive), so neither a long command nor a wait for the session's setup runs into an HTTP client's own limits
+     * (Node's fetch gives up after 300 s without headers or data). Output past 64 KB is cut in the middle, as
+     * `truncated` says.
+     */
+    exec(id: string, command: string, opts?: ExecOptions, options?: RequestOptions): Promise<ExecResult>;
+    /** Runs a command and streams its output as it happens; resolves with the exit information. */
+    execStream(id: string, command: string, onData: (stream: "stdout" | "stderr", data: string) => void, opts?: ExecOptions & {
+        signal?: AbortSignal;
+    }, options?: RequestOptions): Promise<ExecExit>;
+    /**
+     * Runs Playwright code inside the session's own sandbox (needs a shell), streaming its output to `onData`. In
+     * scope: `page`, `context`, `browser`, `env`, and `step()`, `extract()`, `useModel(model)` / `useModel(provider,
+     * model)`. A step or extract uses the call's own `{provider, model}`, else the last `useModel()`, else `ai`.
+     */
+    runScript(id: string, code: string, opts?: RunScriptOptions, options?: RequestOptions): Promise<ScriptResult>;
+    /** Restarts the persistent shell (or the named one). */
+    restartShell(id: string, name?: string, options?: RequestOptions): Promise<void>;
+    /** Writes the browser's cookies as a Netscape cookie file in the workspace (for curl -b / wget). */
+    exportCookies(id: string, path?: string, options?: RequestOptions): Promise<{
+        path: string;
+        count: number;
+    }>;
+    /** Console, network, navigation, error, lifecycle, action, exec and captcha events, oldest first. */
+    events(id: string, params?: SessionEventsParams, options?: RequestOptions): PagePromise<SessionEvent, Page<SessionEvent> & {
+        nextAfter: number;
+    }>;
+    /** Events as they happen: first the backlog after `after`, then live. Stop with `break` or `options.signal`. */
+    streamEvents(id: string, params?: {
+        after?: number;
+    }, options?: RequestOptions): AsyncGenerator<SessionEvent>;
+    /** Pages visited, grouped by tab and URL, in the order they were first visited. */
+    pages(id: string, params?: ListParams, options?: RequestOptions): PagePromise<VisitedPage>;
+    /** Replay frames kept while the session ran. */
+    recording(id: string, options?: RequestOptions): Promise<Recording>;
+    /** One replay frame as JPEG bytes. */
+    recordingFrame(id: string, index: number, options?: RequestOptions): Promise<Uint8Array>;
+}
+export declare class SessionFiles {
+    private readonly client;
+    constructor(client: Boxline);
+    private url;
+    list(id: string, path?: string, options?: RequestOptions): Promise<FileList>;
+    /** A file's bytes. */
+    read(id: string, path: string, options?: RequestOptions): Promise<Uint8Array>;
+    readText(id: string, path: string, options?: RequestOptions): Promise<string>;
+    /** Writes a file (folders are made as needed). */
+    write(id: string, path: string, data: string | Uint8Array | Blob, options?: RequestOptions): Promise<FileRef>;
+    delete(id: string, path: string, options?: RequestOptions): Promise<void>;
+    /** Waits for a file matching a glob (e.g. `downloads/*.csv`) that has finished writing. */
+    waitFor(id: string, pattern: string, timeoutMs?: number, options?: RequestOptions): Promise<FileRef>;
+}
+/** Saved logins: cookies and local storage to start sessions with (`context: {id, persist: true}` fills one). */
+export declare class Contexts {
+    private readonly client;
+    constructor(client: Boxline);
+    /**
+     * A new saved login: empty, or with `fromSession` holding that working session's current cookies and site storage
+     * (sign in there first, e.g. in its live view). `attach: true` also makes the session save to it from now on (at its
+     * checkpoints and when it ends); a session that already has a saved login refuses that (409 `conflict`). 413
+     * `context_too_large` over 16 MB; PlanLimitError (402) past the plan's `maxContexts` or `maxContextBytes`.
+     */
+    create(params?: {
+        name?: string;
+        fromSession?: string;
+        attach?: boolean;
+    }, options?: RequestOptions): Promise<ContextInfo>;
+    get(id: string, options?: RequestOptions): Promise<ContextInfo>;
+    /** Newest first; the first page's `total` counts them all. */
+    list(params?: ListParams, options?: RequestOptions): PagePromise<ContextInfo, Page<ContextInfo> & {
+        total: number;
+    }>;
+    rename(id: string, name: string, options?: RequestOptions): Promise<ContextInfo>;
+    delete(id: string, options?: RequestOptions): Promise<void>;
+    /**
+     * Keeps sign-in details on the saved login (plan feature `loginDetails`), replacing earlier ones: the site, user name,
+     * password and optionally the 2FA setup key, sealed like secrets. Returns the context, whose `login` shows
+     * `{origin, username, hasPassword, hasTotp}`, never the password or the 2FA secret.
+     */
+    setLogin(id: string, details: LoginDetails, options?: RequestOptions): Promise<ContextInfo>;
+    /**
+     * Changes some of the login details and keeps the rest (setLogin replaces them all); `totpSecret: null` removes 2FA.
+     * A password never moves to another site on its own: a new `origin` needs `password` in the same call, and
+     * `totpSecret` (a new one or null) when the login has 2FA (400 otherwise). A BoxlineError with code `conflict` (409)
+     * when the login changed meanwhile: send it again.
+     */
+    updateLogin(id: string, changes: LoginDetailsUpdate, options?: RequestOptions): Promise<ContextInfo>;
+    /** Removes the login details (the saved cookies and storage stay). */
+    deleteLogin(id: string, options?: RequestOptions): Promise<void>;
+}
+/**
+ * Project secrets: write-only values the AI uses as %NAME% placeholders (`secrets` on agent runs, steps and scripts) and
+ * shells get as environment variables (`secrets` on sessions.create and exec), depending on each secret's `scope`. The
+ * value is never returned, logged or shown; every change and use is audited.
+ */
+export declare class Secrets {
+    private readonly client;
+    constructor(client: Boxline);
+    /** The project's secrets, in name order, without their values. */
+    list(params?: ListParams, options?: RequestOptions): PagePromise<Secret>;
+    /**
+     * Stores a secret, sealed; the answer never has the value. SecretExistsError for a name the project has (change it
+     * with update), PlanLimitError beyond the plan's `maxSecrets`. Not retried by the SDK (the API takes no
+     * Idempotency-Key here): a retry after a lost answer may meet SecretExistsError.
+     */
+    create(params: SecretCreateParams, options?: RequestOptions): Promise<Secret>;
+    get(name: string, options?: RequestOptions): Promise<Secret>;
+    /**
+     * Changes the fields you send. A running agent run keeps the value it started with; a session that exports the secret
+     * gets the new value on its next machine (move, resume, recovery).
+     */
+    update(name: string, patch: SecretUpdateParams, options?: RequestOptions): Promise<Secret>;
+    /** Deletes it; sessions that exported it no longer get it on their next machine. */
+    delete(name: string, options?: RequestOptions): Promise<void>;
+    /** Changes to secrets and saved login details, and each use (once per session, command, run or script), newest first. */
+    audit(params?: SecretAuditParams, options?: RequestOptions): PagePromise<SecretAuditEntry>;
+}
+/** Crawls: follow links from a start URL in the background (robots.txt respected); poll with get() or wait(). */
+export declare class Crawl {
+    private readonly client;
+    constructor(client: Boxline);
+    start(params: CrawlParams, options?: RequestOptions): Promise<CrawlJob>;
+    /** The job and one page of its pages (`limit: 0` for the job only); `next` is the cursor of the following pages. */
+    get(id: string, params?: CrawlGetParams, options?: RequestOptions): Promise<CrawlJob>;
+    /** Jobs, newest first (without their pages). */
+    list(params?: ListParams, options?: RequestOptions): PagePromise<CrawlJob>;
+    cancel(id: string, options?: RequestOptions): Promise<CrawlJob>;
+    /** Every page crawled so far, in index order: `for await (const p of bx.crawl.pages(id))`. */
+    pages(id: string, params?: {
+        limit?: number;
+    }, options?: RequestOptions): AsyncGenerator<CrawlPage>;
+    /** Waits for the crawl to finish, then returns the job with every page in `data`. */
+    wait(id: string, opts?: {
+        pollMs?: number;
+        timeoutMs?: number;
+    }, options?: RequestOptions): Promise<CrawlJob>;
+}
+/**
+ * Webhook endpoints: signed HTTPS callbacks when something finishes or needs a person. Verify each delivery with
+ * verifyWebhook(rawBody, header, secret) and drop event ids you have handled already.
+ */
+export declare class Webhooks {
+    private readonly client;
+    constructor(client: Boxline);
+    /** A new endpoint (public HTTPS only); `secret` ("whsec_…") is in this response only. */
+    create(params: WebhookCreateParams, options?: RequestOptions): Promise<NewWebhookEndpoint>;
+    /** The project's endpoints, oldest first (never their secrets). */
+    list(params?: ListParams, options?: RequestOptions): PagePromise<WebhookEndpoint>;
+    get(id: string, options?: RequestOptions): Promise<WebhookEndpoint>;
+    /** Changes the URL, events, description, or switches it on or off (`enabled: true` also forgets its failures). */
+    update(id: string, patch: WebhookUpdateParams, options?: RequestOptions): Promise<WebhookEndpoint>;
+    /** Deletes the endpoint with its queue and delivery log. */
+    delete(id: string, options?: RequestOptions): Promise<void>;
+    /** A new secret (in this response only); the old one keeps signing too for 24 hours (a second v1). */
+    rotateSecret(id: string, options?: RequestOptions): Promise<NewWebhookEndpoint>;
+    /**
+     * Sends a `webhook.test` event to this endpoint now, or with `type` a made-up sample of that event type (marked
+     * `test: true`); one attempt, waits up to 12 s for the answer.
+     */
+    test(id: string, params?: {
+        type?: WebhookEventType | "webhook.test";
+    }, options?: RequestOptions): Promise<WebhookDelivery>;
+    /** Every event type an endpoint can subscribe to, with its group and description (subscribe to "*" for all). */
+    eventTypes(options?: RequestOptions): Promise<WebhookEventTypeList>;
+    /** The endpoint's deliveries, newest first, each with its attempt history; `status` filters them. */
+    deliveries(id: string, params?: WebhookDeliveryListParams, options?: RequestOptions): PagePromise<WebhookDelivery>;
+    /**
+     * Sends a finished delivery again now, with the same event id and body (409 invalid_state while it is still queued,
+     * PayloadExpiredError after 7 days, WebhookDisabledError while the endpoint is switched off).
+     */
+    retryDelivery(id: string, deliveryId: string, options?: RequestOptions): Promise<WebhookDelivery>;
+}
+export interface WaitOptions {
+    /** How often to look, in ms (default 1000). */
+    pollMs?: number;
+    /** Give up after this long, in ms (default 30 minutes): BoxlineTimeoutError. */
+    timeoutMs?: number;
+}
+/**
+ * Tasks: saved agent runs (an instruction with %name% variables, an optional output schema, browser settings, a saved
+ * login and a model), run by hand or on a schedule. Every run is an agent run tagged with the task. Needs the plan's
+ * `agentRuns`; the plan limits tasks and schedules switched on (PlanLimitError).
+ */
+export declare class Tasks {
+    private readonly client;
+    constructor(client: Boxline);
+    /** Saves a task (an Idempotency-Key is sent, so a retry never saves it twice). */
+    create(params: TaskCreateParams, options?: RequestOptions): Promise<Task>;
+    /** The project's tasks, newest first. */
+    list(params?: ListParams, options?: RequestOptions): PagePromise<Task>;
+    get(id: string, options?: RequestOptions): Promise<Task>;
+    /**
+     * Changes the fields you send; `null` removes an optional one. `schedule` fields are merged into the current schedule
+     * (`{schedule: {enabled: false}}` pauses it); switching it on, or changing cron or timezone, counts from now.
+     */
+    update(id: string, patch: TaskUpdateParams, options?: RequestOptions): Promise<Task>;
+    /** Deletes the task with its run history (its agent runs stay, and runs in progress go on). */
+    delete(id: string, options?: RequestOptions): Promise<void>;
+    /**
+     * Runs the task now and returns its task run (status running) right away; waitForRun() waits for the result. Plain
+     * values are written into the instruction; secret ones must come with every run and go in as agent variables (the
+     * model sees only %name%). MissingVariablesError when a variable without a default has no value. Counts as an agent
+     * run (rate, plan, spend cap). An Idempotency-Key is sent, so a retry never starts a second run. `T`: the type of the
+     * result (the JSON answer when the task has an output schema).
+     */
+    run<T = unknown>(id: string, params?: TaskRunParams, options?: RequestOptions): Promise<TaskRun<T>>;
+    /** The task's runs, newest first: by hand, on the schedule, and skipped or missed times (kept 30 days); `status` filters. */
+    runs<T = unknown>(id: string, params?: TaskRunListParams, options?: RequestOptions): PagePromise<TaskRun<T>>;
+    /**
+     * Polls until the task run has finished (completed, failed or canceled; a paused run keeps waiting for a person, a
+     * queued one for its turn) and returns it with its result. Pass the run that run() returned, or the task's and the
+     * run's ids. NotFoundError when the run is not in the task's history.
+     *
+     *   const run = await bx.tasks.run<{ books: Book[] }>(task.id, { variables: { category: "Poetry" } });
+     *   const done = await bx.tasks.waitForRun(run);   // done.result: { books: Book[] } | null
+     */
+    waitForRun<T = unknown>(run: TaskRun<T> | {
+        taskId: string;
+        id: string;
+    }, opts?: WaitOptions, options?: RequestOptions): Promise<TaskRun<T>>;
+    waitForRun<T = unknown>(taskId: string, taskRunId: string, opts?: WaitOptions, options?: RequestOptions): Promise<TaskRun<T>>;
+}
+/**
+ * Chrome extensions (Manifest V3) to start sessions with (`extensions: [id]`; plan feature `extensions`). An extension
+ * sees every page and every typed value in the sessions that use it: upload only extensions you trust.
+ */
+export declare class Extensions {
+    private readonly client;
+    constructor(client: Boxline);
+    /**
+     * Uploads an unpacked extension as a zip, at most 10 MB: its bytes, a Blob, or a file path (Node). It is checked
+     * before it is stored (InvalidExtensionError says why; PayloadTooLargeError over 10 MB; LimitReachedError beyond 100
+     * extensions). An Idempotency-Key is sent, so a retry never stores it twice.
+     */
+    upload(zip: Uint8Array | ArrayBuffer | Blob | string, options?: RequestOptions): Promise<ExtensionInfo>;
+    /** The project's extensions, newest first. */
+    list(params?: ListParams, options?: RequestOptions): PagePromise<ExtensionInfo>;
+    get(id: string, options?: RequestOptions): Promise<ExtensionInfo>;
+    /** Deletes it; sessions already running with it keep it until they move or resume. */
+    delete(id: string, options?: RequestOptions): Promise<void>;
+}
+/** Agent runs: a model (Claude or GPT) drives the session's browser and shell to finish a task. */
+export declare class Agent {
+    private readonly client;
+    constructor(client: Boxline);
+    /** Providers and models customers can choose, with prices and whether each is configured on the server. */
+    models(options?: RequestOptions): Promise<AgentModelCatalog>;
+    /**
+     * Starts a run and returns right away (an Idempotency-Key is sent, so a retry never starts a second run). With
+     * `output` (a JSON Schema) the answer is JSON matching it: read it with `wait<T>(id)` or `get<T>(id)`.
+     */
+    run(params: AgentRunParams, options?: RequestOptions): Promise<AgentRunStarted>;
+    /** The run with its steps. `T`: the type of `result` (text by default; the JSON answer's type with an output schema). */
+    get<T = string>(id: string, options?: RequestOptions): Promise<AgentRun<T>>;
+    /** Runs, newest first. */
+    list(params?: ListParams, options?: RequestOptions): PagePromise<AgentRun>;
+    /** Take the browser from the agent (it finishes its current action, then waits). RunNotLiveError when its server stopped. */
+    takeover(id: string, reason?: string, options?: RequestOptions): Promise<AgentRun>;
+    /** Give the browser back; the agent reads `note` before it continues. RunNotLiveError when its server stopped: continueRun. */
+    handBack(id: string, note?: string, options?: RequestOptions): Promise<AgentRun>;
+    /** Stops the run for good. */
+    cancel(id: string, options?: RequestOptions): Promise<AgentRun>;
+    /**
+     * Continues a run that stopped at one of its limits (errorCode max_steps, max_cost, too_many_errors or no_progress)
+     * while its `continuable` is set: a new run in the same session, with the same model, mode, output schema, secrets
+     * and saved login, and a compact record of what the previous run did. Returns the new run (`continuedFrom` links
+     * back); wait for it with `wait(run.id)` or `stream(run.id)` like any run. A run that had `variables` needs them again
+     * (MissingVariablesError otherwise). NotContinuableError: it did not stop at a limit, was continued already, or its
+     * window passed. An Idempotency-Key is sent, so a retry never starts a second run.
+     *
+     * `const next = await bx.agent.continueRun(run.id, { maxSteps: 30, instruction: "The CSV is downloaded already" })`
+     */
+    continueRun<T = string>(id: string, params?: ContinueRunParams, options?: RequestOptions): Promise<AgentRun<T>>;
+    /**
+     * Tells a working run something (1–2000 characters) without taking the browser: the agent reads it at its next step
+     * (a model call or tool under way is not interrupted), and it shows as a `message` step. A run waiting for your help
+     * (ask_user_for_help) takes it as the answer and goes on. At most 50 per run; InvalidStateError-like 409
+     * (a BoxlineError with code `invalid_state`) once the run has finished, TooManyMessagesError after 50.
+     */
+    sendMessage(id: string, text: string, options?: RequestOptions): Promise<AgentMessageSent>;
+    /**
+     * The run as it happens: its steps so far, then new steps, `status` changes, live shell `exec`/`output`, and a
+     * final `done` event, after which the iteration ends.
+     */
+    stream<T = string>(id: string, options?: RequestOptions): AsyncGenerator<AgentRunEvent<T>>;
+    /**
+     * Polls until the run finishes (a paused run keeps waiting for the user). `T` as on get():
+     * `const run = await bx.agent.wait<{ books: Book[] }>(id)`.
+     */
+    wait<T = string>(id: string, opts?: {
+        pollMs?: number;
+        timeoutMs?: number;
+    }, options?: RequestOptions): Promise<AgentRun<T>>;
+}
+export default Boxline;