@cat-factory/sdk 0.5.0

package/dist/operations.generated.js

@@ -0,0 +1,698 @@
+// GENERATED by `pnpm gen:sdk` from docs/openapi.json — DO NOT EDIT BY HAND.
+// Regenerate after any change to the `/api/v1` contracts; `pnpm check:sdk` fails CI on drift.
+import { encodePathSegment } from './http.js';
+import { repeatedCursorError } from './errors.js';
+/** Headless jobs (a public, inline pipeline run against a brief): start, poll or stream one. */
+export class JobsResource {
+    #transport;
+    constructor(transport) {
+        this.#transport = transport;
+    }
+    /**
+     * Cancel a job
+     * Stop a headless job run, freeing its concurrency slot. Idempotent — an already-finished job is returned as-is. Use this to abandon a run parked on a decision you do not intend to answer.
+     * `POST /api/v1/jobs/{id}/cancel` — operation `cancelPublicJob`.
+     */
+    cancel(id, options = {}) {
+        return this.#transport.request({
+            method: 'POST',
+            path: `/api/v1/jobs/${encodePathSegment(id)}/cancel`,
+            options,
+        });
+    }
+    /**
+     * Start a headless job
+     * Start a public, inline pipeline headlessly against a supplied brief. Returns a job id to poll or stream. Nothing is pushed to GitHub.
+     * `POST /api/v1/jobs` — operation `createPublicJob`.
+     */
+    create(body, options = {}) {
+        return this.#transport.request({
+            method: 'POST',
+            path: `/api/v1/jobs`,
+            body,
+            options,
+        });
+    }
+    /**
+     * Get a job
+     * Poll a headless job started through this surface: its status and, once finished, its result.
+     * `GET /api/v1/jobs/{id}` — operation `getPublicJob`.
+     */
+    get(id, options = {}) {
+        return this.#transport.request({
+            method: 'GET',
+            path: `/api/v1/jobs/${encodePathSegment(id)}`,
+            options,
+        });
+    }
+    /**
+     * List the workspace's jobs
+     * List the headless runs THIS surface created, newest first and keyset-paginated. Scoped to internal-anchored runs exactly like the single-job read, so an external key can never enumerate the workspace’s ordinary board runs.
+     * `GET /api/v1/jobs` — operation `listPublicJobs`.
+     */
+    list(query = {}, options = {}) {
+        return this.#transport.request({
+            method: 'GET',
+            path: `/api/v1/jobs`,
+            query,
+            options,
+        });
+    }
+    /**
+     * Every `jobs` across every page of `list()`.
+     * Follows `nextCursor` until the server reports no further page. The cursor is opaque
+     * and carries a position, never authority — each page re-applies the key's full scope.
+     */
+    async *listAll(query = {}, options = {}) {
+        let cursor = query.cursor;
+        for (;;) {
+            const page = await this.list({ ...query, cursor }, options);
+            for (const item of page.jobs)
+                yield item;
+            if (!page.nextCursor)
+                return;
+            if (page.nextCursor === cursor)
+                throw repeatedCursorError();
+            cursor = page.nextCursor;
+        }
+    }
+    /**
+     * Stream a job (SSE)
+     * Server-sent events for a headless job run: `progress` frames until a terminal `done`/`error`/`stopped`/`timeout` event. Authenticated by the API key header.
+     * `GET /api/v1/jobs/{id}/events` — operation `streamPublicJobEvents`.
+     */
+    stream(id, options = {}) {
+        return this.#transport.stream({
+            method: 'GET',
+            path: `/api/v1/jobs/${encodePathSegment(id)}/events`,
+            options,
+        });
+    }
+}
+/** The workspace's board services — the frames tasks are created under. */
+export class ServicesResource {
+    #transport;
+    constructor(transport) {
+        this.#transport = transport;
+    }
+    /**
+     * List the workspace's services
+     * List the board service frames in the key’s workspace, so a caller can discover the serviceId to create/list tasks under.
+     * `GET /api/v1/services` — operation `listPublicServices`.
+     */
+    list(options = {}) {
+        return this.#transport.request({
+            method: 'GET',
+            path: `/api/v1/services`,
+            options,
+        });
+    }
+}
+/** A board task's whole lifecycle: create, edit, start, stop, retry, watch, delete. */
+export class TasksResource {
+    #transport;
+    constructor(transport) {
+        this.#transport = transport;
+    }
+    /**
+     * Create a task under a service
+     * Create a task inside a service frame the key’s workspace owns. The task starts in the `planned` state; start it with the start endpoint.
+     * `POST /api/v1/services/{serviceId}/tasks` — operation `createPublicTask`.
+     */
+    create(serviceId, body, options = {}) {
+        return this.#transport.request({
+            method: 'POST',
+            path: `/api/v1/services/${encodePathSegment(serviceId)}/tasks`,
+            body,
+            options,
+        });
+    }
+    /**
+     * Delete a task
+     * Delete a task and its run history. Destructive, so it sits at the top of the scope ladder: requires an `admin`-scoped key.
+     * `DELETE /api/v1/tasks/{taskId}` — operation `deletePublicTask`.
+     */
+    delete(taskId, options = {}) {
+        return this.#transport.requestNoContent({
+            method: 'DELETE',
+            path: `/api/v1/tasks/${encodePathSegment(taskId)}`,
+            options,
+        });
+    }
+    /**
+     * Get a task's status
+     * Read a task’s current lifecycle status, run progress, run id, and PR URL (once one exists).
+     * `GET /api/v1/tasks/{taskId}` — operation `getPublicTask`.
+     */
+    get(taskId, options = {}) {
+        return this.#transport.request({
+            method: 'GET',
+            path: `/api/v1/tasks/${encodePathSegment(taskId)}`,
+            options,
+        });
+    }
+    /**
+     * Get a task's run (rich projection)
+     * Read a task’s run in detail: per-step status/progress/subtasks, the failure kind and message, and the PR (url + branch).
+     * `GET /api/v1/tasks/{taskId}/run` — operation `getPublicRun`.
+     */
+    getRun(taskId, options = {}) {
+        return this.#transport.request({
+            method: 'GET',
+            path: `/api/v1/tasks/${encodePathSegment(taskId)}/run`,
+            options,
+        });
+    }
+    /**
+     * List a service's tasks
+     * List every task under a service (the whole subtree — tasks directly under the frame and under its modules).
+     * `GET /api/v1/services/{serviceId}/tasks` — operation `listPublicServiceTasks`.
+     */
+    listByService(serviceId, query = {}, options = {}) {
+        return this.#transport.request({
+            method: 'GET',
+            path: `/api/v1/services/${encodePathSegment(serviceId)}/tasks`,
+            query,
+            options,
+        });
+    }
+    /**
+     * Every `tasks` across every page of `listByService()`.
+     * Follows `nextCursor` until the server reports no further page. The cursor is opaque
+     * and carries a position, never authority — each page re-applies the key's full scope.
+     */
+    async *listByServiceAll(serviceId, query = {}, options = {}) {
+        let cursor = query.cursor;
+        for (;;) {
+            const page = await this.listByService(serviceId, { ...query, cursor }, options);
+            for (const item of page.tasks)
+                yield item;
+            if (!page.nextCursor)
+                return;
+            if (page.nextCursor === cursor)
+                throw repeatedCursorError();
+            cursor = page.nextCursor;
+        }
+    }
+    /**
+     * Retry a task's failed run
+     * Retry a task’s failed run. A task on an individual-usage model cannot be retried through the API (no headless personal-credential unlock).
+     * `POST /api/v1/tasks/{taskId}/retry` — operation `retryPublicTask`.
+     */
+    retry(taskId, options = {}) {
+        return this.#transport.request({
+            method: 'POST',
+            path: `/api/v1/tasks/${encodePathSegment(taskId)}/retry`,
+            options,
+        });
+    }
+    /**
+     * Start (run) a task
+     * Start a task’s pipeline. Uses the request’s pipelineId, else the task’s pinned pipeline. A pipeline that can park on a human decision requires a `decide`-scope key. A task on an individual-usage model cannot be started through the API (no headless personal-credential unlock).
+     * `POST /api/v1/tasks/{taskId}/start` — operation `startPublicTask`.
+     */
+    start(taskId, body, options = {}) {
+        return this.#transport.request({
+            method: 'POST',
+            path: `/api/v1/tasks/${encodePathSegment(taskId)}/start`,
+            body,
+            options,
+        });
+    }
+    /**
+     * Stop a task's run
+     * Stop a task’s in-flight run. Records a `cancelled` terminal state, leaving the run retryable.
+     * `POST /api/v1/tasks/{taskId}/stop` — operation `stopPublicTask`.
+     */
+    stop(taskId, options = {}) {
+        return this.#transport.request({
+            method: 'POST',
+            path: `/api/v1/tasks/${encodePathSegment(taskId)}/stop`,
+            options,
+        });
+    }
+    /**
+     * Stream a task run (SSE)
+     * Server-sent events for a board task run: `progress` frames (the rich run projection) until a terminal `done`/`error` event, or a `timeout` when the connection cap is reached. Authenticated by the API key header.
+     * `GET /api/v1/tasks/{taskId}/events` — operation `streamPublicTaskRun`.
+     */
+    stream(taskId, options = {}) {
+        return this.#transport.stream({
+            method: 'GET',
+            path: `/api/v1/tasks/${encodePathSegment(taskId)}/events`,
+            options,
+        });
+    }
+    /**
+     * Edit a task's title/description
+     * Edit a task’s human-authored fields (title/description) before it runs. Both fields are optional.
+     * `PATCH /api/v1/tasks/{taskId}` — operation `updatePublicTask`.
+     */
+    update(taskId, body, options = {}) {
+        return this.#transport.request({
+            method: 'PATCH',
+            path: `/api/v1/tasks/${encodePathSegment(taskId)}`,
+            body,
+            options,
+        });
+    }
+}
+/** The pipelines a task can be started with, and whether each is headless-startable. */
+export class PipelinesResource {
+    #transport;
+    constructor(transport) {
+        this.#transport = transport;
+    }
+    /**
+     * List the workspace's pipelines
+     * List the pipelines in the key’s workspace — id/name/steps plus whether each is public and safe to run headlessly — so a caller can pick a pipelineId to start a task with.
+     * `GET /api/v1/pipelines` — operation `listPublicPipelines`.
+     */
+    list(options = {}) {
+        return this.#transport.request({
+            method: 'GET',
+            path: `/api/v1/pipelines`,
+            options,
+        });
+    }
+}
+/** The workspace's human-actionable inbox: list, act on, or dismiss a run tail. */
+export class NotificationsResource {
+    #transport;
+    constructor(transport) {
+        this.#transport = transport;
+    }
+    /**
+     * Act on a notification
+     * Run a notification’s typed side-effect and resolve it: merge the PR (merge_review / pipeline_complete) or retry the run (ci_failed / test_failed). Performs a real GitHub merge, so it requires an admin-scoped key. Only these automated-action types are actionable through the API — a notification that parks a run on an interactive human decision cannot be acted on headlessly (dismiss it instead). A card that would retry a run on an individual-usage model likewise cannot be acted on through the API.
+     * `POST /api/v1/notifications/{id}/act` — operation `actPublicNotification`.
+     */
+    act(id, options = {}) {
+        return this.#transport.request({
+            method: 'POST',
+            path: `/api/v1/notifications/${encodePathSegment(id)}/act`,
+            options,
+        });
+    }
+    /**
+     * Dismiss a notification
+     * Dismiss a notification without acting on it.
+     * `POST /api/v1/notifications/{id}/dismiss` — operation `dismissPublicNotification`.
+     */
+    dismiss(id, options = {}) {
+        return this.#transport.request({
+            method: 'POST',
+            path: `/api/v1/notifications/${encodePathSegment(id)}/dismiss`,
+            options,
+        });
+    }
+    /**
+     * List the workspace's open notifications
+     * List the open, human-actionable notifications in the key’s workspace (merge reviews, pipeline-complete confirmations, CI/test failures, and informational cards).
+     * `GET /api/v1/notifications` — operation `listPublicNotifications`.
+     */
+    list(options = {}) {
+        return this.#transport.request({
+            method: 'GET',
+            path: `/api/v1/notifications`,
+            options,
+        });
+    }
+}
+/** The billing period's metered budget position and the per-model breakdown behind it. */
+export class UsageResource {
+    #transport;
+    constructor(transport) {
+        this.#transport = transport;
+    }
+    /**
+     * Read the workspace's usage for the current period
+     * Read this billing period’s METERED spend against the workspace budget (including whether it is exceeded, which pauses runs) plus the per-(billing, vendor, provider, model) token breakdown behind it. Costs on `subscription` rows are illustrative — a flat-rate plan bills nothing per token — so branch on `billing` before summing. Workspace-scoped: the account- and user-tier budgets are not reachable through this surface.
+     * `GET /api/v1/usage` — operation `getPublicUsage`.
+     */
+    get(options = {}) {
+        return this.#transport.request({
+            method: 'GET',
+            path: `/api/v1/usage`,
+            options,
+        });
+    }
+}
+/** A parked run's human decisions — requirement findings, forks and judge verdicts. */
+export class DecisionsResource {
+    #transport;
+    constructor(transport) {
+        this.#transport = transport;
+    }
+    /**
+     * Choose an implementation approach
+     * Pick one of the proposed implementation forks (by id) or submit your own approach. The Coder then runs with the choice folded in as a binding directive. Requires a `decide`-scope key.
+     * `POST /api/v1/runs/{runId}/decisions/fork/choose` — operation `choosePublicRunFork`.
+     */
+    chooseFork(runId, body, options = {}) {
+        return this.#transport.request({
+            method: 'POST',
+            path: `/api/v1/runs/${encodePathSegment(runId)}/decisions/fork/choose`,
+            body,
+            options,
+        });
+    }
+    /**
+     * Incorporate the answers
+     * Fold the recorded answers into one standardized requirements document. Asynchronous — the run re-reviews in the background, so the response shows the review `incorporating`. Requires a `decide`-scope key.
+     * `POST /api/v1/runs/{runId}/decisions/requirements/incorporate` — operation `incorporatePublicRunRequirements`.
+     */
+    incorporate(runId, body, options = {}) {
+        return this.#transport.request({
+            method: 'POST',
+            path: `/api/v1/runs/${encodePathSegment(runId)}/decisions/requirements/incorporate`,
+            body,
+            options,
+        });
+    }
+    /**
+     * List a run's parked decisions
+     * Read what a run is currently asking a human: requirement-review findings (with the stable item ids a reply addresses) and any implementation-fork choice. `parked` is true while the run is blocked awaiting one of them.
+     * `GET /api/v1/runs/{runId}/decisions` — operation `listPublicRunDecisions`.
+     */
+    list(runId, options = {}) {
+        return this.#transport.request({
+            method: 'GET',
+            path: `/api/v1/runs/${encodePathSegment(runId)}/decisions`,
+            options,
+        });
+    }
+    /**
+     * Proceed with the current requirements
+     * Settle the requirements phase and advance the parked run (used when nothing is outstanding). Requires a `decide`-scope key.
+     * `POST /api/v1/runs/{runId}/decisions/requirements/proceed` — operation `proceedPublicRunRequirements`.
+     */
+    proceed(runId, options = {}) {
+        return this.#transport.request({
+            method: 'POST',
+            path: `/api/v1/runs/${encodePathSegment(runId)}/decisions/requirements/proceed`,
+            options,
+        });
+    }
+    /**
+     * Answer a review finding
+     * Record an answer to one reviewer finding. Returns the run's updated decision list. Requires a `decide`-scope key.
+     * `POST /api/v1/runs/{runId}/decisions/requirements/findings/{itemId}/reply` — operation `replyPublicRunFinding`.
+     */
+    replyToFinding(runId, itemId, body, options = {}) {
+        return this.#transport.request({
+            method: 'POST',
+            path: `/api/v1/runs/${encodePathSegment(runId)}/decisions/requirements/findings/${encodePathSegment(itemId)}/reply`,
+            body,
+            options,
+        });
+    }
+    /**
+     * Re-review the incorporated document
+     * Run one more reviewer pass over the incorporated document. On convergence the parked run advances. Requires a `decide`-scope key.
+     * `POST /api/v1/runs/{runId}/decisions/requirements/re-review` — operation `reReviewPublicRunRequirements`.
+     */
+    reReview(runId, options = {}) {
+        return this.#transport.request({
+            method: 'POST',
+            path: `/api/v1/runs/${encodePathSegment(runId)}/decisions/requirements/re-review`,
+            options,
+        });
+    }
+    /**
+     * Resolve a review at its iteration cap
+     * Pick how a review that exhausted its reviewer-pass budget proceeds: one more round, proceed with the last incorporated document, or stop and reset the task. Requires a `decide`-scope key.
+     * `POST /api/v1/runs/{runId}/decisions/requirements/resolve-exceeded` — operation `resolvePublicRunRequirementsExceeded`.
+     */
+    resolveExceeded(runId, body, options = {}) {
+        return this.#transport.request({
+            method: 'POST',
+            path: `/api/v1/runs/${encodePathSegment(runId)}/decisions/requirements/resolve-exceeded`,
+            body,
+            options,
+        });
+    }
+    /**
+     * Resolve a parked judge verdict
+     * Settle a run parked on a judge verdict: proceed anyway, bounce the producing step for rework, or stop the run. Requires a `decide`-scope key.
+     * `POST /api/v1/runs/{runId}/decisions/judge/resolve` — operation `resolvePublicRunJudge`.
+     */
+    resolveJudge(runId, body, options = {}) {
+        return this.#transport.request({
+            method: 'POST',
+            path: `/api/v1/runs/${encodePathSegment(runId)}/decisions/judge/resolve`,
+            body,
+            options,
+        });
+    }
+    /**
+     * Dismiss or reopen a finding
+     * Dismiss a finding as not applicable, or reopen one dismissed by mistake. Requires a `decide`-scope key.
+     * `PATCH /api/v1/runs/{runId}/decisions/requirements/findings/{itemId}` — operation `setPublicRunFindingStatus`.
+     */
+    setFindingStatus(runId, itemId, body, options = {}) {
+        return this.#transport.request({
+            method: 'PATCH',
+            path: `/api/v1/runs/${encodePathSegment(runId)}/decisions/requirements/findings/${encodePathSegment(itemId)}`,
+            body,
+            options,
+        });
+    }
+}
+/** A run's recorded telemetry: LLM calls, the context each agent was given, infra logs. */
+export class DebugResource {
+    #transport;
+    constructor(transport) {
+        this.#transport = transport;
+    }
+    /**
+     * Get one agent-context snapshot
+     * The complete context one dispatch was PROVIDED: system and user prompts, the folded standards fragments, and the injected `.cat-context/*` files an agent reads through tools (which therefore appear in no proxy telemetry). Windowed by `bodyOffset`/`bodyChars`.
+     * `GET /api/v1/debug/agent-context/{snapshotId}` — operation `getDebugAgentContext`.
+     */
+    getAgentContext(snapshotId, query = {}, options = {}) {
+        return this.#transport.request({
+            method: 'GET',
+            path: `/api/v1/debug/agent-context/${encodePathSegment(snapshotId)}`,
+            query,
+            options,
+        });
+    }
+    /**
+     * Get one LLM call
+     * One recorded model call with its budgeted prompt delta, response and reasoning. `bodyOffset`/`bodyChars` window the bodies, so an arbitrarily long transcript is readable in bounded pages.
+     * `GET /api/v1/debug/llm-calls/{callId}` — operation `getDebugLlmCall`.
+     */
+    getLlmCall(callId, query = {}, options = {}) {
+        return this.#transport.request({
+            method: 'GET',
+            path: `/api/v1/debug/llm-calls/${encodePathSegment(callId)}`,
+            query,
+            options,
+        });
+    }
+    /**
+     * Get a run's diagnostic map
+     * One run’s diagnostic overview: its steps, which telemetry sinks this deployment retains (and how much each holds), the LLM cost/latency rollups, and the derived signals worth looking at first.
+     * `GET /api/v1/debug/runs/{runId}` — operation `getDebugRun`.
+     */
+    getRun(runId, options = {}) {
+        return this.#transport.request({
+            method: 'GET',
+            path: `/api/v1/debug/runs/${encodePathSegment(runId)}`,
+            options,
+        });
+    }
+    /**
+     * List a run's agent-context dispatches
+     * Every dispatch whose provided context was captured, with SIZES only (no bodies) so the list stays bounded. Read one in full through the snapshot endpoint.
+     * `GET /api/v1/debug/runs/{runId}/agent-context` — operation `listDebugAgentContext`.
+     */
+    listAgentContext(runId, query = {}, options = {}) {
+        return this.#transport.request({
+            method: 'GET',
+            path: `/api/v1/debug/runs/${encodePathSegment(runId)}/agent-context`,
+            query,
+            options,
+        });
+    }
+    /**
+     * Every `snapshots` across every page of `listAgentContext()`.
+     * Follows `nextCursor` until the server reports no further page. The cursor is opaque
+     * and carries a position, never authority — each page re-applies the key's full scope.
+     */
+    async *listAgentContextAll(runId, query = {}, options = {}) {
+        let cursor = query.cursor;
+        for (;;) {
+            const page = await this.listAgentContext(runId, { ...query, cursor }, options);
+            for (const item of page.snapshots)
+                yield item;
+            if (!page.nextCursor)
+                return;
+            if (page.nextCursor === cursor)
+                throw repeatedCursorError();
+            cursor = page.nextCursor;
+        }
+    }
+    /**
+     * List a run's LLM calls
+     * The model calls a run made, keyset-paginated and filterable by agent kind, phase, outcome or a substring of the bodies. Bodies are returned only when `bodyChars` asks for them.
+     * `GET /api/v1/debug/runs/{runId}/llm-calls` — operation `listDebugLlmCalls`.
+     */
+    listLlmCalls(runId, query = {}, options = {}) {
+        return this.#transport.request({
+            method: 'GET',
+            path: `/api/v1/debug/runs/${encodePathSegment(runId)}/llm-calls`,
+            query,
+            options,
+        });
+    }
+    /**
+     * Every `calls` across every page of `listLlmCalls()`.
+     * Follows `nextCursor` until the server reports no further page. The cursor is opaque
+     * and carries a position, never authority — each page re-applies the key's full scope.
+     */
+    async *listLlmCallsAll(runId, query = {}, options = {}) {
+        let cursor = query.cursor;
+        for (;;) {
+            const page = await this.listLlmCalls(runId, { ...query, cursor }, options);
+            for (const item of page.calls)
+                yield item;
+            if (!page.nextCursor)
+                return;
+            if (page.nextCursor === cursor)
+                throw repeatedCursorError();
+            cursor = page.nextCursor;
+        }
+    }
+    /**
+     * List a run's infrastructure log
+     * The run’s provisioning event log — how its environment, runner pool and containers came up, or why they did not.
+     * `GET /api/v1/debug/runs/{runId}/logs` — operation `listDebugLogs`.
+     */
+    listLogs(runId, query = {}, options = {}) {
+        return this.#transport.request({
+            method: 'GET',
+            path: `/api/v1/debug/runs/${encodePathSegment(runId)}/logs`,
+            query,
+            options,
+        });
+    }
+    /**
+     * Every `entries` across every page of `listLogs()`.
+     * Follows `nextCursor` until the server reports no further page. The cursor is opaque
+     * and carries a position, never authority — each page re-applies the key's full scope.
+     */
+    async *listLogsAll(runId, query = {}, options = {}) {
+        let cursor = query.cursor;
+        for (;;) {
+            const page = await this.listLogs(runId, { ...query, cursor }, options);
+            for (const item of page.entries)
+                yield item;
+            if (!page.nextCursor)
+                return;
+            if (page.nextCursor === cursor)
+                throw repeatedCursorError();
+            cursor = page.nextCursor;
+        }
+    }
+    /**
+     * List the workspace's runs
+     * The triage entry point: the workspace’s runs, newest first and keyset-paginated, with an optional status and `since` filter.
+     * `GET /api/v1/debug/runs` — operation `listDebugRuns`.
+     */
+    listRuns(query = {}, options = {}) {
+        return this.#transport.request({
+            method: 'GET',
+            path: `/api/v1/debug/runs`,
+            query,
+            options,
+        });
+    }
+    /**
+     * Every `runs` across every page of `listRuns()`.
+     * Follows `nextCursor` until the server reports no further page. The cursor is opaque
+     * and carries a position, never authority — each page re-applies the key's full scope.
+     */
+    async *listRunsAll(query = {}, options = {}) {
+        let cursor = query.cursor;
+        for (;;) {
+            const page = await this.listRuns({ ...query, cursor }, options);
+            for (const item of page.runs)
+                yield item;
+            if (!page.nextCursor)
+                return;
+            if (page.nextCursor === cursor)
+                throw repeatedCursorError();
+            cursor = page.nextCursor;
+        }
+    }
+    /**
+     * List a run's web searches
+     * The web searches the run’s agents actually performed, keyset-paginated. Retained only when the deployment records agent context.
+     * `GET /api/v1/debug/runs/{runId}/search-queries` — operation `listDebugSearchQueries`.
+     */
+    listSearchQueries(runId, query = {}, options = {}) {
+        return this.#transport.request({
+            method: 'GET',
+            path: `/api/v1/debug/runs/${encodePathSegment(runId)}/search-queries`,
+            query,
+            options,
+        });
+    }
+    /**
+     * Every `queries` across every page of `listSearchQueries()`.
+     * Follows `nextCursor` until the server reports no further page. The cursor is opaque
+     * and carries a position, never authority — each page re-applies the key's full scope.
+     */
+    async *listSearchQueriesAll(runId, query = {}, options = {}) {
+        let cursor = query.cursor;
+        for (;;) {
+            const page = await this.listSearchQueries(runId, { ...query, cursor }, options);
+            for (const item of page.queries)
+                yield item;
+            if (!page.nextCursor)
+                return;
+            if (page.nextCursor === cursor)
+                throw repeatedCursorError();
+            cursor = page.nextCursor;
+        }
+    }
+}
+/**
+ * The resource clients a `CatFactoryClient` exposes, one per tag of the published OpenAPI surface.
+ *
+ * Generated and INHERITED by the client rather than re-listed on it: a resource group added to the
+ * SDK surface table would otherwise generate, compile, and simply not be reachable from the client
+ * anyone actually constructs. (A declaration-merged interface would do the same job, but TypeScript
+ * cannot see that such properties are initialised — so a real base class it is.)
+ */
+export class CatFactoryResources {
+    /** Headless jobs (a public, inline pipeline run against a brief): start, poll or stream one. */
+    jobs;
+    /** The workspace's board services — the frames tasks are created under. */
+    services;
+    /** A board task's whole lifecycle: create, edit, start, stop, retry, watch, delete. */
+    tasks;
+    /** The pipelines a task can be started with, and whether each is headless-startable. */
+    pipelines;
+    /** The workspace's human-actionable inbox: list, act on, or dismiss a run tail. */
+    notifications;
+    /** The billing period's metered budget position and the per-model breakdown behind it. */
+    usage;
+    /** A parked run's human decisions — requirement findings, forks and judge verdicts. */
+    decisions;
+    /** A run's recorded telemetry: LLM calls, the context each agent was given, infra logs. */
+    debug;
+    constructor(transport) {
+        this.jobs = new JobsResource(transport);
+        this.services = new ServicesResource(transport);
+        this.tasks = new TasksResource(transport);
+        this.pipelines = new PipelinesResource(transport);
+        this.notifications = new NotificationsResource(transport);
+        this.usage = new UsageResource(transport);
+        this.decisions = new DecisionsResource(transport);
+        this.debug = new DebugResource(transport);
+    }
+}
+//# sourceMappingURL=operations.generated.js.map