@sema-agent/server 7.79.2 → 7.80.0

package/dist/http/routes/rules.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { sendJson, sendError, httpErrorCode } from "../send.js";
 import { gatedPrincipal, explicitOperatorOk } from "../principal-gate.js";
+import { assertNever } from "../route-ctx.js";
 import { createLogger } from "../../observability/logger.js";
 import { RULE_IMPORT_RETRY_AFTER_SEC, MAX_RULE_SCOPE_CHARS, parseRuleScope, serializeRuleScope } from "../../rules-consent.js";
 import { CONTROL_AND_BIDI_CHARS } from "../../text-bidi.js";
@@ -82,24 +83,9 @@ function decodeRulesCursor(raw) {
     }
 }
 const rowKey = (r) => `${r.scope}\u0000${r.rule}\u0000${r.behavior}`;
-export async function handleRules(req, res, url, ctx) {
-    const miss = { fell: false };
-    await handleRulesBody(req, res, url, ctx, miss);
-    return !miss.fell;
-}
-async function handleRulesBody(req, res, url, ctx, miss) {
+export async function handleRules(req, res, match, ctx) {
     const { deps } = ctx;
     const { readJson, rateLimited } = ctx.helpers;
-    const isPrepare = req.method === "POST" && url === RULES_CC_IMPORT_PREPARE_PATH;
-    const isRedeem = req.method === "POST" && url === RULES_CC_IMPORT_REDEEM_PATH;
-    const isLocalPrepare = req.method === "POST" && url === RULES_LOCAL_IMPORT_PREPARE_PATH;
-    const isLocalRedeem = req.method === "POST" && url === RULES_LOCAL_IMPORT_REDEEM_PATH;
-    const isList = req.method === "GET" && url === RULES_PATH;
-    const isRevoke = req.method === "DELETE" && url === RULES_PATH;
-    if (!isPrepare && !isRedeem && !isList && !isRevoke && !isLocalPrepare && !isLocalRedeem) {
-        miss.fell = true;
-        return;
-    }
     if (rateLimited(req, res))
         return;
     const principal = gatedPrincipal(req, deps.config);
@@ -112,8 +98,8 @@ async function handleRulesBody(req, res, url, ctx, miss) {
         sendError(res, 501, "capability.rule_store_required", "this deployment has no permission-rule store wired");
         return;
     }
-    if (isList) {
-        await handleRuleList(req, res, principal, lane, deps.config.operatorPrincipals);
+    if (match.decl.id === "rules-list") {
+        await handleRuleList(res, match.search, principal, lane, deps.config.operatorPrincipals);
         return;
     }
     let rawBody;
@@ -128,11 +114,11 @@ async function handleRulesBody(req, res, url, ctx, miss) {
         sendError(res, 400, "request.body_shape", "body must be valid JSON");
         return;
     }
-    if (isRevoke) {
+    if (match.decl.id === "rules-revoke") {
         await handleRuleRevoke(res, rawBody, principal, lane, deps.config.operatorPrincipals);
         return;
     }
-    if (isLocalPrepare) {
+    if (match.decl.id === "rules-local-import-prepare") {
         const parsed = LocalImportPrepareBodySchema.safeParse(rawBody);
         if (!parsed.success) {
             sendError(res, 400, "request.body_shape", "body must be {rows:[{behavior,rule,scope,tool,match,command,adds}]}");
@@ -147,7 +133,7 @@ async function handleRulesBody(req, res, url, ctx, miss) {
         sendJson(res, 200, { preview: prepared.preview, ...(prepared.ticket !== undefined ? { ticket: prepared.ticket, expiresAtMs: prepared.expiresAtMs } : {}) });
         return;
     }
-    if (isLocalRedeem) {
+    if (match.decl.id === "rules-local-import-redeem") {
         const parsed = LocalImportRedeemBodySchema.safeParse(rawBody);
         if (!parsed.success) {
             sendError(res, 400, "request.body_shape", "body must be {ticket}");
@@ -172,7 +158,7 @@ async function handleRulesBody(req, res, url, ctx, miss) {
         sendError(res, 404, "not_found.rule_ticket", "no such import ticket");
         return;
     }
-    if (isPrepare) {
+    if (match.decl.id === "rules-cc-import-prepare") {
         const parsed = CcImportPrepareBodySchema.safeParse(rawBody);
         if (!parsed.success) {
             sendError(res, 400, "request.body_shape", "body must be {layers:[{layer,path,root,content}]}");
@@ -186,6 +172,8 @@ async function handleRulesBody(req, res, url, ctx, miss) {
         sendJson(res, 200, { preview: prepared.preview, ...(prepared.ticket !== undefined ? { ticket: prepared.ticket, expiresAtMs: prepared.expiresAtMs } : {}) });
         return;
     }
+    if (match.decl.id !== "rules-cc-import-redeem")
+        return assertNever(match.decl.id);
     const parsed = CcImportRedeemBodySchema.safeParse(rawBody);
     if (!parsed.success) {
         sendError(res, 400, "request.body_shape", "body must be {ticket}");
@@ -216,8 +204,8 @@ function resolveTargetPrincipal(requested, caller, operatorPrincipals) {
         return { ok: false };
     return { ok: true, principal: requested };
 }
-async function handleRuleList(req, res, caller, lane, operatorPrincipals) {
-    const q = new URL(req.url ?? "/", "http://localhost").searchParams;
+async function handleRuleList(res, search, caller, lane, operatorPrincipals) {
+    const q = new URLSearchParams(search);
     const target = resolveTargetPrincipal(q.get("principal") ?? undefined, caller, operatorPrincipals);
     if (!target.ok) {
         sendError(res, 403, "auth.operator_only", "reading another principal's rules is an operator-only action");
@@ -286,4 +274,14 @@ async function handleRuleRevoke(res, rawBody, caller, lane, operatorPrincipals)
             return;
     }
 }
+export const RULES_ROUTES = [
+    { id: "rules-cc-import-prepare", path: RULES_CC_IMPORT_PREPARE_PATH, methods: ["POST"] },
+    { id: "rules-cc-import-redeem", path: RULES_CC_IMPORT_REDEEM_PATH, methods: ["POST"] },
+    { id: "rules-local-import-prepare", path: RULES_LOCAL_IMPORT_PREPARE_PATH, methods: ["POST"] },
+    { id: "rules-local-import-redeem", path: RULES_LOCAL_IMPORT_REDEEM_PATH, methods: ["POST"] },
+    { id: "rules-list", path: RULES_PATH, methods: ["GET"] },
+    { id: "rules-revoke", path: RULES_PATH, credentialGated: ["DELETE"], methods: ["DELETE"] },
+    { prefix: "/v1/rules/cc-import/", credentialGated: ["POST"] },
+    { prefix: "/v1/rules/local-import/", credentialGated: ["POST"] },
+];
 //# sourceMappingURL=rules.js.map

package/dist/http/routes/run-memory-capture.d.ts

@@ -28,7 +28,14 @@
  * `sessionBackgroundable` 同谓词):老 worker 键缺席 ⇒ 壳不渲入口(假 affordance 纪律)。
  */
 import type { IncomingMessage, ServerResponse } from "node:http";
-import { type RouteCtx } from "../route-ctx.js";
-export declare const RUN_MEMORY_CAPTURE_OPTOUT_RE: RegExp;
-export declare function handleRunMemoryCapture(req: IncomingMessage, res: ServerResponse, url: string, ctx: RouteCtx): Promise<boolean>;
+import { type RouteCtx, type RouteMatch, type RouteIdsOf } from "../route-ctx.js";
+export declare function handleRunMemoryCapture(req: IncomingMessage, res: ServerResponse, match: RouteMatch<RunMemoryCaptureRouteId>, ctx: RouteCtx): Promise<void>;
+export declare const RUN_MEMORY_CAPTURE_ROUTES: readonly [{
+    readonly id: "run-memory-capture-optout";
+    readonly pattern: RegExp;
+    readonly label: "/v1/runs/:id/memory/capture-optout";
+    readonly methods: readonly ["POST"];
+}];
+/** 本域可分派行的 `id` 闭集 —— handler 的 `switch` 按它判穷尽(漏一口 = 编译红)。 */
+export type RunMemoryCaptureRouteId = RouteIdsOf<typeof RUN_MEMORY_CAPTURE_ROUTES>;
 //# sourceMappingURL=run-memory-capture.d.ts.map

package/dist/http/routes/run-memory-capture.js

@@ -3,95 +3,95 @@ import { isParkedRunStatus, isTerminalRunStatus } from "../../plugins/store-cont
 import { sendJson, sendError } from "../send.js";
 import { gatedPrincipal, sendPrincipalRefusal } from "../principal-gate.js";
 import { RUN_NOT_FOUND_MESSAGE, runNotFoundMessage } from "../route-ctx.js";
-export const RUN_MEMORY_CAPTURE_OPTOUT_RE = /^\/v1\/runs\/([^/]+)\/memory\/capture-optout$/;
+import { assertNever } from "../route-ctx.js";
 const BodySchema = z.object({ reason: z.string().min(1).max(500).optional() }).strict();
-export async function handleRunMemoryCapture(req, res, url, ctx) {
-    const miss = { fell: false };
-    await handleBody(req, res, url, ctx, miss);
-    return !miss.fell;
-}
-async function handleBody(req, res, url, ctx, miss) {
+export async function handleRunMemoryCapture(req, res, match, ctx) {
     const { deps } = ctx;
-    const m = req.method === "POST" ? RUN_MEMORY_CAPTURE_OPTOUT_RE.exec(url) : null;
-    if (m === null) {
-        miss.fell = true;
-        return;
-    }
-    if (ctx.helpers.rateLimited(req, res))
-        return;
-    if (!deps.runStore) {
-        sendError(res, 501, "capability.run_store_required", "async runs require a durable run store (DB_BACKEND=mysql|pg|local)");
-        return;
-    }
-    const principal = gatedPrincipal(req, deps.config);
-    if (deps.config.requirePrincipal && principal === undefined) {
-        sendPrincipalRefusal(res, req, deps.config);
-        return;
-    }
-    const taskId = m[1];
-    const parsed = BodySchema.safeParse((await ctx.helpers.readJson(req)) ?? {});
-    if (!parsed.success) {
-        sendError(res, 400, "request.body_shape", "body must be {} or { reason: string (non-empty, at most 500 chars) } — the session memory-capture opt-out verb takes no other keys");
-        return;
-    }
-    const run = await deps.runStore.getRun(taskId);
-    if (!run) {
-        sendError(res, 404, "not_found.run", runNotFoundMessage(taskId));
-        return;
-    }
-    if (run.owner !== null && run.owner !== principal) {
-        sendError(res, 404, "not_found.run", RUN_NOT_FOUND_MESSAGE);
-        return;
-    }
-    const live = ctx.registry.steerableRuns.get(taskId);
-    if (live) {
-        try {
-            const { outcome } = await live.optOutMemoryCapture(parsed.data.reason !== undefined ? { reason: parsed.data.reason } : {});
-            sendJson(res, 200, { taskId, sessionId: run.sessionId, outcome });
-            return;
-        }
-        catch (e) {
-            const code = e.code;
-            const msg = e instanceof Error ? e.message : String(e);
-            switch (code) {
-                case "memory.capture_optout_denied":
-                    sendError(res, 403, "memory.capture_optout_denied", msg);
-                    return;
-                case "memory.capture_optout_unpersisted":
-                    sendError(res, 503, "memory.capture_optout_unpersisted", msg);
-                    return;
-                case "memory.capture_optout_unavailable":
-                    sendError(res, 409, "memory.capture_optout_unavailable", msg);
-                    return;
-                case "memory.capture_optout_sweep_failed":
-                    sendError(res, 409, "memory.capture_optout_sweep_failed", msg);
-                    return;
-                case "config.memory_capture_unsupported":
-                    sendError(res, 409, "config.memory_capture_unsupported", msg);
-                    return;
-                case "steering.invalid_content":
-                    sendError(res, 422, "steering.invalid_content", msg);
-                    return;
-                case "steering.not_running":
-                    sendError(res, 409, "steering.not_running", "run just finished — the memory-capture opt-out verb needs a live run; declare it on the next submit instead (memoryCapture: 'off')");
+    switch (match.decl.id) {
+        case "run-memory-capture-optout": {
+            if (ctx.helpers.rateLimited(req, res))
+                return;
+            if (!deps.runStore) {
+                sendError(res, 501, "capability.run_store_required", "async runs require a durable run store (DB_BACKEND=mysql|pg|local)");
+                return;
+            }
+            const principal = gatedPrincipal(req, deps.config);
+            if (deps.config.requirePrincipal && principal === undefined) {
+                sendPrincipalRefusal(res, req, deps.config);
+                return;
+            }
+            const taskId = match.params.taskId;
+            const parsed = BodySchema.safeParse((await ctx.helpers.readJson(req)) ?? {});
+            if (!parsed.success) {
+                sendError(res, 400, "request.body_shape", "body must be {} or { reason: string (non-empty, at most 500 chars) } — the session memory-capture opt-out verb takes no other keys");
+                return;
+            }
+            const run = await deps.runStore.getRun(taskId);
+            if (!run) {
+                sendError(res, 404, "not_found.run", runNotFoundMessage(taskId));
+                return;
+            }
+            if (run.owner !== null && run.owner !== principal) {
+                sendError(res, 404, "not_found.run", RUN_NOT_FOUND_MESSAGE);
+                return;
+            }
+            const live = ctx.registry.steerableRuns.get(taskId);
+            if (live) {
+                try {
+                    const { outcome } = await live.optOutMemoryCapture(parsed.data.reason !== undefined ? { reason: parsed.data.reason } : {});
+                    sendJson(res, 200, { taskId, sessionId: run.sessionId, outcome });
                     return;
-                default: throw e;
+                }
+                catch (e) {
+                    const code = e.code;
+                    const msg = e instanceof Error ? e.message : String(e);
+                    switch (code) {
+                        case "memory.capture_optout_denied":
+                            sendError(res, 403, "memory.capture_optout_denied", msg);
+                            return;
+                        case "memory.capture_optout_unpersisted":
+                            sendError(res, 503, "memory.capture_optout_unpersisted", msg);
+                            return;
+                        case "memory.capture_optout_unavailable":
+                            sendError(res, 409, "memory.capture_optout_unavailable", msg);
+                            return;
+                        case "memory.capture_optout_sweep_failed":
+                            sendError(res, 409, "memory.capture_optout_sweep_failed", msg);
+                            return;
+                        case "config.memory_capture_unsupported":
+                            sendError(res, 409, "config.memory_capture_unsupported", msg);
+                            return;
+                        case "steering.invalid_content":
+                            sendError(res, 422, "steering.invalid_content", msg);
+                            return;
+                        case "steering.not_running":
+                            sendError(res, 409, "steering.not_running", "run just finished — the memory-capture opt-out verb needs a live run; declare it on the next submit instead (memoryCapture: 'off')");
+                            return;
+                        default: throw e;
+                    }
+                }
+            }
+            if (isParkedRunStatus(run.status)) {
+                sendError(res, 409, "steering.not_running", "run is parked on a pending decision — the memory-capture opt-out verb needs a live turn, and a resumed continuation rebuilds its spec from the persisted body (it cannot take a new declaration); the opt-out becomes effective on this session's next NEW submit (POST /v1/tasks with this sessionId and memoryCapture: 'off') — content captured until then stays captured");
+                return;
             }
+            if (isTerminalRunStatus(run.status)) {
+                sendError(res, 409, "steering.not_running", "run already ended — the memory-capture opt-out verb needs a live run; submit the next turn of this session with memoryCapture: 'off' (the declaration writes the same one-way session record)");
+                return;
+            }
+            const provenElsewhere = typeof run.instanceId === "string" && run.instanceId.length > 0 && deps.instanceId !== undefined && run.instanceId !== deps.instanceId;
+            if (provenElsewhere) {
+                sendError(res, 409, "steering.not_running", "run is live on another replica — the memory-capture opt-out verb must reach the replica holding the stream; resend it there, or declare memoryCapture: 'off' on the next submit");
+                return;
+            }
+            sendError(res, 409, "steering.not_running", "no live steerable face for this run on this replica — verify/cascade execution lanes expose none; declare memoryCapture: 'off' on the next submit of this session instead");
+            return;
         }
+        default:
+            return assertNever(match.decl.id);
     }
-    if (isParkedRunStatus(run.status)) {
-        sendError(res, 409, "steering.not_running", "run is parked on a pending decision — the memory-capture opt-out verb needs a live turn, and a resumed continuation rebuilds its spec from the persisted body (it cannot take a new declaration); the opt-out becomes effective on this session's next NEW submit (POST /v1/tasks with this sessionId and memoryCapture: 'off') — content captured until then stays captured");
-        return;
-    }
-    if (isTerminalRunStatus(run.status)) {
-        sendError(res, 409, "steering.not_running", "run already ended — the memory-capture opt-out verb needs a live run; submit the next turn of this session with memoryCapture: 'off' (the declaration writes the same one-way session record)");
-        return;
-    }
-    const provenElsewhere = typeof run.instanceId === "string" && run.instanceId.length > 0 && deps.instanceId !== undefined && run.instanceId !== deps.instanceId;
-    if (provenElsewhere) {
-        sendError(res, 409, "steering.not_running", "run is live on another replica — the memory-capture opt-out verb must reach the replica holding the stream; resend it there, or declare memoryCapture: 'off' on the next submit");
-        return;
-    }
-    sendError(res, 409, "steering.not_running", "no live steerable face for this run on this replica — verify/cascade execution lanes expose none; declare memoryCapture: 'off' on the next submit of this session instead");
 }
+export const RUN_MEMORY_CAPTURE_ROUTES = [
+    { id: "run-memory-capture-optout", pattern: /^\/v1\/runs\/(?<taskId>[^/]+)\/memory\/capture-optout$/, label: "/v1/runs/:id/memory/capture-optout", methods: ["POST"] },
+];
 //# sourceMappingURL=run-memory-capture.js.map

package/dist/http/routes/runs.d.ts

@@ -1,33 +1,17 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { ActorAssertionWire } from "@sema-agent/settings-schema";
-import type { RouteCtx, PreparedTaskSubmission } from "../route-ctx.js";
-export declare const RUN_ID_RE: RegExp;
-export declare const RUN_CANCEL_RE: RegExp;
-export declare const RUN_STEER_RE: RegExp;
-export declare const RUN_DETACH_RE: RegExp;
-export declare const RUN_COMPACT_RE: RegExp;
-export declare const RUN_INTERRUPT_RE: RegExp;
-/** PAIR-REVIEW F-10:runs 面 404 文案统一富形——a\* 形 id(background-agent registry 句柄,`a`+hex 短形)
- *  是「结构性不在 run 店」的常客([ref]⑤ 记档裁量:不改路由,只给引导)。识别句法形即补引导;
- *  非 a\* 形保通用富文案(cancel 腿 [ref]① 同款)。 */
-export declare const ELICIT_RESPOND_RE: RegExp;
-export declare const QUESTION_RESPOND_RE: RegExp;
-export declare const TOOL_APPROVAL_RESPOND_RE: RegExp;
-export declare const TASK_ASK_DECISION_RE: RegExp;
+import type { RouteCtx, PreparedTaskSubmission, RouteMatch, RouteIdsOf } from "../route-ctx.js";
 /** 行上的 `decision_actor`(裸 JSON)投成回显形;形不认 ⇒ undefined(调用点省略该键,不 500)。
  *  导出仅为契约门(`test/ask-decision-actor-contract.test.ts` 钉「键集同源包版 + 严格度刻意宽读」两条)
  *  —— 导出的是**行为**而不是 schema 对象:schema 的推断类型会牵出 registry-core 内嵌的 zod 路径
  *  (TS2742,不可移植),而这道门要钉的本来就是行为。非 wire 面。 */
 export declare function projectDecisionActor(raw: unknown): ActorAssertionWire | undefined;
-export declare const RUN_SUBAGENT_STEER_RE: RegExp;
-export declare const RUN_SUBAGENT_RESUME_RE: RegExp;
-export declare const RUN_SUBAGENT_OUTPUT_RE: RegExp;
-export declare const RUN_SUBAGENT_STREAM_RE: RegExp;
-export declare const RUN_TASK_OUTPUT_RE: RegExp;
-export declare const RUN_TASK_STOP_RE: RegExp;
-export declare function handleRuns(req: IncomingMessage, res: ServerResponse, url: string, ctx: RouteCtx): Promise<boolean>;
 /** 子代理 / 任务句柄 / HITL 应答段——`handle()` 里它在 SVC-5 workflow steer **之后**,故是独立的域入口。 */
-export declare function handleRunVerbs(req: IncomingMessage, res: ServerResponse, url: string, ctx: RouteCtx): Promise<boolean>;
+/** 路由体 = 从 `server.ts` 的 `handle()` 里**整段剪切**过来的原文(唯一改动:统一去缩进两格)。裸 `return;`
+ *  = 「本域已应答」;走到函数尾才是「没匹配上」。跨域的东西一律在首行解构出来。 */
+export declare function handleRuns(req: IncomingMessage, res: ServerResponse, match: RouteMatch<RunsRouteId>, ctx: RouteCtx): Promise<void>;
+/** 同上纪律(子代理 / 任务句柄 / HITL 应答段)。 */
+export declare function handleRunVerbs(req: IncomingMessage, res: ServerResponse, match: RouteMatch<RunVerbsRouteId>, ctx: RouteCtx): Promise<void>;
 /**
  * DESIGN-269 车2 件2 —— `POST /v1/runs` 的**建行 + 驱动**段,从路由体里原样搬出来的具名腿。
  *
@@ -54,4 +38,100 @@ idemKey: string | undefined): Promise<{
     status: number;
     body: unknown;
 } | null>;
+export declare const RUNS_ROUTES: readonly [{
+    readonly id: "runs-submit";
+    readonly path: "/v1/runs";
+    readonly billable: true;
+    readonly methods: readonly ["POST"];
+}, {
+    readonly id: "run-steer";
+    readonly pattern: RegExp;
+    readonly label: "/v1/runs/:id/steer";
+    readonly methods: readonly ["POST"];
+}, {
+    readonly id: "run-interrupt";
+    readonly pattern: RegExp;
+    readonly label: "/v1/runs/:id/interrupt";
+    readonly methods: readonly ["POST"];
+}, {
+    readonly id: "run-detach";
+    readonly pattern: RegExp;
+    readonly label: "/v1/runs/:id/detach";
+    readonly methods: readonly ["POST"];
+}, {
+    readonly id: "run-cancel";
+    readonly pattern: RegExp;
+    readonly label: "/v1/runs/:id/cancel";
+    readonly methods: readonly ["POST"];
+}, {
+    readonly id: "run-compact";
+    readonly pattern: RegExp;
+    readonly label: "/v1/runs/:id/compact";
+    readonly methods: readonly ["POST"];
+}, {
+    readonly id: "run-events";
+    readonly pattern: RegExp;
+    readonly label: "/v1/runs/:id/events";
+    readonly methods: readonly ["GET"];
+}, {
+    readonly id: "run-detail";
+    readonly pattern: RegExp;
+    readonly label: "/v1/runs/:id";
+    readonly methods: readonly ["GET"];
+}];
+/** 本域可分派行的 `id` 闭集 —— handler 的收尾按它判穷尽(漏一口 = 编译红)。 */
+export type RunsRouteId = RouteIdsOf<typeof RUNS_ROUTES>;
+export declare const RUN_VERBS_ROUTES: readonly [{
+    readonly id: "run-subagent-output";
+    readonly pattern: RegExp;
+    readonly label: "/v1/runs/:id/subagents/:sub/*";
+    readonly methods: readonly ["GET"];
+}, {
+    readonly id: "run-subagent-stream";
+    readonly pattern: RegExp;
+    readonly label: "/v1/runs/:id/subagents/:sub/*";
+    readonly methods: readonly ["GET"];
+}, {
+    readonly id: "run-subagent-steer";
+    readonly pattern: RegExp;
+    readonly label: "/v1/runs/:id/subagents/:sub/*";
+    readonly methods: readonly ["POST"];
+}, {
+    readonly id: "run-subagent-resume";
+    readonly pattern: RegExp;
+    readonly label: "/v1/runs/:id/subagents/:sub/*";
+    readonly billable: true;
+    readonly methods: readonly ["POST"];
+}, {
+    readonly id: "run-task-output";
+    readonly pattern: RegExp;
+    readonly label: "/v1/runs/:id/tasks/:tid/*";
+    readonly methods: readonly ["GET"];
+}, {
+    readonly id: "run-task-stop";
+    readonly pattern: RegExp;
+    readonly label: "/v1/runs/:id/tasks/:tid/*";
+    readonly methods: readonly ["POST"];
+}, {
+    readonly id: "elicitation-respond";
+    readonly pattern: RegExp;
+    readonly label: "/v1/elicitations/:id/respond";
+    readonly methods: readonly ["POST"];
+}, {
+    readonly id: "question-respond";
+    readonly pattern: RegExp;
+    readonly label: "/v1/questions/:id/respond";
+    readonly methods: readonly ["POST"];
+}, {
+    readonly id: "tool-approval-respond";
+    readonly pattern: RegExp;
+    readonly label: "/v1/tool-approvals/:id/respond";
+    readonly methods: readonly ["POST"];
+}, {
+    readonly id: "task-ask-decision";
+    readonly pattern: RegExp;
+    readonly label: "/v1/tasks/:id/asks/:askId/decision";
+    readonly methods: readonly ["POST"];
+}];
+export type RunVerbsRouteId = RouteIdsOf<typeof RUN_VERBS_ROUTES>;
 //# sourceMappingURL=runs.d.ts.map