@desplega.ai/agent-swarm 1.173.0 → 2.1.0

package/src/tests/task-model-effort-rerun.test.ts

@@ -0,0 +1,164 @@
+// What a task records about the model and effort it ran on, and what a re-run
+// of the same row carries over. Regression for: an agent's model/effort changed
+// in the dashboard, and the next run of a task kept the previous values.
+
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  closeDb,
+  createAgent,
+  createTaskExtended,
+  getTaskById,
+  initDb,
+  updateTaskClaudeSessionId,
+} from "../be/db";
+import { effectiveReasoningEffort } from "../providers/reasoning-effort";
+import { resumedTaskModelSelection, taskModelPin } from "../tasks/model-pin";
+
+const TEST_DB_PATH = "./test-task-model-effort-rerun.sqlite";
+
+async function removeDbFiles(path: string): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(path + suffix);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+    }
+  }
+}
+
+beforeAll(async () => {
+  await removeDbFiles(TEST_DB_PATH);
+  initDb(TEST_DB_PATH);
+});
+
+afterAll(async () => {
+  closeDb();
+  await removeDbFiles(TEST_DB_PATH);
+});
+
+describe("taskModelPin", () => {
+  test("a model reported by a previous session is not a pin", () => {
+    expect(taskModelPin({ model: "claude-opus-5-5", claudeSessionId: "s1" })).toBeUndefined();
+  });
+
+  test("a model a tier layer chose is not a pin", () => {
+    expect(
+      taskModelPin({
+        model: "claude-opus-5-5",
+        modelTier: "smart",
+        resolvedModel: "claude-opus-5-5",
+        modelSource: "tier-default",
+      }),
+    ).toBeUndefined();
+  });
+
+  test("the creator's model on an unclaimed row is the pin", () => {
+    expect(taskModelPin({ model: "claude-sonnet-5-5" })).toBe("claude-sonnet-5-5");
+  });
+
+  test("a claimed pin keeps its alias", () => {
+    expect(
+      taskModelPin({
+        model: "claude-opus-5-5",
+        modelSource: "model",
+        modelAlias: "latest:anthropic/opus",
+        claudeSessionId: "s1",
+      }),
+    ).toBe("latest:anthropic/opus");
+  });
+});
+
+describe("resumedTaskModelSelection", () => {
+  test("a paused unpinned task resumes without the previous run's model or claim record", () => {
+    expect(
+      resumedTaskModelSelection({
+        model: "claude-opus-5-5",
+        resolvedModel: "claude-opus-5-5",
+        modelSource: "tier-config",
+        modelTier: "smart",
+        claudeSessionId: "s1",
+      }),
+    ).toEqual({ model: undefined, resolvedModel: undefined, modelSource: undefined });
+  });
+
+  test("a paused pinned task resumes on its pin", () => {
+    expect(
+      resumedTaskModelSelection({
+        model: "claude-sonnet-5-5",
+        resolvedModel: "claude-sonnet-5-5",
+        modelSource: "model",
+        claudeSessionId: "s1",
+      }),
+    ).toEqual({
+      model: "claude-sonnet-5-5",
+      resolvedModel: "claude-sonnet-5-5",
+      modelSource: "model",
+    });
+  });
+});
+
+describe("effectiveReasoningEffort", () => {
+  test("unset effort records nothing", () => {
+    expect(effectiveReasoningEffort("claude", "claude-opus-5-5", undefined)).toBeNull();
+  });
+
+  test("harnesses without effort support record nothing", () => {
+    expect(effectiveReasoningEffort("devin", "", "high")).toBeNull();
+  });
+
+  test("a level the model cannot take is dropped, the same as the adapter does", () => {
+    expect(effectiveReasoningEffort("claude", "not-a-reasoning-model", "high")).toBeNull();
+  });
+});
+
+describe("session report records the effort", () => {
+  test("the effort the session ran at lands on resolvedEffort, and a re-run replaces it", async () => {
+    const agent = await createAgent({ name: "effort-rerun", isLead: false, status: "idle" });
+    const task = await createTaskExtended("work", { agentId: agent.id });
+
+    // First run: the agent's REASONING_EFFORT_OVERRIDE was high.
+    await updateTaskClaudeSessionId(
+      task.id,
+      "run-1",
+      "claude",
+      undefined,
+      "claude-opus-5-5",
+      undefined,
+      undefined,
+      "high",
+    );
+    let row = await getTaskById(task.id);
+    expect(row?.resolvedEffort).toBe("high");
+    // The requested-effort column stays the creator's value, not a pin.
+    expect(row?.effort).toBeUndefined();
+
+    // Effort changed to low in the dashboard; the next run records low.
+    await updateTaskClaudeSessionId(
+      task.id,
+      "run-2",
+      "claude",
+      undefined,
+      "claude-opus-5-5",
+      undefined,
+      undefined,
+      "low",
+    );
+    row = await getTaskById(task.id);
+    expect(row?.resolvedEffort).toBe("low");
+
+    // Effort set back to Auto: the harness default applied, nothing to show.
+    await updateTaskClaudeSessionId(
+      task.id,
+      "run-3",
+      "claude",
+      undefined,
+      "claude-opus-5-5",
+      undefined,
+      undefined,
+      null,
+    );
+    row = await getTaskById(task.id);
+    expect(row?.resolvedEffort).toBeUndefined();
+  });
+});

package/src/tests/task-session-prompts.test.ts

@@ -0,0 +1,132 @@
+import { describe, expect, test } from "bun:test";
+import {
+  buildRequesterProfilePrompt,
+  buildTaskSessionPrompts,
+  type TaskSessionContext,
+} from "../commands/runner";
+import { type BasePromptArgs, getTaskContextPrompt } from "../prompts/base-prompt";
+import type { ProviderName } from "../types";
+
+// The provider caches the system prompt as a prefix, so any per-task byte in it
+// re-bills the whole prompt on the first call of every session. These tests pin
+// the split: one agent, different tasks, requesters and repos, same system
+// prompt; the per-task context still reaches the model, in the task prompt.
+
+const agentArgs = (
+  provider: ProviderName,
+  extra: Partial<BasePromptArgs> = {},
+): BasePromptArgs => ({
+  role: "worker",
+  agentId: "11111111-2222-3333-4444-555555555555",
+  name: "Ada",
+  provider,
+  traits: { hasMcp: true, hasLocalEnvironment: true, nativeSkillDiscovery: provider !== "codex" },
+  soulMd: "You are Ada.",
+  claudeMd: "# Agent: Ada\n\nAlways run the tests before you push.",
+  skillsSummary: [{ name: "commit", description: "Create a commit" }],
+  mcpServers: ["linear"],
+  ...extra,
+});
+
+const sessionA: TaskSessionContext = {
+  repoContext: {
+    clonePath: "/workspace/personal/repos/alpha",
+    claudeMd: "Alpha repo rules.",
+    warning: "Alpha is behind origin",
+    autoStashes: [{ ref: "stash@{0}", message: "WIP alpha" }],
+    guidelines: {
+      prChecks: ["bun run lint"],
+      mergeChecks: ["CI green"],
+      allowMerge: false,
+      review: ["Check the db boundary"],
+    },
+  },
+  slackContext: { channelId: "C0ALPHA", threadTs: "111.222" },
+  requestedBy: {
+    name: "Taras",
+    role: "CTO",
+    notes: "Lead with the answer.",
+    comms: { verbosity: "terse" },
+  },
+  cwdWarning: 'Note: The task requested working directory "/nope" but it does not exist.',
+};
+
+const sessionB: TaskSessionContext = {
+  repoContext: { clonePath: "/workspace/personal/repos/beta", guidelines: null },
+  requestedBy: { name: "Eze", role: "CEO", comms: { language: "Spanish" } },
+};
+
+// A heartbeat: no repository, no requester, no working directory.
+const sessionC: TaskSessionContext = {};
+
+async function build(args: BasePromptArgs, context: TaskSessionContext, taskPrompt: string) {
+  return buildTaskSessionPrompts({
+    basePromptArgs: args,
+    additionalSystemPrompt: "Operator note: be careful.",
+    taskPrompt,
+    context,
+  });
+}
+
+describe("buildTaskSessionPrompts", () => {
+  for (const provider of ["claude", "codex", "opencode", "pi"] as const) {
+    test(`${provider}: the system prompt is byte-identical across tasks, requesters and repos`, async () => {
+      const a = await build(agentArgs(provider), sessionA, "/work-on-task aaa\n\nTask: alpha");
+      const b = await build(agentArgs(provider), sessionB, "/work-on-task bbb\n\nTask: beta");
+      const c = await build(agentArgs(provider), sessionC, "/work-on-task ccc\n\nTask: heartbeat");
+
+      expect(a.systemPrompt).toBe(b.systemPrompt);
+      expect(a.systemPrompt).toBe(c.systemPrompt);
+      expect(a.systemPrompt).toEndWith("\n\nOperator note: be careful.");
+      for (const perTask of ["## Repository", "## Requester Profile", "Taras", "Eze", "/nope"]) {
+        expect(a.systemPrompt).not.toContain(perTask);
+      }
+    });
+  }
+
+  test("a scripts-only worker keeps the system prompt stable across Slack and non-Slack tasks", async () => {
+    const keys = ["SLACK_DISABLE", "SLACK_BOT_TOKEN", "SLACK_APP_TOKEN"] as const;
+    const saved = keys.map((key) => [key, process.env[key]] as const);
+    delete process.env.SLACK_DISABLE;
+    process.env.SLACK_BOT_TOKEN = "xoxb-test-token";
+    process.env.SLACK_APP_TOKEN = "xapp-test-token";
+    try {
+      const args = agentArgs("claude", { scriptsOnly: true });
+      const a = await build(args, sessionA, "task a");
+      const c = await build(args, sessionC, "task c");
+      expect(a.systemPrompt).toBe(c.systemPrompt);
+      expect(a.systemPrompt).not.toContain("C0ALPHA");
+      expect(a.prompt).toContain("## Slack (scripts-only)");
+      expect(a.prompt).toContain("C0ALPHA");
+    } finally {
+      for (const [key, value] of saved) {
+        if (value === undefined) delete process.env[key];
+        else process.env[key] = value;
+      }
+    }
+  });
+
+  test("the per-task context reaches the task prompt with the same text, after the task", async () => {
+    const args = agentArgs("opencode");
+    const taskPrompt = "/work-on-task aaa\n\nTask: alpha";
+    const { prompt } = await build(args, sessionA, taskPrompt);
+
+    const repoBlock = await getTaskContextPrompt({ ...args, repoContext: sessionA.repoContext });
+    const profile = await buildRequesterProfilePrompt(sessionA.requestedBy);
+    expect(repoBlock).toContain("## Repository");
+    expect(repoBlock).toContain("Alpha repo rules.");
+    expect(profile).toContain("This task was requested by Taras (CTO).");
+
+    expect(prompt).toStartWith(`${taskPrompt}\n\n`);
+    expect(prompt).toContain(repoBlock);
+    expect(prompt).toContain(profile);
+    expect(prompt).toEndWith(sessionA.cwdWarning ?? "");
+    expect(prompt.indexOf(repoBlock)).toBeLessThan(prompt.indexOf(profile));
+    expect(prompt).not.toMatch(/\n{3,}/);
+  });
+
+  test("a task with no per-task context keeps its prompt unchanged", async () => {
+    const { prompt } = await build(agentArgs("claude"), sessionC, "/work-on-task ccc");
+    expect(prompt).toBe("/work-on-task ccc");
+  });
+});

package/src/tests/task-tool-manifest.test.ts

@@ -27,6 +27,20 @@ describe("task tool manifests", () => {
     ]);
   });
 
+  test("chat-reply only preloads for a task carrying a chat-sdk contextKey", () => {
+    const manifest = parseTaskToolManifest('{"taskTypes":{"review":["chat-reply","script-run"]}}');
+    expect(selectTaskTools(manifest, { taskType: "review" })).toEqual(["script-run"]);
+    expect(
+      selectTaskTools(manifest, { taskType: "review", contextKey: "task:slack:C123:1700.1" }),
+    ).toEqual(["script-run"]);
+    expect(
+      selectTaskTools(manifest, {
+        taskType: "review",
+        contextKey: "task:chat-sdk:telegram:555001",
+      }),
+    ).toEqual(["chat-reply", "script-run"]);
+  });
+
   test("config writes reject unknown tools, invalid shapes, and oversized selections", () => {
     for (const value of [
       "not json",

package/src/tests/task-tools-ctx.test.ts

@@ -137,8 +137,10 @@ describe("task tool ctx", () => {
     });
     await updateAgentProfile(lead.id, { capabilities: ["merge"] });
     await updateAgentProfile(underprivilegedLead.id, { capabilities: ["typescript"] });
+    // The sender created the parent, so it may continue it (task.parent.attach).
     const parent = await createTaskExtended("privileged parent", {
       agentId: lead.id,
+      creatorAgentId: sender.id,
       routingAffinity: { capabilities: ["merge"], leadOnly: true },
     });
 

package/src/tests/tool-annotations.test.ts

@@ -116,7 +116,6 @@ describe("Tool Annotations & Classification", () => {
       "delete-config",
       "delete-workflow",
       "delete-page",
-      "unregister-service",
       "slack-delete",
       "slack-archive-channel",
     ];
@@ -135,7 +134,6 @@ describe("Tool Annotations & Classification", () => {
       "get-tasks",
       "get-config",
       "list-channels",
-      "list-services",
       "list-schedules",
       "list-config",
       "memory-get",
@@ -350,7 +348,7 @@ describe("Tool Annotations & Classification", () => {
     expect(missing).toEqual([]);
   });
 
-  test("service tools are all deferred", () => {
+  test("the removed PM2 service registry tools stay gone", () => {
     const serviceTools = [
       "register-service",
       "unregister-service",
@@ -358,7 +356,8 @@ describe("Tool Annotations & Classification", () => {
       "update-service-status",
     ];
     for (const tool of serviceTools) {
-      expect(DEFERRED_TOOLS.has(tool)).toBe(true);
+      expect(DEFERRED_TOOLS.has(tool)).toBe(false);
+      expect(tools[tool]).toBeUndefined();
     }
   });
 
@@ -376,9 +375,10 @@ describe("Tool Annotations & Classification", () => {
     // We expect all tools to be registered when all capabilities are enabled
     // (this suite forces ALL_CAPABILITIES, including default-disabled ones).
     // Includes 11 skill tools, 7 MCP server tools, reusable script tools, and the
-    // native Kapso/WhatsApp tools (register/unregister number + send/reply message).
+    // native Kapso/WhatsApp tools (register/unregister number + send/reply message),
+    // and the six Chat SDK tools (chat-* + register/unregister-chat-channel).
     expect(count).toBeGreaterThanOrEqual(45);
-    expect(count).toBeLessThanOrEqual(157);
+    expect(count).toBeLessThanOrEqual(163);
   });
 
   test("core tools are fewer than deferred tools", () => {

package/src/tests/ui-logs-parser.test.ts

@@ -1154,6 +1154,49 @@ describe("ui logs parser", () => {
     ]);
   });
 
+  test("keeps a Claude sub-agent's parent_tool_use_id on its messages", () => {
+    const messages = parseSessionLogs([
+      log("spawn", "claude", 1, {
+        type: "assistant",
+        message: {
+          role: "assistant",
+          content: [{ type: "tool_use", id: "toolu_agent_1", name: "Agent", input: {} }],
+        },
+      }),
+      log("child-call", "claude", 2, {
+        type: "assistant",
+        parent_tool_use_id: "toolu_agent_1",
+        message: {
+          role: "assistant",
+          content: [
+            { type: "thinking", thinking: "Look at the fixtures." },
+            { type: "tool_use", id: "toolu_read_1", name: "Read", input: { file_path: "a.ts" } },
+          ],
+        },
+      }),
+      log("child-result", "claude", 3, {
+        type: "user",
+        parent_tool_use_id: "toolu_agent_1",
+        message: {
+          role: "user",
+          content: [{ type: "tool_result", tool_use_id: "toolu_read_1", content: "ok" }],
+        },
+      }),
+      log("main-text", "claude", 4, {
+        type: "assistant",
+        parent_tool_use_id: null,
+        message: { role: "assistant", content: [{ type: "text", text: "Done." }] },
+      }),
+    ]);
+
+    expect(messages.map((m) => [m.id, m.parentToolUseId])).toEqual([
+      ["spawn", undefined],
+      ["child-call", "toolu_agent_1"],
+      ["child-result", "toolu_agent_1"],
+      ["main-text", undefined],
+    ]);
+  });
+
   test("extracts a completed Claude foreground Agent run from its paired result", () => {
     const runs = extractSubagentRuns([
       log("spawn", "claude", 1, {

package/src/tests/used-by-route.test.ts

@@ -61,10 +61,14 @@ const configValue = async (key: string) =>
 
 describe("POST /api/used-by", () => {
   const originalFetch = globalThis.fetch;
+  const savedEnvWebsite = process.env.SWARM_ORG_WEBSITE;
+  const savedEnvName = process.env.SWARM_ORG_NAME;
   let proxied: Array<{ url: string; body: Record<string, unknown> }>;
   let proxyStatus: number;
 
   beforeAll(async () => {
+    delete process.env.SWARM_ORG_WEBSITE;
+    delete process.env.SWARM_ORG_NAME;
     await removeDbFiles();
     initDb(TEST_DB_PATH);
     await createAgent({ id: WORKER_ID, name: "Worker", isLead: false, status: "idle" });
@@ -75,6 +79,8 @@ describe("POST /api/used-by", () => {
   });
 
   afterAll(async () => {
+    if (savedEnvWebsite !== undefined) process.env.SWARM_ORG_WEBSITE = savedEnvWebsite;
+    if (savedEnvName !== undefined) process.env.SWARM_ORG_NAME = savedEnvName;
     globalThis.fetch = originalFetch;
     closeDb();
     await removeDbFiles();

package/src/tests/vercel-ai-gateway.test.ts

@@ -0,0 +1,149 @@
+/**
+ * Vercel AI Gateway (`vercel/<vendor>/<model>`) on pi and opencode: the full
+ * chat catalog, and the one endpoint no env var or hand-written block can move.
+ */
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  isAgentChatModel,
+  OPENAI_COMPATIBLE_PROVIDERS,
+  openAICompatibleBaseUrlVars,
+  providerBaseUrl,
+  providerForModel,
+  withRegistryCatalogSections,
+} from "@desplega/model-catalog";
+import { buildCatalogEntries } from "../be/model-catalog-store";
+import { isKnownCatalogModel } from "../be/model-validation";
+import { buildModelsCatalog } from "../be/models-catalog";
+import { loadModelsDevCache, type ModelsDevCache } from "../be/modelsdev-cache";
+import snapshot from "../be/modelsdev-cache.json";
+import { applyProviderKeySplice, type OpencodeConfig } from "../providers/opencode-adapter";
+import { customProviderModelsBlock, writeSessionModelsJson } from "../providers/pi-mono-adapter";
+
+const VERCEL = OPENAI_COMPATIBLE_PROVIDERS.vercel;
+const ENDPOINT = "https://ai-gateway.vercel.sh/v1";
+const WRONG = "https://ai-gateway.vercel.sh";
+const raw = snapshot as unknown as ModelsDevCache;
+const rawVercel = (raw.vercel?.models ?? {}) as Record<
+  string,
+  Parameters<typeof isAgentChatModel>[0]
+>;
+const chatIds = Object.keys(rawVercel).filter((id) => isAgentChatModel(rawVercel[id] ?? {}));
+
+describe("Vercel AI Gateway catalog", () => {
+  test("the snapshot carries non-chat rows, so the filter is exercised", () => {
+    expect(rawVercel["voyage/voyage-code-3"]).toBeDefined();
+    expect(chatIds.length).toBeGreaterThan(200);
+    expect(chatIds.length).toBeLessThan(Object.keys(rawVercel).length);
+  });
+
+  test("pi lists every AI Gateway chat model, and no embedding or video model", () => {
+    const block = customProviderModelsBlock(VERCEL);
+    const ids = block.models.map((m) => m.id as string);
+    expect(ids.sort()).toEqual([...chatIds].sort());
+    expect(ids).toContain("zai/glm-5.3");
+    expect(ids).toContain("moonshotai/kimi-k3");
+    expect(ids).toContain("anthropic/claude-sonnet-4.6");
+    expect(ids).not.toContain("voyage/voyage-code-3");
+    expect(ids).not.toContain("klingai/kling-v3.0-t2v");
+    const glm = block.models.find((m) => m.id === "zai/glm-5.3");
+    expect(glm).toMatchObject({ contextWindow: 1000000, maxTokens: 1000000, reasoning: true });
+    expect(block).toMatchObject({
+      baseUrl: ENDPOINT,
+      api: "openai-completions",
+      apiKey: "$AI_GATEWAY_API_KEY",
+    });
+  });
+
+  test("picker, live and validation catalogs drop non-chat Vercel rows", () => {
+    const merged = withRegistryCatalogSections(raw);
+    expect(Object.keys(merged.vercel?.models ?? {}).sort()).toEqual([...chatIds].sort());
+    // OpenRouter is not a registry provider and keeps its full section.
+    expect(Object.keys(merged.openrouter?.models ?? {}).length).toBe(
+      Object.keys(raw.openrouter?.models ?? {}).length,
+    );
+
+    const live = buildCatalogEntries(raw, 0).filter((e) => e.provider === "vercel");
+    expect(live.map((e) => e.modelId).sort()).toEqual([...chatIds].sort());
+
+    const cache = loadModelsDevCache();
+    if (!cache) throw new Error("snapshot missing");
+    const catalog = buildModelsCatalog(cache) as Parameters<typeof isKnownCatalogModel>[1];
+    expect(isKnownCatalogModel("vercel/zai/glm-5.3", catalog)).toBe(true);
+    expect(isKnownCatalogModel("vercel/anthropic/claude-sonnet-4.6", catalog)).toBe(true);
+    expect(isKnownCatalogModel("vercel/voyage/voyage-code-3", catalog)).toBe(false);
+    expect(providerForModel("vercel/moonshotai/kimi-k3")?.id).toBe("vercel");
+  });
+});
+
+describe("Vercel AI Gateway endpoint is fixed", () => {
+  const dirs: string[] = [];
+  afterEach(async () => {
+    await Promise.all(dirs.splice(0).map((d) => rm(d, { recursive: true, force: true })));
+  });
+
+  test("VERCEL_BASE_URL is never read or forwarded", () => {
+    expect(VERCEL.baseUrl).toBe(ENDPOINT);
+    expect(providerBaseUrl(VERCEL, { VERCEL_BASE_URL: WRONG })).toBe(ENDPOINT);
+    expect(openAICompatibleBaseUrlVars()).not.toContain("VERCEL_BASE_URL");
+    expect(openAICompatibleBaseUrlVars()).toContain("NAN_BASE_URL");
+  });
+
+  test("opencode gets the key and no baseURL, even over a configured one", () => {
+    const key = crypto.randomUUID();
+    const config: OpencodeConfig = {
+      model: "vercel/zai/glm-5.3",
+      provider: { vercel: { options: { baseURL: WRONG } } },
+    };
+    const picked = applyProviderKeySplice(config, config.model, {
+      AI_GATEWAY_API_KEY: key,
+      VERCEL_BASE_URL: WRONG,
+    });
+    expect(picked?.key).toBe(key);
+    expect(config.provider?.vercel).toEqual({ env: [], options: { apiKey: key } });
+  });
+
+  test("pi gets the Chat Completions endpoint over VERCEL_BASE_URL and a hand-written block", async () => {
+    const agentDir = await mkdtemp(join(tmpdir(), "pi-vercel-"));
+    dirs.push(agentDir);
+    await Bun.write(
+      join(agentDir, "models.json"),
+      JSON.stringify({
+        providers: { vercel: { baseUrl: WRONG, api: "anthropic-messages", headers: { a: "b" } } },
+      }),
+    );
+    const env = { AI_GATEWAY_API_KEY: "k", VERCEL_BASE_URL: WRONG };
+    const session = await writeSessionModelsJson(agentDir, env, "vercel/vendor/brand-new-model");
+    try {
+      expect(session.modelsPath).toBeDefined();
+      const written = await Bun.file(session.modelsPath as string).json();
+      const block = written.providers.vercel;
+      expect(block.baseUrl).toBe(ENDPOINT);
+      expect(block.api).toBe("openai-completions");
+      expect(block.headers).toEqual({ a: "b" });
+      const ids = (block.models as { id: string }[]).map((m) => m.id);
+      expect(ids).toContain("zai/glm-5.3");
+      // An id the catalog does not know yet still resolves (bare entry).
+      expect(ids).toContain("vendor/brand-new-model");
+    } finally {
+      await session.dispose();
+    }
+  });
+
+  test("pi without a shared block also lands on the endpoint", async () => {
+    const agentDir = await mkdtemp(join(tmpdir(), "pi-vercel-"));
+    dirs.push(agentDir);
+    const session = await writeSessionModelsJson(agentDir, {
+      AI_GATEWAY_API_KEY: "k",
+      VERCEL_BASE_URL: WRONG,
+    });
+    try {
+      const written = await Bun.file(session.modelsPath as string).json();
+      expect(written.providers.vercel.baseUrl).toBe(ENDPOINT);
+    } finally {
+      await session.dispose();
+    }
+  });
+});

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

@@ -77,6 +77,67 @@ describe("resolveWorkflowLlmConfig", () => {
     expect(config.model).toBe("gpt-5.4");
   });
 
+  test("routes a registry-provider model to that provider, not OpenRouter", async () => {
+    const config = await resolveWorkflowLlmConfig("nan/qwen3.8-flash", {
+      OPENROUTER_API_KEY: "sk-or-test",
+      NAN_API_KEY: "nan-test",
+    });
+
+    expect(config).toEqual({
+      apiKey: "nan-test",
+      baseURL: "https://api.nan.builders/v1",
+      headers: {},
+      model: "qwen3.8-flash",
+    });
+  });
+
+  test("reads a registry provider's alias key and base URL override", async () => {
+    const config = await resolveWorkflowLlmConfig("nan/deepseek-v4-flash", {
+      HELMCODE_API_NAN: "nan-alias",
+      NAN_BASE_URL: "https://nan.example.test/v1/",
+    });
+
+    expect(config.apiKey).toBe("nan-alias");
+    expect(config.baseURL).toBe("https://nan.example.test/v1");
+    expect(config.model).toBe("deepseek-v4-flash");
+  });
+
+  test("hands the SDK one key from a canonical NaN key pool", async () => {
+    const pool = ["nan-pool-a", "nan-pool-b", "nan-pool-c"];
+    for (let i = 0; i < 20; i++) {
+      const config = await resolveWorkflowLlmConfig("nan/qwen3.8-flash", {
+        NAN_API_KEY: ` ${pool.join(", ")} `,
+      });
+      expect(pool).toContain(config.apiKey);
+    }
+  });
+
+  test("hands the SDK one key from an alias NaN key pool", async () => {
+    const pool = ["nan-alias-a", "nan-alias-b"];
+    for (let i = 0; i < 20; i++) {
+      const config = await resolveWorkflowLlmConfig("nan/deepseek-v4-flash", {
+        HELMCODE_API_NAN: pool.join(","),
+      });
+      expect(pool).toContain(config.apiKey);
+    }
+  });
+
+  test("fails a registry-provider model without its key instead of falling back to OpenRouter", async () => {
+    await expect(
+      resolveWorkflowLlmConfig("nan/qwen3.8-flash", { OPENROUTER_API_KEY: "sk-or-test" }),
+    ).rejects.toThrow("No NaN credential found for nan/qwen3.8-flash. Set NAN_API_KEY.");
+  });
+
+  test("keeps OpenRouter vendor ids on OpenRouter", async () => {
+    const config = await resolveWorkflowLlmConfig("deepseek/deepseek-v4.1-flash", {
+      OPENROUTER_API_KEY: "sk-or-test",
+      NAN_API_KEY: "nan-test",
+    });
+
+    expect(config.apiKey).toBe("sk-or-test");
+    expect(config.model).toBe("deepseek/deepseek-v4.1-flash");
+  });
+
   test("rejects credential kinds without an OpenAI-compatible endpoint", async () => {
     await expect(
       resolveWorkflowLlmConfig(undefined, { ANTHROPIC_API_KEY: "example-sk-ant-test" }),