@desplega.ai/agent-swarm 1.156.0 → 1.158.0

package/src/http/agents.ts

@@ -7,6 +7,7 @@ import {
   deleteSwarmConfigByKey,
   EXTENSION_AGENT_ROLE,
   getAgentById,
+  getAgentDailyTaskCounts,
   getAgentWithTasks,
   getAllAgents,
   getAllAgentsWithTasks,
@@ -416,6 +417,27 @@ const listAgentRuntimeInstances = route({
   },
 });
 
+const getAgentTaskActivity = route({
+  method: "get",
+  path: "/api/agents/{id}/task-activity",
+  pattern: ["api", "agents", null, "task-activity"],
+  summary: "Daily task counts for an agent",
+  description:
+    "Number of tasks created for the agent per UTC day over the last `days` days (default 365, max 730), oldest first. Days with no tasks are omitted. Backs the activity heatmap on the agent page.",
+  tags: ["Agents"],
+  params: z.object({ id: z.string() }),
+  query: z.object({ days: z.coerce.number().int().min(1).max(730).optional() }),
+  responses: {
+    200: {
+      description: "Daily task counts",
+      schema: z.object({
+        days: z.array(z.object({ date: z.string(), count: z.number().int() })),
+      }),
+    },
+    404: { description: "Agent not found" },
+  },
+});
+
 const ContentHashSchema = z.string().regex(/^[0-9a-f]{64}$/, "sha256 hex");
 
 const ProfileSyncRejectionSchema = z.object({
@@ -820,6 +842,19 @@ export async function handleAgentsRest(
     return true;
   }
 
+  if (getAgentTaskActivity.match(req.method, pathSegments)) {
+    const parsed = await getAgentTaskActivity.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+    if (!(await getAgentById(parsed.params.id))) {
+      jsonError(res, "Agent not found", 404);
+      return true;
+    }
+    getAgentTaskActivity.respond(res, 200, {
+      days: await getAgentDailyTaskCounts(parsed.params.id, parsed.query.days ?? 365),
+    });
+    return true;
+  }
+
   if (updateAgentProfileRoute.match(req.method, pathSegments)) {
     const parsed = await updateAgentProfileRoute.parse(req, res, pathSegments, queryParams);
     if (!parsed) return true;

package/src/http/approval-requests.ts

@@ -4,16 +4,19 @@ import { resolveTaskAuditUserId } from "../be/audit-user";
 import {
   type ApprovalRequest,
   createApprovalRequest,
-  createTaskExtended,
+  getAgentById,
   getApprovalRequestById,
-  getTaskById,
+  getDbClient,
   getWorkflowRun,
   getWorkflowRunStep,
+  listApprovalRequestSummaries,
   listApprovalRequests,
   resolveApprovalRequest,
 } from "../be/db";
-import { resolveTemplate } from "../prompts/resolver";
+import type { RbacPrincipal } from "../rbac";
 import { getRequestAuth } from "../utils/request-auth-context";
+import { cancelApprovalRequest } from "../workflows/approval-cancel";
+import { createApprovalFollowUpTask } from "../workflows/approval-notifications";
 import { workflowEventBus } from "../workflows/event-bus";
 import { route } from "./route-def";
 import { jsonError } from "./utils";
@@ -90,6 +93,15 @@ const ApprovalRequestSchema = z.object({
   updatedAt: z.string(),
 });
 
+/** Slim list row (`?fields=slim`) — see `ApprovalRequestSummary`. */
+const ApprovalRequestSummarySchema = ApprovalRequestSchema.omit({
+  questions: true,
+  approvers: true,
+  responses: true,
+  resolutionReason: true,
+  notificationChannels: true,
+}).extend({ questionCount: z.number().int() });
+
 /**
  * Reshapes a DB `ApprovalRequest` row for `respond()` — identical values,
  * narrowed from the DB layer's `unknown` fields to the precise wire shape
@@ -196,7 +208,14 @@ const createRoute = route({
     workflowRunId: z.string().uuid().optional(),
     workflowRunStepId: z.string().uuid().optional(),
     sourceTaskId: z.string().uuid().optional(),
-    timeoutSeconds: z.number().int().min(1).optional(),
+    timeoutSeconds: z
+      .number()
+      .int()
+      .min(1)
+      .optional()
+      .describe(
+        "Seconds until the request expires. After that the request becomes 'timeout' and you get a hitl-follow-up task. A request with no timeout is cancelled after APPROVAL_REQUEST_AUTO_CANCELLATION_DAYS days (default 7).",
+      ),
     notifications: z
       .array(
         z.object({
@@ -256,21 +275,58 @@ const respondRoute = route({
   auth: { apiKey: true },
 });
 
+const cancelRoute = route({
+  method: "post",
+  path: "/api/approval-requests/{id}/cancel",
+  pattern: ["api", "approval-requests", null, "cancel"],
+  summary: "Cancel a pending approval request",
+  tags: ["ApprovalRequests"],
+  params: z.object({ id: z.string().uuid() }),
+  body: z.object({ reason: z.string().max(500).optional() }),
+  responses: {
+    200: {
+      description:
+        "Request cancelled, or already cancelled. A request that gates a running or waiting workflow run cancels that run too.",
+      schema: z.object({
+        approvalRequest: ApprovalRequestSchema,
+        alreadyCancelled: z.boolean(),
+        runCancelled: z.boolean(),
+      }),
+    },
+    403: { description: "Caller may not cancel this request" },
+    404: { description: "Not found" },
+    409: {
+      description: "Already resolved with approved, rejected, or timeout, or its expiresAt passed",
+    },
+  },
+  auth: { apiKey: true },
+  rbac: { permission: "approval.cancel.any" },
+});
+
 const listRoute = route({
   method: "get",
   path: "/api/approval-requests",
   pattern: ["api", "approval-requests"],
   summary: "List approval requests with optional filters",
+  description:
+    "Returns full approval requests by default. Pass `fields=slim` for the list-view shape: `questions`, `approvers`, `responses`, `resolutionReason` and `notificationChannels` are dropped and `questionCount` is added. Fetch one request in full via `GET /api/approval-requests/{id}`.",
   tags: ["ApprovalRequests"],
   query: z.object({
     status: z.string().optional(),
     workflowRunId: z.string().optional(),
     limit: z.coerce.number().optional(),
+    /** `slim` is the list-view shape; default is full. */
+    fields: z.enum(["full", "slim"]).optional(),
   }),
   responses: {
     200: {
       description: "List of approval requests",
-      schema: z.object({ approvalRequests: z.array(ApprovalRequestSchema) }),
+      schema: z.object({
+        approvalRequests: z.union([
+          z.array(ApprovalRequestSchema),
+          z.array(ApprovalRequestSummarySchema),
+        ]),
+      }),
     },
   },
   auth: { apiKey: true },
@@ -305,6 +361,24 @@ export async function handleApprovalRequests(
       return true;
     }
 
+    // A late answer never resolves the request: it becomes timeout at once.
+    // A workflow run then routes on its timeout port on the next heartbeat
+    // tick through getStuckApprovalRuns, so no approval.resolved is emitted.
+    if (existing.expiresAt && new Date(existing.expiresAt) < new Date()) {
+      // The status change and the follow-up task commit together.
+      await getDbClient().transaction(async () => {
+        const timedOut = await resolveApprovalRequest(existing.id, {
+          status: "timeout",
+          resolutionReason: `Timed out: the answer arrived after the deadline ${existing.expiresAt}`,
+        });
+        if (timedOut && !existing.workflowRunId) {
+          await createApprovalFollowUpTask(timedOut, "hitl.timeout");
+        }
+      });
+      jsonError(res, `Approval request expired at ${existing.expiresAt}`, 409);
+      return true;
+    }
+
     const unavailableReason = await getWorkflowApprovalUnavailableReason(existing);
     if (unavailableReason) {
       jsonError(res, unavailableReason, 409);
@@ -367,44 +441,36 @@ export async function handleApprovalRequests(
 
     // For standalone (non-workflow) requests, create a follow-up task
     // so the requesting agent is notified of the human's response
-    if (!updated.workflowRunId && updated.sourceTaskId) {
-      const sourceTask = await getTaskById(updated.sourceTaskId);
-      if (sourceTask) {
-        // Format responses for the template
-        const formattedResponses = formatResponses(
-          updated.questions as Array<{ id: string; type: string; label: string }>,
-          updated.responses as Record<string, unknown>,
-        );
-
-        const { text: taskText } = resolveTemplate("hitl.follow_up", {
-          request_id: updated.id,
-          title: updated.title,
-          status: updated.status,
-          responses: formattedResponses,
-        });
-
-        await createTaskExtended(taskText, {
-          agentId: sourceTask.agentId,
-          routingReason: sourceTask.agentId ? "continuity" : undefined,
-          routingSource: sourceTask.agentId ? "engine_default" : undefined,
-          parentTaskId: updated.sourceTaskId,
-          source: "system",
-          taskType: "hitl-follow-up",
-          tags: ["hitl", "follow-up"],
-          // Explicit Slack metadata — parentTaskId auto-inherits too,
-          // but being explicit ensures the follow-up task always gets
-          // the right thread context even if inheritance logic changes.
-          slackChannelId: sourceTask.slackChannelId ?? undefined,
-          slackThreadTs: sourceTask.slackThreadTs ?? undefined,
-          slackUserId: sourceTask.slackUserId ?? undefined,
-        });
-      }
-    }
+    await createApprovalFollowUpTask(updated, "hitl.follow_up");
 
     respondRoute.respond(res, 200, { approvalRequest: toApprovalRequestResponse(updated) });
     return true;
   }
 
+  // 4-segment: POST /api/approval-requests/{id}/cancel
+  if (cancelRoute.match(req.method, pathSegments)) {
+    const parsed = await cancelRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+
+    const { principal, resolvedBy } = await approvalCancelPrincipal(req);
+    const result = await cancelApprovalRequest({
+      id: parsed.params.id,
+      reason: parsed.body.reason,
+      principal,
+      resolvedBy,
+    });
+    if (!result.ok) {
+      jsonError(res, result.message, result.status);
+      return true;
+    }
+    cancelRoute.respond(res, 200, {
+      approvalRequest: toApprovalRequestResponse(result.request),
+      alreadyCancelled: result.alreadyCancelled,
+      runCancelled: result.runCancelled,
+    });
+    return true;
+  }
+
   // 3-segment with param: GET /api/approval-requests/{id}
   if (getByIdRoute.match(req.method, pathSegments)) {
     const parsed = await getByIdRoute.parse(req, res, pathSegments, queryParams);
@@ -457,12 +523,20 @@ export async function handleApprovalRequests(
     const parsed = await listRoute.parse(req, res, pathSegments, queryParams);
     if (!parsed) return true;
 
-    const requests = await listApprovalRequests({
+    const filters = {
       status: parsed.query.status || undefined,
       workflowRunId: parsed.query.workflowRunId || undefined,
       limit: parsed.query.limit || undefined,
-    });
+    };
+    // Opt-in: API, MCP and script callers that don't ask keep the full rows.
+    if (parsed.query.fields === "slim") {
+      listRoute.respond(res, 200, {
+        approvalRequests: await listApprovalRequestSummaries(filters),
+      });
+      return true;
+    }
 
+    const requests = await listApprovalRequests(filters);
     listRoute.respond(res, 200, {
       approvalRequests: requests.map(toApprovalRequestResponse),
     });
@@ -472,28 +546,26 @@ export async function handleApprovalRequests(
   return false;
 }
 
-// ─── Helpers ──────────────────────────────────────────────────────────────────
-
-function formatResponses(
-  questions: Array<{ id: string; type: string; label: string }>,
-  responses: Record<string, unknown>,
-): string {
-  return questions
-    .map((q) => {
-      const answer = responses[q.id];
-      let answerText: string;
-      if (answer == null) {
-        answerText = "(no answer)";
-      } else if (q.type === "approval") {
-        const a = answer as { approved?: boolean; comment?: string };
-        answerText = a.approved ? "Approved" : "Rejected";
-        if (a.comment) answerText += ` — ${a.comment}`;
-      } else if (typeof answer === "object") {
-        answerText = JSON.stringify(answer);
-      } else {
-        answerText = String(answer);
-      }
-      return `- ${q.label}: ${answerText}`;
-    })
-    .join("\n");
+/**
+ * The caller of the cancel route. The shared API key with an `X-Agent-ID`
+ * header identifies that agent, as on the create route.
+ */
+async function approvalCancelPrincipal(
+  req: IncomingMessage,
+): Promise<{ principal: RbacPrincipal; resolvedBy: string | null }> {
+  const auth = getRequestAuth(req);
+  if (auth?.kind === "user") {
+    return { principal: { kind: "user", userId: auth.userId }, resolvedBy: auth.userId };
+  }
+  const rawAgentId = req.headers["x-agent-id"];
+  const agentId =
+    auth?.kind === "agent" ? auth.agentId : Array.isArray(rawAgentId) ? rawAgentId[0] : rawAgentId;
+  if (agentId) {
+    const agent = await getAgentById(agentId);
+    return {
+      principal: { kind: "agent", agentId, isLead: agent?.isLead ?? false },
+      resolvedBy: agentId,
+    };
+  }
+  return { principal: { kind: "operator" }, resolvedBy: "operator" };
 }

package/src/http/apps.ts

@@ -1155,9 +1155,20 @@ export async function handleApps(
       json(res, { error: "invalid row query", issues }, 400);
       return true;
     }
-    const rows = (await listAppRows(parsed.params.id, parsed.params.model)).filter((row) =>
-      filters.every((filter) => rowValue(row, filter.column) === filter.value),
-    );
+    // SQL narrows the scan; the `===` re-check keeps the exact filter semantics.
+    const rows = (
+      await listAppRows(
+        parsed.params.id,
+        parsed.params.model,
+        filters.flatMap((filter) =>
+          typeof filter.value === "string" ||
+          typeof filter.value === "number" ||
+          typeof filter.value === "boolean"
+            ? [{ column: filter.column, value: filter.value }]
+            : [],
+        ),
+      )
+    ).filter((row) => filters.every((filter) => rowValue(row, filter.column) === filter.value));
     const sortRaw = parsed.query.sort;
     if (sortRaw) {
       const [column, dir, extra] = sortRaw.split(":");

package/src/http/config.ts

@@ -134,6 +134,11 @@ const getResolvedConfigRoute = route({
   query: z.object({
     agentId: z.string().optional(),
     repoId: z.string().optional(),
+    key: z
+      .string()
+      .min(1)
+      .optional()
+      .describe("Return only the entry with this exact key. Omit to return every resolved entry."),
     includeSecrets: z.enum(["true", "false"]).optional(),
   }),
   responses: {
@@ -216,6 +221,11 @@ const listConfig = route({
   query: z.object({
     scope: z.string().optional(),
     scopeId: z.string().optional(),
+    key: z
+      .string()
+      .min(1)
+      .optional()
+      .describe("Return only entries with this exact key. Omit to return every entry."),
     includeSecrets: z.enum(["true", "false"]).optional(),
   }),
   responses: {
@@ -283,9 +293,12 @@ export async function handleConfig(
     if (!parsed) return true;
     const includeSecrets = parsed.query.includeSecrets === "true";
     const { effectiveIncludeSecrets, secretsNote } = await resolveSecretsRead(req, includeSecrets);
+    const key = parsed.query.key;
+    // Filter by key before masking and before any secret is registered, so a
+    // caller asking for one key never receives the rest (matches get-config).
     const configs = stripApiOnlyKeys(
       await getResolvedConfig(parsed.query.agentId || undefined, parsed.query.repoId || undefined),
-    );
+    ).filter((c) => !key || c.key === key);
     const result = effectiveIncludeSecrets ? configs : maskSecrets(configs);
     if (effectiveIncludeSecrets) {
       for (const c of result) {
@@ -368,6 +381,7 @@ export async function handleConfig(
       await getSwarmConfigs({
         scope: parsed.query.scope || undefined,
         scopeId: parsed.query.scopeId || undefined,
+        key: parsed.query.key,
       }),
     );
     const listResult = effectiveIncludeSecrets ? configs : maskSecrets(configs);

package/src/http/events.ts

@@ -86,12 +86,33 @@ const getEventsRoute = route({
     since: z.string().optional(),
     until: z.string().optional(),
     limit: z.coerce.number().int().min(1).max(1000).optional(),
+    events: z
+      .string()
+      .optional()
+      .describe("Comma-separated event names; matches any of them (ANDed with `event`)"),
+    dataFields: z
+      .string()
+      .optional()
+      .describe("Comma-separated `data.field` values, used with latestPerDataField"),
+    latestPerDataField: z
+      .enum(["true", "false"])
+      .optional()
+      .describe(
+        "When true, return only the newest event per (event, data.field) pair for every name in `event`/`events` and every value in `dataFields`",
+      ),
   }),
   responses: {
     200: {
       description: "List of events",
-      schema: z.object({ events: z.array(SwarmEventSchema) }),
+      schema: z.object({
+        events: z.array(SwarmEventSchema),
+        latestPerDataField: z
+          .literal(true)
+          .optional()
+          .describe("Present only when the request asked for latestPerDataField=true"),
+      }),
     },
+    400: { description: "Validation error" },
   },
   auth: { apiKey: true },
 });
@@ -122,6 +143,9 @@ const getEventCountsRoute = route({
   auth: { apiKey: true },
 });
 
+/** Bounds the UNION ALL built for latestPerDataField: one indexed lookup per pair. */
+const MAX_LATEST_PAIRS = 50;
+
 // ─── Handler ─────────────────────────────────────────────────────────────────
 
 export async function handleEvents(
@@ -184,6 +208,36 @@ export async function handleEvents(
     const parsed = await getEventsRoute.parse(req, res, pathSegments, queryParams);
     if (!parsed) return true;
 
+    const eventNames = parsed.query.events
+      ? parsed.query.events.split(",").map((name) => EventNameSchema.safeParse(name.trim()))
+      : [];
+    const invalid = eventNames.find((result) => !result.success);
+    if (invalid) {
+      jsonError(res, "Invalid event name in `events`", 400);
+      return true;
+    }
+    const eventFilter = eventNames.flatMap((result) => (result.success ? [result.data] : []));
+    const latestPerDataField = parsed.query.latestPerDataField === "true";
+    const dataFields = (parsed.query.dataFields ?? "")
+      .split(",")
+      .map((field) => field.trim())
+      .filter(Boolean);
+    const latestEvents =
+      eventFilter.length > 0 ? eventFilter : parsed.query.event ? [parsed.query.event] : [];
+    if (
+      latestPerDataField &&
+      (latestEvents.length === 0 ||
+        dataFields.length === 0 ||
+        latestEvents.length * dataFields.length > MAX_LATEST_PAIRS)
+    ) {
+      jsonError(
+        res,
+        `latestPerDataField needs \`event\` or \`events\` and \`dataFields\`, at most ${MAX_LATEST_PAIRS} pairs`,
+        400,
+      );
+      return true;
+    }
+
     const events = await getEventsFiltered({
       category: parsed.query.category || undefined,
       event: parsed.query.event || undefined,
@@ -196,8 +250,14 @@ export async function handleEvents(
       since: parsed.query.since || undefined,
       until: parsed.query.until || undefined,
       limit: parsed.query.limit ?? 100,
+      events: eventFilter,
+      latestPerDataField: latestPerDataField ? { events: latestEvents, dataFields } : undefined,
     });
-    getEventsRoute.respond(res, 200, { events });
+    getEventsRoute.respond(
+      res,
+      200,
+      latestPerDataField ? { events, latestPerDataField: true } : { events },
+    );
     return true;
   }
 

package/src/http/index.ts

@@ -595,8 +595,10 @@ try {
 // here surfaces the count in the boot log and makes the API ready to recompute
 // USD before the first POST /api/session-costs lands.
 try {
-  const { seedPricingFromModelsDev } = await import("../be/seed-pricing");
-  seedPricingFromModelsDev();
+  // Guarded per DB handle: `createServer()` (one per MCP session) calls the
+  // same helper, so seeding here is what keeps session init off this path.
+  const { ensurePricingSeeded } = await import("../be/boot-seeds");
+  ensurePricingSeeded();
   const { startPricingRefreshLoop } = await import("../be/pricing-refresh");
   startPricingRefreshLoop();
 } catch (err) {
@@ -604,8 +606,8 @@ try {
 }
 
 try {
-  const { ensureRbacSeedsSynced } = await import("../be/rbac-roles");
-  ensureRbacSeedsSynced();
+  const { ensureRbacSeeded } = await import("../be/boot-seeds");
+  ensureRbacSeeded();
 } catch (err) {
   console.error("[startup] Failed to sync RBAC seed rows:", err);
   // RBAC flag-on must fail closed; flag-off deployments should not be bricked

package/src/http/memory.ts

@@ -24,7 +24,7 @@ import { rerank } from "../be/memory/reranker";
 import { getRetrievalsForAgent, hasRetrievalForTask } from "../be/memory/retrieval-store";
 import { getUsefulnessStats } from "../be/memory/usefulness-stats";
 import { shouldPersistAutomaticTaskMemory } from "../memory/automatic-task-gate";
-import { SIMILARITY_THRESHOLD } from "../prompts/memories";
+import { memoryRelevance, SIMILARITY_THRESHOLD } from "../prompts/memories";
 import { can } from "../rbac";
 import { AgentMemorySchema, AgentMemoryScopeSchema, AgentMemorySourceSchema } from "../types";
 import { getRequestAuth } from "../utils/request-auth-context";
@@ -688,7 +688,24 @@ export async function handleMemory(
         source,
         isLead: false,
       });
-      const ranked = rerank(expanded, { limit: Math.min(limit, 20) });
+      const resultLimit = Math.min(limit, 20);
+      const consumptionHeader = req.headers["x-memory-consumption"];
+      const consumptionMode = Array.isArray(consumptionHeader)
+        ? consumptionHeader[0]
+        : consumptionHeader;
+      // Prompt recall injects only rows above the relevance gate, so the gate
+      // must pick the slots, not trim them afterwards: eligible rows fill the
+      // cap first (in composite order), ineligible rows only the remainder.
+      // Capping by composite first let boosted low-relevance rows take every
+      // slot and render an empty prompt while an eligible hit existed.
+      const ranked =
+        consumptionMode === "prompt"
+          ? rerank(expanded, { limit: expanded.length })
+              .map((r) => ({ r, eligible: memoryRelevance(r) > SIMILARITY_THRESHOLD }))
+              .sort((a, b) => Number(b.eligible) - Number(a.eligible))
+              .slice(0, resultLimit)
+              .map(({ r }) => r)
+          : rerank(expanded, { limit: resultLimit });
 
       // Retrieval bridge — when caller passed `X-Source-Task-ID`, record one
       // `memory_retrieval` row per returned memory so server-side raters
@@ -701,10 +718,6 @@ export async function handleMemory(
         : sourceTaskIdHeader;
       const contextKeyHeader = req.headers["x-context-key"];
       const contextKey = Array.isArray(contextKeyHeader) ? contextKeyHeader[0] : contextKeyHeader;
-      const consumptionHeader = req.headers["x-memory-consumption"];
-      const consumptionMode = Array.isArray(consumptionHeader)
-        ? consumptionHeader[0]
-        : consumptionHeader;
       if (sourceTaskId && intent) {
         try {
           await recordRetrievals(
@@ -713,6 +726,7 @@ export async function handleMemory(
             ranked.map((r) => ({
               memoryId: r.id,
               similarity: r.similarity,
+              relevance: r.rawSimilarity,
               retrievalSource: r.retrievalSource,
             })),
             undefined,
@@ -727,7 +741,7 @@ export async function handleMemory(
       if (intent) {
         const consumed =
           consumptionMode === "prompt"
-            ? ranked.filter((r) => r.similarity > SIMILARITY_THRESHOLD)
+            ? ranked.filter((r) => memoryRelevance(r) > SIMILARITY_THRESHOLD)
             : ranked;
         consumedIds = dedupeMemoryDocumentIds(consumed);
         try {

package/src/http/schedules.ts

@@ -81,7 +81,7 @@ const scheduleWithOptionalFavoriteSchema = ScheduledTaskSchema.safeExtend({
 /** Slim list row — `taskTemplate` swapped for a bounded preview (see `ScheduledTaskSummary`). */
 const { taskTemplate: _omittedTaskTemplate, ...scheduleShapeWithoutTemplate } =
   ScheduledTaskSchema.shape;
-const scheduleSummaryWithFavoriteSchema = z.object({
+export const scheduleSummaryWithFavoriteSchema = z.object({
   ...scheduleShapeWithoutTemplate,
   taskTemplatePreview: z.string(),
   favorite: z.boolean(),

package/src/http/session-data.ts

@@ -18,7 +18,12 @@ import {
 import { recordSessionCost } from "../otel";
 import { incrementServerSessionsProcessed } from "../server-runtime-counters";
 import type { SessionCost } from "../types";
-import { SessionCostModelBreakdownSchema, SessionCostSchema, SessionLogSchema } from "../types";
+import {
+  PricingProviderSchema,
+  SessionCostModelBreakdownSchema,
+  SessionCostSchema,
+  SessionLogSchema,
+} from "../types";
 import { route } from "./route-def";
 import { recomputeSessionCost } from "./session-cost-recompute";
 import { cachedUsageReport } from "./usage-cache";
@@ -205,9 +210,9 @@ const createSessionCostRoute = route({
     // its own billing and the adapter reports `totalCostUsd: 0`, so the row
     // lands as `costSource: 'unpriced'`. It still has to be accepted here or
     // every ACP session's cost POST 400s and the row is silently dropped.
-    provider: z
-      .enum(["claude", "claude-managed", "codex", "pi", "opencode", "devin", "gemini", "acp"])
-      .optional(),
+    // Reuses PricingProviderSchema so this list can't drift from it again
+    // (#1636: it previously forgot `dsh`).
+    provider: PricingProviderSchema.optional(),
     /**
      * Phase 6: epoch-ms timestamp used as the "active price at time T" lookup
      * basis. Defaults to `Date.now()` when omitted. Including it lets