@vellumai/assistant 0.10.7-dev.202607100313.fffdfea → 0.10.7-dev.202607100720.fba456e

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.10.7-dev.202607100313.fffdfea",
+  "version": "0.10.7-dev.202607100720.fba456e",
   "license": "MIT",
   "type": "module",
   "exports": {

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

@@ -136,6 +136,7 @@ mock.module("../runtime/sync/resource-sync-events.js", () => ({
   publishConfigChanged: () => {},
   publishSoundsConfigUpdated: () => {},
   publishAvatarChanged: () => {},
+  publishWorkspaceThemeChanged: () => {},
 }));
 
 mock.module("../platform/sync-identity.js", () => ({

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

@@ -147,6 +147,7 @@ mock.module("../signals/cancel.js", () => ({
 // or client broadcasts.
 let evictCallCount = 0;
 let identityCallCount = 0;
+let themeCallCount = 0;
 
 mock.module("../daemon/conversation-store.js", () => ({
   evictConversationsForReload: () => {
@@ -161,6 +162,9 @@ mock.module("../runtime/sync/resource-sync-events.js", () => ({
   publishConfigChanged: () => {},
   publishSoundsConfigUpdated: () => {},
   publishAvatarChanged: () => {},
+  publishWorkspaceThemeChanged: () => {
+    themeCallCount++;
+  },
 }));
 
 mock.module("../daemon/skill-memory-refresh.js", () => ({
@@ -190,7 +194,12 @@ function findFileWatch(filePath: string): CapturedFileWatch | undefined {
   return capturedFileWatches.find((w) => w.filePath === filePath);
 }
 
-const WORKSPACE_FILES = new Set(["config.json", "SOUL.md", "IDENTITY.md"]);
+const WORKSPACE_FILES = new Set([
+  "config.json",
+  "SOUL.md",
+  "IDENTITY.md",
+  "ui/theme.json",
+]);
 
 // Each call advances the inode + mtime so the listener's early-return guard
 // (curr.ino === prev.ino && curr.mtimeMs === prev.mtimeMs) doesn't fire.
@@ -242,6 +251,7 @@ beforeEach(() => {
   inoMap.clear();
   evictCallCount = 0;
   identityCallCount = 0;
+  themeCallCount = 0;
   watcher = new ConfigWatcher(undefined, TEST_DEBOUNCE_MS);
 });
 
@@ -273,13 +283,21 @@ describe("ConfigWatcher workspace file handlers", () => {
 
   test("unregistered workspace files are not subscribed (only the registered handler set is)", () => {
     watcher.start();
-    // Per-file watching only registers config.json, SOUL.md, IDENTITY.md.
-    // The whole workspace dir must not be watched either — that was the
-    // ENXIO-on-Unix-sockets bug.
+    // Per-file watching only registers config.json, SOUL.md, IDENTITY.md,
+    // and ui/theme.json. The whole workspace dir must not be watched
+    // either — that was the ENXIO-on-Unix-sockets bug.
     expect(findFileWatch(join(WORKSPACE_DIR, "OTHER.md"))).toBeUndefined();
     expect(findWatcher(WORKSPACE_DIR)).toBeUndefined();
   });
 
+  test("ui/theme.json change publishes the workspace-theme invalidation", async () => {
+    watcher.start();
+    simulateFileChange(WORKSPACE_DIR, "ui/theme.json");
+    await new Promise((r) => setTimeout(r, WAIT_MS));
+    expect(themeCallCount).toBe(1);
+    expect(evictCallCount).toBe(0);
+  });
+
   test("config.json change calls refreshConfigFromSources", async () => {
     let refreshCalled = false;
     watcher.refreshConfigFromSources = async () => {

package/src/__tests__/credential-security-invariants.test.ts

@@ -234,7 +234,7 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "tools/executor.ts", // CES approval bridge resolves the CES RPC client via getCesClient
       "tools/network/web-fetch.ts", // Firecrawl /scrape BYOK fetch provider API key lookup (firecrawl provider key)
       "workspace/default-provider-ensure.ts", // legacy anthropic echo disambiguation (vault key presence check)
-      "runtime/routes/default-provider-routes.ts", // default-provider availability status (credential presence check only; value never leaves the handler)
+      "providers/inference/connection-availability.ts", // shared (provider, connection) availability status (credential presence check only; value never leaves the helper)
     ]);
 
     const thisDir = dirname(fileURLToPath(import.meta.url));

package/src/__tests__/plugin-import-boundary-guard.test.ts

@@ -88,7 +88,6 @@ const BASELINE: Record<string, readonly string[]> = {
     "../../../../../persistence/raw-query.js",
     "../../../../../persistence/schema/index.js",
     "../../../../../security/untrusted-content.js",
-    "../../../../../util/platform.js",
     "../../../../agent/image-optimize.js",
     "../../../../api/responses/memory-v3-selection-log.js",
     "../../../../channels/types.js",
@@ -137,14 +136,6 @@ const BASELINE: Record<string, readonly string[]> = {
     "../../../../skills/catalog-cache.js",
     "../../../../telemetry/watchdog-events-store.js",
     "../../../../tools/skills/delete-managed.js",
-    "../../../../util/abort-reasons.js",
-    "../../../../util/errors.js",
-    "../../../../util/log-redact.js",
-    "../../../../util/platform.js",
-    "../../../../util/process-liveness.js",
-    "../../../../util/retry.js",
-    "../../../../util/strip-comment-lines.js",
-    "../../../../util/truncate.js",
     "../../../channels/types.js",
     "../../../config/assistant-feature-flags.js",
     "../../../config/loader.js",
@@ -203,11 +194,17 @@ const BASELINE: Record<string, readonly string[]> = {
     "../../../tools/registry.js",
     "../../../tools/types.js",
     "../../../types.js",
+    "../../../util/abort-reasons.js",
+    "../../../util/errors.js",
+    "../../../util/log-redact.js",
     "../../../util/logger.js",
     "../../../util/platform.js",
+    "../../../util/process-liveness.js",
     "../../../util/promise-guard.js",
+    "../../../util/retry.js",
     "../../../util/sqlite-retry.js",
     "../../../util/strip-comment-lines.js",
+    "../../../util/truncate.js",
     "../../../util/worker-memory.js",
     "../../types.js",
     "../injection-presence.js",

package/src/__tests__/plugin-import-boundary-reverse-guard.test.ts

@@ -81,7 +81,6 @@ const BASELINE: Record<string, readonly string[]> = {
     "src/cli/commands/memory/memory-v2-compare-render.ts",
     "src/cli/commands/memory/memory-v2.ts",
     "src/cli/commands/memory/memory-v3.ts",
-    "src/cli/commands/memory/nodes.ts",
     "src/config/bundled-skills/messaging/tools/messaging-analyze-style.ts",
     "src/config/bundled-skills/playbooks/tools/playbook-create.ts",
     "src/config/bundled-skills/playbooks/tools/playbook-delete.ts",
@@ -104,7 +103,6 @@ const BASELINE: Record<string, readonly string[]> = {
     "src/persistence/conversation-crud.ts",
     "src/persistence/steps.ts",
     "src/persistence/worker-control.ts",
-    "src/plugins/types.ts",
     "src/prompts/system-prompt.ts",
     "src/runtime/routes/consolidation-routes.ts",
     "src/runtime/routes/conversation-query-routes.ts",

package/src/cli/commands/__tests__/inference-models.test.ts

@@ -0,0 +1,86 @@
+/**
+ * Tests for `assistant inference models list` CLI arg parsing / IPC wiring.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { Command } from "commander";
+
+let lastIpcCall: { method: string; params?: any } | null = null;
+let mockIpcResult: { ok: boolean; result?: unknown; error?: string } = {
+  ok: true,
+  result: { models: [] },
+};
+
+mock.module("../../../ipc/cli-client.js", () => ({
+  cliIpcCall: async (method: string, params?: Record<string, unknown>) => {
+    lastIpcCall = { method, params };
+    return mockIpcResult;
+  },
+}));
+
+mock.module("../../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
+  getCliLogger: () =>
+    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
+}));
+
+const { attachModelsSubcommand } = await import("../inference-models.js");
+
+beforeEach(() => {
+  lastIpcCall = null;
+  mockIpcResult = { ok: true, result: { models: [] } };
+  process.exitCode = 0;
+});
+
+async function run(args: string[]): Promise<string> {
+  const originalWrite = process.stdout.write.bind(process.stdout);
+  const chunks: string[] = [];
+  process.stdout.write = ((chunk: unknown) => {
+    chunks.push(typeof chunk === "string" ? chunk : String(chunk));
+    return true;
+  }) as typeof process.stdout.write;
+  try {
+    const program = new Command();
+    program.exitOverride();
+    const inference = program.command("inference");
+    attachModelsSubcommand(inference);
+    await program.parseAsync(["node", "assistant", "inference", ...args]);
+  } catch {
+    // swallow commander exits
+  } finally {
+    process.stdout.write = originalWrite;
+  }
+  return chunks.join("");
+}
+
+describe("models list", () => {
+  test("no filter → empty queryParams", async () => {
+    await run(["models", "list"]);
+    expect(lastIpcCall?.method).toBe("inference_models_list");
+    expect(lastIpcCall?.params).toEqual({ queryParams: {} });
+  });
+
+  test("--provider forwards the filter", async () => {
+    await run(["models", "list", "--provider", "anthropic"]);
+    expect(lastIpcCall?.params).toEqual({
+      queryParams: { provider: "anthropic" },
+    });
+  });
+
+  test("--json emits structured output", async () => {
+    mockIpcResult = {
+      ok: true,
+      result: {
+        models: [
+          { provider: "anthropic", id: "claude-opus-4-8", displayName: "X" },
+        ],
+      },
+    };
+    const out = await run(["models", "list", "--json"]);
+    const parsed = JSON.parse(out.trim());
+    expect(parsed.ok).toBe(true);
+    expect(parsed.models[0].id).toBe("claude-opus-4-8");
+  });
+});

package/src/cli/commands/__tests__/inference-profiles.test.ts

@@ -0,0 +1,254 @@
+/**
+ * Tests for `assistant inference profiles` CLI arg parsing / IPC wiring.
+ *
+ * Validates that flags map onto the correct IPC method + body, that create
+ * requires --provider/--model, that --thinking parses to a boolean, and that
+ * `active` reads via config_get and writes via config_patch.
+ */
+
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { Command } from "commander";
+
+let lastIpcCall: { method: string; params?: any } | null = null;
+let mockIpcResult: { ok: boolean; result?: unknown; error?: string } = {
+  ok: true,
+  result: {},
+};
+
+mock.module("../../../ipc/cli-client.js", () => ({
+  cliIpcCall: async (method: string, params?: Record<string, unknown>) => {
+    lastIpcCall = { method, params };
+    return mockIpcResult;
+  },
+}));
+
+mock.module("../../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
+  getCliLogger: () =>
+    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
+}));
+
+const { attachProfilesSubcommand } = await import("../inference-profiles.js");
+
+beforeEach(() => {
+  lastIpcCall = null;
+  mockIpcResult = { ok: true, result: {} };
+  process.exitCode = 0;
+});
+
+afterEach(() => {
+  process.exitCode = 0;
+});
+
+async function run(
+  args: string[],
+): Promise<{ stdout: string; exitCode: number }> {
+  const originalWrite = process.stdout.write.bind(process.stdout);
+  const chunks: string[] = [];
+  process.stdout.write = ((chunk: unknown) => {
+    chunks.push(typeof chunk === "string" ? chunk : String(chunk));
+    return true;
+  }) as typeof process.stdout.write;
+
+  const prevExit = process.exitCode;
+  process.exitCode = 0;
+  try {
+    const program = new Command();
+    program.exitOverride();
+    const inference = program.command("inference");
+    attachProfilesSubcommand(inference);
+    await program.parseAsync(["node", "assistant", "inference", ...args]);
+  } catch (err: unknown) {
+    if (!(err instanceof Error && err.message.startsWith("(outputHelp)"))) {
+      // swallow commander exits
+    }
+  } finally {
+    process.stdout.write = originalWrite;
+  }
+  const stdout = chunks.join("");
+  const exitCode = (process.exitCode as number) ?? 0;
+  process.exitCode = prevExit;
+  return { stdout, exitCode };
+}
+
+describe("profiles list", () => {
+  test("calls inference_profiles_list", async () => {
+    mockIpcResult = { ok: true, result: { profiles: [] } };
+    await run(["profiles", "list"]);
+    expect(lastIpcCall?.method).toBe("inference_profiles_list");
+  });
+});
+
+describe("profiles create", () => {
+  test("requires --provider", async () => {
+    const { exitCode } = await run(["profiles", "create", "p", "--model", "m"]);
+    expect(exitCode).toBe(1);
+    expect(lastIpcCall).toBeNull();
+  });
+
+  test("requires --model", async () => {
+    const { exitCode } = await run([
+      "profiles",
+      "create",
+      "p",
+      "--provider",
+      "anthropic",
+    ]);
+    expect(exitCode).toBe(1);
+    expect(lastIpcCall).toBeNull();
+  });
+
+  test("maps flags onto the create body with thinking→boolean and numeric parse", async () => {
+    mockIpcResult = {
+      ok: true,
+      result: { ok: true, name: "p", entry: {}, warnings: [] },
+    };
+    await run([
+      "profiles",
+      "create",
+      "p",
+      "--provider",
+      "anthropic",
+      "--model",
+      "claude-opus-4-8",
+      "--connection",
+      "anthropic-personal",
+      "--effort",
+      "high",
+      "--max-tokens",
+      "8000",
+      "--temperature",
+      "0.5",
+      "--thinking",
+      "on",
+      "--allow-unlisted",
+    ]);
+    expect(lastIpcCall?.method).toBe("inference_profiles_create");
+    expect(lastIpcCall?.params?.body).toEqual({
+      name: "p",
+      provider: "anthropic",
+      model: "claude-opus-4-8",
+      connection: "anthropic-personal",
+      effort: "high",
+      maxTokens: 8000,
+      temperature: 0.5,
+      thinking: true,
+      allowUnlisted: true,
+    });
+  });
+
+  test("prints the verification hint on success", async () => {
+    mockIpcResult = {
+      ok: true,
+      result: { ok: true, name: "p", entry: {}, warnings: [] },
+    };
+    const { stdout } = await run([
+      "profiles",
+      "create",
+      "p",
+      "--provider",
+      "anthropic",
+      "--model",
+      "claude-opus-4-8",
+    ]);
+    expect(stdout).toContain("Verify it works:");
+    expect(stdout).toContain("assistant inference send --profile p");
+  });
+
+  test("rejects a non-numeric --max-tokens before calling the daemon", async () => {
+    const { exitCode } = await run([
+      "profiles",
+      "create",
+      "p",
+      "--provider",
+      "anthropic",
+      "--model",
+      "m",
+      "--max-tokens",
+      "lots",
+    ]);
+    expect(exitCode).toBe(1);
+    expect(lastIpcCall).toBeNull();
+  });
+
+  test("rejects an invalid --thinking value", async () => {
+    const { exitCode } = await run([
+      "profiles",
+      "create",
+      "p",
+      "--provider",
+      "anthropic",
+      "--model",
+      "m",
+      "--thinking",
+      "maybe",
+    ]);
+    expect(exitCode).toBe(1);
+    expect(lastIpcCall).toBeNull();
+  });
+});
+
+describe("profiles update", () => {
+  test("sends pathParams + partial body", async () => {
+    mockIpcResult = {
+      ok: true,
+      result: { ok: true, name: "p", entry: {}, warnings: [] },
+    };
+    await run(["profiles", "update", "p", "--effort", "low"]);
+    expect(lastIpcCall?.method).toBe("inference_profiles_update");
+    expect(lastIpcCall?.params).toEqual({
+      pathParams: { name: "p" },
+      body: { effort: "low" },
+    });
+  });
+
+  test("refuses an empty update", async () => {
+    const { exitCode } = await run(["profiles", "update", "p"]);
+    expect(exitCode).toBe(1);
+    expect(lastIpcCall).toBeNull();
+  });
+});
+
+describe("profiles delete", () => {
+  test("sends the name as a path param", async () => {
+    mockIpcResult = { ok: true, result: { ok: true, name: "p" } };
+    await run(["profiles", "delete", "p"]);
+    expect(lastIpcCall?.method).toBe("inference_profiles_delete");
+    expect(lastIpcCall?.params).toEqual({ pathParams: { name: "p" } });
+  });
+});
+
+describe("profiles active", () => {
+  test("no arg reads via config_get", async () => {
+    mockIpcResult = {
+      ok: true,
+      result: { llm: { activeProfile: "balanced" } },
+    };
+    const { stdout } = await run(["profiles", "active"]);
+    expect(lastIpcCall?.method).toBe("config_get");
+    expect(stdout).toContain("balanced");
+  });
+
+  test("with a name writes via the validated set-active route", async () => {
+    mockIpcResult = {
+      ok: true,
+      result: { ok: true, activeProfile: "my-fast" },
+    };
+    const { stdout } = await run(["profiles", "active", "my-fast"]);
+    expect(lastIpcCall?.method).toBe("inference_profiles_set_active");
+    expect(lastIpcCall?.params).toEqual({ body: { name: "my-fast" } });
+    expect(stdout).toContain("active profile set to my-fast");
+  });
+
+  test("surfaces the daemon's rejection for an unknown name", async () => {
+    mockIpcResult = {
+      ok: false,
+      error: 'Profile "balancd" does not exist. Valid profiles: balanced, ...',
+    };
+    const { exitCode } = await run(["profiles", "active", "balancd"]);
+    expect(lastIpcCall?.method).toBe("inference_profiles_set_active");
+    expect(exitCode).toBe(1);
+  });
+});

package/src/cli/commands/__tests__/inference-providers.test.ts

@@ -0,0 +1,171 @@
+/**
+ * Tests for `assistant inference providers connections` CLI arg parsing / IPC
+ * wiring — focused on the openai-compatible `--base-url` / `--model` flags that
+ * forward to the connection route's `base_url` + `models` fields.
+ */
+
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { Command } from "commander";
+
+let lastIpcCall: { method: string; params?: any } | null = null;
+let mockIpcResult: { ok: boolean; result?: unknown; error?: string } = {
+  ok: true,
+  result: {},
+};
+
+mock.module("../../../ipc/cli-client.js", () => ({
+  cliIpcCall: async (method: string, params?: Record<string, unknown>) => {
+    lastIpcCall = { method, params };
+    return mockIpcResult;
+  },
+}));
+
+mock.module("../../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
+  getCliLogger: () =>
+    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
+}));
+
+const { attachProvidersSubcommand } = await import("../inference-providers.js");
+
+const CONNECTION_RESULT = {
+  name: "local-llm",
+  provider: "openai-compatible",
+  auth: { type: "none" },
+  createdAt: Date.now(),
+  updatedAt: Date.now(),
+};
+
+beforeEach(() => {
+  lastIpcCall = null;
+  mockIpcResult = { ok: true, result: CONNECTION_RESULT };
+  process.exitCode = 0;
+});
+
+afterEach(() => {
+  process.exitCode = 0;
+});
+
+async function run(
+  args: string[],
+): Promise<{ stdout: string; exitCode: number }> {
+  const originalWrite = process.stdout.write.bind(process.stdout);
+  const chunks: string[] = [];
+  process.stdout.write = ((chunk: unknown) => {
+    chunks.push(typeof chunk === "string" ? chunk : String(chunk));
+    return true;
+  }) as typeof process.stdout.write;
+
+  const prevExit = process.exitCode;
+  process.exitCode = 0;
+  try {
+    const program = new Command();
+    program.exitOverride();
+    const inference = program.command("inference");
+    attachProvidersSubcommand(inference);
+    await program.parseAsync(["node", "assistant", "inference", ...args]);
+  } catch {
+    // swallow commander exits
+  } finally {
+    process.stdout.write = originalWrite;
+  }
+  const stdout = chunks.join("");
+  const exitCode = (process.exitCode as number) ?? 0;
+  process.exitCode = prevExit;
+  return { stdout, exitCode };
+}
+
+describe("providers connections create — openai-compatible", () => {
+  test("forwards base_url and collected --model list to the route", async () => {
+    await run([
+      "providers",
+      "connections",
+      "create",
+      "local-llm",
+      "--provider",
+      "openai-compatible",
+      "--auth",
+      "none",
+      "--base-url",
+      "http://localhost:1234/v1",
+      "--model",
+      "model-a",
+      "--model",
+      "model-b",
+    ]);
+    expect(lastIpcCall?.method).toBe("inference_provider_connections_create");
+    expect(lastIpcCall?.params?.body).toEqual({
+      name: "local-llm",
+      provider: "openai-compatible",
+      auth: { type: "none" },
+      base_url: "http://localhost:1234/v1",
+      models: [{ id: "model-a" }, { id: "model-b" }],
+    });
+  });
+
+  test("rejects openai-compatible without --base-url before calling the daemon", async () => {
+    const { exitCode } = await run([
+      "providers",
+      "connections",
+      "create",
+      "local-llm",
+      "--provider",
+      "openai-compatible",
+      "--auth",
+      "none",
+      "--model",
+      "model-a",
+    ]);
+    expect(exitCode).toBe(1);
+    expect(lastIpcCall).toBeNull();
+  });
+
+  test("omits base_url/models for a standard provider", async () => {
+    await run([
+      "providers",
+      "connections",
+      "create",
+      "anthropic-personal",
+      "--provider",
+      "anthropic",
+      "--auth",
+      "api_key",
+      "--credential",
+      "credential/anthropic/api_key",
+    ]);
+    expect(lastIpcCall?.params?.body).toEqual({
+      name: "anthropic-personal",
+      provider: "anthropic",
+      auth: { type: "api_key", credential: "credential/anthropic/api_key" },
+    });
+  });
+});
+
+describe("providers connections update — openai-compatible", () => {
+  test("forwards base_url and models alongside auth", async () => {
+    mockIpcResult = { ok: true, result: CONNECTION_RESULT };
+    await run([
+      "providers",
+      "connections",
+      "update",
+      "local-llm",
+      "--auth",
+      "none",
+      "--base-url",
+      "http://localhost:5678/v1",
+      "--model",
+      "model-c",
+    ]);
+    expect(lastIpcCall?.method).toBe("inference_provider_connections_update");
+    expect(lastIpcCall?.params).toEqual({
+      pathParams: { name: "local-llm" },
+      body: {
+        auth: { type: "none" },
+        base_url: "http://localhost:5678/v1",
+        models: [{ id: "model-c" }],
+      },
+    });
+  });
+});