@desplega.ai/agent-swarm 2.5.3 → 2.6.0

package/src/tests/workflow-step-order.test.ts

@@ -0,0 +1,92 @@
+import { afterAll, afterEach, beforeAll, describe, expect, setSystemTime, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  closeDb,
+  createWorkflow,
+  createWorkflowRun,
+  createWorkflowRunStep,
+  getLatestStepForNode,
+  getWorkflowRunStepsByRunId,
+  initDb,
+  updateWorkflowRunStep,
+} from "../be/db";
+import { hasRunningStep } from "../workflows/engine";
+
+const TEST_DB_PATH = "./test-workflow-step-order.sqlite";
+
+// Steps inserted in the same millisecond share `startedAt`. Reads must still
+// return them in insert order, because the engine treats the last row of a
+// node as its latest step.
+describe("workflow run step order with equal startedAt", () => {
+  beforeAll(async () => {
+    try {
+      await unlink(TEST_DB_PATH);
+    } catch {
+      // File doesn't exist
+    }
+    initDb(TEST_DB_PATH);
+  });
+
+  afterEach(() => {
+    setSystemTime();
+  });
+
+  afterAll(async () => {
+    closeDb();
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        await unlink(`${TEST_DB_PATH}${suffix}`);
+      } catch {
+        // File doesn't exist
+      }
+    }
+  });
+
+  async function createRun(): Promise<string> {
+    const workflow = await createWorkflow({
+      name: `step-order-${crypto.randomUUID()}`,
+      definition: { nodes: [{ id: "a", type: "echo", config: { message: "hi" } }] },
+    });
+    const runId = crypto.randomUUID();
+    await createWorkflowRun({ id: runId, workflowId: workflow.id });
+    return runId;
+  }
+
+  // Ids sort opposite to insert order, so an id tiebreaker would also fail.
+  async function insertTwoSteps(runId: string): Promise<[string, string]> {
+    setSystemTime(new Date("2026-10-25T12:00:00.000Z"));
+    const first = `z-${crypto.randomUUID()}`;
+    const second = `a-${crypto.randomUUID()}`;
+    await createWorkflowRunStep({ id: first, runId, nodeId: "a", nodeType: "echo" });
+    await createWorkflowRunStep({ id: second, runId, nodeId: "a", nodeType: "echo" });
+    return [first, second];
+  }
+
+  test("getWorkflowRunStepsByRunId returns steps in insert order", async () => {
+    const runId = await createRun();
+    const [first, second] = await insertTwoSteps(runId);
+
+    const steps = await getWorkflowRunStepsByRunId(runId);
+    expect(steps[0]?.startedAt).toBe(steps[1]?.startedAt);
+    expect(steps.map((s) => s.id)).toEqual([first, second]);
+  });
+
+  test("getLatestStepForNode returns the step inserted last", async () => {
+    const runId = await createRun();
+    const [, second] = await insertTwoSteps(runId);
+
+    const latest = await getLatestStepForNode(runId, "a");
+    expect(latest?.id).toBe(second);
+  });
+
+  test("hasRunningStep ignores a running step superseded at the same startedAt", async () => {
+    const runId = await createRun();
+    const [, second] = await insertTwoSteps(runId);
+    await updateWorkflowRunStep(second, {
+      status: "completed",
+      finishedAt: new Date().toISOString(),
+    });
+
+    expect(hasRunningStep(await getWorkflowRunStepsByRunId(runId))).toBe(false);
+  });
+});

package/src/tests/workflow-sub-workflow.test.ts

@@ -531,6 +531,36 @@ describe("sub-workflow crash recovery", () => {
     for (const result of results) expect(result).toMatchObject({ correlationId: row!.id });
   });
 
+  test("a child deleted before the step reads it back is not retried", async () => {
+    const child = await makeWorkflow(waitingChild);
+    const parent = await makeWorkflow(retryingParentOf(child.id));
+    const { runId, stepId } = await parentStepRow(parent);
+    // Deletes the child's workflow between the start and the read back, as a
+    // concurrent delete would.
+    const racing = new SubWorkflowExecutor(
+      {
+        ...deps,
+        db: {
+          ...db,
+          getWorkflowRun: async (id: string) => {
+            await db.deleteWorkflow(child.id);
+            return db.getWorkflowRun(id);
+          },
+        },
+      },
+      registry,
+    );
+
+    const result = await racing.run({
+      config: { workflowId: child.id, inputs: { n: 1 } },
+      context: {},
+      meta: { runId, stepId, nodeId: "child", workflowId: parent.id, dryRun: false },
+    });
+
+    expect(result).toMatchObject({ status: "failed", retryable: false });
+    expect((result as { error?: string }).error).toContain("not found");
+  });
+
   test("a step that is no longer running starts no child", async () => {
     const child = await makeWorkflow(waitingChild);
     const parent = await makeWorkflow(parentOf(child.id));

package/src/tools/get-tasks.ts

@@ -50,6 +50,11 @@ export const getTasksInputSchema = z.object({
     .uuid()
     .optional()
     .describe("Filter by schedule ID to find tasks created by a specific schedule."),
+  workflowRunId: z
+    .string()
+    .uuid()
+    .optional()
+    .describe("Filter by workflow run ID to find the tasks of a single run."),
   key: AssetKeySchema.optional().describe("Filter by exact logical namespace."),
   keyPrefix: AssetKeySchema.optional().describe("Filter by namespace subtree."),
   includeHeartbeat: z
@@ -130,6 +135,7 @@ export async function getTasksHandler(
     tags,
     search,
     scheduleId,
+    workflowRunId,
     key,
     keyPrefix,
     includeHeartbeat,
@@ -151,6 +157,7 @@ export async function getTasksHandler(
     tags,
     search,
     scheduleId,
+    workflowRunId,
     key,
     keyPrefix,
     includeHeartbeat,
@@ -192,6 +199,7 @@ export async function getTasksHandler(
   if (tags?.length) filters.push(`tags=[${tags.join(", ")}]`);
   if (search) filters.push(`search='${search}'`);
   if (scheduleId) filters.push(`scheduleId='${scheduleId}'`);
+  if (workflowRunId) filters.push(`workflowRunId='${workflowRunId}'`);
   if (key) filters.push(`key='${key}'`);
   if (keyPrefix) filters.push(`keyPrefix='${keyPrefix}'`);
 

package/src/tools/kv/kv-read-auth.ts

@@ -1,13 +1,15 @@
 import { mcpOverflowAuthError } from "@/kv-overflow";
+import { privateNamespaceError } from "@/kv-reserved-namespaces";
 
 /**
  * Ordinary KV namespaces intentionally remain readable across agents. MCP
  * overflow is different: it contains tool-result business data and is private
- * to the authenticated agent whose finalizer created the spill.
+ * to the authenticated agent whose finalizer created the spill. Private
+ * reserved families (`session-labels`) are not readable here at all.
  */
 export function kvReadAuthError(
   namespace: string,
   info: { agentId: string | undefined },
 ): string | null {
-  return mcpOverflowAuthError(namespace, info.agentId);
+  return privateNamespaceError(namespace) ?? mcpOverflowAuthError(namespace, info.agentId);
 }

package/src/tools/task-action.ts

@@ -68,7 +68,7 @@ export const taskActionInputSchema = z.object({
   // For 'create' action:
   task: z.string().min(1).optional().describe("Task description (required for 'create')."),
   key: AssetKeySchema.optional().describe(
-    "Logical namespace for a created task. Defaults to a shared/task:<id>/ resource key.",
+    "Logical namespace for a created task. Default: the Slack or chat source key of the task (for example shared/slack/<channel>/thread:<ts>/), else shared/task:<id>/.",
   ),
   taskType: z.string().max(50).optional().describe("Task type (e.g., 'bug', 'feature')."),
   tags: z

package/src/tools/workflows/cancel-workflow-run.ts

@@ -10,7 +10,7 @@ export const registerCancelWorkflowRunTool = (server: McpServer) => {
       title: "Cancel Workflow Run",
       annotations: { destructiveHint: true },
       description:
-        "Cancel a running or waiting workflow run. Cancels all non-terminal steps and their associated tasks.",
+        "Cancel a running or waiting workflow run and every child run below it. Cancels their non-terminal steps, tasks, pending approvals and queued retries in one transaction; finished child runs keep their status. Repeating the cancel on a cancelled run finishes any child runs still open.",
       inputSchema: z.object({
         runId: z.string().uuid().describe("Workflow run ID to cancel"),
         reason: z.string().optional().describe("Optional reason for cancellation"),

package/src/tools/workflows/get-workflow-run.ts

@@ -1,6 +1,7 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
 import { getWorkflowRun, getWorkflowRunStepsByRunId } from "@/be/db";
+import { getWorkflowRunStepsSlimByRunId, getWorkflowRunSummary } from "@/be/db/workflow-runs";
 import { createToolRegistrar, swarmToolOutputSchema, toolErr, toolOk } from "@/tools/utils";
 
 const STEP_VALUE_CAP = 400;
@@ -15,7 +16,7 @@ function stepValuePreview(value: unknown): string | undefined {
 }
 
 function renderSteps(
-  steps: Awaited<ReturnType<typeof getWorkflowRunStepsByRunId>>,
+  steps: Awaited<ReturnType<typeof getWorkflowRunStepsSlimByRunId>>,
 ): string | undefined {
   if (steps.length === 0) return undefined;
   return steps
@@ -46,20 +47,29 @@ export const registerGetWorkflowRunTool = (server: McpServer) => {
       description: "Get details of a workflow run by ID, including all steps and their statuses.",
       inputSchema: z.object({
         id: z.string().uuid().describe("Workflow run ID"),
+        fields: z
+          .enum(["full", "slim"])
+          .optional()
+          .describe(
+            "`slim` omits run.context and each step's input (a context snapshot per step, large in runs with loops). Outputs, errors and retry fields stay. Default: full.",
+          ),
       }),
       outputSchema: swarmToolOutputSchema({
         run: z.unknown().optional(),
         steps: z.array(z.unknown()).optional(),
       }),
     },
-    async ({ id }) => {
+    async ({ id, fields }) => {
       try {
         // Display view: the scrubbed context and step outputs, never replay state.
-        const run = await getWorkflowRun(id, "display");
+        const slim = fields === "slim";
+        const run = slim ? await getWorkflowRunSummary(id) : await getWorkflowRun(id, "display");
         if (!run) {
           return toolErr(`Workflow run not found: ${id}`, { data: { steps: [] } });
         }
-        const steps = await getWorkflowRunStepsByRunId(id, "display");
+        const steps = slim
+          ? await getWorkflowRunStepsSlimByRunId(id)
+          : await getWorkflowRunStepsByRunId(id, "display");
         return toolOk(`Run ${id} status: ${run.status}.`, {
           details: renderSteps(steps),
           data: { run, steps },

package/src/types.ts

@@ -1341,12 +1341,27 @@ export const AgentSchema = z
 //
 // The cache-hit post-task path does NOT produce a new report; the row's
 // `reportedAt` deliberately stays at the last actual check.
+/** One pool member's live test. `suffix` is its last 5 chars, as in `api_key_status`. */
+export const AgentCredStatusKeyResultSchema = z
+  .object({
+    keyType: z.string(),
+    index: z.number(),
+    suffix: z.string(),
+    ok: z.boolean(),
+    error: z.string().optional(),
+    httpStatus: z.number().optional(),
+    latency_ms: z.number(),
+  })
+  .openapi("AgentCredStatusKeyResult");
+
 export const AgentCredStatusLiveTestSchema = z
   .object({
     ok: z.boolean(),
     error: z.string().nullable().default(null),
     latency_ms: z.number(),
     testedAt: z.number(), // unix ms
+    warning: z.string().optional(),
+    keys: z.array(AgentCredStatusKeyResultSchema).optional(),
   })
   .openapi("AgentCredStatusLiveTest");
 export type AgentCredStatusLiveTest = z.infer<typeof AgentCredStatusLiveTestSchema>;
@@ -3090,6 +3105,15 @@ export const WorkflowRunStepSchema = z
   .openapi("WorkflowRunStep");
 export type WorkflowRunStep = z.infer<typeof WorkflowRunStepSchema>;
 
+/**
+ * Step of `GET /api/workflow-runs/{id}?fields=slim`: no `input`, the context
+ * snapshot taken when the step started. Loops repeat it once per iteration.
+ */
+export const WorkflowRunStepSlimSchema = WorkflowRunStepSchema.omit({ input: true }).openapi(
+  "WorkflowRunStepSlim",
+);
+export type WorkflowRunStepSlim = z.infer<typeof WorkflowRunStepSlimSchema>;
+
 // --- Wait State (workflow `wait` node side table) ---
 
 export const WaitModeSchema = z.enum(["time", "event"]);

package/src/utils/company-profile.ts

@@ -1,6 +1,19 @@
+import type { EventContext } from "../telemetry-contract";
+
 export const COMPANY_TEAM_SIZES = ["1", "2-10", "11-50", "51+"] as const;
 
-export const COMPANY_USE_CASES = ["features", "bugs", "review", "ops", "docs", "data"] as const;
+export const COMPANY_USE_CASES = [
+  "features",
+  "bugs",
+  "review",
+  "ops",
+  "docs",
+  "data",
+  "content",
+  "research",
+  "seo",
+  "admin",
+] as const;
 
 export const COMPANY_ACQUISITION_SOURCES = [
   "search",
@@ -19,6 +32,43 @@ export const USER_FUNCTIONS = [
   "eng_lead",
   "founder",
   "product",
+  "marketing",
+  "sales",
+  "research",
   "ops",
   "other",
 ] as const;
+
+// The values the vendored telemetry catalog (`src/telemetry-contract`) lists.
+// The proxy rejects a whole event, feedback submission or benchmark request
+// for one value it does not list. So a newer value stays out of telemetry, as
+// if unset, until the proxy catalog adds it and `sync:telemetry-contract` runs.
+const REPORTED_USE_CASES = [
+  "features",
+  "bugs",
+  "review",
+  "ops",
+  "docs",
+  "data",
+] as const satisfies readonly NonNullable<EventContext["use_case"]>[];
+
+const REPORTED_USER_FUNCTIONS = [
+  "engineer",
+  "eng_lead",
+  "founder",
+  "product",
+  "ops",
+  "other",
+] as const satisfies readonly NonNullable<EventContext["user_function"]>[];
+
+/** `value` when telemetry may report it as a use case, else undefined. */
+export function reportedUseCase(value: unknown): (typeof REPORTED_USE_CASES)[number] | undefined {
+  return REPORTED_USE_CASES.find((reported) => reported === value);
+}
+
+/** `value` when telemetry may report it as a job function, else undefined. */
+export function reportedUserFunction(
+  value: unknown,
+): (typeof REPORTED_USER_FUNCTIONS)[number] | undefined {
+  return REPORTED_USER_FUNCTIONS.find((reported) => reported === value);
+}

package/src/utils/context-window.ts

@@ -67,7 +67,12 @@ function catalogContext(provider: string, model: string): number | undefined {
  * Unknown models get a conservative 200k so percent math stays finite.
  */
 export function getContextWindowSize(model: string): number {
-  if (!model) return DEFAULT_CONTEXT_WINDOW;
+  return getKnownContextWindowSize(model) ?? DEFAULT_CONTEXT_WINDOW;
+}
+
+/** {@link getContextWindowSize} without the fallback: undefined when the catalog has no window. */
+export function getKnownContextWindowSize(model: string | undefined): number | undefined {
+  if (!model) return undefined;
   const slash = model.indexOf("/");
   if (slash > 0) {
     const scoped = catalogContext(model.slice(0, slash), model.slice(slash + 1));
@@ -83,11 +88,8 @@ export function getContextWindowSize(model: string): number {
     if (dated) return dated;
   }
   const shortname = resolveClaudeShortname(model);
-  if (shortname) {
-    const resolved = catalogContext("anthropic", shortname);
-    if (resolved) return resolved;
-  }
-  return DEFAULT_CONTEXT_WINDOW;
+  if (shortname) return catalogContext("anthropic", shortname);
+  return undefined;
 }
 
 /**

package/src/utils/credentials.ts

@@ -380,6 +380,7 @@ export function validateOpencodeCredentials(
 /** Per-pool availability, including the model-scoped block breakdown when a model was requested. */
 export interface AvailabilityInfo {
   availableIndices: number[];
+  rejectedIndices?: number[];
   modelBlockedIndices?: number[];
   earliestModelResetAt?: string | null;
   /** Indices excluded because the key's subscription plan cannot run the model. */
@@ -414,19 +415,21 @@ async function fetchAvailableIndices(
         if (resp.ok) {
           const data = (await resp.json()) as {
             availableIndices: number[];
+            rejectedIndices?: number[];
             modelBlockedIndices?: number[];
             earliestModelResetAt?: string | null;
             seatBlockedIndices?: number[];
           };
           availableIndicesMap[envVar] = {
             availableIndices: data.availableIndices,
+            rejectedIndices: data.rejectedIndices,
             modelBlockedIndices: data.modelBlockedIndices,
             earliestModelResetAt: data.earliestModelResetAt,
             seatBlockedIndices: data.seatBlockedIndices,
           };
           if (data.availableIndices.length < totalKeys) {
             console.log(
-              `[credentials] ${envVar}: ${data.availableIndices.length}/${totalKeys} keys available (${totalKeys - data.availableIndices.length} rate-limited)`,
+              `[credentials] ${envVar}: ${data.availableIndices.length}/${totalKeys} keys available (${totalKeys - data.availableIndices.length} unavailable)`,
             );
           }
         }
@@ -558,7 +561,7 @@ export async function resolveCredentialPools(
       env[envVar] = result.selected;
       const availInfo = available ? ` (${available.length} available of ${result.total})` : "";
       console.log(
-        `[credentials] Selected ${envVar} credential ${result.index + 1}/${result.total}${availInfo} [...${result.keySuffix}]`,
+        `[credentials] Selected ${envVar} credential ${result.index + 1}/${result.total}${availInfo} [...${result.keySuffix}]${info?.rejectedIndices?.length ? ` (${info.rejectedIndices.length} rejected)` : ""}`,
       );
       selections.push({
         ...result,

package/src/utils/internal-ai/complete-structured.ts

@@ -20,6 +20,7 @@ import { complete } from "@earendil-works/pi-ai/compat";
 import { getBuiltinModel as getModel } from "@earendil-works/pi-ai/providers/all";
 import type { TSchema } from "typebox";
 import { z } from "zod";
+import { selectCredential } from "../credentials.js";
 import {
   DEFAULT_OPENROUTER_BASE_URL,
   getOpenRouterAttributionHeaders,
@@ -134,6 +135,10 @@ export async function defaultSpawnClaudeCli(
   if (!env.CLAUDE_CODE_OAUTH_TOKEN && env.AGENT_SWARM_CLAUDE_OAUTH_TOKEN) {
     env.CLAUDE_CODE_OAUTH_TOKEN = env.AGENT_SWARM_CLAUDE_OAUTH_TOKEN;
   }
+  // API calls and restarted workers can inherit raw pools.
+  for (const keyVar of ["CLAUDE_CODE_OAUTH_TOKEN", "ANTHROPIC_API_KEY"]) {
+    if (env[keyVar]) env[keyVar] = selectCredential(env[keyVar], undefined, keyVar).selected;
+  }
   // Recursion guard: this shellout is itself a full claude session — on exit it
   // fires the same global Stop hook, whose session-summary path would spawn
   // another `claude -p`, recursively (each level holds a ~0.5-1GB node process;

package/src/utils/internal-ai/credentials.ts

@@ -25,6 +25,7 @@ import { registerBunOAuthFlows } from "@earendil-works/pi-ai/bun-oauth";
 import { getEnvApiKey } from "@earendil-works/pi-ai/compat";
 import { builtinModels } from "@earendil-works/pi-ai/providers/all";
 import { getValidCodexOAuth, persistCodexOAuth } from "../../providers/codex-oauth/storage.js";
+import { selectCredential } from "../credentials.js";
 import { type CredentialKind, DEFAULT_MODEL, resolveRaterModelString } from "./models.js";
 
 registerBunOAuthFlows();
@@ -135,7 +136,7 @@ export async function resolveCredential(
   if (openrouterKey) {
     return {
       kind: "openrouter",
-      apiKey: openrouterKey,
+      apiKey: selectCredential(openrouterKey, undefined, "OPENROUTER_API_KEY").selected,
       modelDefault: resolveRaterModelString("openrouter"),
     };
   }
@@ -151,7 +152,7 @@ export async function resolveCredential(
   if (anthropicKey) {
     return {
       kind: "anthropic",
-      apiKey: anthropicKey,
+      apiKey: selectCredential(anthropicKey, undefined, "ANTHROPIC_API_KEY").selected,
       modelDefault: resolveRaterModelString("anthropic"),
     };
   }
@@ -161,7 +162,7 @@ export async function resolveCredential(
   if (openaiKey) {
     return {
       kind: "openai",
-      apiKey: openaiKey,
+      apiKey: selectCredential(openaiKey, undefined, "OPENAI_API_KEY").selected,
       modelDefault: resolveRaterModelString("openai"),
     };
   }