@tai42/api-client 0.1.0

package/dist/client.d.ts

@@ -0,0 +1,1316 @@
+/**
+ * The typed client: one method per endpoint, each validating
+ * its response against the matching zod schema. Server state flows through
+ * TanStack Query in the features; this client is a plain typed transport with no
+ * caching of its own.
+ */
+import { type ApiConfig } from './http';
+import { type SubmitToolRunArgs } from './tool-runs';
+import * as s from './schemas';
+export interface RunToolArgs {
+    readonly tool: string;
+    readonly kwargs?: Record<string, unknown>;
+}
+export interface StartConnectArgs {
+    readonly provider_id: string;
+    readonly alias: string;
+    readonly enabled_sub_services: string[];
+    readonly config_values?: Record<string, string>;
+    readonly return_url?: string;
+}
+/** Body for creating or editing an API key (POST/PUT `/api/auth/api-keys`). */
+export interface ApiKeyBody {
+    readonly user_id: string;
+    readonly description: string;
+    readonly scopes: string[];
+    readonly policy_data?: Record<string, unknown> | null;
+    readonly condition?: string | null;
+    readonly condition_id?: string | null;
+    readonly condition_kwargs?: Record<string, unknown> | null;
+}
+/**
+ * Body for one-time claim-link creation (POST `/api/auth/claim-links`). The
+ * `api_key` is a raw key the caller holds (the just-minted key, client-side
+ * exactly once); `ttl_seconds` optionally overrides the default lifetime (the
+ * server caps it at its ceiling).
+ */
+export interface ClaimLinkBody {
+    readonly api_key: string;
+    readonly ttl_seconds?: number | null;
+}
+/**
+ * Body for the fail-closed jq guard (POST `/api/auth/validate-condition`).
+ * `condition` (inline jq) and `condition_id` (named template) are mutually
+ * exclusive — send exactly one. `sample_context` is a `JqAuthContext`-shaped
+ * sample; when present the guard also evaluates the condition against it and
+ * returns the boolean `result` (else `result` is `null`).
+ */
+export interface ValidateConditionBody {
+    readonly condition?: string;
+    readonly condition_id?: string;
+    readonly condition_kwargs?: Record<string, unknown>;
+    readonly sample_context?: Record<string, unknown>;
+}
+/**
+ * Body for binding a webhook verifier to a topic
+ * (PUT `/api/hooks/topics/{topic}/verifier`). `verifier` is a registered verifier
+ * NAME, resolved against the live registry at bind time (an unknown name is a loud
+ * 400). `config` is that verifier's config object — it carries a `secret_env` name,
+ * never a secret value — and defaults to `{}` when omitted.
+ */
+export interface TopicVerifierBody {
+    readonly verifier: string;
+    readonly config?: Record<string, unknown>;
+}
+/** Body for adding a URL to a scope (POST `/api/auth/scopes`). */
+export interface AddUrlToScopeBody {
+    readonly scope_id: string;
+    readonly url: string;
+    readonly pattern?: string;
+}
+/**
+ * Body for pinning a route public (POST `/api/auth/public-routes`). `pattern` is an
+ * optional regex the AC verifier full-matches request paths against, mapping every
+ * match to the `url` key (so a mount's whole subtree can be pinned in one call).
+ */
+export interface PinRoutePublicBody {
+    readonly url: string;
+    readonly pattern?: string;
+}
+/**
+ * Body for creating a preset (POST `/api/presets`). `tags` are the preset's
+ * categorization labels. `extensions` is the combos list — the create flow OMITS
+ * it when there are no combos (the route rejects an explicit `extensions: []`).
+ * `output_schema` is the optional author-set output JSON Schema. Each combo
+ * element is a bare extension name or a `{ name, config }` mapping.
+ */
+export interface CreatePresetBody {
+    readonly name: string;
+    readonly base_tool: string;
+    readonly description?: string;
+    readonly fixed_kwargs?: Record<string, unknown>;
+    readonly tags?: readonly string[];
+    readonly extensions?: readonly s.PresetExtensionElement[][];
+    readonly output_schema?: Record<string, unknown> | null;
+}
+/**
+ * Body for saving a new preset version (POST `/api/presets/{name}/versions`). At
+ * least one field must be provided (an empty body is a loud 400). Each field's
+ * sentinel is uniform: omitted carries the active version's value forward; an
+ * explicit `[]` clears `tags`/`extensions`, and an explicit `null` clears
+ * `output_schema`.
+ */
+export interface SavePresetVersionBody {
+    readonly fixed_kwargs?: Record<string, unknown>;
+    readonly tags?: readonly string[];
+    readonly extensions?: readonly s.PresetExtensionElement[][];
+    readonly output_schema?: Record<string, unknown> | null;
+}
+/**
+ * Body for the dry-run validate door (POST `/api/presets/validate`). `name` is
+ * required and selects the verdict mode server-side: CREATE when no preset named
+ * `name` exists (then `base_tool` is required), VERSION when one does (the version
+ * fields are read under save-version semantics). The draft is sent exactly as the
+ * matching write would send it.
+ */
+export interface ValidatePresetBody {
+    readonly name: string;
+    readonly base_tool?: string;
+    readonly description?: string;
+    readonly fixed_kwargs?: Record<string, unknown>;
+    readonly tags?: readonly string[];
+    readonly extensions?: readonly s.PresetExtensionElement[][];
+    readonly output_schema?: Record<string, unknown> | null;
+}
+/**
+ * Body for a storage upload (POST `/api/storage/resources`). Exactly ONE of
+ * `content_text` (stored verbatim) or `content_base64` (a base64 string decoded to
+ * bytes) supplies the content for `id`; uploading an existing id overwrites it
+ * (provider passthrough semantics).
+ */
+export interface StorageUploadBody {
+    readonly id: string;
+    readonly content_text?: string;
+    readonly content_base64?: string;
+}
+/** The observability-metrics window + bucket size (GET query params). */
+export interface MetricsQuery {
+    readonly from?: string;
+    readonly to?: string;
+    readonly granularity?: string;
+}
+/**
+ * The observability runs filter. List/dict-valued params (`tags`) are
+ * JSON-encoded into the query string; scalars are sent verbatim. Shared by
+ * `listRuns` and the `exportRuns` download.
+ */
+export interface RunsQuery {
+    readonly from?: string;
+    readonly to?: string;
+    readonly tags?: string[];
+    readonly status?: 'error' | 'success';
+    readonly minCost?: number;
+    readonly maxCost?: number;
+    readonly minTokens?: number;
+    readonly maxTokens?: number;
+    readonly minLatencyMs?: number;
+    readonly maxLatencyMs?: number;
+    readonly sort?: string;
+    readonly dir?: 'asc' | 'desc';
+    readonly page?: number;
+    readonly pageSize?: number;
+}
+/**
+ * The marketplace search filter (GET `/api/marketplace/search` query params).
+ * `tags` is sent as REPEATED `tags` params, one per value; `page` is supplied
+ * per-request by the infinite query, never from the URL. `tier`, `namespace`,
+ * `contract`, and `page_size` are accepted by the route but the v1 UI sends none
+ * of them (every v1 row is official/tai42; the page size stays the server
+ * default) — they exist for contract completeness.
+ */
+export interface MarketplaceSearchQuery {
+    readonly q?: string;
+    readonly kind?: string;
+    readonly category?: string;
+    readonly tags?: string[];
+    readonly namespace?: string;
+    readonly tier?: string;
+    readonly contract?: string;
+    readonly sort?: 'downloads' | 'updated' | 'name' | 'relevance';
+    readonly page?: number;
+    readonly page_size?: number;
+}
+/** Body for installing / updating a plugin. `ref` is `namespace/name`. */
+export interface MarketplaceInstallBody {
+    readonly ref: string;
+    readonly version?: string;
+}
+/** Body for uninstalling a plugin. */
+export interface MarketplaceUninstallBody {
+    readonly ref: string;
+}
+/**
+ * Whether a login-method target is a safe same-origin relative API path. The
+ * login screen is the one page where a misconfigured/compromised manifest could
+ * redirect CREDENTIALS off-origin, so a `submit_path`/`href` MUST start `/api/`
+ * — anything else (absolute URL, protocol-relative `//host`, missing prefix) is
+ * rejected. The `/api/` prefix already excludes `//`-prefixed values; the
+ * explicit double-slash clause is kept for readability.
+ */
+export declare function isSafeApiPath(path: string): boolean;
+export declare function createApiClient(config: ApiConfig): {
+    readonly listTools: (signal?: AbortSignal) => Promise<string[]>;
+    readonly getToolSchema: (name: string, signal?: AbortSignal) => Promise<{
+        input: Record<string, unknown>;
+        output: Record<string, unknown> | null;
+        description: string | null;
+    }>;
+    readonly getAllToolSchemas: (signal?: AbortSignal) => Promise<Record<string, {
+        input: Record<string, unknown>;
+        output: Record<string, unknown> | null;
+        description: string | null;
+    }>>;
+    readonly runTool: (args: RunToolArgs, signal?: AbortSignal) => Promise<unknown>;
+    readonly submitToolRun: (args: SubmitToolRunArgs, signal?: AbortSignal) => Promise<{
+        run_id: string;
+    }>;
+    readonly getToolRun: (runId: string, signal?: AbortSignal) => Promise<{
+        status: "failed" | "running" | "succeeded" | "lost";
+        run_id: string;
+        tool_name: string;
+        started_at: string;
+        error?: string | undefined;
+        result?: unknown;
+        finished_at?: string | undefined;
+    }>;
+    readonly listToolRuns: (toolName: string, signal?: AbortSignal) => Promise<{
+        status: "failed" | "running" | "succeeded" | "lost";
+        run_id: string;
+        tool_name: string;
+        started_at: string;
+        finished_at?: string | undefined;
+    }[]>;
+    readonly listToolTags: (signal?: AbortSignal) => Promise<{
+        name: string;
+        tags: string[];
+    }[]>;
+    readonly listPresets: (signal?: AbortSignal) => Promise<{
+        description: string;
+        name: string;
+        tags: string[];
+        base_tool: string;
+        active_version: number;
+        extensions: (string | {
+            name: string;
+            config: Record<string, unknown>;
+        })[][];
+        output_schema: Record<string, unknown> | null;
+        conflicted: boolean;
+        conflicted_reason: string | null;
+    }[]>;
+    readonly createPreset: (body: CreatePresetBody) => Promise<{
+        description: string;
+        name: string;
+        tags: string[];
+        base_tool: string;
+        active_version: number;
+        extensions: (string | {
+            name: string;
+            config: Record<string, unknown>;
+        })[][];
+        output_schema: Record<string, unknown> | null;
+        conflicted: boolean;
+        conflicted_reason: string | null;
+    }>;
+    readonly getPreset: (name: string, signal?: AbortSignal) => Promise<{
+        description: string;
+        name: string;
+        tags: string[];
+        base_tool: string;
+        active_version: number;
+        extensions: (string | {
+            name: string;
+            config: Record<string, unknown>;
+        })[][];
+        output_schema: Record<string, unknown> | null;
+        conflicted: boolean;
+        conflicted_reason: string | null;
+        fixed_kwargs: Record<string, unknown>;
+    }>;
+    readonly listPresetVersions: (name: string, signal?: AbortSignal) => Promise<{
+        tags: string[];
+        version: number;
+        body: {
+            description: string;
+            tags: string[];
+            base_tool: string;
+            extensions: (string | {
+                name: string;
+                config: Record<string, unknown>;
+            })[][];
+            output_schema: Record<string, unknown> | null;
+            fixed_kwargs: Record<string, unknown>;
+        };
+        created_at: string;
+        is_current: boolean;
+    }[]>;
+    readonly getPresetVersion: (name: string, version: number, signal?: AbortSignal) => Promise<{
+        tags: string[];
+        version: number;
+        body: {
+            description: string;
+            tags: string[];
+            base_tool: string;
+            extensions: (string | {
+                name: string;
+                config: Record<string, unknown>;
+            })[][];
+            output_schema: Record<string, unknown> | null;
+            fixed_kwargs: Record<string, unknown>;
+        };
+        created_at: string;
+        is_current: boolean;
+    }>;
+    readonly savePresetVersion: (name: string, body: SavePresetVersionBody) => Promise<{
+        tags: string[];
+        version: number;
+        body: {
+            description: string;
+            tags: string[];
+            base_tool: string;
+            extensions: (string | {
+                name: string;
+                config: Record<string, unknown>;
+            })[][];
+            output_schema: Record<string, unknown> | null;
+            fixed_kwargs: Record<string, unknown>;
+        };
+        created_at: string;
+        is_current: boolean;
+    }>;
+    readonly rollbackPreset: (name: string, version: number) => Promise<{
+        name: string;
+        active_version: number;
+    }>;
+    readonly deletePreset: (name: string) => Promise<{
+        name: string;
+        deleted: true;
+    }>;
+    readonly renamePreset: (name: string, newName: string) => Promise<{
+        name: string;
+        active_version: number;
+        renamed_from: string;
+    }>;
+    readonly getPresetReferees: (name: string, signal?: AbortSignal) => Promise<{
+        name: string;
+        referees: string[];
+    }>;
+    readonly validatePreset: (body: ValidatePresetBody) => Promise<{
+        error: string | null;
+        valid: boolean;
+    }>;
+    readonly setPresetVersionTags: (name: string, version: number, tags: readonly string[]) => Promise<{
+        name: string;
+        tags: string[];
+        version: number;
+    }>;
+    readonly getStorageInfo: (signal?: AbortSignal) => Promise<{
+        present: boolean;
+        provider: string | null;
+        module: string | null;
+    }>;
+    readonly listStorageResources: (signal?: AbortSignal) => Promise<{
+        resources: string[];
+    }>;
+    readonly statStorageResource: (id: string, signal?: AbortSignal) => Promise<{
+        id: string;
+        content_type: string | null;
+    }>;
+    readonly downloadStorageResource: (id: string, signal?: AbortSignal) => Promise<Blob>;
+    readonly uploadStorageResource: (body: StorageUploadBody) => Promise<{
+        id: string;
+        stored: true;
+    }>;
+    readonly deleteStorageResource: (id: string) => Promise<{
+        deleted: true;
+        id: string;
+    }>;
+    readonly deleteStorageDir: (path: string) => Promise<{
+        deleted: true;
+        dir: string;
+    }>;
+    readonly getBackendInfo: (signal?: AbortSignal) => Promise<{
+        present: boolean;
+        module: string | null;
+        backend: string | null;
+    }>;
+    readonly listFleetWorkers: (signal?: AbortSignal) => Promise<{
+        workers: {
+            kind: "backend" | "serve";
+            origin: string;
+            pid: number;
+        }[];
+    }>;
+    readonly reloadFleetConfig: (targets: string[] | null) => Promise<{
+        error: string | null;
+        op: string;
+        reachable: boolean;
+        local_only: boolean;
+        results: {
+            error: string | null;
+            origin: string;
+            outcome: "applied" | "failed" | "missing" | "departed" | "timed_out";
+            detail: string | null;
+            payload?: unknown;
+        }[];
+    }>;
+    readonly listExtensions: (signal?: AbortSignal) => Promise<{
+        name: string;
+        kind: string;
+    }[]>;
+    readonly getToolExtensions: (name: string, signal?: AbortSignal) => Promise<{
+        combos: (string | {
+            name: string;
+            config: Record<string, unknown>;
+        })[][];
+        available: {
+            name: string;
+            kind: string;
+        }[];
+    }>;
+    readonly setToolExtensions: (name: string, combos: readonly s.PresetExtensionElement[][]) => Promise<{
+        status: string;
+        env_keys: number;
+        fanout: {
+            mode: "local-only";
+            note: string;
+        } | {
+            error: string | null;
+            op: string;
+            reachable: boolean;
+            local_only: boolean;
+            results: {
+                error: string | null;
+                origin: string;
+                outcome: "applied" | "failed" | "missing" | "departed" | "timed_out";
+                detail: string | null;
+                payload?: unknown;
+            }[];
+            mode: "fleet";
+        } | {
+            error: string | null;
+            op: string;
+            reachable: boolean;
+            local_only: boolean;
+            results: {
+                error: string | null;
+                origin: string;
+                outcome: "applied" | "failed" | "missing" | "departed" | "timed_out";
+                detail: string | null;
+                payload?: unknown;
+            }[];
+            mode: "unreachable";
+        };
+    }>;
+    readonly listTemplates: (signal?: AbortSignal) => Promise<string[]>;
+    readonly getTemplate: (templateId: string) => Promise<{
+        template: string;
+        schema: Record<string, unknown>;
+    }>;
+    readonly uploadTemplate: (path: string, content: string) => Promise<{
+        path: string;
+        uploaded: true;
+    }>;
+    readonly deleteTemplate: (path: string) => Promise<{
+        path: string;
+        deleted: true;
+    }>;
+    readonly renderTemplate: (body: {
+        content?: string;
+        template_id?: string;
+        kwargs?: Record<string, unknown>;
+    }) => Promise<{
+        rendered: string;
+    }>;
+    readonly clearTemplatesCache: () => Promise<{
+        cleared: true;
+    }>;
+    readonly getManifest: (signal?: AbortSignal) => Promise<{
+        mcp: Record<string, unknown>[];
+        user_tools: string[];
+    }>;
+    readonly setMcpConfig: (mcp: unknown[]) => Promise<{
+        status: string;
+        env_keys: number;
+        fanout: {
+            mode: "local-only";
+            note: string;
+        } | {
+            error: string | null;
+            op: string;
+            reachable: boolean;
+            local_only: boolean;
+            results: {
+                error: string | null;
+                origin: string;
+                outcome: "applied" | "failed" | "missing" | "departed" | "timed_out";
+                detail: string | null;
+                payload?: unknown;
+            }[];
+            mode: "fleet";
+        } | {
+            error: string | null;
+            op: string;
+            reachable: boolean;
+            local_only: boolean;
+            results: {
+                error: string | null;
+                origin: string;
+                outcome: "applied" | "failed" | "missing" | "departed" | "timed_out";
+                detail: string | null;
+                payload?: unknown;
+            }[];
+            mode: "unreachable";
+        };
+    }>;
+    readonly getMcpStatus: (signal?: AbortSignal) => Promise<{
+        failed: {
+            status: string;
+            title: string;
+        }[];
+        bound: Record<string, string[]>;
+    }>;
+    readonly reloadMcp: (title: string) => Promise<{
+        error: string | null;
+        op: string;
+        reachable: boolean;
+        local_only: boolean;
+        results: {
+            error: string | null;
+            origin: string;
+            outcome: "applied" | "failed" | "missing" | "departed" | "timed_out";
+            detail: string | null;
+            payload?: unknown;
+        }[];
+    }>;
+    readonly listSubMcp: (signal?: AbortSignal) => Promise<Record<string, Record<string, unknown>>>;
+    readonly createSubMcp: (slug: string, tools: string[]) => Promise<{
+        slug: string;
+        tools: string[];
+    }>;
+    readonly deleteSubMcp: (slug: string) => Promise<{
+        slug: string;
+        removed: true;
+    }>;
+    readonly getEnvConfig: (signal?: AbortSignal) => Promise<{
+        env: Record<string, string>;
+        secret_keys: string[];
+    }>;
+    readonly setEnvConfig: (env: Record<string, string>) => Promise<{
+        status: string;
+        env_keys: number;
+        fanout: {
+            mode: "local-only";
+            note: string;
+        } | {
+            error: string | null;
+            op: string;
+            reachable: boolean;
+            local_only: boolean;
+            results: {
+                error: string | null;
+                origin: string;
+                outcome: "applied" | "failed" | "missing" | "departed" | "timed_out";
+                detail: string | null;
+                payload?: unknown;
+            }[];
+            mode: "fleet";
+        } | {
+            error: string | null;
+            op: string;
+            reachable: boolean;
+            local_only: boolean;
+            results: {
+                error: string | null;
+                origin: string;
+                outcome: "applied" | "failed" | "missing" | "departed" | "timed_out";
+                detail: string | null;
+                payload?: unknown;
+            }[];
+            mode: "unreachable";
+        };
+    }>;
+    readonly getConfigMode: (signal?: AbortSignal) => Promise<{
+        config_mode: string;
+        read_only: boolean;
+    }>;
+    readonly listProviders: (signal?: AbortSignal) => Promise<{
+        description: string;
+        kind: "oauth" | "none";
+        id: string;
+        origin: "system" | "community";
+        display_name: string;
+        icon_url: string;
+        category: string;
+        sub_services: {
+            description: string;
+            id: string;
+            display_name: string;
+            scopes: string[];
+        }[];
+        config_fields: {
+            key: string;
+            required: boolean;
+            label: string;
+            target: "env" | "header";
+            secret: boolean;
+        }[];
+    }[]>;
+    readonly listConnections: (signal?: AbortSignal) => Promise<{
+        items: {
+            kind: "oauth" | "none";
+            created_at: string;
+            connection_id: string;
+            provider_id: string;
+            alias: string;
+            account_identity: string | null;
+            enabled_sub_services: string[];
+            granted_scopes: string[];
+            auth_health_state: "healthy" | "reconnect_required" | "refresh_failing";
+        }[];
+        total: number;
+    }>;
+    readonly getConnection: (id: string, signal?: AbortSignal) => Promise<{
+        kind: "oauth" | "none";
+        created_at: string;
+        connection_id: string;
+        provider_id: string;
+        alias: string;
+        account_identity: string | null;
+        enabled_sub_services: string[];
+        granted_scopes: string[];
+        auth_health_state: "healthy" | "reconnect_required" | "refresh_failing";
+    }>;
+    readonly startConnect: (args: StartConnectArgs) => Promise<{
+        flow_id: string;
+        authorize_url: string;
+    } | {
+        fanout: {
+            mode: "local-only";
+            note: string;
+        } | {
+            error: string | null;
+            op: string;
+            reachable: boolean;
+            local_only: boolean;
+            results: {
+                error: string | null;
+                origin: string;
+                outcome: "applied" | "failed" | "missing" | "departed" | "timed_out";
+                detail: string | null;
+                payload?: unknown;
+            }[];
+            mode: "fleet";
+        } | {
+            error: string | null;
+            op: string;
+            reachable: boolean;
+            local_only: boolean;
+            results: {
+                error: string | null;
+                origin: string;
+                outcome: "applied" | "failed" | "missing" | "departed" | "timed_out";
+                detail: string | null;
+                payload?: unknown;
+            }[];
+            mode: "unreachable";
+        } | null;
+        connection_id: string;
+        added_manifest_entries: string[];
+    }>;
+    readonly disconnect: (id: string) => Promise<{
+        fanout: {
+            mode: "local-only";
+            note: string;
+        } | {
+            error: string | null;
+            op: string;
+            reachable: boolean;
+            local_only: boolean;
+            results: {
+                error: string | null;
+                origin: string;
+                outcome: "applied" | "failed" | "missing" | "departed" | "timed_out";
+                detail: string | null;
+                payload?: unknown;
+            }[];
+            mode: "fleet";
+        } | {
+            error: string | null;
+            op: string;
+            reachable: boolean;
+            local_only: boolean;
+            results: {
+                error: string | null;
+                origin: string;
+                outcome: "applied" | "failed" | "missing" | "departed" | "timed_out";
+                detail: string | null;
+                payload?: unknown;
+            }[];
+            mode: "unreachable";
+        } | null;
+        connection_id: string;
+        upstream_revoke_outcome: "failed" | "success" | "skipped";
+        upstream_revoke_status: number | null;
+        removed_manifest_entries: string[];
+    }>;
+    readonly reconnect: (id: string, enabled_sub_services: string[], return_url?: string) => Promise<{
+        flow_id: string;
+        authorize_url: string;
+    }>;
+    readonly patchSubServices: (id: string, enabled_sub_services: string[], return_url?: string) => Promise<{
+        fanout: {
+            mode: "local-only";
+            note: string;
+        } | {
+            error: string | null;
+            op: string;
+            reachable: boolean;
+            local_only: boolean;
+            results: {
+                error: string | null;
+                origin: string;
+                outcome: "applied" | "failed" | "missing" | "departed" | "timed_out";
+                detail: string | null;
+                payload?: unknown;
+            }[];
+            mode: "fleet";
+        } | {
+            error: string | null;
+            op: string;
+            reachable: boolean;
+            local_only: boolean;
+            results: {
+                error: string | null;
+                origin: string;
+                outcome: "applied" | "failed" | "missing" | "departed" | "timed_out";
+                detail: string | null;
+                payload?: unknown;
+            }[];
+            mode: "unreachable";
+        } | null;
+        connection_id: string;
+        enabled_sub_services: string[];
+        flow_id: string | null;
+        authorize_url: string | null;
+        added_manifest_entries: string[];
+        removed_manifest_entries: string[];
+        consent_required: boolean;
+    }>;
+    readonly completeOAuth: (state: string, code: string, error?: string) => Promise<{
+        kind: "success";
+        fanout: {
+            mode: "local-only";
+            note: string;
+        } | {
+            error: string | null;
+            op: string;
+            reachable: boolean;
+            local_only: boolean;
+            results: {
+                error: string | null;
+                origin: string;
+                outcome: "applied" | "failed" | "missing" | "departed" | "timed_out";
+                detail: string | null;
+                payload?: unknown;
+            }[];
+            mode: "fleet";
+        } | {
+            error: string | null;
+            op: string;
+            reachable: boolean;
+            local_only: boolean;
+            results: {
+                error: string | null;
+                origin: string;
+                outcome: "applied" | "failed" | "missing" | "departed" | "timed_out";
+                detail: string | null;
+                payload?: unknown;
+            }[];
+            mode: "unreachable";
+        } | null;
+        connection_id: string;
+        return_url: string;
+    } | {
+        kind: "failed";
+        reason: string;
+    } | {
+        message: string;
+        kind: "cancelled";
+    }>;
+    readonly listStudioPlugins: (signal?: AbortSignal) => Promise<{
+        name: string;
+        version: string;
+        api_version: number;
+        entry: string;
+        integrity: Record<string, string>;
+        contributions: {
+            tool_panels: Record<string, string>;
+            pages: string[];
+            settings_tabs: string[];
+            nav_entries: string[];
+        };
+    }[]>;
+    readonly answerInteraction: (interactionId: string, answer: unknown) => Promise<{
+        status: string;
+        interaction_id: string;
+    }>;
+    readonly listChannels: (signal?: AbortSignal) => Promise<{
+        channels: string[];
+    }>;
+    readonly listNotifications: (signal?: AbortSignal) => Promise<{
+        notifications: {
+            message: string;
+            created_at: string;
+            id: string;
+            recipient: string | null;
+        }[];
+    }>;
+    readonly listAgents: (signal?: AbortSignal) => Promise<{
+        items: {
+            description: string;
+            name: string;
+            tool_name: string;
+            input_schema: Record<string, unknown>;
+            spec_runnable: boolean;
+        }[];
+        total: number;
+    }>;
+    readonly listSpecRunnableAgents: (signal?: AbortSignal) => Promise<{
+        items: {
+            description: string;
+            name: string;
+            tool_name: string;
+            input_schema: Record<string, unknown>;
+            spec_runnable: boolean;
+        }[];
+        total: number;
+    }>;
+    readonly streamAgentRun: (name: string, input: unknown, signal?: AbortSignal) => Promise<AsyncGenerator<import("./agents").ParsedAgentEvent, any, any>>;
+    readonly streamAuthoredAgentRun: (name: string, input: unknown, signal?: AbortSignal) => Promise<AsyncGenerator<import("./agents").ParsedAgentEvent, any, any>>;
+    readonly listHooks: (topic?: string, signal?: AbortSignal) => Promise<{
+        items: {
+            name: string;
+            topic: string;
+            tool: string;
+            tool_kwargs: Record<string, unknown>;
+            condition: string | null;
+            condition_id: string | null;
+            condition_kwargs: Record<string, unknown>;
+            expr: string | null;
+            expr_id: string | null;
+            expr_kwargs: Record<string, unknown>;
+        }[];
+        total: number;
+        topic_verifiers: Record<string, {
+            config: Record<string, unknown>;
+            verifier: string;
+        }>;
+    }>;
+    readonly registerHook: (params: s.HookParams) => Promise<{
+        name: string;
+        registered: boolean;
+    }>;
+    readonly unregisterHook: (name: string) => Promise<{
+        name: string;
+        removed: boolean;
+    }>;
+    readonly listHookVerifiers: (signal?: AbortSignal) => Promise<string[]>;
+    readonly setTopicVerifier: (topic: string, body: TopicVerifierBody) => Promise<{
+        topic: string;
+        verifier: string;
+    }>;
+    readonly deleteTopicVerifier: (topic: string) => Promise<{
+        removed: boolean;
+        topic: string;
+    }>;
+    readonly getMcpConfigSchema: (signal?: AbortSignal) => Promise<Record<string, unknown>>;
+    readonly getSettingsSchema: (signal?: AbortSignal) => Promise<{
+        groups: {
+            name: string;
+            module: string;
+            qualname: string;
+            fields: {
+                type: string;
+                description: string | null;
+                required: boolean;
+                name: string;
+                secret: boolean;
+                env_var: string;
+                nested_group: string | null;
+                value?: unknown;
+                default?: unknown;
+            }[];
+        }[];
+    }>;
+    readonly listScopes: (signal?: AbortSignal) => Promise<Record<string, string>>;
+    readonly addUrlToScope: (body: AddUrlToScopeBody) => Promise<{
+        url: string;
+        scope_id: string;
+    }>;
+    readonly removeUrlFromScope: (body: {
+        url: string;
+    }) => Promise<{
+        url: string;
+    }>;
+    readonly removeScope: (scopeId: string) => Promise<{
+        scope_id: string;
+        deleted_keys: number;
+    }>;
+    readonly listAuthRoutes: (signal?: AbortSignal) => Promise<{
+        path: string;
+        methods: string[];
+        mapped: string | null;
+    }[]>;
+    readonly listPublicRoutes: (signal?: AbortSignal) => Promise<string[]>;
+    readonly pinRoutePublic: (body: PinRoutePublicBody) => Promise<{
+        url: string;
+    }>;
+    readonly unpinPublicRoute: (url: string) => Promise<{
+        url: string;
+    }>;
+    readonly listTokensPayload: (signal?: AbortSignal) => Promise<{
+        description: string;
+        scopes: string[];
+        user_id: string;
+        condition?: string | null | undefined;
+        condition_id?: string | null | undefined;
+        condition_kwargs?: unknown;
+        policy_data?: unknown;
+    }[]>;
+    readonly createApiKey: (body: ApiKeyBody) => Promise<string>;
+    readonly editApiKey: (userId: string, body: Omit<ApiKeyBody, "user_id">) => Promise<{
+        user_id: string;
+        updated: boolean;
+    }>;
+    readonly revokeApiKey: (userId: string) => Promise<{
+        user_id: string;
+        revoked: boolean;
+    }>;
+    readonly createClaimLink: (body: ClaimLinkBody) => Promise<{
+        token: string;
+        claim_path: string;
+        expires_at: string;
+    }>;
+    readonly getMe: (signal?: AbortSignal) => Promise<{
+        tools: string[];
+        scopes: string[];
+        user_id: string;
+        owner_user_id: string | null;
+        admin: boolean;
+        routes: {
+            path: string;
+            methods: string[];
+        }[];
+        route_patterns: {
+            scope_id: string;
+            pattern: string;
+        }[];
+        sub_mcp: {
+            slug: string;
+            tools: string[];
+            transport: string;
+        }[];
+        agents: string[];
+        mintable: boolean;
+    }>;
+    readonly getLoginMethods: (options?: {
+        signal?: AbortSignal;
+    }) => Promise<{
+        methods: ({
+            shape: "form";
+            id: string;
+            title: string;
+            fields: {
+                name: string;
+                label: string;
+                secret: boolean;
+                autocomplete?: string | undefined;
+            }[];
+            purpose: "login" | "bootstrap" | "invite";
+            submit_path: string;
+        } | {
+            shape: "button";
+            id: string;
+            label: string;
+            href: string;
+            icon?: string | undefined;
+        })[];
+        bootstrap: boolean;
+    }>;
+    readonly submitLoginForm: (path: string, values: Record<string, string>) => Promise<{
+        user_id: string;
+        token: string;
+    }>;
+    readonly exchangeSsoCode: (code: string) => Promise<{
+        user_id: string;
+        token: string;
+    }>;
+    readonly claimLogin: (body: {
+        token: string;
+    }) => Promise<{
+        user_id: string;
+        token: string;
+    }>;
+    readonly getAuthCapabilities: (signal?: AbortSignal) => Promise<{
+        mintable: boolean;
+        providers: {
+            name: string;
+            mintable: boolean;
+        }[];
+    }>;
+    readonly logout: () => Promise<{
+        revoked: boolean;
+    }>;
+    readonly validateCondition: (body: ValidateConditionBody) => Promise<{
+        ok: boolean;
+        result: boolean | null;
+    }>;
+    readonly listPolicyVersions: (userId: string, signal?: AbortSignal) => Promise<{
+        tags: string[];
+        version: number;
+        body: {
+            scopes: string[];
+            condition: string | null;
+            condition_id: string | null;
+            condition_kwargs?: unknown;
+            policy_data?: unknown;
+        };
+        created_at: string;
+        is_current: boolean;
+    }[]>;
+    readonly rollbackPolicy: (userId: string, version: number) => Promise<{
+        active_version: number;
+        user_id: string;
+    }>;
+    readonly listBackupSections: (signal?: AbortSignal) => Promise<{
+        name: string;
+        secret: boolean;
+    }[]>;
+    readonly exportBackup: (sections: string[], signal?: AbortSignal) => Promise<Blob>;
+    readonly importBackup: (body: {
+        document: unknown;
+        sections: string[];
+    }) => Promise<{
+        ok: boolean;
+        sections: Record<string, {
+            skipped: number;
+            updated: number;
+            errors: string[];
+            created: number;
+            fanout?: {
+                mode: "local-only";
+                note: string;
+            } | {
+                error: string | null;
+                op: string;
+                reachable: boolean;
+                local_only: boolean;
+                results: {
+                    error: string | null;
+                    origin: string;
+                    outcome: "applied" | "failed" | "missing" | "departed" | "timed_out";
+                    detail: string | null;
+                    payload?: unknown;
+                }[];
+                mode: "fleet";
+            } | {
+                error: string | null;
+                op: string;
+                reachable: boolean;
+                local_only: boolean;
+                results: {
+                    error: string | null;
+                    origin: string;
+                    outcome: "applied" | "failed" | "missing" | "departed" | "timed_out";
+                    detail: string | null;
+                    payload?: unknown;
+                }[];
+                mode: "unreachable";
+            } | undefined;
+            new_api_keys?: {
+                description: string;
+                user_id: string;
+                api_key: string;
+            }[] | undefined;
+        }>;
+    }>;
+    readonly listSchedules: (signal?: AbortSignal) => Promise<import("zod").objectOutputType<{
+        name: import("zod").ZodString;
+        enabled: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        schedule: import("zod").ZodOptional<import("zod").ZodType<unknown, import("zod").ZodTypeDef, unknown>>;
+        target: import("zod").ZodOptional<import("zod").ZodType<unknown, import("zod").ZodTypeDef, unknown>>;
+        args: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodType<unknown, import("zod").ZodTypeDef, unknown>, "many">>;
+        kwargs: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodType<unknown, import("zod").ZodTypeDef, unknown>>>;
+    }, import("zod").ZodTypeAny, "passthrough">[]>;
+    readonly getServerDateTime: (signal?: AbortSignal) => Promise<import("zod").objectOutputType<{
+        utc: import("zod").ZodType<unknown, import("zod").ZodTypeDef, unknown>;
+        local: import("zod").ZodOptional<import("zod").ZodType<unknown, import("zod").ZodTypeDef, unknown>>;
+        system: import("zod").ZodOptional<import("zod").ZodType<unknown, import("zod").ZodTypeDef, unknown>>;
+    }, import("zod").ZodTypeAny, "passthrough">>;
+    readonly addSchedule: (body: {
+        tool_name: string;
+        tool_kwargs: Record<string, unknown>;
+        schedule_kwargs: Record<string, unknown>;
+    }) => Promise<unknown>;
+    readonly deleteSchedule: (name: string) => Promise<unknown>;
+    readonly getObservabilityMetrics: (params?: MetricsQuery, signal?: AbortSignal) => Promise<{
+        summary: {
+            totalRuns: number;
+            totalCost: number;
+            totalTokens: number;
+            averageLatencyMs: number;
+            avgCostPerRun: number;
+            avgTokensPerRun: number;
+            timeToFirstTokenMs: number | null;
+        };
+        timeSeries: {
+            totalTokens: number;
+            bucket: string | null;
+            runs: number;
+            cost: number;
+            avgLatencyMs: number;
+        }[];
+        byModel: {
+            totalTokens: number;
+            cost: number;
+            avgLatencyMs: number;
+            model: string;
+            calls: number;
+        }[];
+        granularity: "hour" | "day" | "week";
+    }>;
+    readonly listRuns: (params?: RunsQuery, signal?: AbortSignal) => Promise<{
+        items: {
+            status: "error" | "success";
+            tags: string[];
+            id: string;
+            totalTokens: number | null;
+            cost: number | null;
+            model: string | null;
+            traceId: string;
+            createdAt: string | null;
+            latencyMs: number | null;
+            fetchError: string | null;
+            inputPreview?: unknown;
+            outputPreview?: unknown;
+        }[];
+        page: number;
+        nextPage: number | null;
+    }>;
+    readonly getRunTrace: (traceId: string, signal?: AbortSignal) => Promise<{
+        tags: string[];
+        totalCost: number | null;
+        traceId: string;
+        fetchError: string | null;
+        timestamp: string | null;
+        availability: "partial" | "unavailable" | "full";
+        spans: {
+            type: string | null;
+            name: string | null;
+            id: string;
+            model: string | null;
+            traceId: string | null;
+            parentId: string | null;
+            level: string | null;
+            statusMessage: string | null;
+            start: string | null;
+            end: string | null;
+            nodeId: string | null;
+            input?: unknown;
+            output?: unknown;
+            usage?: unknown;
+            metadata?: unknown;
+        }[];
+        input?: unknown;
+        output?: unknown;
+        metadata?: unknown;
+    }>;
+    readonly exportTrace: (traceId: string, signal?: AbortSignal) => Promise<Blob>;
+    readonly exportRuns: (params: RunsQuery & {
+        format: "csv" | "json";
+    }, signal?: AbortSignal) => Promise<Blob>;
+    readonly searchMarketplace: (query?: MarketplaceSearchQuery, signal?: AbortSignal) => Promise<{
+        items: {
+            description: string;
+            name: string;
+            tags: string[];
+            display_name: string | null;
+            icon_url: string | null;
+            item: {
+                description: string;
+                name: string;
+                tags: string[];
+                kind: string;
+            };
+            ref: string;
+            namespace: string;
+            package: string;
+            categories: string[];
+            trust_tier: string;
+            pricing: string;
+            latest_version: string | null;
+            downloads: number;
+            updated_at: string;
+        }[];
+        total: number;
+        page: number;
+        page_size: number;
+    }>;
+    readonly getMarketplacePlugin: (namespace: string, name: string, signal?: AbortSignal) => Promise<{
+        description: string;
+        name: string;
+        tags: string[];
+        display_name: string | null;
+        icon_url: string | null;
+        namespace: string;
+        package: string;
+        categories: string[];
+        trust_tier: string;
+        pricing: string;
+        downloads: number;
+        readme_md: string | null;
+        license: string | null;
+        homepage_url: string | null;
+        repository_url: string | null;
+        latest: {
+            status: string;
+            version: string;
+            items: {
+                description: string;
+                name: string;
+                tags: string[];
+                kind: string;
+            }[];
+            contract_range: string | null;
+            published_at: string | null;
+        } | null;
+        versions: {
+            status: string;
+            version: string;
+            contract_range: string | null;
+            published_at: string | null;
+        }[];
+    }>;
+    readonly listMarketplaceCategories: (signal?: AbortSignal) => Promise<string[]>;
+    readonly listInstalledMarketplacePlugins: (signal?: AbortSignal) => Promise<{
+        version: string;
+        ref: string;
+        latest: string | null;
+        source: string;
+        installed_at: string;
+        update_available: boolean;
+        missing_upstream: boolean;
+    }[]>;
+    readonly installMarketplacePlugin: (body: MarketplaceInstallBody) => Promise<{
+        version: string;
+        ref: string;
+        advisories: {
+            created_at: string;
+            id: number;
+            summary: string;
+            listing: string;
+            affected_versions: string;
+            severity: string;
+            withdrawn_at: string | null;
+        }[];
+        notes: string[];
+    }>;
+    readonly uninstallMarketplacePlugin: (body: MarketplaceUninstallBody) => Promise<{
+        ref: string;
+        notes: string[];
+        uninstalled: true;
+    }>;
+    readonly updateMarketplacePlugin: (body: MarketplaceInstallBody) => Promise<{
+        version: string;
+        ref: string;
+        advisories: {
+            created_at: string;
+            id: number;
+            summary: string;
+            listing: string;
+            affected_versions: string;
+            severity: string;
+            withdrawn_at: string | null;
+        }[];
+        notes: string[];
+    }>;
+    readonly getMarketplaceAdvisories: (signal?: AbortSignal) => Promise<{
+        advisories: {
+            created_at: string;
+            id: number;
+            summary: string;
+            listing: string;
+            affected_versions: string;
+            severity: string;
+            withdrawn_at: string | null;
+        }[];
+        fetched_at: string;
+    }>;
+    readonly getHealth: (signal?: AbortSignal) => Promise<string>;
+    readonly getMetrics: (signal?: AbortSignal) => Promise<string>;
+    readonly getSystemKinds: (signal?: AbortSignal) => Promise<{
+        kind: string;
+        detail: string;
+        state: "active" | "default" | "off";
+        plugin: string | null;
+    }[]>;
+    /**
+     * Open the authed interactions SSE stream. The caller drives reconnect +
+     * backlog-replay dedup. Returns the raw frame iterator; the interactions
+     * feature maps frames to typed events.
+     */
+    readonly streamInteractions: (signal?: AbortSignal) => Promise<AsyncGenerator<import("./sse").SseFrame, any, any>>;
+};
+export type ApiClient = ReturnType<typeof createApiClient>;
+//# sourceMappingURL=client.d.ts.map