@vellumai/assistant 0.12.1 → 0.12.2-staging.2

package/src/config/__tests__/platform-identity.test.ts

@@ -0,0 +1,255 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import {
+  getPlatformBaseUrl,
+  setPlatformAssistantId,
+  setPlatformBaseUrl,
+  setPlatformOrganizationId,
+  setPlatformUserId,
+} from "../env.js";
+
+const actualSecureKeys = await import("../../security/secure-keys.js");
+mock.module("../../security/secure-keys.js", () => ({
+  ...actualSecureKeys,
+  getSecureKeyAsync: async () => undefined,
+}));
+
+const {
+  _resetPlatformIdentityEnsureForTests,
+  fetchPlatformIdentityIds,
+  PLATFORM_IDENTITY_VALIDATE_PATH,
+  resolvePlatformAssistantId,
+} = await import("../platform-identity.js");
+
+const BASE_URL = "https://platform.vellum.ai";
+const ASSISTANT_ID = "11111111-2222-4333-8444-555555555555";
+const ORG_ID = "22222222-3333-4444-8555-666666666666";
+const USER_ID = "33333333-4444-4555-8666-777777777777";
+
+describe("fetchPlatformIdentityIds", () => {
+  const originalFetch = globalThis.fetch;
+  const fetchCalls: Array<{ url: string; init?: RequestInit }> = [];
+  let fetchImpl: (
+    input: RequestInfo | URL,
+    init?: RequestInit,
+  ) => Promise<Response> = async () =>
+    new Response("not found", { status: 404 });
+
+  beforeEach(() => {
+    fetchCalls.length = 0;
+    fetchImpl = async () => new Response("not found", { status: 404 });
+    globalThis.fetch = (async (
+      input: RequestInfo | URL,
+      init?: RequestInit,
+    ) => {
+      const url = typeof input === "string" ? input : input.toString();
+      fetchCalls.push({ url, init });
+      return fetchImpl(input, init);
+    }) as unknown as typeof fetch;
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+  });
+
+  test("returns the three ids from a successful validate response", async () => {
+    fetchImpl = async () =>
+      new Response(
+        JSON.stringify({
+          assistant_id: ASSISTANT_ID,
+          organization_id: ORG_ID,
+          user_id: USER_ID,
+          name: "Example Assistant",
+        }),
+        { status: 200 },
+      );
+
+    await expect(
+      fetchPlatformIdentityIds(BASE_URL, "assistant-key"),
+    ).resolves.toEqual({
+      assistantId: ASSISTANT_ID,
+      organizationId: ORG_ID,
+      userId: USER_ID,
+    });
+    expect(fetchCalls[0]?.url).toBe(
+      `${BASE_URL}${PLATFORM_IDENTITY_VALIDATE_PATH}`,
+    );
+    expect(fetchCalls[0]?.init?.method).toBe("POST");
+    const headers = new Headers(fetchCalls[0]?.init?.headers);
+    expect(headers.get("Authorization")).toBe("Api-Key assistant-key");
+  });
+
+  test("strips a trailing slash from the base URL", async () => {
+    fetchImpl = async () =>
+      new Response(
+        JSON.stringify({
+          assistant_id: ASSISTANT_ID,
+          organization_id: ORG_ID,
+          user_id: USER_ID,
+        }),
+        { status: 200 },
+      );
+
+    await fetchPlatformIdentityIds(`${BASE_URL}/`, "assistant-key");
+    expect(fetchCalls[0]?.url).toBe(
+      `${BASE_URL}${PLATFORM_IDENTITY_VALIDATE_PATH}`,
+    );
+  });
+
+  test("returns null on 401 without throwing", async () => {
+    fetchImpl = async () => new Response("no", { status: 401 });
+    await expect(
+      fetchPlatformIdentityIds(BASE_URL, "assistant-key"),
+    ).resolves.toBeNull();
+  });
+
+  test("returns null on a network error without throwing", async () => {
+    fetchImpl = async () => {
+      throw new Error("network down");
+    };
+    await expect(
+      fetchPlatformIdentityIds(BASE_URL, "assistant-key"),
+    ).resolves.toBeNull();
+  });
+});
+
+describe("resolvePlatformAssistantId", () => {
+  const originalFetch = globalThis.fetch;
+  const originalAssistantApiKeyEnv = process.env.ASSISTANT_API_KEY;
+  const fetchCalls: Array<{ url: string; init?: RequestInit }> = [];
+  let fetchImpl: (
+    input: RequestInfo | URL,
+    init?: RequestInit,
+  ) => Promise<Response> = async () =>
+    new Response("not found", { status: 404 });
+
+  beforeEach(() => {
+    fetchCalls.length = 0;
+    fetchImpl = async () => new Response("not found", { status: 404 });
+    globalThis.fetch = (async (
+      input: RequestInfo | URL,
+      init?: RequestInit,
+    ) => {
+      const url = typeof input === "string" ? input : input.toString();
+      fetchCalls.push({ url, init });
+      return fetchImpl(input, init);
+    }) as unknown as typeof fetch;
+    delete process.env.ASSISTANT_API_KEY;
+    setPlatformBaseUrl(undefined);
+    setPlatformAssistantId(undefined);
+    setPlatformOrganizationId(undefined);
+    setPlatformUserId(undefined);
+    _resetPlatformIdentityEnsureForTests();
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+    if (originalAssistantApiKeyEnv === undefined) {
+      delete process.env.ASSISTANT_API_KEY;
+    } else {
+      process.env.ASSISTANT_API_KEY = originalAssistantApiKeyEnv;
+    }
+    setPlatformBaseUrl(undefined);
+    setPlatformAssistantId(undefined);
+    setPlatformOrganizationId(undefined);
+    setPlatformUserId(undefined);
+    _resetPlatformIdentityEnsureForTests();
+  });
+
+  test("returns the in-memory override without calling validate", async () => {
+    setPlatformAssistantId(ASSISTANT_ID);
+    process.env.ASSISTANT_API_KEY = "assistant-key";
+    await expect(resolvePlatformAssistantId()).resolves.toBe(ASSISTANT_ID);
+    expect(fetchCalls).toHaveLength(0);
+  });
+
+  test("returns empty when the in-memory override is unset and there is no API key", async () => {
+    await expect(resolvePlatformAssistantId()).resolves.toBe("");
+    expect(fetchCalls).toHaveLength(0);
+  });
+
+  test("loads ids from validate when the in-memory override is empty", async () => {
+    process.env.ASSISTANT_API_KEY = "assistant-key";
+    setPlatformBaseUrl(BASE_URL);
+    fetchImpl = async () =>
+      new Response(
+        JSON.stringify({
+          assistant_id: ASSISTANT_ID,
+          organization_id: ORG_ID,
+          user_id: USER_ID,
+        }),
+        { status: 200 },
+      );
+
+    await expect(resolvePlatformAssistantId()).resolves.toBe(ASSISTANT_ID);
+    expect(fetchCalls).toHaveLength(1);
+    expect(fetchCalls[0]?.url).toBe(
+      `${getPlatformBaseUrl().replace(/\/+$/, "")}${PLATFORM_IDENTITY_VALIDATE_PATH}`,
+    );
+  });
+
+  test("does not retry validate during the cooldown after a failure", async () => {
+    process.env.ASSISTANT_API_KEY = "assistant-key";
+    setPlatformBaseUrl(BASE_URL);
+    fetchImpl = async () => new Response("down", { status: 503 });
+
+    await expect(resolvePlatformAssistantId()).resolves.toBe("");
+    await expect(resolvePlatformAssistantId()).resolves.toBe("");
+    expect(fetchCalls).toHaveLength(1);
+  });
+
+  test("retries validate after a failed attempt once the cooldown is cleared", async () => {
+    process.env.ASSISTANT_API_KEY = "assistant-key";
+    setPlatformBaseUrl(BASE_URL);
+    fetchImpl = async () => new Response("down", { status: 503 });
+
+    await expect(resolvePlatformAssistantId()).resolves.toBe("");
+    _resetPlatformIdentityEnsureForTests();
+    fetchImpl = async () =>
+      new Response(
+        JSON.stringify({
+          assistant_id: ASSISTANT_ID,
+          organization_id: ORG_ID,
+          user_id: USER_ID,
+        }),
+        { status: 200 },
+      );
+
+    await expect(resolvePlatformAssistantId()).resolves.toBe(ASSISTANT_ID);
+    expect(fetchCalls).toHaveLength(2);
+  });
+
+  test("concurrent resolves share one in-flight validate", async () => {
+    process.env.ASSISTANT_API_KEY = "assistant-key";
+    setPlatformBaseUrl(BASE_URL);
+    let release!: (value: Response) => void;
+    let notifyFetchStarted!: () => void;
+    const fetchStarted = new Promise<void>((resolve) => {
+      notifyFetchStarted = resolve;
+    });
+    fetchImpl = () => {
+      notifyFetchStarted();
+      return new Promise<Response>((resolve) => {
+        release = resolve;
+      });
+    };
+
+    const first = resolvePlatformAssistantId();
+    const second = resolvePlatformAssistantId();
+    await fetchStarted;
+    expect(fetchCalls).toHaveLength(1);
+    release(
+      new Response(
+        JSON.stringify({
+          assistant_id: ASSISTANT_ID,
+          organization_id: ORG_ID,
+          user_id: USER_ID,
+        }),
+        { status: 200 },
+      ),
+    );
+    await expect(first).resolves.toBe(ASSISTANT_ID);
+    await expect(second).resolves.toBe(ASSISTANT_ID);
+    expect(fetchCalls).toHaveLength(1);
+  });
+});

package/src/config/__tests__/platform-rehydration.test.ts

@@ -27,6 +27,8 @@ const {
   setPlatformOrganizationId,
   setPlatformUserId,
 } = await import("../env.js");
+const { _resetPlatformIdentityEnsureForTests } =
+  await import("../platform-identity.js");
 const { rehydratePlatformCredentials } =
   await import("../platform-rehydration.js");
 
@@ -39,23 +41,44 @@ describe("rehydratePlatformCredentials", () => {
   const originalPlatformUrlEnv = process.env.VELLUM_PLATFORM_URL;
   const originalOrgEnv = process.env.PLATFORM_ORGANIZATION_ID;
   const originalUserEnv = process.env.PLATFORM_USER_ID;
+  const originalAssistantApiKeyEnv = process.env.ASSISTANT_API_KEY;
+  const originalFetch = globalThis.fetch;
+  const fetchCalls: Array<{ url: string; init?: RequestInit }> = [];
+  let fetchImpl: (
+    input: RequestInfo | URL,
+    init?: RequestInit,
+  ) => Promise<Response> = async () =>
+    new Response("not found", { status: 404 });
 
   beforeEach(() => {
     mockSecureKeys = {};
     throwForKey = undefined;
+    fetchCalls.length = 0;
+    fetchImpl = async () => new Response("not found", { status: 404 });
+    globalThis.fetch = (async (
+      input: RequestInfo | URL,
+      init?: RequestInit,
+    ) => {
+      const url = typeof input === "string" ? input : input.toString();
+      fetchCalls.push({ url, init });
+      return fetchImpl(input, init);
+    }) as unknown as typeof fetch;
     // Env vars take precedence over the rehydrated overrides for some fields;
     // clear them so the credential-store values are what we observe.
     delete process.env.VELLUM_PLATFORM_URL;
     delete process.env.PLATFORM_ORGANIZATION_ID;
     delete process.env.PLATFORM_USER_ID;
+    delete process.env.ASSISTANT_API_KEY;
     // Reset in-memory overrides between tests.
     setPlatformBaseUrl(undefined);
     setPlatformAssistantId(undefined);
     setPlatformOrganizationId(undefined);
     setPlatformUserId(undefined);
+    _resetPlatformIdentityEnsureForTests();
   });
 
   afterEach(() => {
+    globalThis.fetch = originalFetch;
     if (originalPlatformUrlEnv === undefined) {
       delete process.env.VELLUM_PLATFORM_URL;
     } else {
@@ -71,13 +94,18 @@ describe("rehydratePlatformCredentials", () => {
     } else {
       process.env.PLATFORM_USER_ID = originalUserEnv;
     }
+    if (originalAssistantApiKeyEnv === undefined) {
+      delete process.env.ASSISTANT_API_KEY;
+    } else {
+      process.env.ASSISTANT_API_KEY = originalAssistantApiKeyEnv;
+    }
     setPlatformBaseUrl(undefined);
     setPlatformAssistantId(undefined);
     setPlatformOrganizationId(undefined);
     setPlatformUserId(undefined);
   });
 
-  test("rehydrates base URL and all platform IDs from the credential store", async () => {
+  test("rehydrates the platform base URL from the credential store", async () => {
     mockSecureKeys[credentialKey("vellum", "platform_base_url")] = PROD_URL;
     mockSecureKeys[credentialKey("vellum", "platform_assistant_id")] =
       ASSISTANT_ID;
@@ -88,21 +116,18 @@ describe("rehydratePlatformCredentials", () => {
     await rehydratePlatformCredentials();
 
     expect(getPlatformBaseUrl()).toBe(PROD_URL);
-    expect(getPlatformAssistantId()).toBe(ASSISTANT_ID);
-    expect(getPlatformOrganizationId()).toBe(ORG_ID);
-    expect(getPlatformUserId()).toBe(USER_ID);
+    expect(getPlatformAssistantId()).toBe("");
+    expect(getPlatformOrganizationId()).toBe("");
+    expect(getPlatformUserId()).toBe("");
   });
 
   test("trims stored values before applying them", async () => {
     mockSecureKeys[credentialKey("vellum", "platform_base_url")] =
       `  ${PROD_URL}  `;
-    mockSecureKeys[credentialKey("vellum", "platform_assistant_id")] =
-      `\n${ASSISTANT_ID}\n`;
 
     await rehydratePlatformCredentials();
 
     expect(getPlatformBaseUrl()).toBe(PROD_URL);
-    expect(getPlatformAssistantId()).toBe(ASSISTANT_ID);
   });
 
   test("leaves overrides untouched when nothing is stored", async () => {
@@ -113,13 +138,78 @@ describe("rehydratePlatformCredentials", () => {
     expect(getPlatformUserId()).toBe("");
   });
 
-  test("a per-field read failure does not block the remaining fields", async () => {
+  test("a credential-store read failure does not throw", async () => {
     throwForKey = credentialKey("vellum", "platform_base_url");
+
+    await expect(rehydratePlatformCredentials()).resolves.toBeUndefined();
+    expect(getPlatformAssistantId()).toBe("");
+  });
+
+  test("trades the assistant API key for ids via platform validate", async () => {
+    mockSecureKeys[credentialKey("vellum", "platform_base_url")] = PROD_URL;
+    mockSecureKeys[credentialKey("vellum", "assistant_api_key")] =
+      "assistant-key";
+    fetchImpl = async () =>
+      new Response(
+        JSON.stringify({
+          assistant_id: ASSISTANT_ID,
+          organization_id: ORG_ID,
+          user_id: USER_ID,
+        }),
+        { status: 200 },
+      );
+
+    await rehydratePlatformCredentials();
+
+    expect(fetchCalls).toHaveLength(1);
+    expect(fetchCalls[0]?.url).toBe(
+      `${PROD_URL}/v1/internal/assistants/validate/`,
+    );
+    const headers = new Headers(fetchCalls[0]?.init?.headers);
+    expect(headers.get("Authorization")).toBe("Api-Key assistant-key");
+    expect(getPlatformAssistantId()).toBe(ASSISTANT_ID);
+    expect(getPlatformOrganizationId()).toBe(ORG_ID);
+    expect(getPlatformUserId()).toBe(USER_ID);
+  });
+
+  test("validate ids are used when the vault also has a copy", async () => {
+    mockSecureKeys[credentialKey("vellum", "platform_base_url")] = PROD_URL;
+    mockSecureKeys[credentialKey("vellum", "assistant_api_key")] =
+      "assistant-key";
     mockSecureKeys[credentialKey("vellum", "platform_assistant_id")] =
-      ASSISTANT_ID;
+      "asst-from-vault";
+    fetchImpl = async () =>
+      new Response(
+        JSON.stringify({
+          assistant_id: ASSISTANT_ID,
+          organization_id: ORG_ID,
+          user_id: USER_ID,
+        }),
+        { status: 200 },
+      );
 
     await rehydratePlatformCredentials();
 
     expect(getPlatformAssistantId()).toBe(ASSISTANT_ID);
   });
+
+  test("does not populate ids from the vault when validate is unreachable", async () => {
+    mockSecureKeys[credentialKey("vellum", "platform_base_url")] = PROD_URL;
+    mockSecureKeys[credentialKey("vellum", "assistant_api_key")] =
+      "assistant-key";
+    mockSecureKeys[credentialKey("vellum", "platform_assistant_id")] =
+      ASSISTANT_ID;
+    mockSecureKeys[credentialKey("vellum", "platform_organization_id")] =
+      ORG_ID;
+    mockSecureKeys[credentialKey("vellum", "platform_user_id")] = USER_ID;
+    fetchImpl = async () => {
+      throw new Error("network down");
+    };
+
+    await rehydratePlatformCredentials();
+
+    expect(getPlatformAssistantId()).toBe("");
+    expect(getPlatformOrganizationId()).toBe("");
+    expect(getPlatformUserId()).toBe("");
+  });
 });

package/src/config/acp-agent-write.ts

@@ -0,0 +1,43 @@
+/**
+ * Raw-config helper shared by the config PATCH and SET routes, the paths that
+ * write a coding agent's entry.
+ */
+
+import { isPlainObject } from "../util/object.js";
+
+/**
+ * Clearing a leaf of a coding agent's entry is a write of `null` - a PATCH of
+ * `{ acp: { agents: { <id>: { model: null } } } }` or a
+ * `config set acp.agents.<id>.model null`. The deep-merge assigns that literal
+ * `null` because the stored value is a scalar, and a SET writes it verbatim by
+ * design. Both `command` and `model` are optional strings in `AcpConfigSchema`,
+ * so a persisted `null` makes every later `loadConfig()` warn and take its
+ * salvage path, dropping the whole `acp` section with the agents defined in it.
+ * Clearing means removing the key, so drop it here on every write path.
+ *
+ * A cleared `command` then reads as an omitted one: a bundled id inherits the
+ * profile's command, and an id that has no profile fails the agents refinement
+ * with a message naming the id, which tells the user more than zod's "expected
+ * string, received null".
+ */
+export function scrubNulledAcpAgentLeaves(raw: Record<string, unknown>): void {
+  const acp = raw.acp;
+  if (!isPlainObject(acp)) {
+    return;
+  }
+  const agents = acp.agents;
+  if (!isPlainObject(agents)) {
+    return;
+  }
+  for (const entry of Object.values(agents)) {
+    if (!isPlainObject(entry)) {
+      continue;
+    }
+    if (entry.command === null) {
+      delete entry.command;
+    }
+    if (entry.model === null) {
+      delete entry.model;
+    }
+  }
+}

package/src/config/acp-defaults.test.ts

@@ -13,15 +13,17 @@ describe("DEFAULT_ACP_AGENT_PROFILES", () => {
     ]);
   });
 
-  test("claude profile uses the @agentclientprotocol adapter binary", () => {
+  test("claude profile uses the @agentclientprotocol adapter binary on opus", () => {
     expect(DEFAULT_ACP_AGENT_PROFILES.claude).toEqual({
       command: "claude-agent-acp",
       args: [],
       description: "Claude Code (via @agentclientprotocol/claude-agent-acp)",
+      model: "opus",
     });
   });
 
   test("codex profile uses the @agentclientprotocol adapter binary", () => {
+    // No model: Codex aliases are its own, so the adapter's default stands.
     expect(DEFAULT_ACP_AGENT_PROFILES.codex).toEqual({
       command: "codex-acp",
       args: [],
@@ -44,11 +46,19 @@ describe("DEFAULT_ACP_AGENT_PROFILES", () => {
 describe("DEFAULT_AGENT_NPM_PACKAGES", () => {
   test("is keyed by command name with the canonical npm package", () => {
     expect(DEFAULT_AGENT_NPM_PACKAGES).toEqual({
-      "claude-agent-acp": "@agentclientprotocol/claude-agent-acp",
-      "codex-acp": "@agentclientprotocol/codex-acp",
+      "claude-agent-acp": "@agentclientprotocol/claude-agent-acp@0.75.1",
+      "codex-acp": "@agentclientprotocol/codex-acp@1.10.0",
     });
   });
 
+  test("every package spec pins an exact version", () => {
+    // A bare name would let a clean install resolve whatever npm calls
+    // latest, which is what the repo's pinning rule exists to prevent.
+    for (const spec of Object.values(DEFAULT_AGENT_NPM_PACKAGES)) {
+      expect(spec).toMatch(/^@?[^@]+@\d+\.\d+\.\d+$/);
+    }
+  });
+
   test("every default profile's command has a matching npm package", () => {
     for (const profile of Object.values(DEFAULT_ACP_AGENT_PROFILES)) {
       expect(DEFAULT_AGENT_NPM_PACKAGES[profile.command]).toBeDefined();

package/src/config/acp-defaults.ts

@@ -1,5 +1,11 @@
 import type { AcpAgentConfig } from "./acp-schema.js";
 
+/**
+ * A bundled profile always names its command; a user entry for the same id
+ * may omit `command` and inherit this one.
+ */
+export type AcpAgentProfile = AcpAgentConfig & { command: string };
+
 // Shared frozen empty args array — these defaults are read by every ACP spawn,
 // so a single accidental `args.push(...)` from one caller would corrupt every
 // subsequent read. Cast through `unknown` because `AcpAgentConfig.args` is
@@ -13,17 +19,22 @@ const FROZEN_EMPTY_ARGS = Object.freeze([] as string[]) as unknown as string[];
  * falls back to this map so common agents like `claude` and `codex` Just Work
  * without requiring per-user config.
  *
- * Keyed by agent id. Deeply frozen — the outer object, each profile, and the
- * `args` arrays — so mutation throws in strict mode rather than silently
+ * A profile's `model` is the model a session of that agent starts on when the
+ * ask names none, and is the rung `acp.agents.<id>.model` fills: a user config
+ * entry that names a model overrides it, one that omits it inherits it.
+ *
+ * Keyed by agent id. Deeply frozen: the outer object, each profile, and the
+ * `args` arrays, so mutation throws in strict mode rather than silently
  * corrupting the shared defaults.
  */
 export const DEFAULT_ACP_AGENT_PROFILES: Readonly<
-  Record<string, AcpAgentConfig>
+  Record<string, AcpAgentProfile>
 > = Object.freeze({
   claude: Object.freeze({
     command: "claude-agent-acp",
     args: FROZEN_EMPTY_ARGS,
     description: "Claude Code (via @agentclientprotocol/claude-agent-acp)",
+    model: "opus",
   }),
   codex: Object.freeze({
     command: "codex-acp",
@@ -33,15 +44,21 @@ export const DEFAULT_ACP_AGENT_PROFILES: Readonly<
 });
 
 /**
- * Single source of truth for adapter binary → npm package name. Automatic
+ * Single source of truth for adapter binary → npm package spec. Automatic
  * installation and the resolver's install hints use this map, so a new
  * adapter only needs one entry here.
  *
  * Keyed by command name (not agent id) so the mapping follows the binary
  * regardless of how a user's config aliases an agent.
+ *
+ * Values carry an exact version, so a clean install lands the adapter version
+ * the daemon was tested against instead of whatever npm calls latest today.
+ * An adapter already on PATH is left alone: installation runs only when
+ * preflight found no binary at all, so this never moves a version the user
+ * installed themselves.
  */
 export const DEFAULT_AGENT_NPM_PACKAGES: Readonly<Record<string, string>> =
   Object.freeze({
-    "claude-agent-acp": "@agentclientprotocol/claude-agent-acp",
-    "codex-acp": "@agentclientprotocol/codex-acp",
+    "claude-agent-acp": "@agentclientprotocol/claude-agent-acp@0.75.1",
+    "codex-acp": "@agentclientprotocol/codex-acp@1.10.0",
   });

package/src/config/acp-schema.test.ts

@@ -0,0 +1,81 @@
+/**
+ * Covers the ACP config leaf that carries model selection, the per-agent
+ * `model`. It is optional with no `.default()`, so an absent value must stay
+ * absent after parsing: the bundled profile supplies the model a session
+ * starts on, and a key materialized as `undefined` would shadow it.
+ *
+ * `command` is optional in the same shape, so an entry for a bundled id can
+ * carry a model and nothing else; the record's own check keeps a command
+ * required for every id that has no bundled profile to inherit one from.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import { AcpAgentConfigSchema, AcpConfigSchema } from "./acp-schema.js";
+
+describe("AcpConfigSchema", () => {
+  test("populates defaults for an empty config", () => {
+    expect(AcpConfigSchema.parse({})).toEqual({
+      maxConcurrentSessions: 4,
+      agents: {},
+    });
+  });
+});
+
+describe("AcpConfigSchema agents", () => {
+  test("a bundled id's entry may omit command and name only a model", () => {
+    const parsed = AcpConfigSchema.parse({
+      agents: { claude: { model: "sonnet" } },
+    });
+
+    expect(parsed.agents).toEqual({ claude: { args: [], model: "sonnet" } });
+    expect("command" in parsed.agents.claude!).toBe(false);
+  });
+
+  test("an id with no bundled profile needs a command", () => {
+    const result = AcpConfigSchema.safeParse({
+      agents: { mine: { model: "sonnet" } },
+    });
+
+    expect(result.success).toBe(false);
+    if (result.success) {
+      return;
+    }
+    expect(result.error.issues.map((issue) => issue.path)).toEqual([
+      ["agents", "mine", "command"],
+    ]);
+    expect(result.error.issues[0]?.message).toContain("acp.agents.mine");
+  });
+
+  test("an id naming an Object.prototype member inherits no command", () => {
+    expect(
+      AcpConfigSchema.safeParse({ agents: { constructor: { model: "x" } } })
+        .success,
+    ).toBe(false);
+  });
+});
+
+describe("AcpAgentConfigSchema", () => {
+  test("round-trips a per-agent model override", () => {
+    expect(
+      AcpAgentConfigSchema.parse({
+        command: "claude-agent-acp",
+        model: "opus",
+      }),
+    ).toEqual({ command: "claude-agent-acp", args: [], model: "opus" });
+  });
+
+  test("leaves model unset when omitted, so a bundled profile's shows through", () => {
+    const parsed = AcpAgentConfigSchema.parse({ command: "claude-agent-acp" });
+
+    expect(parsed.model).toBeUndefined();
+    expect("model" in parsed).toBe(false);
+  });
+
+  test("rejects a non-string model", () => {
+    expect(
+      AcpAgentConfigSchema.safeParse({ command: "claude-agent-acp", model: 3 })
+        .success,
+    ).toBe(false);
+  });
+});