@tai42/api-client 16.0.0 → 16.0.1

package/dist/client.js

@@ -1,920 +0,0 @@
-/**
- * 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 { apiDownload, apiRequest, apiText, encodeSegment, extractError, isUnsafePathSegment, } from './http';
-import { ApiError, ApiLoginFailedError, ApiUnauthorizedError } from './errors';
-import { readSseFrames, sseOpenToken } from './sse';
-import { agentList, streamAgentRun, streamAuthoredAgentRun } from './agents';
-import { getToolRun, listToolRuns, submitToolRun } from './tool-runs';
-import * as s from './schemas';
-/**
- * Encode a possibly-nested storage id / directory path for use in a URL path,
- * percent-encoding each segment while preserving the `/` separators. A storage id
- * can be a nested path (e.g. `a/b c.txt`); encoding each segment independently keeps
- * the slashes structural and escapes everything else (spaces, `#`, `?`, …).
- *
- * Dot segments (`.`, `..`), empty segments (a leading/trailing/doubled `/`, or an
- * empty id) are REJECTED loudly rather than encoded: the browser's WHATWG URL parser
- * removes dot-segments from a relative request path before it is sent — collapsing
- * `..` even when percent-encoded — so such an id can never be faithfully transmitted.
- * Left to encode, it would silently retarget the request at an unrelated same-origin
- * route. The server enforces the same relative-path rule; failing fast here keeps a
- * malformed id from ever leaving the client.
- */
-function encodePath(id) {
-    const segments = id.split('/');
-    if (segments.some(isUnsafePathSegment)) {
-        throw new Error("storage path must be a relative path with no empty, '.', or '..' segment");
-    }
-    return segments.map(encodeURIComponent).join('/');
-}
-/** Flatten a `RunsQuery` to transport params, JSON-encoding the `tags` list. */
-function runsQueryToParams(query) {
-    return {
-        from: query.from,
-        to: query.to,
-        tags: query.tags === undefined ? undefined : JSON.stringify(query.tags),
-        status: query.status,
-        minCost: query.minCost,
-        maxCost: query.maxCost,
-        minTokens: query.minTokens,
-        maxTokens: query.maxTokens,
-        minLatencyMs: query.minLatencyMs,
-        maxLatencyMs: query.maxLatencyMs,
-        sort: query.sort,
-        dir: query.dir,
-        page: query.page,
-        pageSize: query.pageSize,
-    };
-}
-/**
- * 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 function isSafeApiPath(path) {
-    return path.startsWith('/api/') && !path.startsWith('//');
-}
-/**
- * Map a transport error from a login submission onto an `ApiLoginFailedError`
- * (rendered inline on the login page) or rethrow it unchanged (5xx, schema
- * drift, network — the page's generic failure branch surfaces it loudly).
- *
- * A transport 401 arrives as `ApiUnauthorizedError` before any body is read, so
- * its message is generic by construction; the domain 4xx statuses carry the
- * server's informative envelope text (rate-limit, bootstrap-already-initialized,
- * password-policy, or the claim exchange's uniform "unknown or already used"
- * 404) straight through to the inline surface.
- */
-function asLoginError(error) {
-    if (error instanceof ApiUnauthorizedError) {
-        throw new ApiLoginFailedError('Sign-in failed — check your credentials.', 401);
-    }
-    if (error instanceof ApiError &&
-        (error.status === 400 ||
-            error.status === 403 ||
-            error.status === 404 ||
-            error.status === 409 ||
-            error.status === 422 ||
-            error.status === 429)) {
-        throw new ApiLoginFailedError(error.message, error.status);
-    }
-    throw error;
-}
-/**
- * The subject-addressed record path: `/api/states/{name}/records/{target_kind}/
- * {target_name}/{kind}/{key}` — four path segments, each percent-encoded, so a key
- * carrying a slash or a colon never escapes its segment.
- */
-function stateRecordPath(name, subject) {
-    return (`/api/states/${encodeSegment(name)}/records/` +
-        `${encodeSegment(subject.target_kind)}/${encodeSegment(subject.target_name)}/` +
-        `${encodeSegment(subject.kind)}/${encodeSegment(subject.key)}`);
-}
-/**
- * Encode a template jq's declared params as JSON query values: the record `template-jq`
- * route reads each `?<param>=<json>` as a JSON-decoded argument, so a string, number,
- * array or object round-trips faithfully. An `undefined` value is dropped (an
- * omitted optional param).
- */
-function encodeJqParams(params) {
-    if (params === undefined)
-        return undefined;
-    const query = {};
-    for (const [key, value] of Object.entries(params)) {
-        if (value === undefined)
-            continue;
-        query[key] = JSON.stringify(value);
-    }
-    return query;
-}
-export function createApiClient(config) {
-    const req = (path, schema, options) => apiRequest(config, path, schema, options);
-    return {
-        // The configured API base — the exact `baseUrl` this client was constructed
-        // with (`''` for a same-origin deployment). Read-only: features that must
-        // compose an ABSOLUTE API URL (a QR-encoded public path the API origin must
-        // receive, not the SPA origin) read it instead of assuming same-origin. The
-        // transport itself still joins it per request; this only surfaces the value.
-        baseUrl: config.baseUrl ?? '',
-        // -- tools ---------------------------------------------------------------
-        listTools: (signal) => req('/api/tools', s.toolNames, { signal }),
-        getToolSchema: (name, signal) => req(`/api/tools/${encodeSegment(name)}/schema`, s.toolSchema, { signal }),
-        getAllToolSchemas: (signal) => req('/api/tools-schema', s.allToolSchemas, { signal }),
-        runTool: (args, signal) => req('/api/run-tool', s.runToolResult, {
-            method: 'POST',
-            // The backend's `/api/run-tool` door reads `{tool_name, arguments}` (the
-            // shape `read_tool_call` enforces and the background `/api/tool-runs`
-            // submit already sends). The SPA keeps `tool`/`kwargs` as its ergonomic
-            // arg names; map them onto the wire fields here.
-            body: { tool_name: args.tool, arguments: args.kwargs ?? {} },
-            signal,
-        }),
-        // -- app tool live-registry admin ----------------------------------------
-        // Re-register or remove one app tool by kind+name, applied on this worker and
-        // broadcast to the fleet (all workers, or only `targets`); both return the bare
-        // per-worker `fleetResult` the shared fleet-report handler renders. Both are
-        // fenced + destructive server-side, so a refusal surfaces as a loud error.
-        reloadTool: (args) => req('/api/tools/reload', s.fleetResult, {
-            method: 'POST',
-            body: { kind: args.kind, name: args.name, targets: args.targets ?? null },
-        }),
-        removeTool: (args) => req('/api/tools/remove', s.fleetResult, {
-            method: 'POST',
-            body: { kind: args.kind, name: args.name, targets: args.targets ?? null },
-        }),
-        // -- background tool runs ------------------------------------------------
-        submitToolRun: (args, signal) => submitToolRun(config, args, signal),
-        getToolRun: (runId, signal) => getToolRun(config, runId, signal),
-        listToolRuns: (toolName, signal) => listToolRuns(config, toolName, signal),
-        // -- tool tags (additive map feeding the ToolPicker tag grouping) --------
-        listToolTags: (signal) => req('/api/tools/tags', s.toolTags, { signal }),
-        // -- presets -------------------------------------------------------------
-        // Every preset is store-backed and versioned; the list is the single
-        // management population (the presets plus the conflicted quarantined rows).
-        listPresets: (signal) => req('/api/presets', s.presetList, { signal }),
-        createPreset: (body) => req('/api/presets', s.presetRecord, { method: 'POST', body }),
-        getPreset: (name, signal) => req(`/api/presets/${encodeSegment(name)}`, s.presetDetail, { signal }),
-        listPresetVersions: (name, signal) => req(`/api/presets/${encodeSegment(name)}/versions`, s.presetVersionList, { signal }),
-        getPresetVersion: (name, version, signal) => req(`/api/presets/${encodeSegment(name)}/versions/${encodeSegment(version)}`, s.presetVersion, { signal }),
-        savePresetVersion: (name, body) => req(`/api/presets/${encodeSegment(name)}/versions`, s.presetVersion, {
-            method: 'POST',
-            body,
-        }),
-        rollbackPreset: (name, version) => req(`/api/presets/${encodeSegment(name)}/rollback`, s.presetRollback, {
-            method: 'POST',
-            body: { version },
-        }),
-        deletePreset: (name) => req(`/api/presets/${encodeSegment(name)}`, s.presetDeleted, { method: 'DELETE' }),
-        renamePreset: (name, newName) => req(`/api/presets/${encodeSegment(name)}/rename`, s.presetRenamed, {
-            method: 'POST',
-            body: { new_name: newName },
-        }),
-        // The presets whose active composition names this one as a tool — the referees
-        // a rename would strand. A rename preflight reads this to warn before the 409.
-        getPresetReferees: (name, signal) => req(`/api/presets/${encodeSegment(name)}/referees`, s.presetReferees, { signal }),
-        // The dry-run verdict for a draft (create OR version, mode-resolved server-side):
-        // `valid` plus the server's verbatim `error` message. Both verdicts are HTTP 200.
-        validatePreset: (body) => req('/api/presets/validate', s.presetValidation, { method: 'POST', body }),
-        // Replace one version's `tags` annotation — labels on an immutable body, so no
-        // rebind. Returns the re-annotated identity + new tag list.
-        setPresetVersionTags: (name, version, tags) => req(`/api/presets/${encodeSegment(name)}/versions/${encodeSegment(version)}/tags`, s.presetVersionTags, { method: 'PUT', body: { tags } }),
-        // -- states --------------------------------------------------------------
-        // A state is a declared JSON document, one per subject. The list is the
-        // management population; a single state read composes the declaration with its
-        // effective schema, regimes and attachments. Every record route addresses its subject
-        // as four percent-encoded path segments (see `stateRecordPath`).
-        listStates: (signal) => req('/api/states', s.stateList, { signal }),
-        getState: (name, signal) => req(`/api/states/${encodeSegment(name)}`, s.stateDetail, { signal }),
-        // A plain declaration upsert — no `replace` flag. With records present the server
-        // accepts additive schema changes and refuses with a 409 any change that removes or
-        // alters an existing field, or a subject-kind removal that would strand records.
-        putState: (name, body) => req(`/api/states/${encodeSegment(name)}`, s.stateDetail, {
-            method: 'PUT',
-            body,
-        }),
-        deleteState: (name) => req(`/api/states/${encodeSegment(name)}`, s.stateDeleted, { method: 'DELETE' }),
-        getStateStats: (name, signal) => req(`/api/states/${encodeSegment(name)}/stats`, s.stateStats, { signal }),
-        // -- state template attachments ------------------------------------------
-        listStateAttachments: (name, signal) => req(`/api/states/${encodeSegment(name)}/attachments`, s.stateAttachmentList, { signal }),
-        getStateAttachment: (name, template, signal) => req(`/api/states/${encodeSegment(name)}/attachments/${encodeSegment(template)}`, s.stateAttachment, { signal }),
-        attachStateTemplate: (name, template, body) => req(`/api/states/${encodeSegment(name)}/attachments/${encodeSegment(template)}`, s.stateAttached, { method: 'PUT', body }),
-        patchStateAttachment: (name, template, body) => req(`/api/states/${encodeSegment(name)}/attachments/${encodeSegment(template)}`, s.stateAttachmentUpdated, { method: 'PATCH', body }),
-        detachStateTemplate: (name, template) => req(`/api/states/${encodeSegment(name)}/attachments/${encodeSegment(template)}`, s.stateDetached, { method: 'DELETE' }),
-        // -- state subjects + records -------------------------------------------
-        listStateSubjects: (name, params, signal) => req(`/api/states/${encodeSegment(name)}/subjects`, s.subjectPage, {
-            signal,
-            query: { kind: params.kind, limit: params.limit, cursor: params.cursor },
-        }),
-        // The content search body is a single JSONB containment document (`filters`); the
-        // server refuses an empty one, so the UI validates a non-empty object first.
-        searchStateRecords: (name, body, signal) => req(`/api/states/${encodeSegment(name)}/records/search`, s.recordSearchPage, {
-            method: 'POST',
-            body,
-            signal,
-        }),
-        // A subject with no document yet reads as `null` (a 200 `{data: null}`, the record
-        // page's Create path) — never an error, so the schema is nullable.
-        getStateRecord: (name, subject, signal) => req(stateRecordPath(name, subject), s.stateRecord.nullable(), { signal }),
-        putStateRecord: (name, subject, data) => req(stateRecordPath(name, subject), s.stateRecord, { method: 'PUT', body: data }),
-        patchStateRecord: (name, subject, data) => req(stateRecordPath(name, subject), s.stateRecord, { method: 'PATCH', body: data }),
-        applyStateRecord: (name, subject, ops) => req(`${stateRecordPath(name, subject)}/deltas`, s.applyResult, {
-            method: 'POST',
-            body: { ops },
-        }),
-        // Evaluate a template jq over the subject: each declared param is JSON-encoded into
-        // the query string (`?<param>=<json>`); the response is `{name, purpose, value}`. An
-        // `attachment.name` jq is percent-encoded as one path segment.
-        evalTemplateJq: (name, subject, jqName, params, signal) => req(`${stateRecordPath(name, subject)}/template-jq/${encodeSegment(jqName)}`, s.templateJqResult, { signal, query: encodeJqParams(params) }),
-        // Apply an `update`-purpose template jq to the subject: `input` is the jq's argument,
-        // `op_id` its idempotency key (a replay is a no-op). The jq lands its op batch through
-        // the apply chokepoint. An `attachment.name` jq is percent-encoded as one path segment.
-        applyTemplateJq: (name, subject, jqName, body) => req(`${stateRecordPath(name, subject)}/template-jq/${encodeSegment(jqName)}`, s.templateJqApplyResult, { method: 'POST', body: body ?? {} }),
-        deleteStateRecord: (name, subject) => req(stateRecordPath(name, subject), s.recordErased, { method: 'DELETE' }),
-        // `mode` is required server-side (`switch` drops, `merge` combines); the fold returns
-        // a report, not the surviving record.
-        foldStateRecord: (name, subject, into, mode) => req(`${stateRecordPath(name, subject)}/fold`, s.stateFoldReport, {
-            method: 'POST',
-            body: { into, mode },
-        }),
-        listStateWrites: (name, subject, params, signal) => req(`${stateRecordPath(name, subject)}/writes`, s.writesPage, {
-            signal,
-            query: { limit: params?.limit, cursor: params?.cursor },
-        }),
-        stateConsumers: (name, signal) => req(`/api/states/${encodeSegment(name)}/consumers`, s.stateConsumers, { signal }),
-        // -- state-template documents (top-level sibling collection) ---------------
-        listStateTemplates: (signal) => req('/api/state-templates', s.stateTemplateList, { signal }),
-        getStateTemplate: (name, signal) => req(`/api/state-templates/${encodeSegment(name)}`, s.stateTemplateDocument, { signal }),
-        putStateTemplate: (name, body, replace) => req(`/api/state-templates/${encodeSegment(name)}`, s.stateTemplateDocument, {
-            method: 'PUT',
-            body,
-            query: replace === true ? { replace: 'true' } : undefined,
-        }),
-        deleteStateTemplate: (name) => req(`/api/state-templates/${encodeSegment(name)}`, s.stateTemplateDeleted, {
-            method: 'DELETE',
-        }),
-        // -- state retention -----------------------------------------------------
-        pruneStateRetention: () => req('/api/state-retention/prune', s.stateRetentionPruned, { method: 'POST', body: {} }),
-        // -- tool_meta (the organizational overlay) ------------------------------
-        // The folder tree + per-tool overlay rows in one read; the features merge the
-        // rows against the live tool list and native tags client-side.
-        listToolMeta: (signal) => req('/api/tool-meta', s.toolMetaOverlay, { signal }),
-        // Merge-patch a tool's overlay row (create it if absent). `patch` carries ONLY
-        // the fields to change — a present-null clears, an absent field is untouched,
-        // and a present `tags` array replaces the set.
-        upsertToolMeta: (toolName, patch) => req(`/api/tool-meta/tools/${encodeSegment(toolName)}`, s.toolMetaRecord, {
-            method: 'PATCH',
-            body: patch,
-        }),
-        deleteToolMeta: (toolName) => req(`/api/tool-meta/tools/${encodeSegment(toolName)}`, s.toolMetaDeleted, {
-            method: 'DELETE',
-        }),
-        createFolder: (name, parentId = null) => req('/api/tool-meta/folders', s.folderRecord, {
-            method: 'POST',
-            body: { name, parent_id: parentId },
-        }),
-        renameFolder: (folderId, name) => req(`/api/tool-meta/folders/${encodeSegment(folderId)}/rename`, s.folderRecord, {
-            method: 'POST',
-            body: { name },
-        }),
-        // `null` re-parents to the root.
-        moveFolder: (folderId, parentId) => req(`/api/tool-meta/folders/${encodeSegment(folderId)}/move`, s.folderRecord, {
-            method: 'POST',
-            body: { parent_id: parentId },
-        }),
-        deleteFolder: (folderId) => req(`/api/tool-meta/folders/${encodeSegment(folderId)}`, s.folderDeleted, {
-            method: 'DELETE',
-        }),
-        // -- storage -------------------------------------------------------------
-        // The content store a storage-provider plugin exposes. Dead by default:
-        // `getStorageInfo` reports `present: false` (a 200 empty state) and every other
-        // door answers a loud 501 when no provider is installed. Ids may be nested
-        // paths, so each is `encodePath`-encoded (per-segment, `/` preserved).
-        getStorageInfo: (signal) => req('/api/storage', s.storageInfo, { signal }),
-        listStorageResources: (signal) => req('/api/storage/resources', s.storageResourceList, { signal }),
-        statStorageResource: (id, signal) => req(`/api/storage/resources/${encodePath(id)}/stat`, s.storageResourceStat, { signal }),
-        downloadStorageResource: (id, signal) => apiDownload(config, `/api/storage/resources/${encodePath(id)}/content`, { signal }),
-        uploadStorageResource: (body) => req('/api/storage/resources', s.storageResourceStored, { method: 'POST', body }),
-        deleteStorageResource: (id) => req(`/api/storage/resources/${encodePath(id)}`, s.storageResourceDeleted, {
-            method: 'DELETE',
-        }),
-        deleteStorageDir: (path) => req(`/api/storage/dirs/${encodePath(path)}`, s.storageDirDeleted, { method: 'DELETE' }),
-        // -- backend identity + fleet (worker bus) -------------------------------
-        // Backend IDENTITY (`getBackendInfo`, kept on `/api/backend`) is distinct from
-        // the FLEET doors, which ride the app's worker bus and need no backend at all.
-        // `getBackendInfo` reports `present: false` (a 200 empty state) when no backend
-        // plugin is registered. `listFleetWorkers` reads the live bus presence census
-        // (every subscribed worker, ASGI + backend-runtime) and never fabricates an empty
-        // fleet — a census read that fails surfaces as a loud 500.
-        getBackendInfo: (signal) => req('/api/backend', s.backendInfo, { signal }),
-        listFleetWorkers: (signal) => req('/api/fleet/workers', s.fleetWorkers, { signal }),
-        // Soft-restart the fleet: `targets` names the workers to reload, or `null` for
-        // the whole fleet. The serving worker applies locally then broadcasts; a 200
-        // response carries the per-worker fleet report, so workers that did not converge
-        // are named, not hidden. A failed local apply instead re-raises as a loud error
-        // (the transport throws with the failure message), not a returned report.
-        reloadFleetConfig: (targets) => req('/api/fleet/reload-config', s.fleetReloadResult, { method: 'POST', body: { targets } }),
-        // -- extensions ----------------------------------------------------------
-        listExtensions: (signal) => req('/api/extensions', s.extensions, { signal }),
-        // A MANIFEST-provided tool's current combos + the extension catalog. (A preset
-        // tool's extensions live on the preset spec, read via `getPreset`.)
-        getToolExtensions: (name, signal) => req(`/api/tools/${encodeSegment(name)}/extensions`, s.toolExtensions, { signal }),
-        // Author ALL of a MANIFEST tool's combos at once (the full lossless list; `[]`
-        // clears). Returns the apply result: the local reload (`status` + `env_keys`) plus
-        // the mode-wrapped fleet `fanout` of the reload it broadcast, from which the shared
-        // fleet-report handler surfaces any failed propagation.
-        setToolExtensions: (name, combos) => req(`/api/tools/${encodeSegment(name)}/extensions`, s.toolExtensionsApplyResult, {
-            method: 'POST',
-            body: { combos },
-        }),
-        // -- templates -----------------------------------------------------------
-        listTemplates: (signal) => req('/api/templates', s.templateNames, { signal }),
-        getTemplate: (templateId) => req('/api/template', s.templateDetail, { method: 'POST', body: { template_id: templateId } }),
-        uploadTemplate: (path, content) => req('/api/upload-template', s.templateUploaded, { method: 'POST', body: { path, content } }),
-        deleteTemplate: (path) => req('/api/delete-template', s.templateDeleted, { method: 'POST', body: { path } }),
-        // Delete every stored template under a directory prefix. Unlike the idempotent
-        // single delete, the server 404s a prefix matching nothing and 400s the template
-        // root; those surface as loud errors, never a faked success.
-        deleteTemplateDir: (path) => req('/api/delete-template-dir', s.templateDirDeleted, { method: 'POST', body: { path } }),
-        // Render one authored text — inline `content` OR a stored template `id`, plus its
-        // render `kwargs` — and parse the rendered output. The value is the shared
-        // `TemplatedText` (exactly one source); the route wraps it under `text`.
-        renderTemplate: (text) => req('/api/render-template', s.templateRendered, { method: 'POST', body: { text } }),
-        clearTemplatesCache: () => req('/api/clear-templates-cache', s.templateCacheCleared, { method: 'POST' }),
-        // -- manifest / mcp ------------------------------------------------------
-        getManifest: (signal) => req('/api/manifest', s.manifestView, { signal }),
-        setMcpConfig: (mcp) => req('/api/mcp-config', s.reloadConfigResult, { method: 'POST', body: { mcp } }),
-        getMcpStatus: (signal) => req('/api/mcp-status', s.mcpStatus, { signal }),
-        reloadMcp: (title) => req(`/api/mcp-status/${encodeSegment(title)}/reload`, s.mcpReloadResult, {
-            method: 'POST',
-        }),
-        // Granular manifest-section entry edits — add/replace or remove ONE entry by
-        // title, leaving the rest of the section untouched (the surgical counterpart to
-        // the whole-section `setMcpConfig`). Each crosses the config pipeline and returns
-        // the shared apply-result (`status` + `env_keys` + fleet `fanout`). `replace` lets
-        // an entry whose title already exists swap in; without it a collision is refused.
-        addToolsEntries: (entries, replace = false) => req('/api/tools-config/entries', s.reloadConfigResult, {
-            method: 'POST',
-            body: { entries, replace },
-        }),
-        removeToolsEntry: (title) => req(`/api/tools-config/entries/${encodeSegment(title)}`, s.reloadConfigResult, {
-            method: 'DELETE',
-        }),
-        addAgentsEntries: (entries, replace = false) => req('/api/agents-config/entries', s.reloadConfigResult, {
-            method: 'POST',
-            body: { entries, replace },
-        }),
-        removeAgentsEntry: (title) => req(`/api/agents-config/entries/${encodeSegment(title)}`, s.reloadConfigResult, {
-            method: 'DELETE',
-        }),
-        // Edit the manifest `api_tools` include/exclude name lists by delta (add/remove
-        // names on either list). Absent fields default to empty; the server refuses a body
-        // whose four lists are all empty. Returns the shared apply-result.
-        updateApiTools: (body) => req('/api/api-tools', s.reloadConfigResult, {
-            method: 'POST',
-            body: {
-                include_add: body.include_add ?? [],
-                include_remove: body.include_remove ?? [],
-                exclude_add: body.exclude_add ?? [],
-                exclude_remove: body.exclude_remove ?? [],
-            },
-        }),
-        // -- failed-MCP health ---------------------------------------------------
-        // The MCP servers skipped by the viability check, plus their remediation ops. The
-        // LIST rides the fleet fan-out primitive (each worker's failed roster arrives as
-        // its own report payload; `failedMcpsFromReport` unions them). Reload-all re-probes
-        // every failed server; deregister detaches one server's tools by title. Each op
-        // returns the bare per-worker `fleetResult`.
-        listFailedMcps: (signal) => req('/api/mcp-status/failed', s.fleetResult, { signal }),
-        reloadFailedMcps: () => req('/api/mcp-status/reload-failed', s.fleetResult, {
-            method: 'POST',
-            body: { targets: null },
-        }),
-        deregisterMcp: (title) => req(`/api/mcp-status/${encodeSegment(title)}/deregister`, s.fleetResult, {
-            method: 'POST',
-            body: { targets: null },
-        }),
-        // -- sub-mcp -------------------------------------------------------------
-        listSubMcp: (signal) => req('/api/sub-mcp', s.subMcpList, { signal }),
-        // `transport` is optional at the client boundary (the server defaults it to
-        // `http`); when omitted, JSON.stringify drops the undefined key from the body.
-        createSubMcp: (slug, tools, transport) => req('/api/sub-mcp', s.subMcpCreated, { method: 'POST', body: { slug, tools, transport } }),
-        deleteSubMcp: (slug) => req(`/api/sub-mcp/${encodeSegment(slug)}`, s.subMcpRemoved, { method: 'DELETE' }),
-        // -- config --------------------------------------------------------------
-        getEnvConfig: (signal) => req('/api/config/env', s.envConfig, { signal }),
-        setEnvConfig: (env) => req('/api/config/env', s.reloadConfigResult, { method: 'POST', body: env }),
-        getConfigMode: (signal) => req('/api/config/mode', s.configMode, { signal }),
-        // The LOCAL soft-restart door (distinct from the System page's fleet door
-        // `/api/fleet/reload-config`): refresh env from the config manager, reset the
-        // settings caches, and re-initialize from the manifest — applied on the serving
-        // worker and broadcast to the fleet (all workers, or only `targets`; `null` = all).
-        // Admin-`fenced`; the 200 body is the bare per-worker fleet report so an
-        // unconverged sibling is visible, never hidden.
-        reloadConfig: (targets = null) => req('/api/config/reload', s.fleetReloadResult, { method: 'POST', body: { targets } }),
-        // -- settings profiles ---------------------------------------------------
-        // The admin-only `/api/config/profiles/*` surface. Bodies/diff/versions carry
-        // REAL secret values (secret/fenced routes); masking is CLIENT-SIDE.
-        listSettingsProfiles: (signal) => req('/api/config/profiles', s.settingsProfileList, { signal }),
-        getSettingsProfile: (name, signal) => req(`/api/config/profiles/${encodeSegment(name)}`, s.settingsProfileBody, { signal }),
-        putSettingsProfile: (name, body) => req(`/api/config/profiles/${encodeSegment(name)}`, s.settingsProfileSaved, {
-            method: 'PUT',
-            body,
-        }),
-        deleteSettingsProfile: (name) => req(`/api/config/profiles/${encodeSegment(name)}`, s.settingsProfileDeleted, {
-            method: 'DELETE',
-        }),
-        // Diff of the SAVED profile vs the stored env — server-computed, no request body.
-        diffSettingsProfile: (name) => req(`/api/config/profiles/${encodeSegment(name)}/diff`, s.settingsProfileDiff, {
-            method: 'POST',
-        }),
-        // Apply the SAVED profile (full-replace of the profile-managed band). Fenced,
-        // destructive → the dedicated `profile_apply_response` report.
-        applySettingsProfile: (name) => req(`/api/config/profiles/${encodeSegment(name)}/apply`, s.profileApplyResponse, {
-            method: 'POST',
-        }),
-        listSettingsProfileVersions: (name, signal) => req(`/api/config/profiles/${encodeSegment(name)}/versions`, s.settingsProfileVersionList, {
-            signal,
-        }),
-        getSettingsProfileVersion: (name, version, signal) => req(`/api/config/profiles/${encodeSegment(name)}/versions/${encodeSegment(version)}`, s.settingsProfileVersion, { signal }),
-        rollbackSettingsProfile: (name, version) => req(`/api/config/profiles/${encodeSegment(name)}/rollback`, s.settingsProfileRollback, {
-            method: 'POST',
-            body: { version },
-        }),
-        // -- combined env+manifest op + preserved manifest -----------------------
-        // The SecretRefField server half: one atomic env-value + `!ENV` manifest
-        // write, returning the shared apply-result shape (reload + fleet fanout).
-        setMcpSecretEnv: (body) => req('/api/mcp-config/secret-env', s.reloadConfigResult, { method: 'POST', body }),
-        // The PRESERVED manifest (`!ENV` markers intact, no resolved secrets) — the
-        // connectors page's McpServersSection reads this so round-trips never inline
-        // resolved values.
-        getManifestPreserved: (signal) => req('/api/manifest/preserved', s.manifestView, { signal }),
-        // The manifest MCP section's `!ENV ${VAR[:default]}` marker refs — NAMES and
-        // set/unset BOOLEANS only, never values. Drives the McpServersSection env-refs
-        // checklist on the connectors page.
-        getMcpEnvRefs: (signal) => req('/api/manifest/mcp-env-refs', s.mcpEnvRefs, { signal }),
-        // -- connectors ----------------------------------------------------------
-        listProviders: (signal) => req('/api/connectors/providers', s.providers, { signal }),
-        listConnections: (signal) => req('/api/connectors/connections', s.connectionsList, { signal }),
-        getConnection: (id, signal) => req(`/api/connectors/connections/${encodeSegment(id)}`, s.connectionView, { signal }),
-        startConnect: (args) => req('/api/connectors/connections/start', s.startConnectResult, {
-            method: 'POST',
-            body: args,
-        }),
-        disconnect: (id) => req(`/api/connectors/connections/${encodeSegment(id)}`, s.disconnectResult, {
-            method: 'DELETE',
-        }),
-        reconnect: (id, enabled_sub_services, return_url) => req(`/api/connectors/connections/${encodeSegment(id)}/reconnect`, s.reconnectResult, {
-            method: 'POST',
-            body: { enabled_sub_services, return_url },
-        }),
-        patchSubServices: (id, enabled_sub_services, return_url) => req(`/api/connectors/connections/${encodeSegment(id)}/sub-services`, s.patchSubServicesResult, {
-            method: 'PATCH',
-            body: { enabled_sub_services, return_url },
-        }),
-        completeOAuth: (state, code, error) => req('/api/connectors/oauth/complete', s.oauthCompleteResult, {
-            method: 'POST',
-            body: { state, code, error },
-        }),
-        // -- studio plugin registry ---------------------------------------------
-        listStudioPlugins: (signal) => req('/api/plugins', s.studioPluginRegistry, { signal }),
-        // -- interactions --------------------------------------------------------
-        // One page of the pending interactions (the tail-only stream's paged base). The
-        // door filters by audience before paging — the SAME filter the stream applies —
-        // so `total` is the caller's own count, and every terminal frame it later receives
-        // refers to a question within that `total`.
-        listInteractions: (page, pageSize, signal) => req('/api/interactions', s.interactionsPage, { signal, query: { page, pageSize } }),
-        answerInteraction: (interactionId, answer) => req(`/api/interactions/${encodeSegment(interactionId)}/answer`, s.interactionAnswered, {
-            method: 'POST',
-            body: { answer },
-        }),
-        // Withdraw a pending ask WITHOUT answering it (a bodyless POST): the question is
-        // resolved as cancelled and the flow that asked never resumes. Terminal like an
-        // answer, so the loud failure mappings mirror it — a 409 (already answered, so no
-        // longer cancellable) surfaces as `ApiConflictError`, a 404 (unknown/already gone)
-        // and a 403 (not this caller's audience) as `ApiError` — all via the shared
-        // `apiRequest` status handling.
-        cancelInteraction: (interactionId) => req(`/api/interactions/${encodeSegment(interactionId)}/cancel`, s.interactionCancelled, {
-            method: 'POST',
-        }),
-        // -- channels --------------------------------------------------------------
-        // The installed channel-plugin names (delivery media for ask_user questions).
-        listChannels: (signal) => req('/api/channels', s.channels, { signal }),
-        // -- conversations ---------------------------------------------------------
-        // The stored routing rows, each with its `callback_secret` withheld — the
-        // conversation monitor's route picker.
-        listConversationRoutes: (signal) => req('/api/conversations', s.conversationRoutes, { signal }),
-        // Create or REPLACE a route (an UPSERT: the same door is the create and the
-        // edit path). `route_name` rides the URL path AND the body; the door rejects a
-        // disagreeing pair, so both come from the one create object. The reply carries
-        // the freshly-minted `callback_secret` for an `api`-door row, returned ONCE.
-        createOrReplaceConversationRoute: (route) => req(`/api/conversations/${encodeSegment(route.route_name)}`, s.conversationRouteWritten, {
-            method: 'POST',
-            body: route,
-        }),
-        // Delete a route by name (destructive + authority-changing server-side): it
-        // drops the routing row and reclaims the thread indexes it owned.
-        deleteConversationRoute: (routeName) => req(`/api/conversations/${encodeSegment(routeName)}`, s.conversationRouteDeleted, {
-            method: 'DELETE',
-        }),
-        // One route's threads, newest activity first. Admin-only server-side: a
-        // listing spans every caller on the route, so a scoped session gets a 403.
-        listConversationThreads: (routeName, page, pageSize, filters = {}, signal) => req(`/api/conversations/${encodeSegment(routeName)}/threads`, s.conversationThreadsPage, {
-            signal,
-            query: { page, pageSize, status: filters.status, address: filters.address },
-        }),
-        // One thread's transcript, caller-scoped, read in the asked-for direction.
-        // The `thread_id` rides the QUERY STRING, never the path: it embeds the api
-        // door's `{principal}/{end user}` address with the principal already
-        // percent-encoded, which a path segment would have to encode a second time
-        // and the server would then decode once too few. A query value is decoded
-        // exactly once whatever it holds, so it is passed through verbatim.
-        readConversationTranscript: (query, signal) => req(`/api/conversations/${encodeSegment(query.routeName)}/transcript`, s.conversationTranscriptPage, {
-            signal,
-            query: {
-                thread_id: query.threadId,
-                page: query.page,
-                pageSize: query.pageSize,
-                order: query.order,
-                q: query.q,
-            },
-        }),
-        // Search every record on a route by text, across threads, newest first. The
-        // needle rides the QUERY (`q`); paging is the infinite query's own window. The
-        // page's `truncated` flag says the match set outran the door's scan cap.
-        searchConversationMessages: (query, signal) => req(`/api/conversations/${encodeSegment(query.routeName)}/messages/search`, s.conversationMessageSearchPage, { signal, query: { q: query.q, page: query.page, pageSize: query.pageSize } }),
-        // Send a human message into a thread. The `thread_id` rides the BODY (a POST,
-        // never a path segment) — same encode-once reasoning as the transcript read.
-        sendConversationThreadMessage: (routeName, body) => req(`/api/conversations/${encodeSegment(routeName)}/thread/messages`, s.conversationThreadMessageSent, { method: 'POST', body }),
-        // Read a thread's reply mode (`agent`/`manual`) and where it comes from. The
-        // `thread_id` rides the QUERY value, encoded once, as the transcript read does.
-        getConversationThreadMode: (routeName, threadId, signal) => req(`/api/conversations/${encodeSegment(routeName)}/thread/mode`, s.conversationThreadModeState, { signal, query: { thread_id: threadId } }),
-        // Flip a thread's reply mode. The `thread_id` rides the BODY (a PUT).
-        setConversationThreadMode: (routeName, threadId, mode) => req(`/api/conversations/${encodeSegment(routeName)}/thread/mode`, s.conversationThreadModeState, { method: 'PUT', body: { thread_id: threadId, mode } }),
-        // -- conversation target configs -------------------------------------------
-        // The stored per-target presentation configs (each `(target_kind, target_name)`
-        // pair's multichannel flag + first-contact greeting). Admin config surface.
-        listConversationConfigs: (signal) => req('/api/conversation-configs', s.conversationConfigs, { signal }),
-        // One config by its `(target_kind, target_name)` key. 404 when unknown.
-        getConversationConfig: (targetKind, targetName, signal) => req(`/api/conversation-configs/${encodeSegment(targetKind)}/${encodeSegment(targetName)}`, s.targetConversationConfig, { signal }),
-        // Create or REPLACE a config (an UPSERT: the same door is the create and the
-        // edit path). The `(target_kind, target_name)` key rides the URL path; the door
-        // rejects a body whose key disagrees, so both come from the one config object.
-        setConversationConfig: (config) => req(`/api/conversation-configs/${encodeSegment(config.target_kind)}/${encodeSegment(config.target_name)}`, s.conversationConfigWritten, { method: 'PUT', body: config }),
-        // Delete a config by its key. 404 when the key is unknown.
-        deleteConversationConfig: (targetKind, targetName) => req(`/api/conversation-configs/${encodeSegment(targetKind)}/${encodeSegment(targetName)}`, s.conversationConfigDeleted, { method: 'DELETE' }),
-        // -- conversation admin ----------------------------------------------------
-        // Every answer record whose delivery ended `failed`, across every route and
-        // caller. Admin-only server-side; not a paged window (returns `{items, total}`).
-        listFailedConversationMessages: (signal) => req('/api/conversations/messages/failed', s.conversationFailedMessages, { signal }),
-        // Forget ONE thread on a route (destructive): its checkpoint, answer records and
-        // thread indexes. The `thread_id` rides the QUERY value, encoded once — it embeds
-        // the api door's percent-encoded `{principal}/{end user}` address, which a path
-        // segment would encode a second time. `removed` counts the records this call
-        // cleared; a valid id on its own route always succeeds, never a 404.
-        deleteConversationThread: (routeName, threadId) => req(`/api/conversations/${encodeSegment(routeName)}/thread`, s.conversationThreadDeleted, {
-            method: 'DELETE',
-            query: { thread_id: threadId },
-        }),
-        // Erase a LINKED person ENTIRELY (GDPR, wide blast radius): its aggregated thread
-        // and checkpoint, its person row, and every address→person index mapping, across
-        // EVERY route it wrote under. The `person_id` is a uuid4 with no percent-encoded
-        // principal, so it rides the PATH cleanly. `erased` says whether this call removed
-        // the person row (idempotent — a retry answers `false`, never a 404).
-        deleteConversationPerson: (personId) => req(`/api/conversations/persons/${encodeSegment(personId)}`, s.conversationPersonDeleted, {
-            method: 'DELETE',
-        }),
-        // -- channel-web entry gate ------------------------------------------------
-        // A web route's entry gate, keyed by its `our_identity`: read the flag + its
-        // live codes, flip the flag, mint a code (raw returned ONCE), revoke a code by
-        // its hash id. The conversation monitor's first route mutations.
-        getWebEntryGate: (identity, signal) => req(`/api/channels/web/gates/${encodeSegment(identity)}`, s.webEntryGate, { signal }),
-        setWebEntryGate: (identity, enabled) => req(`/api/channels/web/gates/${encodeSegment(identity)}`, s.webEntryGateState, {
-            method: 'PUT',
-            body: { enabled },
-        }),
-        // Mint a code. `label`/`expires_at` are sent EXPLICITLY (including `null`). The
-        // raw `code` rides the reply ONCE (composed into the chat URL client-side).
-        mintWebEntryCode: (identity, body) => req(`/api/channels/web/gates/${encodeSegment(identity)}/codes`, s.webEntryCodeMinted, {
-            method: 'POST',
-            body: { label: body.label, expires_at: body.expires_at },
-        }),
-        // Revoke a code by its hash id (immediate + durable). 404 when the id is unknown.
-        revokeWebEntryCode: (identity, codeId) => req(`/api/channels/web/gates/${encodeSegment(identity)}/codes/${encodeSegment(codeId)}`, s.webEntryCodeRevoked, { method: 'DELETE' }),
-        // -- notifications ---------------------------------------------------------
-        // The internal notifications sink, newest-first — the messages the `notify_user`
-        // operation records with no channel, so they surface only in this inbox.
-        listNotifications: (signal) => req('/api/notifications', s.notifications, { signal }),
-        // -- agents --------------------------------------------------------------
-        listAgents: (signal) => req('/api/agents', agentList, { signal }),
-        // The authorable subset (agents whose `spec_runnable` is true) — the compose
-        // UI's base-agent picker. An empty `items` list ⇒ no authoring is possible.
-        listSpecRunnableAgents: (signal) => req('/api/agents/spec-runnable', agentList, { signal }),
-        // The streaming run: opens POST /api/agents/{name}/runs and yields parsed
-        // agent events. The auto-form's built value is the POST body.
-        streamAgentRun: (name, input, signal) => streamAgentRun(config, name, input, signal),
-        // The streaming run of an AUTHORED agent (POST /api/agents/authored/{name}/runs).
-        // The body carries only the non-baked ToolInput fields; the baked spec is
-        // resolved server-side. Reuses the same SSE parser (never EventSource).
-        streamAuthoredAgentRun: (name, input, signal) => streamAuthoredAgentRun(config, name, input, signal),
-        // -- hooks --------------------------------------------------------
-        listHooks: (topic, signal) => req('/api/hooks', s.hookList, { signal, query: topic === undefined ? undefined : { topic } }),
-        registerHook: (params) => req('/api/hooks', s.hookRegistered, { method: 'POST', body: params }),
-        unregisterHook: (name) => req(`/api/hooks/${encodeSegment(name)}`, s.hookRemoved, { method: 'DELETE' }),
-        // The registered webhook-verifier catalog — the only source the bind picker
-        // reads (names only; an empty registry is a valid empty list).
-        listHookVerifiers: (signal) => req('/api/hooks/verifiers', s.hookVerifiers, { signal }),
-        // Bind a verifier to a topic (locks its otherwise-open public ingress). A PUT
-        // replaces any existing binding; an unknown verifier name is a loud 400.
-        setTopicVerifier: (topic, body) => req(`/api/hooks/topics/${encodeSegment(topic)}/verifier`, s.topicVerifierSet, {
-            method: 'PUT',
-            body,
-        }),
-        // Unbind a topic's verifier (re-opens its public ingress). 404 when no binding.
-        deleteTopicVerifier: (topic) => req(`/api/hooks/topics/${encodeSegment(topic)}/verifier`, s.topicVerifierRemoved, {
-            method: 'DELETE',
-        }),
-        // -- hooks: trigger links -------------------------------------------------
-        // Mint a trigger link for a topic. `ttl_seconds` is sent EXPLICITLY
-        // (including `null` for a permanent link) — the server requires the key present
-        // and 400s a dropped one; `tool_kwargs` is omitted when undefined. The raw
-        // `token` rides the response ONCE (composed into the QR URL client-side).
-        createTriggerLink: (body) => req('/api/hooks/trigger-links', s.triggerLinkCreated, {
-            method: 'POST',
-            body: {
-                topic: body.topic,
-                name: body.name,
-                execution_key: body.execution_key,
-                require_api_key: body.require_api_key,
-                ttl_seconds: body.ttl_seconds,
-                tool_kwargs: body.tool_kwargs,
-            },
-        }),
-        // Every live trigger-link record (hash prefix only — never a raw token).
-        listTriggerLinks: (signal) => req('/api/hooks/trigger-links', s.triggerLinkList, { signal }),
-        // Revoke a link by name (immediate + durable). 404 when the name is unknown.
-        deleteTriggerLink: (name) => req(`/api/hooks/trigger-links/${encodeSegment(name)}`, s.triggerLinkDeleted, {
-            method: 'DELETE',
-        }),
-        // -- mcp config schema (connectors McpServersSection form) ---------------
-        getMcpConfigSchema: (signal) => req('/api/mcp-config/schema', s.jsonSchema, { signal }),
-        // -- settings schema -----------------------------------------------------
-        getSettingsSchema: (signal) => req('/api/config/settings-schema', s.settingsSchema, { signal }),
-        // -- auth: scopes --------------------------------------------------------
-        listScopes: (signal) => req('/api/auth/scopes', s.authScopes, { signal }),
-        addUrlToScope: (body) => req('/api/auth/scopes', s.addUrlToScopeResult, { method: 'POST', body }),
-        removeUrlFromScope: (body) => req('/api/auth/scopes/urls', s.removeUrlFromScopeResult, { method: 'DELETE', body }),
-        removeScope: (scopeId) => req(`/api/auth/scopes/${encodeSegment(scopeId)}`, s.removeScopeResult, {
-            method: 'DELETE',
-        }),
-        // The app's HTTP route catalog with each route's current mapping — the only
-        // source of the mapper's unassigned-routes bucket (`mapped: null` entries).
-        listAuthRoutes: (signal) => req('/api/auth/routes', s.authRoutes, { signal }),
-        // The urls pinned to the public marker; pinning/unpinning is the dedicated
-        // public-routes writer, never the scope machinery.
-        listPublicRoutes: (signal) => req('/api/auth/public-routes', s.publicRoutes, { signal }),
-        pinRoutePublic: (body) => req('/api/auth/public-routes', s.pinPublicResult, { method: 'POST', body }),
-        // Unpin a public url. A url that is absent or scope-mapped is a loud 404.
-        unpinPublicRoute: (url) => req('/api/auth/public-routes', s.unpinPublicResult, { method: 'DELETE', body: { url } }),
-        // -- auth: roles (editable per-tag RBAC) ---------------------------------
-        // The seeded + operator-authored roles as full bodies (base-tier ceiling +
-        // editable per-tag grant map). ADMIN-ONLY — the route is `secret` (a listing
-        // exposes each role's raw base-tier jq); a non-admin projection never reaches it.
-        listRoles: (signal) => req('/api/auth/roles', s.roleList, { signal }),
-        // Create an operator-authored role. The server validates the grant map + base
-        // tier and 409s on a name collision; the reserved `admin` role cannot be created.
-        createRole: (body) => req('/api/auth/roles', s.roleBody, { method: 'POST', body }),
-        // Edit a role's per-tag grant map + description (omit-means-keep). The reserved
-        // `admin` role and any `allow_all` role are block-downgrade guarded server-side.
-        updateRole: (name, body) => req(`/api/auth/roles/${encodeSegment(name)}`, s.roleBody, { method: 'PUT', body }),
-        // Delete a role. The reserved `admin` role is undeletable; a role still assigned
-        // to any principal is a loud 409.
-        deleteRole: (name) => req(`/api/auth/roles/${encodeSegment(name)}`, s.roleDeleted, { method: 'DELETE' }),
-        // A role's append-only version history + who/action/before→after audit trail.
-        // ADMIN-ONLY (`secret`).
-        listRoleVersions: (name, signal) => req(`/api/auth/roles/${encodeSegment(name)}/versions`, s.roleVersions, { signal }),
-        // Re-point a role's active version to a prior one (LIVE — holders follow on
-        // their next request); returns the re-pointed role body.
-        rollbackRole: (name, version) => req(`/api/auth/roles/${encodeSegment(name)}/rollback`, s.roleBody, {
-            method: 'POST',
-            body: { version },
-        }),
-        // -- auth: api keys ------------------------------------------------------
-        listTokensPayload: (signal) => req('/api/auth/tokens-payload', s.tokensPayload, { signal }),
-        createApiKey: (body) => req('/api/auth/api-keys', s.createdApiKey, { method: 'POST', body }),
-        editApiKey: (userId, body) => req(`/api/auth/api-keys/${encodeSegment(userId)}`, s.editApiKeyResult, {
-            method: 'PUT',
-            body,
-        }),
-        revokeApiKey: (userId) => req(`/api/auth/api-keys/${encodeSegment(userId)}`, s.revokeApiKeyResult, {
-            method: 'DELETE',
-        }),
-        // Mint a one-time claim link carrying a raw key to another device (the QR
-        // onboarding leg). The token rides the URL fragment; the server returns a
-        // relative `claim_path` and the raw token ONCE.
-        createClaimLink: (body) => req('/api/auth/claim-links', s.claimLinkCreated, { method: 'POST', body }),
-        // -- auth: the caller's capability projection ----------------------------
-        // The derived (path, method) surface + tools/agents the caller can reach
-        // right now — the projection the Studio filters its nav and pages on.
-        getMe: (signal) => req('/api/auth/me', s.meProjection, { signal }),
-        // -- login: the public sign-in aggregator --------------------------------
-        // PUBLIC by design: `apiRequest` attaches `x-api-key` only when a token
-        // exists, so the unauthenticated call carries no auth header — no transport
-        // change needed.
-        getLoginMethods: (options) => req('/api/login/methods', s.loginMethods, { signal: options?.signal }),
-        // Submit a `form` method's field VALUES as a flat top-level JSON body (the
-        // server's request models take the declared field names top-level). `path`
-        // is re-checked with the same relative-`/api/` guard the renderer uses — an
-        // off-origin path is a PROGRAMMING error (loud `Error`), not a login failure.
-        // A refused credential becomes an inline `ApiLoginFailedError`.
-        submitLoginForm: async (path, values) => {
-            if (!isSafeApiPath(path)) {
-                throw new Error(`login submit_path must be a relative /api/ path; received ${JSON.stringify(path)}`);
-            }
-            try {
-                return await req(path, s.loginResult, { method: 'POST', body: values });
-            }
-            catch (error) {
-                return asLoginError(error);
-            }
-        },
-        // Exchange a one-time SSO hand-back code for a session (never a token in the
-        // URL). An expired/reused code is a login failure, surfaced inline.
-        exchangeSsoCode: async (code) => {
-            try {
-                return await req('/api/login/sso/exchange', s.loginResult, {
-                    method: 'POST',
-                    body: { code },
-                });
-            }
-            catch (error) {
-                return asLoginError(error);
-            }
-        },
-        // Exchange a one-time claim token (read from the login URL fragment, never a
-        // query param) for a session. PUBLIC. The token is single-use and burns
-        // server-side; a used/unknown/expired token answers the uniform 404, which —
-        // like the SSO leg — maps to an inline `ApiLoginFailedError`, not a global
-        // unauthorized redirect. The caller latches the exchange so it fires once.
-        claimLogin: async (body) => {
-            try {
-                return await req('/api/login/claim', s.loginResult, { method: 'POST', body });
-            }
-            catch (error) {
-                return asLoginError(error);
-            }
-        },
-        // Whether this deployment can mint API keys locally (the settings key-create
-        // UI gates on `mintable`). AUTHED.
-        getAuthCapabilities: (signal) => req('/api/auth/capabilities', s.authCapabilities, { signal }),
-        // -- auth: session logout ------------------------------------------------
-        // The single authed logout dispatcher — revokes the caller's accounts
-        // session server-side before the shell clears local state. A plain `sk-` key
-        // has nothing to revoke and answers 404 (surfaced as an `ApiError`, quiet at
-        // the call site); a 5xx/network failure is a real revoke failure the shell
-        // surfaces loudly.
-        logout: () => req('/api/auth/logout', s.logoutResult, { method: 'POST' }),
-        // -- auth: policy authoring + versioning ---------------------------------
-        // The fail-closed jq guard: compiles (and, with `sample_context`, evaluates) a
-        // condition without persisting anything, so a broken condition is caught at
-        // author time instead of locking a key out at enforcement. A broken condition
-        // is a 400 the transport throws — never a false-positive `ok`.
-        validateCondition: (body) => req('/api/auth/validate-condition', s.validateConditionResult, { method: 'POST', body }),
-        // The user's append-only policy version history (each row's `is_current`
-        // derived from the active pointer). SECRET-ADJACENT — the body carries the raw
-        // condition, so its fixtures are hand-authored.
-        listPolicyVersions: (userId, signal) => req(`/api/auth/api-keys/${encodeSegment(userId)}/policy/versions`, s.policyVersionList, {
-            signal,
-        }),
-        // Re-point the enforced policy to a prior version; returns the re-pointed
-        // active version. Enforcement follows on cache invalidation.
-        rollbackPolicy: (userId, version) => req(`/api/auth/api-keys/${encodeSegment(userId)}/policy/rollback`, s.policyRollback, {
-            method: 'POST',
-            body: { version },
-        }),
-        // -- backup --------------------------------------------------------------
-        listBackupSections: (signal) => req('/api/backup/sections', s.backupSections, { signal }),
-        exportBackup: (sections, signal) => apiDownload(config, '/api/backup/export', { method: 'POST', body: { sections }, signal }),
-        importBackup: (body) => req('/api/backup/import', s.backupImportReport, { method: 'POST', body }),
-        // -- schedules -----------------------------------------------------------
-        listSchedules: (signal) => req('/api/schedules', s.scheduleList, { signal }),
-        getServerDateTime: (signal) => req('/api/schedules/server-datetime', s.serverDateTime, { signal }),
-        addSchedule: (body) => req('/api/schedules', s.jsonValue, { method: 'POST', body }),
-        deleteSchedule: (name) => req(`/api/schedules/${encodeSegment(name)}`, s.jsonValue, { method: 'DELETE' }),
-        // -- observability -------------------------------------------------------
-        // The monitoring-backend dashboard rollups (`GET /api/observability/metrics`),
-        // a JSON aggregate distinct from any raw process-metrics text endpoint.
-        getObservabilityMetrics: (params = {}, signal) => req('/api/observability/metrics', s.dashboardMetrics, {
-            query: { from: params.from, to: params.to, granularity: params.granularity },
-            signal,
-        }),
-        listRuns: (params = {}, signal) => req('/api/observability/runs', s.runsPage, { query: runsQueryToParams(params), signal }),
-        getRunTrace: (traceId, signal) => req(`/api/observability/runs/${encodeSegment(traceId)}/trace`, s.runTrace, { signal }),
-        exportTrace: (traceId, signal) => apiDownload(config, `/api/observability/runs/${encodeSegment(traceId)}/trace/export`, {
-            signal,
-        }),
-        exportRuns: (params, signal) => apiDownload(config, '/api/observability/runs/export', {
-            query: { ...runsQueryToParams(params), format: params.format },
-            signal,
-        }),
-        // -- marketplace ---------------------------------------------------------
-        // Browse/search proxy the registry through the app (one origin, one auth);
-        // install/uninstall/update mutate the RUNNING app (pip install + manifest
-        // patch + reload) and return synchronous receipts.
-        searchMarketplace: (query = {}, signal) => req('/api/marketplace/search', s.marketplaceSearchPage, {
-            query: {
-                q: query.q,
-                kind: query.kind,
-                category: query.category,
-                tags: query.tags,
-                namespace: query.namespace,
-                tier: query.tier,
-                contract: query.contract,
-                sort: query.sort,
-                page: query.page,
-                page_size: query.page_size,
-            },
-            signal,
-        }),
-        getMarketplacePlugin: (namespace, name, signal) => req(`/api/marketplace/plugins/${encodeSegment(namespace)}/${encodeSegment(name)}`, s.marketplacePluginDetail, { signal }),
-        listMarketplaceCategories: (signal) => req('/api/marketplace/categories', s.marketplaceCategories, { signal }),
-        listMarketplaceKinds: (signal) => req('/api/marketplace/kinds', s.marketplaceKinds, { signal }),
-        listInstalledMarketplacePlugins: (signal) => req('/api/marketplace/installed', s.marketplaceInstalled, { signal }),
-        // Preview resolves the spec and computes routes/collisions/public rows with
-        // NO side effects, so the install dialog can show absolute paths, block on a
-        // collision, and surface the public routes before the operator commits.
-        previewMarketplaceInstall: (body, signal) => req('/api/marketplace/install/preview', s.marketplaceInstallPreview, {
-            method: 'POST',
-            body,
-            signal,
-        }),
-        installMarketplacePlugin: (body) => req('/api/marketplace/install', s.marketplaceInstallResult, { method: 'POST', body }),
-        uninstallMarketplacePlugin: (body) => req('/api/marketplace/uninstall', s.marketplaceUninstallResult, { method: 'POST', body }),
-        updateMarketplacePlugin: (body) => req('/api/marketplace/update', s.marketplaceInstallResult, { method: 'POST', body }),
-        // Upgrade EVERY installed plugin to its newest compatible version in one
-        // pass; the response is the per-plugin outcome readout.
-        upgradeAllMarketplacePlugins: () => req('/api/marketplace/upgrade-all', s.marketplaceUpgradeAllResult, { method: 'POST' }),
-        getMarketplaceAdvisories: (signal) => req('/api/marketplace/advisories', s.marketplaceAdvisories, { signal }),
-        // -- system (plain-text ops endpoint) ------------------------------------
-        getHealth: (signal) => apiText(config, '/health', { signal }),
-        // The pluggable-kind status table (`GET /api/system/kinds`) — a JSON `{data}`
-        // envelope, one row per kind with its active/default/off state.
-        getSystemKinds: (signal) => req('/api/system/kinds', s.kindStatusList, { signal }),
-        /**
-         * Open the authed interactions SSE stream. The stream is TAIL-ONLY: its cursor
-         * is the stream tail at connect, so it carries no backlog and no
-         * `interaction.backlog_done` frame — the pending base comes from
-         * `listInteractions`. The caller drives reconnect and refetches that base on
-         * each (re)connect. Returns the raw frame iterator; the interactions feature
-         * maps frames to typed events.
-         *
-         * `lastEventId` (the id of the last frame the caller saw) is sent as the
-         * `Last-Event-ID` header so the server resumes AFTER it and replays any frame —
-         * including a card's `answered` — that landed during a disconnect gap. It is
-         * also sent as a `?last_event_id=` query param so a proxy that strips the header
-         * still resumes; the server reads either. Omitted on a first connect.
-         */
-        streamInteractions: async (signal, lastEventId) => {
-            const doFetch = config.fetch ?? globalThis.fetch;
-            const token = config.getToken();
-            const headers = { accept: 'text/event-stream' };
-            if (token)
-                headers['x-api-key'] = token;
-            if (lastEventId)
-                headers['last-event-id'] = lastEventId;
-            // Distinct-URL per open — see the canonical constraint on `sseOpenToken`.
-            const resume = lastEventId ? `&last_event_id=${encodeURIComponent(lastEventId)}` : '';
-            const url = `${config.baseUrl ?? ''}/api/interactions/stream?_=${sseOpenToken()}${resume}`;
-            const response = await doFetch(url, {
-                headers,
-                signal,
-            });
-            if (response.status === 401)
-                throw new ApiUnauthorizedError();
-            // A non-ok stream open (5xx/4xx) still carries a body, which would parse to
-            // zero frames and look like a silently-empty stream — surface it loudly so
-            // the caller shows an error instead of hanging on a reconnect loop. Read the
-            // `{ "error" }` envelope so a load-bearing server message (e.g. the OFF
-            // store's 501 remediation line) surfaces verbatim instead of collapsing to
-            // the bare status text.
-            if (!response.ok) {
-                let payload;
-                try {
-                    payload = await response.json();
-                }
-                catch {
-                    throw new ApiError(response.statusText || 'stream failed', response.status);
-                }
-                const { message, code } = extractError(payload);
-                throw new ApiError(message ?? (response.statusText || 'stream failed'), response.status, code);
-            }
-            return readSseFrames(response, signal);
-        },
-    };
-}
-//# sourceMappingURL=client.js.map