@vellumai/assistant 0.4.41 → 0.4.43

package/src/__tests__/notification-guardian-path.test.ts

@@ -34,28 +34,9 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
-let mockTelegramBinding: unknown = null;
-let mockVellumBinding: unknown = null;
-
-mock.module("../memory/channel-guardian-store.js", () => ({
-  getActiveBinding: (_assistantId: string, channel: string) => {
-    if (channel === "telegram") return mockTelegramBinding;
-    if (channel === "vellum") return mockVellumBinding;
-    return null;
-  },
-  createBinding: (params: Record<string, unknown>) => ({
-    id: `binding-${Date.now()}`,
-    ...params,
-    status: "active",
-    verifiedAt: Date.now(),
-    verifiedVia: "test",
-    metadataJson: null,
-    createdAt: Date.now(),
-    updatedAt: Date.now(),
-  }),
-  listActiveBindingsByAssistant: () =>
-    mockVellumBinding ? [mockVellumBinding] : [],
-}));
+// Note: stale mock for channel-guardian-store.js removed — the barrel was
+// deleted and none of the functions it mocked (getActiveBinding, createBinding,
+// listActiveBindingsByAssistant) existed in the barrel.
 
 mock.module("../config/loader.js", () => ({
   getConfig: () => ({
@@ -143,23 +124,8 @@ function resetTables(): void {
   db.run("DELETE FROM conversations");
 
   emitCalls.length = 0;
-  mockTelegramBinding = null;
-  // Pre-seed vellum binding so the self-healing path in dispatchGuardianQuestion
-  // never triggers (avoids UNIQUE constraint violations on repeated dispatches).
-  mockVellumBinding = {
-    id: "binding-vellum-test",
-    assistantId: "self",
-    channel: "vellum",
-    guardianExternalUserId: "vellum-guardian",
-    guardianDeliveryChatId: "local",
-    guardianPrincipalId: "test-principal-id",
-    status: "active",
-    verifiedAt: Date.now(),
-    verifiedVia: "test",
-    metadataJson: null,
-    createdAt: Date.now(),
-    updatedAt: Date.now(),
-  };
+  // Note: mockTelegramBinding/mockVellumBinding assignments
+  // removed — they only fed the stale channel-guardian-store mock.
   mockThreadCreated = null;
   mockEmitResult = {
     signalId: "sig-1",
@@ -213,7 +179,7 @@ describe("ASK_GUARDIAN canonical notification path", () => {
     expect(emitCalls.length).toBe(1);
     const signalParams = emitCalls[0] as Record<string, unknown>;
     expect(signalParams.sourceEventName).toBe("guardian.question");
-    expect(signalParams.sourceChannel).toBe("voice");
+    expect(signalParams.sourceChannel).toBe("phone");
     expect(signalParams.dedupeKey).toMatch(/^guardian:/);
 
     const hints = signalParams.attentionHints as Record<string, unknown>;
@@ -278,10 +244,6 @@ describe("ASK_GUARDIAN canonical notification path", () => {
     const convId = "conv-guardian-notif-3";
     ensureConversation(convId);
 
-    mockTelegramBinding = {
-      guardianDeliveryChatId: "tg-chat-abc",
-      guardianExternalUserId: "tg-user-xyz",
-    };
     mockEmitResult = {
       signalId: "sig-3",
       deduplicated: false,

package/src/__tests__/notification-routing-intent.test.ts

@@ -104,9 +104,9 @@ describe("routing intent enforcement", () => {
       expect(enforced.selectedChannels).toEqual(["vellum"]);
     });
 
-    test("includes SMS when SMS is among connected channels", () => {
+    test("includes all connected channels in all_channels mode", () => {
       const decision = makeDecision({ selectedChannels: ["vellum"] });
-      const connected: NotificationChannel[] = ["vellum", "telegram", "sms"];
+      const connected: NotificationChannel[] = ["vellum", "telegram", "slack"];
 
       const enforced = enforceRoutingIntent(
         decision,
@@ -114,13 +114,17 @@ describe("routing intent enforcement", () => {
         connected,
       );
 
-      expect(enforced.selectedChannels).toEqual(["vellum", "telegram", "sms"]);
+      expect(enforced.selectedChannels).toEqual([
+        "vellum",
+        "telegram",
+        "slack",
+      ]);
       expect(enforced.reasoningSummary).toContain(
         "routing_intent=all_channels",
       );
     });
 
-    test("excludes SMS when SMS is not among connected channels", () => {
+    test("excludes disconnected channels from all_channels", () => {
       const decision = makeDecision({ selectedChannels: ["vellum"] });
       const connected: NotificationChannel[] = ["vellum", "telegram"];
 
@@ -131,7 +135,7 @@ describe("routing intent enforcement", () => {
       );
 
       expect(enforced.selectedChannels).toEqual(["vellum", "telegram"]);
-      expect(enforced.selectedChannels).not.toContain("sms");
+      expect(enforced.selectedChannels).not.toContain("slack");
     });
   });
 
@@ -154,7 +158,7 @@ describe("routing intent enforcement", () => {
 
     test("does not expand to all channels when 3+ are connected", () => {
       const decision = makeDecision({ selectedChannels: ["telegram"] });
-      const connected: NotificationChannel[] = ["vellum", "telegram", "sms"];
+      const connected: NotificationChannel[] = ["vellum", "telegram", "slack"];
 
       const enforced = enforceRoutingIntent(
         decision,
@@ -163,7 +167,7 @@ describe("routing intent enforcement", () => {
       );
 
       expect(enforced.selectedChannels).toEqual(["telegram", "vellum"]);
-      expect(enforced.selectedChannels).not.toContain("sms");
+      expect(enforced.selectedChannels).not.toContain("slack");
     });
 
     test("does not override when LLM already picked 2+ channels", () => {

package/src/__tests__/oauth-cli.test.ts

@@ -66,7 +66,7 @@ mock.module("../util/logger.js", () => ({
 // Import the module under test (after mocks are registered)
 // ---------------------------------------------------------------------------
 
-const { registerOAuthCommand } = await import("../cli/oauth.js");
+const { registerOAuthCommand } = await import("../cli/commands/oauth.js");
 
 // ---------------------------------------------------------------------------
 // Test helper

package/src/__tests__/onboarding-starter-tasks.test.ts

@@ -28,7 +28,7 @@ mock.module("../util/platform.js", () => ({
   getLogPath: () => join(TEST_DIR, "logs", "vellum.log"),
   getHistoryPath: () => join(TEST_DIR, "history"),
   getHooksDir: () => join(TEST_DIR, "hooks"),
-  getIpcBlobDir: () => join(TEST_DIR, "ipc-blobs"),
+
   getSandboxRootDir: () => join(TEST_DIR, "sandbox"),
   getSandboxWorkingDir: () => TEST_DIR,
   getInterfacesDir: () => join(TEST_DIR, "interfaces"),
@@ -38,10 +38,6 @@ mock.module("../util/platform.js", () => ({
   getPlatformName: () => process.platform,
   getClipboardCommand: () => null,
   readSessionToken: () => null,
-  removeSocketFile: () => {},
-  migratePath: () => {},
-  migrateToWorkspaceLayout: () => {},
-  migrateToDataLayout: () => {},
   readLockfile: () => null,
   writeLockfile: () => {},
 }));
@@ -63,7 +59,7 @@ mock.module("../util/logger.js", () => ({
 }));
 
 const { buildStarterTaskPlaybookSection, buildSystemPrompt } =
-  await import("../config/system-prompt.js");
+  await import("../prompts/system-prompt.js");
 
 describe("buildStarterTaskPlaybookSection", () => {
   test("returns a string with the section heading", () => {

package/src/__tests__/onboarding-template-contract.test.ts

@@ -2,7 +2,7 @@ import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { describe, expect, test } from "bun:test";
 
-const templatesDir = join(import.meta.dirname, "..", "config", "templates");
+const templatesDir = join(import.meta.dirname, "..", "prompts", "templates");
 const bootstrap = readFileSync(join(templatesDir, "BOOTSTRAP.md"), "utf-8");
 const identity = readFileSync(join(templatesDir, "IDENTITY.md"), "utf-8");
 const user = readFileSync(join(templatesDir, "USER.md"), "utf-8");
@@ -77,7 +77,7 @@ describe("onboarding template contracts", () => {
       expect(lower).toContain("do not delete this file");
       // Assistant name is hard-required
       expect(lower).toContain("you have a name");
-      expect(lower).toContain("hard requirement");
+      expect(lower).toContain("hard-required");
       expect(lower).toContain("vibe");
       // User detail fields must be resolved (provided, inferred, or declined)
       expect(lower).toContain("resolved");

package/src/__tests__/platform.test.ts

@@ -1,8 +1,15 @@
 import { randomBytes } from "node:crypto";
-import { existsSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
 import { join } from "node:path";
-import { afterEach, describe, expect, test } from "bun:test";
+import { afterEach, describe, expect, mock, test } from "bun:test";
+
+// Mutable homedir override — when set, resolveInstanceDataDir reads from here.
+let homedirOverride: string | undefined;
+mock.module("node:os", () => ({
+  homedir: () => homedirOverride ?? homedir(),
+  tmpdir,
+}));
 
 import {
   ensureDataDir,
@@ -11,7 +18,6 @@ import {
   getHistoryPath,
   getHooksDir,
   getInterfacesDir,
-  getIpcBlobDir,
   getLogPath,
   getPidPath,
   getRootDir,
@@ -22,6 +28,7 @@ import {
   getWorkspaceHooksDir,
   getWorkspacePromptPath,
   getWorkspaceSkillsDir,
+  resolveInstanceDataDir,
 } from "../util/platform.js";
 
 const originalBaseDataDir = process.env.BASE_DATA_DIR;
@@ -32,6 +39,7 @@ afterEach(() => {
   } else {
     process.env.BASE_DATA_DIR = originalBaseDataDir;
   }
+  homedirOverride = undefined;
 });
 
 // Baseline path characterization: documents current pre-migration path layout.
@@ -57,7 +65,6 @@ describe("baseline path characterization (pre-migration)", () => {
     expect(getDbPath()).toBe(join(data, "db", "assistant.db"));
     expect(getLogPath()).toBe(join(data, "logs", "vellum.log"));
     expect(getHistoryPath()).toBe(join(data, "history"));
-    expect(getIpcBlobDir()).toBe(join(data, "ipc-blobs"));
     expect(getInterfacesDir()).toBe(join(data, "interfaces"));
     expect(getSandboxRootDir()).toBe(join(data, "sandbox"));
     expect(getSandboxWorkingDir()).toBe(join(root, "workspace"));
@@ -138,3 +145,159 @@ describe("workspace path primitives", () => {
     expect(getWorkspaceDir()).toBe("/tmp/custom-base/.vellum/workspace");
   });
 });
+
+describe("resolveInstanceDataDir", () => {
+  function makeTempHome(): string {
+    const dir = join(
+      tmpdir(),
+      `platform-home-${randomBytes(4).toString("hex")}`,
+    );
+    mkdirSync(dir, { recursive: true });
+    homedirOverride = dir;
+    return dir;
+  }
+
+  function writeLockfileToHome(
+    home: string,
+    data: Record<string, unknown>,
+  ): void {
+    writeFileSync(
+      join(home, ".vellum.lock.json"),
+      JSON.stringify(data, null, 2),
+    );
+  }
+
+  test("returns undefined when no lockfile exists", () => {
+    makeTempHome();
+    expect(resolveInstanceDataDir()).toBeUndefined();
+  });
+
+  test("returns sole local assistant instanceDir when no activeAssistant", () => {
+    const home = makeTempHome();
+    writeLockfileToHome(home, {
+      assistants: [
+        {
+          assistantId: "vellum-calm-stork",
+          cloud: "local",
+          resources: {
+            instanceDir:
+              "/Users/test/.local/share/vellum/assistants/vellum-calm-stork",
+          },
+        },
+      ],
+    });
+    expect(resolveInstanceDataDir()).toBe(
+      "/Users/test/.local/share/vellum/assistants/vellum-calm-stork",
+    );
+  });
+
+  test("returns active assistant instanceDir when activeAssistant matches", () => {
+    const home = makeTempHome();
+    writeLockfileToHome(home, {
+      activeAssistant: "vellum-bold-fox",
+      assistants: [
+        {
+          assistantId: "vellum-calm-stork",
+          cloud: "local",
+          resources: {
+            instanceDir:
+              "/Users/test/.local/share/vellum/assistants/vellum-calm-stork",
+          },
+        },
+        {
+          assistantId: "vellum-bold-fox",
+          cloud: "local",
+          resources: {
+            instanceDir:
+              "/Users/test/.local/share/vellum/assistants/vellum-bold-fox",
+          },
+        },
+      ],
+    });
+    expect(resolveInstanceDataDir()).toBe(
+      "/Users/test/.local/share/vellum/assistants/vellum-bold-fox",
+    );
+  });
+
+  test("returns undefined when multiple local assistants and no activeAssistant", () => {
+    const home = makeTempHome();
+    writeLockfileToHome(home, {
+      assistants: [
+        {
+          assistantId: "vellum-calm-stork",
+          cloud: "local",
+          resources: {
+            instanceDir:
+              "/Users/test/.local/share/vellum/assistants/vellum-calm-stork",
+          },
+        },
+        {
+          assistantId: "vellum-bold-fox",
+          cloud: "local",
+          resources: {
+            instanceDir:
+              "/Users/test/.local/share/vellum/assistants/vellum-bold-fox",
+          },
+        },
+      ],
+    });
+    expect(resolveInstanceDataDir()).toBeUndefined();
+  });
+
+  test("returns undefined when lockfile has no assistants array", () => {
+    const home = makeTempHome();
+    writeLockfileToHome(home, { version: 1 });
+    expect(resolveInstanceDataDir()).toBeUndefined();
+  });
+
+  test("returns undefined when lockfile is malformed JSON", () => {
+    const home = makeTempHome();
+    writeFileSync(join(home, ".vellum.lock.json"), "{{not json");
+    expect(resolveInstanceDataDir()).toBeUndefined();
+  });
+
+  test("treats assistants without cloud field as local", () => {
+    const home = makeTempHome();
+    writeLockfileToHome(home, {
+      assistants: [
+        {
+          assistantId: "vellum-quiet-owl",
+          resources: {
+            instanceDir:
+              "/Users/test/.local/share/vellum/assistants/vellum-quiet-owl",
+          },
+        },
+      ],
+    });
+    expect(resolveInstanceDataDir()).toBe(
+      "/Users/test/.local/share/vellum/assistants/vellum-quiet-owl",
+    );
+  });
+
+  test("ignores cloud assistants when resolving", () => {
+    const home = makeTempHome();
+    writeLockfileToHome(home, {
+      assistants: [
+        {
+          assistantId: "vellum-cloud-eagle",
+          cloud: "platform",
+          resources: {
+            instanceDir: "/some/cloud/path",
+          },
+        },
+        {
+          assistantId: "vellum-local-robin",
+          cloud: "local",
+          resources: {
+            instanceDir:
+              "/Users/test/.local/share/vellum/assistants/vellum-local-robin",
+          },
+        },
+      ],
+    });
+    // Only one local assistant, so it auto-selects
+    expect(resolveInstanceDataDir()).toBe(
+      "/Users/test/.local/share/vellum/assistants/vellum-local-robin",
+    );
+  });
+});

package/src/__tests__/playbook-execution.test.ts

@@ -15,8 +15,6 @@ mock.module("../util/platform.js", () => ({
   getDbPath: () => join(testDir, "test.db"),
   getLogPath: () => join(testDir, "test.log"),
   ensureDataDir: () => {},
-  migrateToDataLayout: () => {},
-  migrateToWorkspaceLayout: () => {},
 }));
 
 mock.module("../util/logger.js", () => ({

package/src/__tests__/playbook-tools.test.ts

@@ -15,8 +15,6 @@ mock.module("../util/platform.js", () => ({
   getDbPath: () => join(testDir, "test.db"),
   getLogPath: () => join(testDir, "test.log"),
   ensureDataDir: () => {},
-  migrateToDataLayout: () => {},
-  migrateToWorkspaceLayout: () => {},
 }));
 
 mock.module("../util/logger.js", () => ({

package/src/__tests__/pricing.test.ts

@@ -1,14 +1,39 @@
 import { describe, expect, test } from "bun:test";
 
 import type { ModelPricingOverride } from "../config/schema.js";
+import type { PricingUsage } from "../usage/types.js";
 import {
   estimateCost,
   resolvePricing,
+  resolvePricingForUsage,
+  resolvePricingForUsageWithOverrides,
   resolvePricingWithOverrides,
 } from "../util/pricing.js";
 
 describe("resolvePricing", () => {
   describe("Anthropic models", () => {
+    test("returns priced for claude-opus-4-6", () => {
+      const result = resolvePricing(
+        "anthropic",
+        "claude-opus-4-6",
+        1_000_000,
+        1_000_000,
+      );
+      expect(result.pricingStatus).toBe("priced");
+      expect(result.estimatedCostUsd).toBe(5 + 25);
+    });
+
+    test("returns priced for claude-opus-4-6-fast", () => {
+      const result = resolvePricing(
+        "anthropic",
+        "claude-opus-4-6-fast",
+        1_000_000,
+        1_000_000,
+      );
+      expect(result.pricingStatus).toBe("priced");
+      expect(result.estimatedCostUsd).toBe(30 + 150);
+    });
+
     test("returns priced for claude-opus-4", () => {
       const result = resolvePricing(
         "anthropic",
@@ -159,6 +184,17 @@ describe("resolvePricing", () => {
   });
 
   describe("prefix matching", () => {
+    test("matches claude-opus-4-6-20260205 via claude-opus-4-6 prefix", () => {
+      const result = resolvePricing(
+        "anthropic",
+        "claude-opus-4-6-20260205",
+        1_000_000,
+        1_000_000,
+      );
+      expect(result.pricingStatus).toBe("priced");
+      expect(result.estimatedCostUsd).toBe(5 + 25);
+    });
+
     test("matches claude-sonnet-4-6 via claude-sonnet-4 prefix", () => {
       const result = resolvePricing(
         "anthropic",
@@ -225,6 +261,52 @@ describe("resolvePricing", () => {
   });
 });
 
+describe("resolvePricingForUsage", () => {
+  test("prices mixed direct, cache read, and cache write Anthropic usage", () => {
+    const usage: PricingUsage = {
+      directInputTokens: 1_000_000,
+      outputTokens: 2_000_000,
+      cacheCreationInputTokens: 300_000,
+      cacheReadInputTokens: 300_000,
+      anthropicCacheCreation: {
+        ephemeral_5m_input_tokens: 200_000,
+        ephemeral_1h_input_tokens: 100_000,
+      },
+    };
+
+    const result = resolvePricingForUsage(
+      "anthropic",
+      "claude-opus-4-6",
+      usage,
+    );
+
+    expect(result.pricingStatus).toBe("priced");
+    expect(result.estimatedCostUsd).toBeCloseTo(57.4, 10);
+  });
+
+  test("returns unpriced with null cost for unknown provider", () => {
+    const usage: PricingUsage = {
+      directInputTokens: 10,
+      outputTokens: 20,
+      cacheCreationInputTokens: 30,
+      cacheReadInputTokens: 40,
+      anthropicCacheCreation: {
+        ephemeral_5m_input_tokens: 10,
+        ephemeral_1h_input_tokens: 20,
+      },
+    };
+
+    const result = resolvePricingForUsage(
+      "unknown-provider",
+      "some-model",
+      usage,
+    );
+
+    expect(result.pricingStatus).toBe("unpriced");
+    expect(result.estimatedCostUsd).toBeNull();
+  });
+});
+
 describe("resolvePricingWithOverrides", () => {
   test("uses override when matching provider and modelPattern", () => {
     const overrides: ModelPricingOverride[] = [
@@ -357,6 +439,39 @@ describe("resolvePricingWithOverrides", () => {
   });
 });
 
+describe("resolvePricingForUsageWithOverrides", () => {
+  test("uses override pricing for structured Anthropic usage", () => {
+    const usage: PricingUsage = {
+      directInputTokens: 1_000_000,
+      outputTokens: 1_000_000,
+      cacheCreationInputTokens: 200_000,
+      cacheReadInputTokens: 100_000,
+      anthropicCacheCreation: {
+        ephemeral_5m_input_tokens: 200_000,
+        ephemeral_1h_input_tokens: 0,
+      },
+    };
+    const overrides: ModelPricingOverride[] = [
+      {
+        provider: "anthropic",
+        modelPattern: "claude-opus-4-6",
+        inputPer1M: 10,
+        outputPer1M: 20,
+      },
+    ];
+
+    const result = resolvePricingForUsageWithOverrides(
+      "anthropic",
+      "claude-opus-4-6",
+      usage,
+      overrides,
+    );
+
+    expect(result.pricingStatus).toBe("priced");
+    expect(result.estimatedCostUsd).toBeCloseTo(32.6, 10);
+  });
+});
+
 describe("estimateCost", () => {
   test("returns a number for known Anthropic model", () => {
     const cost = estimateCost(
@@ -369,6 +484,16 @@ describe("estimateCost", () => {
     expect(cost).toBe(3 + 15);
   });
 
+  test("returns correct cost for standard claude-opus-4-6", () => {
+    const cost = estimateCost(
+      1_000_000,
+      1_000_000,
+      "claude-opus-4-6",
+      "anthropic",
+    );
+    expect(cost).toBe(5 + 25);
+  });
+
   test("returns 0 for unknown model", () => {
     const cost = estimateCost(
       1_000_000,

package/src/__tests__/provider-error-scenarios.test.ts

@@ -9,6 +9,8 @@ mock.module("../util/logger.js", () => ({
 // Only mock sleep so retries complete instantly; keep real retry logic.
 // NOTE: We must NOT use `await import()` inside mock.module — it deadlocks
 // bun's module resolver. Instead, inline the real exports and only replace sleep.
+const sleepSpy = mock((_ms: number) => Promise.resolve());
+
 mock.module("../util/retry.js", () => {
   const DEFAULT_MAX_RETRIES = 3;
   const DEFAULT_BASE_DELAY_MS = 1000;
@@ -86,7 +88,7 @@ mock.module("../util/retry.js", () => {
     isRetryableStatus,
     isRetryableNetworkError,
     extractRetryAfterMs,
-    sleep: () => Promise.resolve(),
+    sleep: sleepSpy,
     abortableSleep: () => Promise.resolve(),
   };
 });
@@ -256,6 +258,7 @@ describe("RetryProvider — rate limit backoff", () => {
   });
 
   test("caps retryAfterMs at MAX_RETRY_DELAY_MS", async () => {
+    sleepSpy.mockClear();
     const error = new ProviderError("rate limited", "anthropic", 429, {
       retryAfterMs: 3_600_000, // 1 hour - way too long
     });
@@ -265,8 +268,11 @@ describe("RetryProvider — rate limit backoff", () => {
     const result = await provider.sendMessage(MESSAGES);
     expect(result.content[0]).toMatchObject({ type: "text", text: "ok" });
     expect(inner.calls).toBe(2);
-    // The test passes quickly because sleep is mocked, but the important thing
-    // is that the provider doesn't hang - the cap is applied in the production code
+
+    // Verify sleep was called with the capped delay, not the original 3,600,000ms
+    const sleepCalls = sleepSpy.mock.calls;
+    const lastDelay = sleepCalls[sleepCalls.length - 1][0];
+    expect(lastDelay).toBe(60_000);
   });
 });