@vellumai/assistant 0.7.1 → 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-init.benchmark.test.ts

@@ -140,14 +140,12 @@ mock.module("../config/loader.js", () => ({
   getConfig: () => mockConfig,
   getConfigReadOnly: () => mockConfig,
   loadConfig: () => mockConfig,
-  saveConfig: () => {},
   invalidateConfigCache: () => {},
   loadRawConfig: () => ({}),
   saveRawConfig: () => {},
   getNestedValue: () => undefined,
   setNestedValue: () => {},
   applyNestedDefaults: (c: unknown) => c,
-  deepMergeMissing: () => {},
   deepMergeOverwrite: () => {},
   mergeDefaultWorkspaceConfig: () => {},
 }));

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

@@ -308,6 +308,42 @@ describe("loadFromDb metadata injection rehydration", () => {
     expect(messages[2].content).toEqual([{ type: "text", text: "Second" }]);
   });
 
+  test("historical wrapped memoryInjectedBlock rehydrates singly-wrapped", async () => {
+    // Historical v2 rows persisted `injectedBlockText` already wrapped in
+    // `<memory>...</memory>`. After unifying v2's storage with v1's
+    // unwrapped contract, the rehydrate path must defensively strip any
+    // pre-existing wrapper so old rows don't render double-wrapped.
+    mockConversation = defaultConv();
+    mockDbMessages = [
+      {
+        id: "m1",
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "Hi" }]),
+        metadata: JSON.stringify({
+          memoryInjectedBlock: "<memory>\nremember: alice\n</memory>",
+        }),
+      },
+      {
+        id: "m2",
+        role: "assistant",
+        content: JSON.stringify([{ type: "text", text: "Hello" }]),
+      },
+    ];
+
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+    const messages = conversation.getMessages();
+
+    expect(messages).toHaveLength(2);
+    const firstBlock = messages[0].content[0];
+    expect(firstBlock).toEqual({
+      type: "text",
+      text: "<memory>\nremember: alice\n</memory>",
+    });
+    if (firstBlock.type !== "text") throw new Error("unexpected block type");
+    expect(firstBlock.text.match(/<memory>/g)?.length).toBe(1);
+  });
+
   test("malformed metadata is tolerated: load does not throw, content unchanged", async () => {
     mockConversation = defaultConv();
     mockDbMessages = [

package/src/__tests__/conversation-process-app-control-preactivation.test.ts

@@ -0,0 +1,283 @@
+/**
+ * Verifies that the queue-drain paths in `conversation-process.ts` re-add
+ * the `app-control` skill to the conversation's preactivated set when the
+ * dequeued message's `userMessageInterface` supports the `host_app_control`
+ * proxy capability.
+ *
+ * Both `drainSingleMessage` (single-message path) and `drainBatch`
+ * (batched path) reset `preactivatedSkillIds = undefined` at the top of
+ * each drain. Without an explicit re-add, queued messages 2+ would lose
+ * the `app-control` skill — its tools wouldn't be projected to the LLM —
+ * even though the `HostAppControlProxy` is still attached to the
+ * conversation. This mirrors the existing parallel re-add for
+ * `computer-use` and uses the same `supportsHostProxy(_, "host_app_control")`
+ * gate that `prepareConversationForMessage` and the `conversation-routes`
+ * instantiation block use at first-message time.
+ */
+
+import { describe, expect, mock, test } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Module mocks for downstream side effects (DB writes, slash resolution,
+// notification preference extraction). The drain paths must be allowed to
+// reach the preactivation block; they must not be allowed to touch a real DB.
+// ---------------------------------------------------------------------------
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
+}));
+
+mock.module("../memory/conversation-crud.js", () => ({
+  setConversationOriginChannelIfUnset: () => {},
+  setConversationOriginInterfaceIfUnset: () => {},
+  provenanceFromTrustContext: () => ({
+    source: "user",
+    trustContext: undefined,
+  }),
+  addMessage: () => ({ id: "msg-mock" }),
+}));
+
+mock.module("../memory/canonical-guardian-store.js", () => ({
+  listPendingRequestsByConversationScope: () => [],
+}));
+
+mock.module("../memory/trace-event-store.js", () => ({
+  persistTraceEvent: () => {},
+  getMaxSequence: () => 0,
+}));
+
+mock.module("../notifications/preference-extractor.js", () => ({
+  extractPreferences: async () => ({ detected: false, preferences: [] }),
+}));
+
+mock.module("../notifications/preferences-store.js", () => ({
+  createPreference: () => {},
+}));
+
+mock.module("../agent/attachments.ts", () => ({
+  enrichMessageWithSourcePaths: <T>(msg: T) => msg,
+}));
+
+// Stub the batched-drain helper so the test doesn't fall through to real
+// SQLite paths after the preactivation block has already run. The drain
+// chain doesn't recurse here because our stubbed `runAgentLoop` is a no-op.
+mock.module("../daemon/conversation-messaging.js", () => ({
+  persistQueuedMessageBody: async () => "user-msg-id",
+}));
+
+// ---------------------------------------------------------------------------
+// Imports under test (after mocks)
+// ---------------------------------------------------------------------------
+
+import type { TurnInterfaceContext } from "../channels/types.js";
+import type { ProcessConversationContext } from "../daemon/conversation-process.js";
+import { drainQueue } from "../daemon/conversation-process.js";
+import {
+  MessageQueue,
+  type QueuedMessage,
+} from "../daemon/conversation-queue-manager.js";
+import { TraceEmitter } from "../daemon/trace-emitter.js";
+
+// ---------------------------------------------------------------------------
+// Fake context — captures preactivation calls, satisfies the bare minimum
+// of `ProcessConversationContext`. `runAgentLoop` resolves immediately so
+// the drain-chain does not recurse forever.
+// ---------------------------------------------------------------------------
+
+interface FakeRecord {
+  preactivatedSkillIdCalls: string[];
+}
+
+function makeFakeContext(opts: {
+  queue: MessageQueue;
+  turnInterfaceContext?: TurnInterfaceContext;
+}): ProcessConversationContext & FakeRecord {
+  const calls: string[] = [];
+  let preactivatedSkillIds: string[] | undefined = undefined;
+  const ctx = {
+    conversationId: "conv-app-control-preactivation",
+    messages: [],
+    processing: false,
+    abortController: null,
+    queue: opts.queue,
+    traceEmitter: new TraceEmitter("conv-app-control-preactivation", () => {}),
+    surfaceActionRequestIds: new Set<string>(),
+    usageStats: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
+    get preactivatedSkillIds(): string[] | undefined {
+      return preactivatedSkillIds;
+    },
+    set preactivatedSkillIds(value: string[] | undefined) {
+      preactivatedSkillIds = value;
+    },
+    preactivatedSkillIdCalls: calls,
+    addPreactivatedSkillId(id: string) {
+      calls.push(id);
+      if (!preactivatedSkillIds) {
+        preactivatedSkillIds = [id];
+      } else if (!preactivatedSkillIds.includes(id)) {
+        preactivatedSkillIds.push(id);
+      }
+    },
+    async ensureActorScopedHistory() {},
+    async persistUserMessage() {
+      return "user-msg-id";
+    },
+    async runAgentLoop() {
+      // No-op: the drain path's finally block would normally call drainQueue
+      // recursively. We intentionally do not chain another drain here so the
+      // test asserts on what the FIRST dequeue produced.
+    },
+    getTurnChannelContext: () => null,
+    setTurnChannelContext() {},
+    getTurnInterfaceContext: () => opts.turnInterfaceContext ?? null,
+    setTurnInterfaceContext() {},
+    emitActivityState() {},
+    async forceCompact() {
+      return {
+        compacted: false,
+        reason: "no-op",
+        estimatedInputTokens: 0,
+        previousEstimatedInputTokens: 0,
+        maxInputTokens: 100000,
+        compactedMessages: 0,
+      } as never;
+    },
+    setTransportHints() {},
+    applyHostEnvFromTransport() {},
+  } as unknown as ProcessConversationContext & FakeRecord;
+  return ctx;
+}
+
+function makeQueuedMessage(opts: {
+  requestId: string;
+  content?: string;
+  turnInterfaceContext?: TurnInterfaceContext;
+}): QueuedMessage {
+  return {
+    content: opts.content ?? "follow up",
+    attachments: [],
+    requestId: opts.requestId,
+    onEvent: () => {},
+    metadata: {},
+    sentAt: Date.now(),
+    turnInterfaceContext: opts.turnInterfaceContext,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("drainQueue preactivation re-add for host-proxy interfaces", () => {
+  test("drainSingleMessage re-adds 'app-control' for macOS-sourced queued message", async () => {
+    const queue = new MessageQueue();
+    const ifCtx: TurnInterfaceContext = {
+      userMessageInterface: "macos",
+      assistantMessageInterface: "macos",
+    };
+    queue.push(
+      makeQueuedMessage({ requestId: "req-2", turnInterfaceContext: ifCtx }),
+    );
+    const ctx = makeFakeContext({ queue, turnInterfaceContext: ifCtx });
+
+    await drainQueue(ctx);
+
+    // Both CU and app-control must be re-preactivated for queued macOS turns.
+    expect(ctx.preactivatedSkillIdCalls).toContain("computer-use");
+    expect(ctx.preactivatedSkillIdCalls).toContain("app-control");
+    expect(ctx.preactivatedSkillIds).toContain("app-control");
+  });
+
+  test("drainSingleMessage does not re-add 'app-control' for chrome-extension (host_app_control unsupported)", async () => {
+    const queue = new MessageQueue();
+    // chrome-extension supports host_browser but NOT host_app_control. The
+    // CU re-add (no-arg form) also returns false for chrome-extension, so
+    // neither skill should be re-preactivated.
+    const ifCtx: TurnInterfaceContext = {
+      userMessageInterface: "chrome-extension",
+      assistantMessageInterface: "chrome-extension",
+    };
+    queue.push(
+      makeQueuedMessage({ requestId: "req-2", turnInterfaceContext: ifCtx }),
+    );
+    const ctx = makeFakeContext({ queue, turnInterfaceContext: ifCtx });
+
+    await drainQueue(ctx);
+
+    expect(ctx.preactivatedSkillIdCalls).not.toContain("computer-use");
+    expect(ctx.preactivatedSkillIdCalls).not.toContain("app-control");
+  });
+
+  test("drainSingleMessage does not re-add 'app-control' for non-host-proxy interface (slack)", async () => {
+    const queue = new MessageQueue();
+    const ifCtx: TurnInterfaceContext = {
+      userMessageInterface: "slack",
+      assistantMessageInterface: "slack",
+    };
+    queue.push(
+      makeQueuedMessage({ requestId: "req-2", turnInterfaceContext: ifCtx }),
+    );
+    const ctx = makeFakeContext({ queue, turnInterfaceContext: ifCtx });
+
+    await drainQueue(ctx);
+
+    expect(ctx.preactivatedSkillIdCalls).not.toContain("computer-use");
+    expect(ctx.preactivatedSkillIdCalls).not.toContain("app-control");
+  });
+
+  test("drainBatch re-adds 'app-control' for macOS-sourced batched queue", async () => {
+    const queue = new MessageQueue();
+    const ifCtx: TurnInterfaceContext = {
+      userMessageInterface: "macos",
+      assistantMessageInterface: "macos",
+    };
+    // Two passthrough siblings with matching interface — buildPassthroughBatch
+    // groups them into a batch, exercising drainBatch.
+    queue.push(
+      makeQueuedMessage({
+        requestId: "req-2",
+        content: "msg-2",
+        turnInterfaceContext: ifCtx,
+      }),
+    );
+    queue.push(
+      makeQueuedMessage({
+        requestId: "req-3",
+        content: "msg-3",
+        turnInterfaceContext: ifCtx,
+      }),
+    );
+    const ctx = makeFakeContext({ queue, turnInterfaceContext: ifCtx });
+
+    await drainQueue(ctx);
+
+    // Batched path mirrors the single-message preactivation block.
+    expect(ctx.preactivatedSkillIdCalls).toContain("computer-use");
+    expect(ctx.preactivatedSkillIdCalls).toContain("app-control");
+    expect(ctx.preactivatedSkillIds).toContain("app-control");
+  });
+
+  test("drainSingleMessage skips 'app-control' re-add when isInteractive=false", async () => {
+    const queue = new MessageQueue();
+    const ifCtx: TurnInterfaceContext = {
+      userMessageInterface: "macos",
+      assistantMessageInterface: "macos",
+    };
+    const qm = makeQueuedMessage({
+      requestId: "req-2",
+      turnInterfaceContext: ifCtx,
+    });
+    qm.isInteractive = false;
+    queue.push(qm);
+    const ctx = makeFakeContext({ queue, turnInterfaceContext: ifCtx });
+
+    await drainQueue(ctx);
+
+    // Both branches share the outer `isInteractive !== false` gate, so
+    // app-control follows CU's behavior and is skipped for non-interactive
+    // turns even on macOS.
+    expect(ctx.preactivatedSkillIdCalls).not.toContain("computer-use");
+    expect(ctx.preactivatedSkillIdCalls).not.toContain("app-control");
+  });
+});

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-routes-disk-view.test.ts

@@ -207,6 +207,12 @@ function createFakeConversation(conversationId: string): Conversation {
     setHostCuProxy(this: { hostCuProxy: unknown }, proxy: unknown) {
       this.hostCuProxy = proxy;
     },
+    setHostAppControlProxy(
+      this: { hostAppControlProxy: unknown },
+      proxy: unknown,
+    ) {
+      this.hostAppControlProxy = proxy;
+    },
     restoreBrowserProxyAvailability: () => {},
     addPreactivatedSkillId: () => {},
     hasAnyPendingConfirmation: () => false,