@vellumai/assistant 0.12.0-dev.202609111417.417f7af → 0.12.0-dev.202609111458.db63c16

package/ARCHITECTURE.md

@@ -1294,9 +1294,8 @@ graph TB
         RM_DIR["rmSync skill directory"]
     end
 
-    subgraph "File Watcher"
-        WATCHER["Skills directory watcher<br/>detects changes"]
-        EVICT["Session eviction<br/>+ recreation"]
+    subgraph "Capability reseed"
+        RESEED["SKILL.md mtime poll<br/>reseeds capability cards"]
     end
 
     SNIPPET --> EVAL_TOOL
@@ -1309,14 +1308,12 @@ graph TB
     SCAFFOLD --> MANAGED_STORE
     MANAGED_STORE --> SKILL_DIR
 
-    SKILL_DIR --> WATCHER
-    WATCHER --> EVICT
-
+    SKILL_DIR --> RESEED
     SKILL_DIR --> SKILL_LOAD
     SKILL_LOAD --> SESSION
 
     DELETE --> RM_DIR
-    RM_DIR --> WATCHER
+    RM_DIR --> RESEED
 ```
 
 **Key design decisions:**
@@ -1324,7 +1321,7 @@ graph TB
 - `evaluate_typescript_code` always forces `sandbox.enabled = true` regardless of global config.
 - Snippet contract: must export `default` or `run` with signature `(input: unknown) => unknown | Promise<unknown>`.
 - Managed-store writes are atomic (tmp file + rename) to prevent partial `SKILL.md` files.
-- After persist or delete, the file watcher triggers conversation eviction; the next turn runs in a fresh conversation. The model's system prompt instructs it to continue normally.
+- After persist or delete, capability cards reseed from the `SKILL.md` set. The next turn continues in the same conversation.
 - macOS UI shows Inspect and Delete controls for managed skills only (source = "managed").
 - `skill_load` resolves the recursive include graph (via `include-graph.ts`) before emitting output. Missing children are listed as suggested skills without child `<loaded_skill>` markers; cycles still produce `isError: true` with no marker. Valid includes produce an "Included Skills (immediate)" metadata section showing child ID, name, description, and path.
 

package/openapi.yaml

@@ -469,6 +469,33 @@ paths:
                           type: string
                         authErrorCode:
                           type: string
+                        model:
+                          type: string
+                        availableModels:
+                          type: array
+                          items:
+                            type: object
+                            properties:
+                              value:
+                                type: string
+                              label:
+                                type: string
+                              description:
+                                type: string
+                              group:
+                                type: string
+                            required:
+                              - value
+                              - label
+                            additionalProperties: false
+                        modelRevisionEpoch:
+                          type: string
+                          format: uuid
+                          pattern: ^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$
+                        modelRevision:
+                          type: integer
+                          minimum: 0
+                          maximum: 9007199254740991
                         usedTokens:
                           type: number
                         contextSize:
@@ -548,6 +575,9 @@ paths:
                 cwd:
                   type: string
                   description: Working directory
+                model:
+                  description: Optional model id or alias to request for the session.
+                  type: string
               required:
                 - agent
                 - task
@@ -566,6 +596,9 @@ paths:
                     type: string
                   agent:
                     type: string
+                  modelWarning:
+                    description: Why the requested model was not applied. The session is running on the agent's own model.
+                    type: string
                 required:
                   - acpSessionId
                   - protocolSessionId
@@ -5441,9 +5474,7 @@ paths:
     post:
       operationId: channels_send_post
       summary: Send text to a channel chat
-      description:
-        Deliver text to a chat or person on a channel through the channel's transport, recorded after the channel
-        acknowledges it.
+      description: Deliver text to a chat on a channel through the channel's transport, recorded after the channel acknowledges it.
       tags:
         - channels
       requestBody:
@@ -5468,36 +5499,22 @@ paths:
                     - plugin
                   description: Channel to send on
                 target:
-                  oneOf:
-                    - type: object
-                      properties:
-                        kind:
-                          type: string
-                          const: chat
-                        chatId:
-                          type: string
-                          minLength: 1
-                          description: Chat id in the channel's own id space
-                        threadId:
-                          description: Thread within the chat, in the channel's own id space
-                          type: string
-                          minLength: 1
-                      required:
-                        - kind
-                        - chatId
-                    - type: object
-                      properties:
-                        kind:
-                          type: string
-                          const: person
-                        userId:
-                          type: string
-                          minLength: 1
-                          description: Person to reach in their DM, in the channel's own id space
-                      required:
-                        - kind
-                        - userId
                   type: object
+                  properties:
+                    kind:
+                      type: string
+                      const: chat
+                    chatId:
+                      type: string
+                      minLength: 1
+                      description: Chat id in the channel's own id space
+                    threadId:
+                      description: Thread within the chat, in the channel's own id space
+                      type: string
+                      minLength: 1
+                  required:
+                    - kind
+                    - chatId
                 text:
                   type: string
                   minLength: 1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.12.0-dev.202609111417.417f7af",
+  "version": "0.12.0-dev.202609111458.db63c16",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/config-watcher.test.ts

@@ -154,10 +154,6 @@ mock.module("../runtime/sync/resource-sync-events.js", () => ({
   },
 }));
 
-mock.module("../daemon/skill-memory-refresh.js", () => ({
-  refreshSkillCapabilityMemories: () => {},
-}));
-
 mock.module("../platform/sync-identity.js", () => ({
   syncIdentityNameToPlatform: () => {},
 }));
@@ -332,6 +328,12 @@ describe("ConfigWatcher watcher lifecycle", () => {
     expect(findFileWatch(join(WORKSPACE_DIR, "IDENTITY.md"))).toBeDefined();
   });
 
+  test("start does not watch the skills directory", () => {
+    mkdirSync(join(WORKSPACE_DIR, "skills"), { recursive: true });
+    watcher.start();
+    expect(findWatcher(join(WORKSPACE_DIR, "skills"))).toBeUndefined();
+  });
+
   test("stop cancels pending debounce work, no eviction fires after", async () => {
     watcher.start();
     simulateFileChange(WORKSPACE_DIR, "SOUL.md");

package/src/__tests__/evict-conversations-for-reload.test.ts

@@ -1,6 +1,6 @@
 /**
  * `evictConversationsForReload` drops in-memory conversations after a
- * config/prompt/skills reload so the next turn rebuilds them against the new
+ * config/prompt reload so the next turn rebuilds them against the new
  * config. Queued messages live only on the instance being disposed, so the
  * same "not idle while a queue is pending" rule the periodic evictor applies
  * has to hold here: `isProcessing()` reads false in the window between a turn

package/src/__tests__/skill-feature-flags-integration.test.ts

@@ -60,7 +60,7 @@ function makeConfig(overrides: Partial<AssistantConfig> = {}): AssistantConfig {
   return {
     skills: {
       entries: {},
-      load: { extraDirs: [], watch: true, watchDebounceMs: 250 },
+      load: { extraDirs: [] },
       install: { nodeManager: "npm" },
       allowBundled: null,
       remoteProviders: {

package/src/__tests__/skill-feature-flags.test.ts

@@ -28,7 +28,7 @@ function makeConfig(overrides: Partial<AssistantConfig> = {}): AssistantConfig {
   return {
     skills: {
       entries: {},
-      load: { extraDirs: [], watch: true, watchDebounceMs: 250 },
+      load: { extraDirs: [] },
       install: { nodeManager: "npm" },
       allowBundled: null,
       remoteProviders: {
@@ -233,7 +233,7 @@ describe("resolveSkillStates with feature flags", () => {
     const config = makeConfig({
       skills: {
         entries: { [DECLARED_SKILL_ID]: { enabled: true } },
-        load: { extraDirs: [], watch: true, watchDebounceMs: 250 },
+        load: { extraDirs: [] },
         install: { nodeManager: "npm" },
         allowBundled: null,
         remoteProviders: {

package/src/acp/__tests__/agent-process.test.ts

@@ -8,9 +8,16 @@
 
 import { describe, expect, mock, test } from "bun:test";
 
-import type { AuthMethod, InitializeResponse } from "@agentclientprotocol/sdk";
+import type {
+  AuthMethod,
+  InitializeResponse,
+  SessionConfigOption,
+} from "@agentclientprotocol/sdk";
+import * as acp from "@agentclientprotocol/sdk";
 
 import { AcpAgentProcess } from "../agent-process.js";
+import { AcpConfigOptionRefusedError } from "../types.js";
+import { modelOption } from "./helpers/acp-model-option.js";
 
 function makeProcess(): AcpAgentProcess {
   return new AcpAgentProcess(
@@ -160,6 +167,139 @@ describe("AcpAgentProcess loadSession/resumeSession", () => {
   });
 });
 
+describe("AcpAgentProcess config options", () => {
+  /** Injects a connection whose session calls report `configOptions`. */
+  function stubSessionResponses(
+    proc: AcpAgentProcess,
+    configOptions: SessionConfigOption[] | null | undefined,
+  ): void {
+    (proc as unknown as { connection: unknown }).connection = {
+      newSession: () =>
+        Promise.resolve({ sessionId: "session-1", configOptions }),
+      loadSession: () => Promise.resolve({ configOptions }),
+      resumeSession: () => Promise.resolve({ configOptions }),
+    };
+  }
+
+  test("createSession returns the reported options", async () => {
+    const proc = makeProcess();
+    const options = [modelOption("sonnet")];
+    stubSessionResponses(proc, options);
+
+    await expect(proc.createSession("/tmp/project")).resolves.toEqual({
+      sessionId: "session-1",
+      configOptions: options,
+    });
+  });
+
+  test("loadSession returns the reported options", async () => {
+    const proc = makeProcess();
+    const options = [modelOption("sonnet")];
+    stubSessionResponses(proc, options);
+
+    await expect(
+      proc.loadSession("session-1", "/tmp/project"),
+    ).resolves.toEqual({ configOptions: options });
+  });
+
+  test("resumeSession returns the reported options", async () => {
+    const proc = makeProcess();
+    const options = [modelOption("opus")];
+    stubSessionResponses(proc, options);
+
+    await expect(
+      proc.resumeSession("session-1", "/tmp/project"),
+    ).resolves.toEqual({ configOptions: options });
+  });
+
+  test("a null or absent configOptions normalizes to an empty array", async () => {
+    const created = makeProcess();
+    stubSessionResponses(created, null);
+    await expect(created.createSession("/tmp/project")).resolves.toEqual({
+      sessionId: "session-1",
+      configOptions: [],
+    });
+
+    const loaded = makeProcess();
+    stubSessionResponses(loaded, null);
+    await expect(
+      loaded.loadSession("session-1", "/tmp/project"),
+    ).resolves.toEqual({ configOptions: [] });
+
+    const resumed = makeProcess();
+    stubSessionResponses(resumed, undefined);
+    await expect(
+      resumed.resumeSession("session-1", "/tmp/project"),
+    ).resolves.toEqual({ configOptions: [] });
+  });
+
+  test("setConfigOption forwards the value and returns the refreshed set", async () => {
+    const proc = makeProcess();
+    const calls: unknown[] = [];
+    const refreshed = [modelOption("opus")];
+    (proc as unknown as { connection: unknown }).connection = {
+      setSessionConfigOption: (params: unknown) => {
+        calls.push(params);
+        return Promise.resolve({ configOptions: refreshed });
+      },
+    };
+
+    await expect(
+      proc.setConfigOption("session-1", "model", "opus"),
+    ).resolves.toEqual(refreshed);
+
+    expect(calls).toEqual([
+      { sessionId: "session-1", configId: "model", value: "opus" },
+    ]);
+  });
+
+  test("setConfigOption sends the boolean request variant", async () => {
+    const proc = makeProcess();
+    const calls: unknown[] = [];
+    const refreshed = [modelOption("opus")];
+    (proc as unknown as { connection: unknown }).connection = {
+      setSessionConfigOption: (params: unknown) => {
+        calls.push(params);
+        return Promise.resolve({ configOptions: refreshed });
+      },
+    };
+
+    await proc.setConfigOption("session-1", "thinking", true);
+
+    expect(calls).toEqual([
+      {
+        sessionId: "session-1",
+        configId: "thinking",
+        type: "boolean",
+        value: true,
+      },
+    ]);
+  });
+
+  test("setConfigOption omits the discriminator for string values", async () => {
+    const proc = makeProcess();
+    const calls: unknown[] = [];
+    (proc as unknown as { connection: unknown }).connection = {
+      setSessionConfigOption: (params: unknown) => {
+        calls.push(params);
+        return Promise.resolve({ configOptions: [modelOption("opus")] });
+      },
+    };
+
+    await proc.setConfigOption("session-1", "model", "opus");
+
+    expect(calls[0]).not.toHaveProperty("type");
+  });
+
+  test("setConfigOption throws when the process is not spawned", async () => {
+    const proc = makeProcess();
+
+    await expect(
+      proc.setConfigOption("session-1", "model", "opus"),
+    ).rejects.toThrow('ACP agent "test-agent" is not spawned');
+  });
+});
+
 describe("AcpAgentProcess auth_required retry", () => {
   // spawnedEnv is injected the way spawn() builds it ({ ...process.env,
   // ...config.env }), so the advertised var names use a VELLUM_TEST_ prefix
@@ -196,17 +336,19 @@ describe("AcpAgentProcess auth_required retry", () => {
    * initialize() so the advertised authMethods are captured.
    */
   async function setupAuthProcess(options: {
+    command?: string;
     env?: Record<string, string>;
     authMethods?: AuthMethod[];
     /** Rejections to throw from successive newSession calls before succeeding. */
     newSessionRejections?: unknown[];
     loadSessionRejections?: unknown[];
     resumeSessionRejections?: unknown[];
+    setConfigOptionRejections?: unknown[];
     promptRejections?: unknown[];
   }) {
     const proc = new AcpAgentProcess(
       "codex",
-      { command: "echo", args: [], env: options.env },
+      { command: options.command ?? "echo", args: [], env: options.env },
       () => {
         throw new Error("client factory should not be called in this test");
       },
@@ -234,6 +376,10 @@ describe("AcpAgentProcess auth_required retry", () => {
       options.resumeSessionRejections ?? [],
       {},
     );
+    const setSessionConfigOption = failThenSucceed(
+      options.setConfigOptionRejections ?? [],
+      { configOptions: [] },
+    );
     const prompt = failThenSucceed(options.promptRejections ?? [], {
       stopReason: "end_turn",
     });
@@ -252,6 +398,7 @@ describe("AcpAgentProcess auth_required retry", () => {
       newSession,
       loadSession,
       resumeSession,
+      setSessionConfigOption,
       prompt,
       authenticate,
     };
@@ -264,18 +411,112 @@ describe("AcpAgentProcess auth_required retry", () => {
       newSession,
       loadSession,
       resumeSession,
+      setSessionConfigOption,
       prompt,
       authenticate,
       internals,
     };
   }
 
+  // An adapter that throws a plain Error reaches the client as a generic
+  // "Internal error" carrying the real sentence in `data.details`, which is
+  // the shape these fixtures reproduce.
+  test("setConfigOption surfaces the adapter's error answer as a refusal", async () => {
+    const { proc } = await setupAuthProcess({
+      setConfigOptionRejections: [
+        new acp.RequestError(-32603, "Internal error", {
+          details: "Invalid value for config option model: nope",
+        }),
+      ],
+    });
+
+    const refusal = await proc
+      .setConfigOption("session-1", "model", "nope")
+      .catch((err: unknown) => err);
+
+    expect(refusal).toBeInstanceOf(AcpConfigOptionRefusedError);
+    // The adapter's sentence, not the message the SDK framed it in.
+    expect((refusal as Error).message).toBe(
+      "Invalid value for config option model: nope",
+    );
+  });
+
+  test("setConfigOption serializes a payload that names no reason", async () => {
+    const { proc } = await setupAuthProcess({
+      setConfigOptionRejections: [
+        new acp.RequestError(-32603, "Internal error", { code: 7 }),
+      ],
+    });
+
+    await expect(
+      proc.setConfigOption("session-1", "model", "nope"),
+    ).rejects.toThrow('{"code":7}');
+  });
+
+  test("setConfigOption falls back to the message when there is no payload", async () => {
+    const { proc } = await setupAuthProcess({
+      setConfigOptionRejections: [
+        new acp.RequestError(-32603, "Session not found"),
+      ],
+    });
+
+    await expect(
+      proc.setConfigOption("session-1", "model", "nope"),
+    ).rejects.toThrow("Session not found");
+  });
+
+  test.each(["claude-agent-acp", "/usr/local/bin/claude-agent-acp"])(
+    "setConfigOption leaves Claude's message-shaped auth failure untyped (%s)",
+    async (command) => {
+      const expired = new acp.RequestError(-32603, "Internal error", {
+        details: "Not logged in",
+      });
+      const { proc } = await setupAuthProcess({
+        command,
+        setConfigOptionRejections: [expired],
+      });
+
+      await expect(
+        proc.setConfigOption("session-1", "model", "opus"),
+      ).rejects.toBe(expired);
+    },
+  );
+
+  test("setConfigOption reads Claude's login wording from another adapter as a refusal", async () => {
+    const { proc } = await setupAuthProcess({
+      command: "codex-acp",
+      setConfigOptionRejections: [
+        new acp.RequestError(-32603, "Internal error", {
+          details: "Not logged in",
+        }),
+      ],
+    });
+
+    const refusal = await proc
+      .setConfigOption("session-1", "model", "gpt-5")
+      .catch((err: unknown) => err);
+
+    expect(refusal).toBeInstanceOf(AcpConfigOptionRefusedError);
+    expect((refusal as Error).message).toBe("Not logged in");
+  });
+
+  test("setConfigOption leaves a transport failure untyped", async () => {
+    const closed = new Error("ACP connection closed");
+    const { proc } = await setupAuthProcess({
+      setConfigOptionRejections: [closed],
+    });
+
+    await expect(
+      proc.setConfigOption("session-1", "model", "opus"),
+    ).rejects.toBe(closed);
+  });
+
   test("createSession does not authenticate when newSession succeeds", async () => {
     const { proc, newSession, authenticate } = await setupAuthProcess({
       env: { [OPENAI_VAR]: "sk-test" },
     });
 
-    const sessionId = await proc.createSession("/tmp/project");
+    const { sessionId } = await proc.createSession("/tmp/project");
 
     expect(sessionId).toBe("session-1");
     expect(newSession).toHaveBeenCalledTimes(1);
@@ -288,7 +529,7 @@ describe("AcpAgentProcess auth_required retry", () => {
       newSessionRejections: [authRequiredError],
     });
 
-    const sessionId = await proc.createSession("/tmp/project");
+    const { sessionId } = await proc.createSession("/tmp/project");
 
     expect(sessionId).toBe("session-1");
     expect(authenticate).toHaveBeenCalledTimes(1);
@@ -387,6 +628,19 @@ describe("AcpAgentProcess auth_required retry", () => {
     expect(resumeSession).toHaveBeenCalledTimes(2);
   });
 
+  test("setConfigOption authenticates and retries on auth_required", async () => {
+    const { proc, setSessionConfigOption, authenticate } =
+      await setupAuthProcess({
+        env: { [OPENAI_VAR]: "sk-test" },
+        setConfigOptionRejections: [authRequiredError],
+      });
+
+    await proc.setConfigOption("session-1", "model", "opus");
+
+    expect(authenticate).toHaveBeenCalledWith({ methodId: "openai-api-key" });
+    expect(setSessionConfigOption).toHaveBeenCalledTimes(2);
+  });
+
   test("prompt authenticates and retries on auth_required, returning the response", async () => {
     const { proc, prompt, authenticate } = await setupAuthProcess({
       env: { [OPENAI_VAR]: "sk-test" },

package/src/acp/__tests__/auth-required.test.ts

@@ -6,6 +6,8 @@
 
 import { describe, expect, test } from "bun:test";
 
+import { RequestError } from "@agentclientprotocol/sdk";
+
 import { AcpAuthRequiredEventSchema } from "../../api/events/acp-auth-required.js";
 import { AcpSessionErrorEventSchema } from "../../api/events/acp-session-error.js";
 import {
@@ -15,6 +17,7 @@ import {
   CLAUDE_ACP_COMMAND,
   isAcpAuthRequired,
   isClaudeAuthFailureMessage,
+  requestErrorReason,
 } from "../auth-required.js";
 
 describe("isAcpAuthRequired", () => {
@@ -89,6 +92,99 @@ describe("isClaudeAuthFailureMessage", () => {
   });
 });
 
+describe("requestErrorReason", () => {
+  test("decodes the sentence the SDK moved into the payload", () => {
+    const rejection = new RequestError(-32603, "Internal error", {
+      details: "Failed to authenticate. Please run /login",
+    });
+
+    expect(requestErrorReason(rejection)).toBe(
+      "Failed to authenticate. Please run /login",
+    );
+    // The point of decoding: the generic message never matches.
+    expect(isClaudeAuthFailureMessage(rejection.message)).toBe(false);
+    expect(isClaudeAuthFailureMessage(requestErrorReason(rejection))).toBe(
+      true,
+    );
+  });
+
+  test("reads the message off a rejection that carries no payload", () => {
+    // Straight off the wire: a plain object, not an instance of any class we
+    // control, and with the auth text where the SDK leaves a framed one.
+    const rejection = {
+      code: -32603,
+      message: "Failed to authenticate. Please run /login",
+    };
+
+    expect(requestErrorReason(rejection)).toBe(
+      "Failed to authenticate. Please run /login",
+    );
+    expect(isClaudeAuthFailureMessage(requestErrorReason(rejection))).toBe(
+      true,
+    );
+  });
+
+  test("keeps the rejection's own message when the payload names no reason", () => {
+    expect(requestErrorReason(new RequestError(-32603, "boom", { c: 7 }))).toBe(
+      "boom",
+    );
+    expect(
+      requestErrorReason(
+        RequestError.methodNotFound("session/set_config_option"),
+      ),
+    ).toBe('"Method not found": session/set_config_option');
+    expect(requestErrorReason(new Error("Not logged in"))).toBe(
+      "Not logged in",
+    );
+  });
+
+  test("keeps a specific rejection message ahead of supplemental details", () => {
+    expect(
+      requestErrorReason(
+        new RequestError(-32603, "Model unavailable", {
+          details: "The selected deployment is temporarily unavailable",
+        }),
+      ),
+    ).toBe("Model unavailable");
+  });
+
+  test("serializes the payload behind a bare Internal error that names no reason", () => {
+    expect(
+      requestErrorReason(new RequestError(-32603, "Internal error", { c: 7 })),
+    ).toBe('{"c":7}');
+  });
+
+  test("serializes the payload behind a generic Invalid params", () => {
+    // How the agent-side SDK answers a request its schema rejects.
+    expect(
+      requestErrorReason(
+        RequestError.invalidParams({ _errors: ["model: Invalid option"] }),
+      ),
+    ).toBe('{"_errors":["model: Invalid option"]}');
+  });
+
+  test("decodes claude-agent-acp's prompt-time 401 from its message", () => {
+    // RequestError.internalError({ errorKind }, cliText) as the adapter raises
+    // it: the CLI's text rides the message and the payload only names a kind.
+    const rejection = new RequestError(
+      -32603,
+      "Internal error: Failed to authenticate. API Error: 401 OAuth access token has expired.",
+      { errorKind: "authentication_failed" },
+    );
+
+    expect(requestErrorReason(rejection)).toBe(rejection.message);
+    expect(isClaudeAuthFailureMessage(requestErrorReason(rejection))).toBe(
+      true,
+    );
+  });
+
+  test("stringifies a rejection that is not an object at all", () => {
+    expect(requestErrorReason("plain string")).toBe("plain string");
+    expect(requestErrorReason(-32603)).toBe("-32603");
+    expect(requestErrorReason(null)).toBe("null");
+  });
+});
+
 describe("AcpAuthRequiredError", () => {
   test("is an Error that carries the agent id and its message", () => {
     const err = new AcpAuthRequiredError("claude", "needs a reconnect");