@vellumai/assistant 0.7.2 → 0.7.3

package/src/__tests__/conversation-error.test.ts

@@ -1,4 +1,11 @@
-import { describe, expect, it } from "bun:test";
+import { beforeEach, describe, expect, it, mock } from "bun:test";
+
+let providerRoutingSources: Record<string, "user-key" | "managed-proxy"> = {};
+
+mock.module("../providers/registry.js", () => ({
+  getProviderRoutingSource: (provider: string) =>
+    providerRoutingSources[provider],
+}));
 
 import type { ErrorContext } from "../daemon/conversation-error.js";
 import {
@@ -63,6 +70,10 @@ describe("isUserCancellation", () => {
 describe("classifyConversationError", () => {
   const baseCtx: ErrorContext = { phase: "agent_loop" };
 
+  beforeEach(() => {
+    providerRoutingSources = {};
+  });
+
   describe("network errors", () => {
     const cases = [
       "ECONNREFUSED",
@@ -105,6 +116,52 @@ describe("classifyConversationError", () => {
         expect(result.errorCategory).toBe("rate_limit");
       });
     }
+
+    it("classifies managed-proxy daily quota responses as MANAGED_USAGE_LIMIT", () => {
+      const err = new ProviderError(
+        'Anthropic API error (429): 429 {"code":"daily_quota_exceeded","detail":"You\'ve reached your usage limit for today. You\'ve made 1000 requests, but your current plan allows 1000 per day.","provider":"anthropic"}',
+        "anthropic",
+        429,
+      );
+
+      const result = classifyConversationError(err, baseCtx);
+
+      expect(result.code).toBe("MANAGED_USAGE_LIMIT");
+      expect(result.retryable).toBe(true);
+      expect(result.userMessage).toContain("Vellum managed inference");
+      expect(result.userMessage).toContain("not an AI provider outage");
+      expect(result.errorCategory).toBe("managed_usage_limit");
+    });
+
+    it("classifies managed-proxy routed 429s as MANAGED_USAGE_LIMIT", () => {
+      providerRoutingSources.anthropic = "managed-proxy";
+      const err = new ProviderError(
+        "Anthropic API error (429): Too many requests",
+        "anthropic",
+        429,
+      );
+
+      const result = classifyConversationError(err, baseCtx);
+
+      expect(result.code).toBe("MANAGED_USAGE_LIMIT");
+      expect(result.userMessage).toContain("Vellum managed inference");
+      expect(result.errorCategory).toBe("managed_usage_limit");
+    });
+
+    it("keeps provider copy for direct provider 429s", () => {
+      providerRoutingSources.anthropic = "user-key";
+      const err = new ProviderError(
+        "Anthropic API error (429): Too many requests",
+        "anthropic",
+        429,
+      );
+
+      const result = classifyConversationError(err, baseCtx);
+
+      expect(result.code).toBe("PROVIDER_RATE_LIMIT");
+      expect(result.userMessage).toContain("AI provider");
+      expect(result.errorCategory).toBe("rate_limit");
+    });
   });
 
   describe("provider overloaded errors", () => {
@@ -509,11 +566,11 @@ describe("classifyConversationError", () => {
       expect(result.errorCategory).toBe("provider_not_configured");
     });
 
-    it("classifies ProviderError with 402 as credits_exhausted (non-retryable)", () => {
+    it("classifies direct ProviderError with 402 as provider_billing (non-retryable)", () => {
       const err = new ProviderError("Payment Required", "anthropic", 402);
       const result = classifyConversationError(err, baseCtx);
       expect(result.code).toBe("PROVIDER_BILLING");
-      expect(result.errorCategory).toBe("credits_exhausted");
+      expect(result.errorCategory).toBe("provider_billing");
       expect(result.retryable).toBe(false);
     });
 
@@ -560,6 +617,96 @@ describe("classifyConversationError", () => {
     });
   });
 
+  describe("OpenRouter billing classification", () => {
+    it("keeps managed-proxy OpenRouter 402 responses as credits_exhausted", () => {
+      providerRoutingSources.openrouter = "managed-proxy";
+      const err = new ProviderError(
+        "OpenRouter API error (402): Payment Required",
+        "openrouter",
+        402,
+      );
+
+      const result = classifyConversationError(err, baseCtx);
+
+      expect(result.code).toBe("PROVIDER_BILLING");
+      expect(result.errorCategory).toBe("credits_exhausted");
+      expect(result.retryable).toBe(false);
+      expect(result.userMessage).toContain("Add funds");
+      expect(result.userMessage).toContain("assistant");
+    });
+
+    it("classifies direct Anthropic, OpenAI, and OpenRouter 402 responses as provider_billing", () => {
+      providerRoutingSources.anthropic = "user-key";
+      providerRoutingSources.openai = "user-key";
+      providerRoutingSources.openrouter = "user-key";
+
+      for (const provider of ["anthropic", "openai", "openrouter"]) {
+        const err = new ProviderError(
+          `${provider} API error (402): Payment Required`,
+          provider,
+          402,
+        );
+
+        const result = classifyConversationError(err, baseCtx);
+
+        expect(result.code).toBe("PROVIDER_BILLING");
+        expect(result.errorCategory).toBe("provider_billing");
+        expect(result.retryable).toBe(false);
+        expect(result.userMessage).toContain("provider");
+        expect(result.userMessage).toContain("Settings");
+      }
+    });
+
+    it("classifies OpenRouter 400 credit-limit messages as provider_billing", () => {
+      const cases = [
+        "OpenRouter API error (400): This request requires more credits",
+        "OpenRouter API error (400): You can only afford 1000 tokens",
+      ];
+
+      for (const message of cases) {
+        const err = new ProviderError(message, "openrouter", 400);
+
+        const result = classifyConversationError(err, baseCtx);
+
+        expect(result.code).toBe("PROVIDER_BILLING");
+        expect(result.errorCategory).toBe("provider_billing");
+        expect(result.retryable).toBe(false);
+      }
+    });
+
+    it("classifies managed-proxy OpenRouter insufficient_balance bodies as credits_exhausted", () => {
+      providerRoutingSources.openrouter = "managed-proxy";
+      const err = new ProviderError(
+        'OpenRouter API error (402): {"code":"insufficient_balance","detail":"Managed balance exhausted"}',
+        "openrouter",
+        402,
+      );
+
+      const result = classifyConversationError(err, baseCtx);
+
+      expect(result.code).toBe("PROVIDER_BILLING");
+      expect(result.errorCategory).toBe("credits_exhausted");
+      expect(result.retryable).toBe(false);
+    });
+
+    it("classifies direct OpenRouter insufficient_balance bodies as provider_billing", () => {
+      providerRoutingSources.openrouter = "user-key";
+      const err = new ProviderError(
+        'OpenRouter API error (402): {"code":"insufficient_balance","detail":"Provider account balance exhausted"}',
+        "openrouter",
+        402,
+      );
+
+      const result = classifyConversationError(err, baseCtx);
+
+      expect(result.code).toBe("PROVIDER_BILLING");
+      expect(result.errorCategory).toBe("provider_billing");
+      expect(result.retryable).toBe(false);
+      expect(result.userMessage).toContain("provider");
+      expect(result.userMessage).toContain("Settings");
+    });
+  });
+
   describe("debug detail truncation", () => {
     it("truncates debugDetails longer than 4000 chars", () => {
       const longMsg = "x".repeat(5000);

package/src/__tests__/conversation-process-callsite.test.ts

@@ -12,8 +12,14 @@
  */
 import { describe, expect, mock, test } from "bun:test";
 
+import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
 import type { Message, ProviderResponse } from "../providers/types.js";
 
+// This test exercises v1 conversation routing. The `memory-v2-enabled` flag
+// (registry default `true`) flips memory routing to v2 — disable it here so
+// the v1 paths under test stay active.
+_setOverridesForTesting({ "memory-v2-enabled": false });
+
 // Use an object wrapper so TypeScript doesn't narrow the captured type to
 // `undefined` based on the initial assignment in the test setup.
 const captured: {
@@ -382,4 +388,41 @@ describe("processMessage callSite threading", () => {
     expect(captured.resolvedMaxTokens).toBe(1234);
     expect(captured.resolvedHasMaxTokens).toBe(true);
   });
+
+  test("applies clientTimezone in the create and reuse transport metadata path", async () => {
+    mockConversation = {
+      id: "conv-store-client-timezone",
+      contextSummary: null,
+      contextCompactedMessageCount: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalEstimatedCost: 0,
+    };
+    mockDbMessages = [];
+    clearCaptured();
+    clearAllActiveConversations();
+
+    const conversation = await getOrCreateConversation(
+      "conv-store-client-timezone",
+      {
+        transport: {
+          channelId: "vellum",
+          interfaceId: "macos",
+          clientTimezone: "america/new_york",
+        },
+      },
+    );
+
+    expect(conversation.clientTimezone).toBe("America/New_York");
+
+    await getOrCreateConversation("conv-store-client-timezone", {
+      transport: {
+        channelId: "vellum",
+        interfaceId: "ios",
+        clientTimezone: "europe/london",
+      },
+    });
+
+    expect(conversation.clientTimezone).toBe("Europe/London");
+  });
 });

package/src/__tests__/conversation-provider-retry-repair.test.ts

@@ -1,11 +1,17 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type { AgentEvent } from "../agent/loop.js";
+import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
 import type { UserMessageAttachment } from "../daemon/message-protocol.js";
 import { resetPluginRegistryAndRegisterDefaults } from "../plugins/defaults/index.js";
 import type { Message, ProviderResponse } from "../providers/types.js";
 import { ProviderError } from "../util/errors.js";
 
+// This test exercises v1 conversation routing. The `memory-v2-enabled` flag
+// (registry default `true`) flips memory routing to v2 — disable it here so
+// the v1 paths under test stay active.
+_setOverridesForTesting({ "memory-v2-enabled": false });
+
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, { get: () => () => {} }),

package/src/__tests__/conversation-runtime-assembly.test.ts

@@ -1,5 +1,12 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
+
+// This test exercises v1 conversation routing. The `memory-v2-enabled` flag
+// (registry default `true`) flips memory routing to v2 — disable it here so
+// the v1 paths under test stay active.
+_setOverridesForTesting({ "memory-v2-enabled": false });
+
 // PKB search is mocked so the reminder-hints tests can assert behavior
 // without standing up Qdrant. The mock returns whatever is staged in
 // `pkbSearchResults` / `pkbSearchThrows` for the enclosing test.
@@ -1430,6 +1437,64 @@ describe("buildUnifiedTurnContextBlock", () => {
     expect(text).toContain("time_since_last_message: yesterday");
     expect(text).toContain("canonical_actor_identity: user-1");
   });
+
+  test("timezone mismatch: omits extra lines when there is no manual override", () => {
+    const text = buildUnifiedTurnContextBlock({
+      timestamp: "2026-04-02 (Thursday) 08:00:00 -04:00 (America/New_York)",
+      clientTimezone: "America/New_York",
+      detectedTimezone: "America/New_York",
+    });
+
+    expect(text).toContain(
+      "current_time: 2026-04-02 (Thursday) 08:00:00 -04:00 (America/New_York)",
+    );
+    expect(text).not.toContain("configured_user_timezone:");
+    expect(text).not.toContain("client_device_timezone:");
+    expect(text).not.toContain("timezone_update_available:");
+  });
+
+  test("timezone mismatch: omits extra lines when configured and client timezone match", () => {
+    const text = buildUnifiedTurnContextBlock({
+      timestamp: "2026-04-02 (Thursday) 08:00:00 -04:00 (America/New_York)",
+      configuredUserTimezone: "America/New_York",
+      clientTimezone: "America/New_York",
+      detectedTimezone: "America/New_York",
+    });
+
+    expect(text).not.toContain("configured_user_timezone:");
+    expect(text).not.toContain("client_device_timezone:");
+    expect(text).not.toContain("timezone_update_available:");
+  });
+
+  test("timezone mismatch: emits configured and client device timezone when they differ", () => {
+    const text = buildUnifiedTurnContextBlock({
+      timestamp: "2026-04-02 (Thursday) 08:00:00 -04:00 (America/New_York)",
+      configuredUserTimezone: "America/New_York",
+      clientTimezone: "America/Los_Angeles",
+      detectedTimezone: "America/Los_Angeles",
+    });
+
+    expect(text).toContain("configured_user_timezone: America/New_York");
+    expect(text).toContain("client_device_timezone: America/Los_Angeles");
+  });
+
+  test("timezone mismatch: emits CLI affordance only in mismatch case", () => {
+    const mismatchText = buildUnifiedTurnContextBlock({
+      timestamp: "2026-04-02 (Thursday) 08:00:00 -04:00 (America/New_York)",
+      configuredUserTimezone: "America/New_York",
+      clientTimezone: "America/Los_Angeles",
+    });
+    const matchingText = buildUnifiedTurnContextBlock({
+      timestamp: "2026-04-02 (Thursday) 08:00:00 -04:00 (America/New_York)",
+      configuredUserTimezone: "America/New_York",
+      clientTimezone: "America/New_York",
+    });
+
+    expect(mismatchText).toContain(
+      'timezone_update_available: after explicit user confirmation, persist client_device_timezone with `assistant config set ui.userTimezone "America/Los_Angeles"`',
+    );
+    expect(matchingText).not.toContain("timezone_update_available:");
+  });
 });
 
 // ---------------------------------------------------------------------------

package/src/__tests__/conversation-slash-unknown.test.ts

@@ -5,9 +5,15 @@ import type {
   CheckpointDecision,
   CheckpointInfo,
 } from "../agent/loop.js";
+import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import type { Message, ProviderResponse } from "../providers/types.js";
 
+// This test exercises v1 conversation routing. The `memory-v2-enabled` flag
+// (registry default `true`) flips memory routing to v2 — disable it here so
+// the v1 paths under test stay active.
+_setOverridesForTesting({ "memory-v2-enabled": false });
+
 // ---------------------------------------------------------------------------
 // Mocks — must precede the Conversation import so Bun applies them at load time.
 // ---------------------------------------------------------------------------

package/src/__tests__/conversation-speed-override.test.ts

@@ -294,7 +294,6 @@ describe("per-conversation speed override", () => {
       4096,
       makeSendToClient(),
       "/tmp",
-      undefined, // memoryPolicy
       undefined, // sharedCesClient
       "standard", // speedOverride
     );
@@ -315,7 +314,6 @@ describe("per-conversation speed override", () => {
       4096,
       makeSendToClient(),
       "/tmp",
-      undefined, // memoryPolicy
       undefined, // sharedCesClient
       // no speedOverride — should fall back to global config "fast"
     );
@@ -335,7 +333,6 @@ describe("per-conversation speed override", () => {
       4096,
       makeSendToClient(),
       "/tmp",
-      undefined, // memoryPolicy
       undefined, // sharedCesClient
       "fast", // speedOverride
     );

package/src/__tests__/conversation-store.test.ts

@@ -19,7 +19,6 @@ import {
   createConversation,
   deleteLastExchange,
   getConversation,
-  getConversationMemoryScopeId,
   getMessages,
 } from "../memory/conversation-crud.js";
 import { isLastUserMessageToolResult } from "../memory/conversation-queries.js";
@@ -454,23 +453,6 @@ describe("createConversation with conversation type option", () => {
   });
 });
 
-describe("conversation metadata read helpers", () => {
-  beforeEach(() => {
-    const db = getDb();
-    db.run(`DELETE FROM messages`);
-    db.run(`DELETE FROM conversations`);
-  });
-
-  test("getConversationMemoryScopeId returns default for standard conversation", () => {
-    const conv = createConversation("test");
-    expect(getConversationMemoryScopeId(conv.id)).toBe("default");
-  });
-
-  test("getConversationMemoryScopeId returns default for missing conversation", () => {
-    expect(getConversationMemoryScopeId("nonexistent-id")).toBe("default");
-  });
-});
-
 // ---------------------------------------------------------------------------
 // Baseline: attachment reuse across conversations
 // ---------------------------------------------------------------------------

package/src/__tests__/conversation-surfaces-app-control.test.ts

@@ -33,8 +33,11 @@ mock.module("../runtime/pending-interactions.js", () => ({
 
 const { surfaceProxyResolver } =
   await import("../daemon/conversation-surfaces.js");
-const { HostAppControlProxy, _resetActiveAppControlConversationId } =
-  await import("../daemon/host-app-control-proxy.js");
+const {
+  HostAppControlProxy,
+  _resetActiveAppControlSession,
+  _setActiveAppControlSession,
+} = await import("../daemon/host-app-control-proxy.js");
 type SurfaceConversationContext =
   import("../daemon/conversation-surfaces.js").SurfaceConversationContext;
 
@@ -83,11 +86,11 @@ describe("surfaceProxyResolver — app-control tool routing", () => {
   beforeEach(() => {
     sentMessages.length = 0;
     mockHasClient = true;
-    _resetActiveAppControlConversationId();
+    _resetActiveAppControlSession();
   });
 
   afterEach(() => {
-    _resetActiveAppControlConversationId();
+    _resetActiveAppControlSession();
   });
 
   // -------------------------------------------------------------------------
@@ -148,6 +151,10 @@ describe("surfaceProxyResolver — app-control tool routing", () => {
     test("app_control_observe routes through proxy and returns observation", async () => {
       const proxy = new HostAppControlProxy("conv-1");
       const ctx = buildMockContext(proxy, "conv-1");
+      _setActiveAppControlSession({
+        conversationId: "conv-1",
+        app: "com.example.editor",
+      });
 
       const resultPromise = surfaceProxyResolver(ctx, "app_control_observe", {
         tool: "observe",
@@ -254,6 +261,10 @@ describe("surfaceProxyResolver — app-control tool routing", () => {
     test("injects `tool` derived from toolName when the agent input omits it", async () => {
       const proxy = new HostAppControlProxy("conv-1");
       const ctx = buildMockContext(proxy, "conv-1");
+      _setActiveAppControlSession({
+        conversationId: "conv-1",
+        app: "com.example.editor",
+      });
 
       // Agent inputs do not carry the discriminator — the resolver has to
       // synthesize it from `toolName` ("app_control_observe" → "observe")