@cat-factory/gatekeeper-bindings 0.6.0

package/dist/bindings.generated.js

@@ -0,0 +1,1552 @@
+// 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.
+/**
+ * The scope ladder, least to greatest. The ARRAY ORDER is the ranking, and this is the
+ * deployment's own vocabulary: generated from the spec's `x-public-api-scopes`, which the
+ * server stamps from the same constant its admission check ranks with.
+ */
+export const PUBLIC_API_SCOPE_LADDER = ['read', 'write', 'decide', 'admin'];
+/** Read a required string argument, failing with the parameter's own name. */
+function str(args, name) {
+    const value = args[name];
+    if (typeof value !== 'string' || value.length === 0) {
+        throw new TypeError(`${name} is required and must be a non-empty string`);
+    }
+    return value;
+}
+/** The subset of `args` that belongs in the query string, picked by name. */
+function pick(args, names) {
+    const out = {};
+    for (const name of names) {
+        if (args[name] !== undefined)
+            out[name] = args[name];
+    }
+    return out;
+}
+const QUERY_JOBS_LIST = ['limit', 'cursor', 'status', 'since'];
+const QUERY_TASKS_LIST_BY_SERVICE = ['limit', 'cursor', 'status'];
+const QUERY_DEBUG_GET_AGENT_CONTEXT = ['bodyChars', 'bodyOffset'];
+const QUERY_DEBUG_GET_LLM_CALL = ['bodyChars', 'bodyOffset', 'view'];
+const QUERY_DEBUG_LIST_AGENT_CONTEXT = ['stepIndex', 'limit', 'cursor'];
+const QUERY_DEBUG_LIST_LLM_CALLS = ['agentKind', 'phase', 'outcome', 'contains', 'order', 'limit', 'cursor', 'bodyChars'];
+const QUERY_DEBUG_LIST_LOGS = ['limit', 'cursor'];
+const QUERY_DEBUG_LIST_RUNS = ['status', 'since', 'limit', 'cursor'];
+const QUERY_DEBUG_LIST_SEARCH_QUERIES = ['limit', 'cursor'];
+const QUERY_DEBUG_LIST_TOOL_CALLS = ['limit', 'cursor', 'jobId', 'order', 'outcome'];
+/** Every `/api/v1` operation as a policy-annotated binding, in resource-group order. */
+export const GATEKEEPER_BINDINGS = [
+    {
+        name: 'jobs_cancel',
+        group: 'jobs',
+        method: 'cancel',
+        operationId: 'cancelPublicJob',
+        httpMethod: 'POST',
+        path: '/api/v1/jobs/{id}/cancel',
+        summary: 'Cancel a job',
+        minScope: 'write',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['id'],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.jobs.cancel(str(args, 'id')),
+    },
+    {
+        name: 'jobs_create',
+        group: 'jobs',
+        method: 'create',
+        operationId: 'createPublicJob',
+        httpMethod: 'POST',
+        path: '/api/v1/jobs',
+        summary: 'Start a headless job',
+        minScope: 'write',
+        readOnly: false,
+        result: 'value',
+        consequence: { "destructive": true, "idempotent": false },
+        pathParams: [],
+        queryParams: [],
+        hasBody: true,
+        invoke: async (client, args) => client.jobs.create(args.body),
+    },
+    {
+        name: 'jobs_get',
+        group: 'jobs',
+        method: 'get',
+        operationId: 'getPublicJob',
+        httpMethod: 'GET',
+        path: '/api/v1/jobs/{id}',
+        summary: 'Get a job',
+        minScope: 'read',
+        readOnly: true,
+        result: 'value',
+        pathParams: ['id'],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.jobs.get(str(args, 'id')),
+    },
+    {
+        name: 'jobs_list',
+        group: 'jobs',
+        method: 'list',
+        operationId: 'listPublicJobs',
+        httpMethod: 'GET',
+        path: '/api/v1/jobs',
+        summary: 'List the workspace\'s jobs',
+        minScope: 'read',
+        readOnly: true,
+        result: 'value',
+        pathParams: [],
+        queryParams: QUERY_JOBS_LIST,
+        hasBody: false,
+        invoke: async (client, args) => client.jobs.list(pick(args, QUERY_JOBS_LIST)),
+    },
+    {
+        name: 'jobs_stream',
+        group: 'jobs',
+        method: 'stream',
+        operationId: 'streamPublicJobEvents',
+        httpMethod: 'GET',
+        path: '/api/v1/jobs/{id}/events',
+        summary: 'Stream a job (SSE)',
+        minScope: 'read',
+        readOnly: true,
+        result: 'stream',
+        pathParams: ['id'],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.jobs.stream(str(args, 'id')),
+    },
+    {
+        name: 'services_create',
+        group: 'services',
+        method: 'create',
+        operationId: 'createPublicService',
+        httpMethod: 'POST',
+        path: '/api/v1/services',
+        summary: 'Create a service',
+        minScope: 'admin',
+        readOnly: false,
+        result: 'value',
+        pathParams: [],
+        queryParams: [],
+        hasBody: true,
+        invoke: async (client, args) => client.services.create(args.body),
+    },
+    {
+        name: 'services_list',
+        group: 'services',
+        method: 'list',
+        operationId: 'listPublicServices',
+        httpMethod: 'GET',
+        path: '/api/v1/services',
+        summary: 'List the workspace\'s services',
+        minScope: 'read',
+        readOnly: true,
+        result: 'value',
+        pathParams: [],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.services.list(),
+    },
+    {
+        name: 'repos_list',
+        group: 'repos',
+        method: 'list',
+        operationId: 'listPublicRepos',
+        httpMethod: 'GET',
+        path: '/api/v1/repos',
+        summary: 'List the repositories a service can be created against',
+        minScope: 'read',
+        readOnly: true,
+        result: 'value',
+        pathParams: [],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.repos.list(),
+    },
+    {
+        name: 'tasks_add_dependency',
+        group: 'tasks',
+        method: 'addDependency',
+        operationId: 'addPublicTaskDependency',
+        httpMethod: 'POST',
+        path: '/api/v1/tasks/{taskId}/dependencies',
+        summary: 'Declare that a task waits for another',
+        minScope: 'write',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['taskId'],
+        queryParams: [],
+        hasBody: true,
+        invoke: async (client, args) => client.tasks.addDependency(str(args, 'taskId'), args.body),
+    },
+    {
+        name: 'tasks_attach_document',
+        group: 'tasks',
+        method: 'attachDocument',
+        operationId: 'attachPublicTaskDocument',
+        httpMethod: 'POST',
+        path: '/api/v1/tasks/{taskId}/documents',
+        summary: 'Attach a document to a task',
+        minScope: 'write',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['taskId'],
+        queryParams: [],
+        hasBody: true,
+        invoke: async (client, args) => client.tasks.attachDocument(str(args, 'taskId'), args.body),
+    },
+    {
+        name: 'tasks_create',
+        group: 'tasks',
+        method: 'create',
+        operationId: 'createPublicTask',
+        httpMethod: 'POST',
+        path: '/api/v1/services/{serviceId}/tasks',
+        summary: 'Create a task under a service',
+        minScope: 'write',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['serviceId'],
+        queryParams: [],
+        hasBody: true,
+        invoke: async (client, args) => client.tasks.create(str(args, 'serviceId'), args.body),
+    },
+    {
+        name: 'tasks_delete',
+        group: 'tasks',
+        method: 'delete',
+        operationId: 'deletePublicTask',
+        httpMethod: 'DELETE',
+        path: '/api/v1/tasks/{taskId}',
+        summary: 'Delete a task',
+        minScope: 'admin',
+        readOnly: false,
+        result: 'value',
+        consequence: { "destructive": true, "idempotent": true },
+        pathParams: ['taskId'],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.tasks.delete(str(args, 'taskId')),
+    },
+    {
+        name: 'tasks_detach_document',
+        group: 'tasks',
+        method: 'detachDocument',
+        operationId: 'detachPublicTaskDocument',
+        httpMethod: 'POST',
+        path: '/api/v1/tasks/{taskId}/documents/detach',
+        summary: 'Detach a document from a task',
+        minScope: 'write',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['taskId'],
+        queryParams: [],
+        hasBody: true,
+        invoke: async (client, args) => client.tasks.detachDocument(str(args, 'taskId'), args.body),
+    },
+    {
+        name: 'tasks_get',
+        group: 'tasks',
+        method: 'get',
+        operationId: 'getPublicTask',
+        httpMethod: 'GET',
+        path: '/api/v1/tasks/{taskId}',
+        summary: 'Get a task\'s status',
+        minScope: 'read',
+        readOnly: true,
+        result: 'value',
+        pathParams: ['taskId'],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.tasks.get(str(args, 'taskId')),
+    },
+    {
+        name: 'tasks_get_run',
+        group: 'tasks',
+        method: 'getRun',
+        operationId: 'getPublicRun',
+        httpMethod: 'GET',
+        path: '/api/v1/tasks/{taskId}/run',
+        summary: 'Get a task\'s run (rich projection)',
+        minScope: 'read',
+        readOnly: true,
+        result: 'value',
+        pathParams: ['taskId'],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.tasks.getRun(str(args, 'taskId')),
+    },
+    {
+        name: 'tasks_list_by_service',
+        group: 'tasks',
+        method: 'listByService',
+        operationId: 'listPublicServiceTasks',
+        httpMethod: 'GET',
+        path: '/api/v1/services/{serviceId}/tasks',
+        summary: 'List a service\'s tasks',
+        minScope: 'read',
+        readOnly: true,
+        result: 'value',
+        pathParams: ['serviceId'],
+        queryParams: QUERY_TASKS_LIST_BY_SERVICE,
+        hasBody: false,
+        invoke: async (client, args) => client.tasks.listByService(str(args, 'serviceId'), pick(args, QUERY_TASKS_LIST_BY_SERVICE)),
+    },
+    {
+        name: 'tasks_list_documents',
+        group: 'tasks',
+        method: 'listDocuments',
+        operationId: 'listPublicTaskDocuments',
+        httpMethod: 'GET',
+        path: '/api/v1/tasks/{taskId}/documents',
+        summary: 'List a task\'s attached documents',
+        minScope: 'read',
+        readOnly: true,
+        result: 'value',
+        pathParams: ['taskId'],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.tasks.listDocuments(str(args, 'taskId')),
+    },
+    {
+        name: 'tasks_remove_dependency',
+        group: 'tasks',
+        method: 'removeDependency',
+        operationId: 'removePublicTaskDependency',
+        httpMethod: 'POST',
+        path: '/api/v1/tasks/{taskId}/dependencies/remove',
+        summary: 'Drop a dependency edge',
+        minScope: 'write',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['taskId'],
+        queryParams: [],
+        hasBody: true,
+        invoke: async (client, args) => client.tasks.removeDependency(str(args, 'taskId'), args.body),
+    },
+    {
+        name: 'tasks_retry',
+        group: 'tasks',
+        method: 'retry',
+        operationId: 'retryPublicTask',
+        httpMethod: 'POST',
+        path: '/api/v1/tasks/{taskId}/retry',
+        summary: 'Retry a task\'s failed run',
+        minScope: 'write',
+        readOnly: false,
+        result: 'value',
+        consequence: { "destructive": true, "idempotent": false },
+        pathParams: ['taskId'],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.tasks.retry(str(args, 'taskId')),
+    },
+    {
+        name: 'tasks_start',
+        group: 'tasks',
+        method: 'start',
+        operationId: 'startPublicTask',
+        httpMethod: 'POST',
+        path: '/api/v1/tasks/{taskId}/start',
+        summary: 'Start (run) a task',
+        minScope: 'write',
+        readOnly: false,
+        result: 'value',
+        consequence: { "destructive": true, "idempotent": false },
+        pathParams: ['taskId'],
+        queryParams: [],
+        hasBody: true,
+        invoke: async (client, args) => client.tasks.start(str(args, 'taskId'), args.body),
+    },
+    {
+        name: 'tasks_stop',
+        group: 'tasks',
+        method: 'stop',
+        operationId: 'stopPublicTask',
+        httpMethod: 'POST',
+        path: '/api/v1/tasks/{taskId}/stop',
+        summary: 'Stop a task\'s run',
+        minScope: 'write',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['taskId'],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.tasks.stop(str(args, 'taskId')),
+    },
+    {
+        name: 'tasks_stream',
+        group: 'tasks',
+        method: 'stream',
+        operationId: 'streamPublicTaskRun',
+        httpMethod: 'GET',
+        path: '/api/v1/tasks/{taskId}/events',
+        summary: 'Stream a task run (SSE)',
+        minScope: 'read',
+        readOnly: true,
+        result: 'stream',
+        pathParams: ['taskId'],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.tasks.stream(str(args, 'taskId')),
+    },
+    {
+        name: 'tasks_update',
+        group: 'tasks',
+        method: 'update',
+        operationId: 'updatePublicTask',
+        httpMethod: 'PATCH',
+        path: '/api/v1/tasks/{taskId}',
+        summary: 'Edit a task\'s inputs',
+        minScope: 'write',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['taskId'],
+        queryParams: [],
+        hasBody: true,
+        invoke: async (client, args) => client.tasks.update(str(args, 'taskId'), args.body),
+    },
+    {
+        name: 'pipelines_list',
+        group: 'pipelines',
+        method: 'list',
+        operationId: 'listPublicPipelines',
+        httpMethod: 'GET',
+        path: '/api/v1/pipelines',
+        summary: 'List the workspace\'s pipelines',
+        minScope: 'read',
+        readOnly: true,
+        result: 'value',
+        pathParams: [],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.pipelines.list(),
+    },
+    {
+        name: 'task_types_list',
+        group: 'taskTypes',
+        method: 'list',
+        operationId: 'listPublicTaskTypes',
+        httpMethod: 'GET',
+        path: '/api/v1/task-types',
+        summary: 'List the task types this workspace may create',
+        minScope: 'read',
+        readOnly: true,
+        result: 'value',
+        pathParams: [],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.taskTypes.list(),
+    },
+    {
+        name: 'notifications_act',
+        group: 'notifications',
+        method: 'act',
+        operationId: 'actPublicNotification',
+        httpMethod: 'POST',
+        path: '/api/v1/notifications/{id}/act',
+        summary: 'Act on a notification',
+        minScope: 'admin',
+        readOnly: false,
+        result: 'value',
+        consequence: { "destructive": true, "idempotent": false },
+        pathParams: ['id'],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.notifications.act(str(args, 'id')),
+    },
+    {
+        name: 'notifications_dismiss',
+        group: 'notifications',
+        method: 'dismiss',
+        operationId: 'dismissPublicNotification',
+        httpMethod: 'POST',
+        path: '/api/v1/notifications/{id}/dismiss',
+        summary: 'Dismiss a notification',
+        minScope: 'write',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['id'],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.notifications.dismiss(str(args, 'id')),
+    },
+    {
+        name: 'notifications_list',
+        group: 'notifications',
+        method: 'list',
+        operationId: 'listPublicNotifications',
+        httpMethod: 'GET',
+        path: '/api/v1/notifications',
+        summary: 'List the workspace\'s open notifications',
+        minScope: 'read',
+        readOnly: true,
+        result: 'value',
+        pathParams: [],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.notifications.list(),
+    },
+    {
+        name: 'webhook_delete',
+        group: 'webhook',
+        method: 'delete',
+        operationId: 'deletePublicNotificationWebhook',
+        httpMethod: 'DELETE',
+        path: '/api/v1/notification-webhook',
+        summary: 'Remove the outbound webhook',
+        minScope: 'admin',
+        readOnly: false,
+        result: 'value',
+        consequence: { "destructive": true, "idempotent": true },
+        pathParams: [],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.webhook.delete(),
+    },
+    {
+        name: 'webhook_delete_named',
+        group: 'webhook',
+        method: 'deleteNamed',
+        operationId: 'deletePublicNamedNotificationWebhook',
+        httpMethod: 'DELETE',
+        path: '/api/v1/notification-webhooks/{webhookId}',
+        summary: 'Remove one named outbound webhook',
+        minScope: 'admin',
+        readOnly: false,
+        result: 'value',
+        consequence: { "destructive": true, "idempotent": true },
+        pathParams: ['webhookId'],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.webhook.deleteNamed(str(args, 'webhookId')),
+    },
+    {
+        name: 'webhook_get',
+        group: 'webhook',
+        method: 'get',
+        operationId: 'getPublicNotificationWebhook',
+        httpMethod: 'GET',
+        path: '/api/v1/notification-webhook',
+        summary: 'Read the workspace\'s outbound webhook',
+        minScope: 'admin',
+        readOnly: true,
+        result: 'value',
+        pathParams: [],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.webhook.get(),
+    },
+    {
+        name: 'webhook_get_named',
+        group: 'webhook',
+        method: 'getNamed',
+        operationId: 'getPublicNamedNotificationWebhook',
+        httpMethod: 'GET',
+        path: '/api/v1/notification-webhooks/{webhookId}',
+        summary: 'Read one named outbound webhook',
+        minScope: 'admin',
+        readOnly: true,
+        result: 'value',
+        pathParams: ['webhookId'],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.webhook.getNamed(str(args, 'webhookId')),
+    },
+    {
+        name: 'webhook_list',
+        group: 'webhook',
+        method: 'list',
+        operationId: 'listPublicNotificationWebhooks',
+        httpMethod: 'GET',
+        path: '/api/v1/notification-webhooks',
+        summary: 'List the workspace\'s outbound webhooks',
+        minScope: 'admin',
+        readOnly: true,
+        result: 'value',
+        pathParams: [],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.webhook.list(),
+    },
+    {
+        name: 'webhook_set',
+        group: 'webhook',
+        method: 'set',
+        operationId: 'putPublicNotificationWebhook',
+        httpMethod: 'PUT',
+        path: '/api/v1/notification-webhook',
+        summary: 'Register or update the outbound webhook',
+        minScope: 'admin',
+        readOnly: false,
+        result: 'value',
+        consequence: { "destructive": true, "idempotent": true },
+        pathParams: [],
+        queryParams: [],
+        hasBody: true,
+        invoke: async (client, args) => client.webhook.set(args.body),
+    },
+    {
+        name: 'webhook_set_named',
+        group: 'webhook',
+        method: 'setNamed',
+        operationId: 'putPublicNamedNotificationWebhook',
+        httpMethod: 'PUT',
+        path: '/api/v1/notification-webhooks/{webhookId}',
+        summary: 'Register or update one named outbound webhook',
+        minScope: 'admin',
+        readOnly: false,
+        result: 'value',
+        consequence: { "destructive": true, "idempotent": true },
+        pathParams: ['webhookId'],
+        queryParams: [],
+        hasBody: true,
+        invoke: async (client, args) => client.webhook.setNamed(str(args, 'webhookId'), args.body),
+    },
+    {
+        name: 'usage_get',
+        group: 'usage',
+        method: 'get',
+        operationId: 'getPublicUsage',
+        httpMethod: 'GET',
+        path: '/api/v1/usage',
+        summary: 'Read the workspace\'s usage for the current period',
+        minScope: 'read',
+        readOnly: true,
+        result: 'value',
+        pathParams: [],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.usage.get(),
+    },
+    {
+        name: 'me_get',
+        group: 'me',
+        method: 'get',
+        operationId: 'getPublicIdentity',
+        httpMethod: 'GET',
+        path: '/api/v1/me',
+        summary: 'Describe the calling key',
+        minScope: 'read',
+        readOnly: true,
+        result: 'value',
+        pathParams: [],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.me.get(),
+    },
+    {
+        name: 'decisions_answer_agent_decision',
+        group: 'decisions',
+        method: 'answerAgentDecision',
+        operationId: 'resolvePublicRunAgentDecision',
+        httpMethod: 'POST',
+        path: '/api/v1/runs/{runId}/decisions/questions/{decisionId}/answer',
+        summary: 'Answer an agent-raised decision',
+        minScope: 'decide',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['runId', 'decisionId'],
+        queryParams: [],
+        hasBody: true,
+        invoke: async (client, args) => client.decisions.answerAgentDecision(str(args, 'runId'), str(args, 'decisionId'), args.body),
+    },
+    {
+        name: 'decisions_answer_follow_up',
+        group: 'decisions',
+        method: 'answerFollowUp',
+        operationId: 'answerPublicRunFollowUp',
+        httpMethod: 'POST',
+        path: '/api/v1/runs/{runId}/decisions/follow-ups/items/{itemId}/answer',
+        summary: 'Answer a follow-up question',
+        minScope: 'decide',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['runId', 'itemId'],
+        queryParams: [],
+        hasBody: true,
+        invoke: async (client, args) => client.decisions.answerFollowUp(str(args, 'runId'), str(args, 'itemId'), args.body),
+    },
+    {
+        name: 'decisions_answer_interview_question',
+        group: 'decisions',
+        method: 'answerInterviewQuestion',
+        operationId: 'answerPublicRunInterview',
+        httpMethod: 'POST',
+        path: '/api/v1/runs/{runId}/decisions/interview/answer',
+        summary: 'Answer an interview question',
+        minScope: 'decide',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['runId'],
+        queryParams: [],
+        hasBody: true,
+        invoke: async (client, args) => client.decisions.answerInterviewQuestion(str(args, 'runId'), args.body),
+    },
+    {
+        name: 'decisions_approve_step',
+        group: 'decisions',
+        method: 'approveStep',
+        operationId: 'approvePublicRunStep',
+        httpMethod: 'POST',
+        path: '/api/v1/runs/{runId}/decisions/approvals/{approvalId}/approve',
+        summary: 'Approve a parked step',
+        minScope: 'decide',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['runId', 'approvalId'],
+        queryParams: [],
+        hasBody: true,
+        invoke: async (client, args) => client.decisions.approveStep(str(args, 'runId'), str(args, 'approvalId'), args.body),
+    },
+    {
+        name: 'decisions_approve_visual_confirmation',
+        group: 'decisions',
+        method: 'approveVisualConfirmation',
+        operationId: 'approvePublicRunVisualConfirm',
+        httpMethod: 'POST',
+        path: '/api/v1/runs/{runId}/decisions/visual-confirmation/approve',
+        summary: 'Approve a visual-confirmation gate',
+        minScope: 'decide',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['runId'],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.decisions.approveVisualConfirmation(str(args, 'runId')),
+    },
+    {
+        name: 'decisions_challenge_pr_review_finding',
+        group: 'decisions',
+        method: 'challengePrReviewFinding',
+        operationId: 'challengePublicRunPrReviewFinding',
+        httpMethod: 'POST',
+        path: '/api/v1/runs/{runId}/decisions/pr-review/findings/{findingId}/challenge',
+        summary: 'Challenge a PR review finding',
+        minScope: 'decide',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['runId', 'findingId'],
+        queryParams: [],
+        hasBody: true,
+        invoke: async (client, args) => client.decisions.challengePrReviewFinding(str(args, 'runId'), str(args, 'findingId'), args.body),
+    },
+    {
+        name: 'decisions_choose_fork',
+        group: 'decisions',
+        method: 'chooseFork',
+        operationId: 'choosePublicRunFork',
+        httpMethod: 'POST',
+        path: '/api/v1/runs/{runId}/decisions/fork/choose',
+        summary: 'Choose an implementation approach',
+        minScope: 'decide',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['runId'],
+        queryParams: [],
+        hasBody: true,
+        invoke: async (client, args) => client.decisions.chooseFork(str(args, 'runId'), args.body),
+    },
+    {
+        name: 'decisions_confirm_human_test',
+        group: 'decisions',
+        method: 'confirmHumanTest',
+        operationId: 'confirmPublicRunHumanTest',
+        httpMethod: 'POST',
+        path: '/api/v1/runs/{runId}/decisions/human-test/confirm',
+        summary: 'Confirm a human-test gate',
+        minScope: 'decide',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['runId'],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.decisions.confirmHumanTest(str(args, 'runId')),
+    },
+    {
+        name: 'decisions_continue_interview',
+        group: 'decisions',
+        method: 'continueInterview',
+        operationId: 'continuePublicRunInterview',
+        httpMethod: 'POST',
+        path: '/api/v1/runs/{runId}/decisions/interview/continue',
+        summary: 'Continue a parked interview',
+        minScope: 'decide',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['runId'],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.decisions.continueInterview(str(args, 'runId')),
+    },
+    {
+        name: 'decisions_dismiss_follow_up',
+        group: 'decisions',
+        method: 'dismissFollowUp',
+        operationId: 'dismissPublicRunFollowUp',
+        httpMethod: 'POST',
+        path: '/api/v1/runs/{runId}/decisions/follow-ups/items/{itemId}/dismiss',
+        summary: 'Dismiss a follow-up item',
+        minScope: 'decide',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['runId', 'itemId'],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.decisions.dismissFollowUp(str(args, 'runId'), str(args, 'itemId')),
+    },
+    {
+        name: 'decisions_dismiss_pr_review_finding',
+        group: 'decisions',
+        method: 'dismissPrReviewFinding',
+        operationId: 'dismissPublicRunPrReviewFinding',
+        httpMethod: 'POST',
+        path: '/api/v1/runs/{runId}/decisions/pr-review/findings/{findingId}/dismiss',
+        summary: 'Dismiss a PR review finding',
+        minScope: 'decide',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['runId', 'findingId'],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.decisions.dismissPrReviewFinding(str(args, 'runId'), str(args, 'findingId')),
+    },
+    {
+        name: 'decisions_file_follow_up',
+        group: 'decisions',
+        method: 'fileFollowUp',
+        operationId: 'filePublicRunFollowUp',
+        httpMethod: 'POST',
+        path: '/api/v1/runs/{runId}/decisions/follow-ups/items/{itemId}/file',
+        summary: 'File a follow-up item as an issue',
+        minScope: 'decide',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['runId', 'itemId'],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.decisions.fileFollowUp(str(args, 'runId'), str(args, 'itemId')),
+    },
+    {
+        name: 'decisions_incorporate',
+        group: 'decisions',
+        method: 'incorporate',
+        operationId: 'incorporatePublicRunRequirements',
+        httpMethod: 'POST',
+        path: '/api/v1/runs/{runId}/decisions/requirements/incorporate',
+        summary: 'Incorporate the answers',
+        minScope: 'decide',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['runId'],
+        queryParams: [],
+        hasBody: true,
+        invoke: async (client, args) => client.decisions.incorporate(str(args, 'runId'), args.body),
+    },
+    {
+        name: 'decisions_incorporate_brainstorm',
+        group: 'decisions',
+        method: 'incorporateBrainstorm',
+        operationId: 'incorporatePublicRunBrainstorm',
+        httpMethod: 'POST',
+        path: '/api/v1/runs/{runId}/decisions/brainstorm/{stage}/incorporate',
+        summary: 'Incorporate brainstorm picks',
+        minScope: 'decide',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['runId', 'stage'],
+        queryParams: [],
+        hasBody: true,
+        invoke: async (client, args) => client.decisions.incorporateBrainstorm(str(args, 'runId'), str(args, 'stage'), args.body),
+    },
+    {
+        name: 'decisions_incorporate_clarity',
+        group: 'decisions',
+        method: 'incorporateClarity',
+        operationId: 'incorporatePublicRunClarity',
+        httpMethod: 'POST',
+        path: '/api/v1/runs/{runId}/decisions/clarity/incorporate',
+        summary: 'Incorporate clarity answers',
+        minScope: 'decide',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['runId'],
+        queryParams: [],
+        hasBody: true,
+        invoke: async (client, args) => client.decisions.incorporateClarity(str(args, 'runId'), args.body),
+    },
+    {
+        name: 'decisions_list',
+        group: 'decisions',
+        method: 'list',
+        operationId: 'listPublicRunDecisions',
+        httpMethod: 'GET',
+        path: '/api/v1/runs/{runId}/decisions',
+        summary: 'List a run\'s parked decisions',
+        minScope: 'read',
+        readOnly: true,
+        result: 'value',
+        pathParams: ['runId'],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.decisions.list(str(args, 'runId')),
+    },
+    {
+        name: 'decisions_proceed',
+        group: 'decisions',
+        method: 'proceed',
+        operationId: 'proceedPublicRunRequirements',
+        httpMethod: 'POST',
+        path: '/api/v1/runs/{runId}/decisions/requirements/proceed',
+        summary: 'Proceed with the current requirements',
+        minScope: 'decide',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['runId'],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.decisions.proceed(str(args, 'runId')),
+    },
+    {
+        name: 'decisions_proceed_brainstorm',
+        group: 'decisions',
+        method: 'proceedBrainstorm',
+        operationId: 'proceedPublicRunBrainstorm',
+        httpMethod: 'POST',
+        path: '/api/v1/runs/{runId}/decisions/brainstorm/{stage}/proceed',
+        summary: 'Proceed past a brainstorm',
+        minScope: 'decide',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['runId', 'stage'],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.decisions.proceedBrainstorm(str(args, 'runId'), str(args, 'stage')),
+    },
+    {
+        name: 'decisions_proceed_clarity',
+        group: 'decisions',
+        method: 'proceedClarity',
+        operationId: 'proceedPublicRunClarity',
+        httpMethod: 'POST',
+        path: '/api/v1/runs/{runId}/decisions/clarity/proceed',
+        summary: 'Proceed past the clarity review',
+        minScope: 'decide',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['runId'],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.decisions.proceedClarity(str(args, 'runId')),
+    },
+    {
+        name: 'decisions_proceed_interview',
+        group: 'decisions',
+        method: 'proceedInterview',
+        operationId: 'proceedPublicRunInterview',
+        httpMethod: 'POST',
+        path: '/api/v1/runs/{runId}/decisions/interview/proceed',
+        summary: 'Proceed past a parked interview',
+        minScope: 'decide',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['runId'],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.decisions.proceedInterview(str(args, 'runId')),
+    },
+    {
+        name: 'decisions_reject_step',
+        group: 'decisions',
+        method: 'rejectStep',
+        operationId: 'rejectPublicRunStep',
+        httpMethod: 'POST',
+        path: '/api/v1/runs/{runId}/decisions/approvals/{approvalId}/reject',
+        summary: 'Reject a parked step',
+        minScope: 'decide',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['runId', 'approvalId'],
+        queryParams: [],
+        hasBody: true,
+        invoke: async (client, args) => client.decisions.rejectStep(str(args, 'runId'), str(args, 'approvalId'), args.body),
+    },
+    {
+        name: 'decisions_reply_to_brainstorm_option',
+        group: 'decisions',
+        method: 'replyToBrainstormOption',
+        operationId: 'replyPublicRunBrainstormOption',
+        httpMethod: 'POST',
+        path: '/api/v1/runs/{runId}/decisions/brainstorm/{stage}/options/{itemId}/reply',
+        summary: 'Respond to a brainstorm option',
+        minScope: 'decide',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['runId', 'stage', 'itemId'],
+        queryParams: [],
+        hasBody: true,
+        invoke: async (client, args) => client.decisions.replyToBrainstormOption(str(args, 'runId'), str(args, 'stage'), str(args, 'itemId'), args.body),
+    },
+    {
+        name: 'decisions_reply_to_clarity_finding',
+        group: 'decisions',
+        method: 'replyToClarityFinding',
+        operationId: 'replyPublicRunClarityFinding',
+        httpMethod: 'POST',
+        path: '/api/v1/runs/{runId}/decisions/clarity/findings/{itemId}/reply',
+        summary: 'Answer a clarity (bug-triage) finding',
+        minScope: 'decide',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['runId', 'itemId'],
+        queryParams: [],
+        hasBody: true,
+        invoke: async (client, args) => client.decisions.replyToClarityFinding(str(args, 'runId'), str(args, 'itemId'), args.body),
+    },
+    {
+        name: 'decisions_reply_to_finding',
+        group: 'decisions',
+        method: 'replyToFinding',
+        operationId: 'replyPublicRunFinding',
+        httpMethod: 'POST',
+        path: '/api/v1/runs/{runId}/decisions/requirements/findings/{itemId}/reply',
+        summary: 'Answer a review finding',
+        minScope: 'decide',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['runId', 'itemId'],
+        queryParams: [],
+        hasBody: true,
+        invoke: async (client, args) => client.decisions.replyToFinding(str(args, 'runId'), str(args, 'itemId'), args.body),
+    },
+    {
+        name: 'decisions_request_human_test_fix',
+        group: 'decisions',
+        method: 'requestHumanTestFix',
+        operationId: 'requestPublicRunHumanTestFix',
+        httpMethod: 'POST',
+        path: '/api/v1/runs/{runId}/decisions/human-test/request-fix',
+        summary: 'Request a fix from a human-test gate',
+        minScope: 'decide',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['runId'],
+        queryParams: [],
+        hasBody: true,
+        invoke: async (client, args) => client.decisions.requestHumanTestFix(str(args, 'runId'), args.body),
+    },
+    {
+        name: 'decisions_request_step_changes',
+        group: 'decisions',
+        method: 'requestStepChanges',
+        operationId: 'requestPublicRunStepChanges',
+        httpMethod: 'POST',
+        path: '/api/v1/runs/{runId}/decisions/approvals/{approvalId}/request-changes',
+        summary: 'Request changes on a parked step',
+        minScope: 'decide',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['runId', 'approvalId'],
+        queryParams: [],
+        hasBody: true,
+        invoke: async (client, args) => client.decisions.requestStepChanges(str(args, 'runId'), str(args, 'approvalId'), args.body),
+    },
+    {
+        name: 'decisions_request_visual_confirmation_fix',
+        group: 'decisions',
+        method: 'requestVisualConfirmationFix',
+        operationId: 'requestPublicRunVisualConfirmFix',
+        httpMethod: 'POST',
+        path: '/api/v1/runs/{runId}/decisions/visual-confirmation/request-fix',
+        summary: 'Request a fix from a visual-confirmation gate',
+        minScope: 'decide',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['runId'],
+        queryParams: [],
+        hasBody: true,
+        invoke: async (client, args) => client.decisions.requestVisualConfirmationFix(str(args, 'runId'), args.body),
+    },
+    {
+        name: 'decisions_re_review',
+        group: 'decisions',
+        method: 'reReview',
+        operationId: 'reReviewPublicRunRequirements',
+        httpMethod: 'POST',
+        path: '/api/v1/runs/{runId}/decisions/requirements/re-review',
+        summary: 'Re-review the incorporated document',
+        minScope: 'decide',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['runId'],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.decisions.reReview(str(args, 'runId')),
+    },
+    {
+        name: 'decisions_re_review_brainstorm',
+        group: 'decisions',
+        method: 'reReviewBrainstorm',
+        operationId: 'reReviewPublicRunBrainstorm',
+        httpMethod: 'POST',
+        path: '/api/v1/runs/{runId}/decisions/brainstorm/{stage}/re-review',
+        summary: 'Re-run a brainstorm pass',
+        minScope: 'decide',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['runId', 'stage'],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.decisions.reReviewBrainstorm(str(args, 'runId'), str(args, 'stage')),
+    },
+    {
+        name: 'decisions_re_review_clarity',
+        group: 'decisions',
+        method: 'reReviewClarity',
+        operationId: 'reReviewPublicRunClarity',
+        httpMethod: 'POST',
+        path: '/api/v1/runs/{runId}/decisions/clarity/re-review',
+        summary: 'Re-triage the clarified report',
+        minScope: 'decide',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['runId'],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.decisions.reReviewClarity(str(args, 'runId')),
+    },
+    {
+        name: 'decisions_resolve_brainstorm_exceeded',
+        group: 'decisions',
+        method: 'resolveBrainstormExceeded',
+        operationId: 'resolvePublicRunBrainstormExceeded',
+        httpMethod: 'POST',
+        path: '/api/v1/runs/{runId}/decisions/brainstorm/{stage}/resolve-exceeded',
+        summary: 'Resolve a brainstorm at its iteration cap',
+        minScope: 'decide',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['runId', 'stage'],
+        queryParams: [],
+        hasBody: true,
+        invoke: async (client, args) => client.decisions.resolveBrainstormExceeded(str(args, 'runId'), str(args, 'stage'), args.body),
+    },
+    {
+        name: 'decisions_resolve_clarity_exceeded',
+        group: 'decisions',
+        method: 'resolveClarityExceeded',
+        operationId: 'resolvePublicRunClarityExceeded',
+        httpMethod: 'POST',
+        path: '/api/v1/runs/{runId}/decisions/clarity/resolve-exceeded',
+        summary: 'Resolve a clarity review at its iteration cap',
+        minScope: 'decide',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['runId'],
+        queryParams: [],
+        hasBody: true,
+        invoke: async (client, args) => client.decisions.resolveClarityExceeded(str(args, 'runId'), args.body),
+    },
+    {
+        name: 'decisions_resolve_exceeded',
+        group: 'decisions',
+        method: 'resolveExceeded',
+        operationId: 'resolvePublicRunRequirementsExceeded',
+        httpMethod: 'POST',
+        path: '/api/v1/runs/{runId}/decisions/requirements/resolve-exceeded',
+        summary: 'Resolve a review at its iteration cap',
+        minScope: 'decide',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['runId'],
+        queryParams: [],
+        hasBody: true,
+        invoke: async (client, args) => client.decisions.resolveExceeded(str(args, 'runId'), args.body),
+    },
+    {
+        name: 'decisions_resolve_input_gate',
+        group: 'decisions',
+        method: 'resolveInputGate',
+        operationId: 'resolvePublicRunInputGate',
+        httpMethod: 'POST',
+        path: '/api/v1/runs/{runId}/decisions/input-gate/resolve',
+        summary: 'Resolve a run parked on the task\'s input check',
+        minScope: 'decide',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['runId'],
+        queryParams: [],
+        hasBody: true,
+        invoke: async (client, args) => client.decisions.resolveInputGate(str(args, 'runId'), args.body),
+    },
+    {
+        name: 'decisions_resolve_judge',
+        group: 'decisions',
+        method: 'resolveJudge',
+        operationId: 'resolvePublicRunJudge',
+        httpMethod: 'POST',
+        path: '/api/v1/runs/{runId}/decisions/judge/resolve',
+        summary: 'Resolve a parked judge verdict',
+        minScope: 'decide',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['runId'],
+        queryParams: [],
+        hasBody: true,
+        invoke: async (client, args) => client.decisions.resolveJudge(str(args, 'runId'), args.body),
+    },
+    {
+        name: 'decisions_resolve_pr_review',
+        group: 'decisions',
+        method: 'resolvePrReview',
+        operationId: 'resolvePublicRunPrReview',
+        httpMethod: 'POST',
+        path: '/api/v1/runs/{runId}/decisions/pr-review/resolve',
+        summary: 'Resolve a parked PR deep review',
+        minScope: 'decide',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['runId'],
+        queryParams: [],
+        hasBody: true,
+        invoke: async (client, args) => client.decisions.resolvePrReview(str(args, 'runId'), args.body),
+    },
+    {
+        name: 'decisions_resolve_step_exceeded',
+        group: 'decisions',
+        method: 'resolveStepExceeded',
+        operationId: 'resolvePublicRunStepExceeded',
+        httpMethod: 'POST',
+        path: '/api/v1/runs/{runId}/decisions/approvals/{approvalId}/resolve-exceeded',
+        summary: 'Resolve a companion gate at its rework cap',
+        minScope: 'decide',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['runId', 'approvalId'],
+        queryParams: [],
+        hasBody: true,
+        invoke: async (client, args) => client.decisions.resolveStepExceeded(str(args, 'runId'), str(args, 'approvalId'), args.body),
+    },
+    {
+        name: 'decisions_send_back_follow_up',
+        group: 'decisions',
+        method: 'sendBackFollowUp',
+        operationId: 'sendBackPublicRunFollowUp',
+        httpMethod: 'POST',
+        path: '/api/v1/runs/{runId}/decisions/follow-ups/items/{itemId}/send-back',
+        summary: 'Send a follow-up item back to the Coder',
+        minScope: 'decide',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['runId', 'itemId'],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.decisions.sendBackFollowUp(str(args, 'runId'), str(args, 'itemId')),
+    },
+    {
+        name: 'decisions_set_brainstorm_option_status',
+        group: 'decisions',
+        method: 'setBrainstormOptionStatus',
+        operationId: 'setPublicRunBrainstormOptionStatus',
+        httpMethod: 'PATCH',
+        path: '/api/v1/runs/{runId}/decisions/brainstorm/{stage}/options/{itemId}',
+        summary: 'Dismiss or reopen a brainstorm option',
+        minScope: 'decide',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['runId', 'stage', 'itemId'],
+        queryParams: [],
+        hasBody: true,
+        invoke: async (client, args) => client.decisions.setBrainstormOptionStatus(str(args, 'runId'), str(args, 'stage'), str(args, 'itemId'), args.body),
+    },
+    {
+        name: 'decisions_set_clarity_finding_status',
+        group: 'decisions',
+        method: 'setClarityFindingStatus',
+        operationId: 'setPublicRunClarityFindingStatus',
+        httpMethod: 'PATCH',
+        path: '/api/v1/runs/{runId}/decisions/clarity/findings/{itemId}',
+        summary: 'Dismiss or reopen a clarity finding',
+        minScope: 'decide',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['runId', 'itemId'],
+        queryParams: [],
+        hasBody: true,
+        invoke: async (client, args) => client.decisions.setClarityFindingStatus(str(args, 'runId'), str(args, 'itemId'), args.body),
+    },
+    {
+        name: 'decisions_set_finding_status',
+        group: 'decisions',
+        method: 'setFindingStatus',
+        operationId: 'setPublicRunFindingStatus',
+        httpMethod: 'PATCH',
+        path: '/api/v1/runs/{runId}/decisions/requirements/findings/{itemId}',
+        summary: 'Dismiss or reopen a finding',
+        minScope: 'decide',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['runId', 'itemId'],
+        queryParams: [],
+        hasBody: true,
+        invoke: async (client, args) => client.decisions.setFindingStatus(str(args, 'runId'), str(args, 'itemId'), args.body),
+    },
+    {
+        name: 'debug_get_agent_context',
+        group: 'debug',
+        method: 'getAgentContext',
+        operationId: 'getDebugAgentContext',
+        httpMethod: 'GET',
+        path: '/api/v1/debug/agent-context/{snapshotId}',
+        summary: 'Get one agent-context snapshot',
+        minScope: 'read',
+        readOnly: true,
+        result: 'value',
+        pathParams: ['snapshotId'],
+        queryParams: QUERY_DEBUG_GET_AGENT_CONTEXT,
+        hasBody: false,
+        invoke: async (client, args) => client.debug.getAgentContext(str(args, 'snapshotId'), pick(args, QUERY_DEBUG_GET_AGENT_CONTEXT)),
+    },
+    {
+        name: 'debug_get_llm_call',
+        group: 'debug',
+        method: 'getLlmCall',
+        operationId: 'getDebugLlmCall',
+        httpMethod: 'GET',
+        path: '/api/v1/debug/llm-calls/{callId}',
+        summary: 'Get one LLM call',
+        minScope: 'read',
+        readOnly: true,
+        result: 'value',
+        pathParams: ['callId'],
+        queryParams: QUERY_DEBUG_GET_LLM_CALL,
+        hasBody: false,
+        invoke: async (client, args) => client.debug.getLlmCall(str(args, 'callId'), pick(args, QUERY_DEBUG_GET_LLM_CALL)),
+    },
+    {
+        name: 'debug_get_run',
+        group: 'debug',
+        method: 'getRun',
+        operationId: 'getDebugRun',
+        httpMethod: 'GET',
+        path: '/api/v1/debug/runs/{runId}',
+        summary: 'Get a run\'s diagnostic map',
+        minScope: 'read',
+        readOnly: true,
+        result: 'value',
+        pathParams: ['runId'],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.debug.getRun(str(args, 'runId')),
+    },
+    {
+        name: 'debug_list_agent_context',
+        group: 'debug',
+        method: 'listAgentContext',
+        operationId: 'listDebugAgentContext',
+        httpMethod: 'GET',
+        path: '/api/v1/debug/runs/{runId}/agent-context',
+        summary: 'List a run\'s agent-context dispatches',
+        minScope: 'read',
+        readOnly: true,
+        result: 'value',
+        pathParams: ['runId'],
+        queryParams: QUERY_DEBUG_LIST_AGENT_CONTEXT,
+        hasBody: false,
+        invoke: async (client, args) => client.debug.listAgentContext(str(args, 'runId'), pick(args, QUERY_DEBUG_LIST_AGENT_CONTEXT)),
+    },
+    {
+        name: 'debug_list_llm_calls',
+        group: 'debug',
+        method: 'listLlmCalls',
+        operationId: 'listDebugLlmCalls',
+        httpMethod: 'GET',
+        path: '/api/v1/debug/runs/{runId}/llm-calls',
+        summary: 'List a run\'s LLM calls',
+        minScope: 'read',
+        readOnly: true,
+        result: 'value',
+        pathParams: ['runId'],
+        queryParams: QUERY_DEBUG_LIST_LLM_CALLS,
+        hasBody: false,
+        invoke: async (client, args) => client.debug.listLlmCalls(str(args, 'runId'), pick(args, QUERY_DEBUG_LIST_LLM_CALLS)),
+    },
+    {
+        name: 'debug_list_logs',
+        group: 'debug',
+        method: 'listLogs',
+        operationId: 'listDebugLogs',
+        httpMethod: 'GET',
+        path: '/api/v1/debug/runs/{runId}/logs',
+        summary: 'List a run\'s infrastructure log',
+        minScope: 'read',
+        readOnly: true,
+        result: 'value',
+        pathParams: ['runId'],
+        queryParams: QUERY_DEBUG_LIST_LOGS,
+        hasBody: false,
+        invoke: async (client, args) => client.debug.listLogs(str(args, 'runId'), pick(args, QUERY_DEBUG_LIST_LOGS)),
+    },
+    {
+        name: 'debug_list_runs',
+        group: 'debug',
+        method: 'listRuns',
+        operationId: 'listDebugRuns',
+        httpMethod: 'GET',
+        path: '/api/v1/debug/runs',
+        summary: 'List the workspace\'s runs',
+        minScope: 'read',
+        readOnly: true,
+        result: 'value',
+        pathParams: [],
+        queryParams: QUERY_DEBUG_LIST_RUNS,
+        hasBody: false,
+        invoke: async (client, args) => client.debug.listRuns(pick(args, QUERY_DEBUG_LIST_RUNS)),
+    },
+    {
+        name: 'debug_list_search_queries',
+        group: 'debug',
+        method: 'listSearchQueries',
+        operationId: 'listDebugSearchQueries',
+        httpMethod: 'GET',
+        path: '/api/v1/debug/runs/{runId}/search-queries',
+        summary: 'List a run\'s web searches',
+        minScope: 'read',
+        readOnly: true,
+        result: 'value',
+        pathParams: ['runId'],
+        queryParams: QUERY_DEBUG_LIST_SEARCH_QUERIES,
+        hasBody: false,
+        invoke: async (client, args) => client.debug.listSearchQueries(str(args, 'runId'), pick(args, QUERY_DEBUG_LIST_SEARCH_QUERIES)),
+    },
+    {
+        name: 'debug_list_tool_calls',
+        group: 'debug',
+        method: 'listToolCalls',
+        operationId: 'listDebugToolCalls',
+        httpMethod: 'GET',
+        path: '/api/v1/debug/runs/{runId}/tool-calls',
+        summary: 'List a run\'s tool calls',
+        minScope: 'read',
+        readOnly: true,
+        result: 'value',
+        pathParams: ['runId'],
+        queryParams: QUERY_DEBUG_LIST_TOOL_CALLS,
+        hasBody: false,
+        invoke: async (client, args) => client.debug.listToolCalls(str(args, 'runId'), pick(args, QUERY_DEBUG_LIST_TOOL_CALLS)),
+    },
+    {
+        name: 'evidence_download_artifact',
+        group: 'evidence',
+        method: 'downloadArtifact',
+        operationId: 'getPublicArtifactBlob',
+        httpMethod: 'GET',
+        path: '/api/v1/artifacts/{artifactId}/blob',
+        summary: 'Download an artifact\'s bytes',
+        minScope: 'read',
+        readOnly: true,
+        result: 'binary',
+        pathParams: ['artifactId'],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.evidence.downloadArtifact(str(args, 'artifactId')),
+    },
+    {
+        name: 'evidence_get_outcome',
+        group: 'evidence',
+        method: 'getOutcome',
+        operationId: 'getPublicRunOutcome',
+        httpMethod: 'GET',
+        path: '/api/v1/runs/{runId}/outcome',
+        summary: 'Get a run\'s outcome summary',
+        minScope: 'read',
+        readOnly: true,
+        result: 'value',
+        pathParams: ['runId'],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.evidence.getOutcome(str(args, 'runId')),
+    },
+    {
+        name: 'evidence_get_report',
+        group: 'evidence',
+        method: 'getReport',
+        operationId: 'getPublicRunReport',
+        httpMethod: 'GET',
+        path: '/api/v1/runs/{runId}/report',
+        summary: 'Get a run\'s verification report',
+        minScope: 'read',
+        readOnly: true,
+        result: 'value',
+        pathParams: ['runId'],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.evidence.getReport(str(args, 'runId')),
+    },
+    {
+        name: 'evidence_list_artifacts',
+        group: 'evidence',
+        method: 'listArtifacts',
+        operationId: 'listPublicRunArtifacts',
+        httpMethod: 'GET',
+        path: '/api/v1/runs/{runId}/artifacts',
+        summary: 'List a run\'s captured artifacts',
+        minScope: 'read',
+        readOnly: true,
+        result: 'value',
+        pathParams: ['runId'],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.evidence.listArtifacts(str(args, 'runId')),
+    },
+    {
+        name: 'keys_create',
+        group: 'keys',
+        method: 'create',
+        operationId: 'createPublicKey',
+        httpMethod: 'POST',
+        path: '/api/v1/keys',
+        summary: 'Provision an API key',
+        minScope: 'admin',
+        readOnly: false,
+        result: 'value',
+        pathParams: [],
+        queryParams: [],
+        hasBody: true,
+        invoke: async (client, args) => client.keys.create(args.body),
+    },
+    {
+        name: 'keys_list',
+        group: 'keys',
+        method: 'list',
+        operationId: 'listPublicKeys',
+        httpMethod: 'GET',
+        path: '/api/v1/keys',
+        summary: 'List the workspace\'s API keys',
+        minScope: 'admin',
+        readOnly: true,
+        result: 'value',
+        pathParams: [],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.keys.list(),
+    },
+    {
+        name: 'keys_revoke',
+        group: 'keys',
+        method: 'revoke',
+        operationId: 'revokePublicKey',
+        httpMethod: 'DELETE',
+        path: '/api/v1/keys/{keyId}',
+        summary: 'Revoke an API key',
+        minScope: 'admin',
+        readOnly: false,
+        result: 'value',
+        pathParams: ['keyId'],
+        queryParams: [],
+        hasBody: false,
+        invoke: async (client, args) => client.keys.revoke(str(args, 'keyId')),
+    },
+];
+//# sourceMappingURL=bindings.generated.js.map