@vellumai/assistant 0.6.3 → 0.6.5

package/src/__tests__/conversation-confirmation-signals.test.ts

@@ -57,15 +57,33 @@ mock.module("../providers/registry.js", () => ({
 mock.module("../config/loader.js", () => ({
   getConfig: () => ({
     ui: {},
-    provider: "mock-provider",
-    maxTokens: 4096,
-    thinking: false,
-    contextWindow: {
-      maxInputTokens: 100000,
-      thresholdTokens: 80000,
-      preserveRecentMessages: 6,
-      summaryModel: "mock-model",
-      maxSummaryTokens: 512,
+    llm: {
+      default: {
+        provider: "mock-provider",
+        model: "mock-model",
+        maxTokens: 4096,
+        effort: "max" as const,
+        speed: "standard" as const,
+        temperature: null,
+        thinking: { enabled: false, streamThinking: true },
+        contextWindow: {
+          enabled: true,
+          maxInputTokens: 100000,
+          targetBudgetRatio: 0.3,
+          compactThreshold: 0.8,
+          summaryBudgetRatio: 0.05,
+          overflowRecovery: {
+            enabled: true,
+            safetyMarginRatio: 0.05,
+            maxAttempts: 3,
+            interactiveLatestTurnCompression: "summarize",
+            nonInteractiveLatestTurnCompression: "truncate",
+          },
+        },
+      },
+      profiles: {},
+      callSites: {},
+      pricingOverrides: [],
     },
     rateLimit: { maxRequestsPerMinute: 0 },
     timeouts: { permissionTimeoutSec: 1 },
@@ -177,6 +195,9 @@ mock.module("../agent/loop.js", () => ({
     getToolTokenBudget() {
       return 0;
     }
+    getActiveModel() {
+      return undefined;
+    }
     async run(
       _messages: Message[],
       _onEvent: (event: AgentEvent) => void,
@@ -713,3 +734,138 @@ describe("restoreBrowserProxyAvailability", () => {
     expect(registry).not.toContain(probe);
   });
 });
+
+describe("hostBrowserSenderOverride is sender-mode based, not interface-string based", () => {
+  test("macOS turn with registry override routes browser frames through the registry sender", () => {
+    // When a macOS turn sets hostBrowserSenderOverride (because the
+    // guardian has an active extension connection), the browser proxy
+    // must route through the registry sender, not the SSE hub — the
+    // same behavior chrome-extension turns have always used.
+    const sseHub: ServerMessage[] = [];
+    const registry: ServerMessage[] = [];
+    const conversation = makeConversation((msg) => sseHub.push(msg));
+    const browserProxy = new HostBrowserProxy(() => {});
+    conversation.setHostBrowserProxy(browserProxy);
+
+    // macOS is interactive — hasNoClient is false.
+    conversation.updateClient((msg) => sseHub.push(msg), false);
+
+    // The POST /messages handler detected an active extension connection
+    // and set the registry-routed sender override.
+    const registrySender = (msg: ServerMessage) => registry.push(msg);
+    conversation.hostBrowserSenderOverride = registrySender;
+
+    // restoreBrowserProxyAvailability (called after updateClient in the
+    // POST handler) must prefer the override.
+    conversation.restoreBrowserProxyAvailability();
+    expect(browserProxy.isAvailable()).toBe(true);
+
+    // Verify frames flow through the registry, not the SSE hub.
+    const internalSend = (
+      browserProxy as unknown as {
+        sendToClient: (msg: ServerMessage) => void;
+      }
+    ).sendToClient;
+    const probe: ServerMessage = {
+      type: "host_browser_cancel",
+      requestId: "probe-macos-registry",
+    } as ServerMessage;
+    internalSend(probe);
+    expect(registry).toHaveLength(1);
+    expect(sseHub.some((m) => m === probe)).toBe(false);
+  });
+
+  test("macOS turn without registry override clears the browser proxy on restore", () => {
+    // When a macOS turn has no active extension connection, the override
+    // is cleared and restoreBrowserProxyAvailability falls back to the
+    // SSE hub sender. The proxy should not be stuck on an unavailable
+    // registry-routed sender from a prior chrome-extension turn.
+    const sseHub: ServerMessage[] = [];
+    const conversation = makeConversation((msg) => sseHub.push(msg));
+    const browserProxy = new HostBrowserProxy(() => {});
+    conversation.setHostBrowserProxy(browserProxy);
+
+    // Interactive macOS turn without extension connectivity.
+    conversation.updateClient((msg) => sseHub.push(msg), false);
+    conversation.hostBrowserSenderOverride = undefined;
+    conversation.restoreBrowserProxyAvailability();
+
+    // The proxy should be available and routed through SSE.
+    expect(browserProxy.isAvailable()).toBe(true);
+    const internalSend = (
+      browserProxy as unknown as {
+        sendToClient: (msg: ServerMessage) => void;
+      }
+    ).sendToClient;
+    const probe: ServerMessage = {
+      type: "host_browser_cancel",
+      requestId: "probe-macos-sse",
+    } as ServerMessage;
+    internalSend(probe);
+    expect(sseHub).toContain(probe);
+  });
+
+  test("override semantics are symmetric: chrome-extension and macOS both set override when registry-routed", () => {
+    // The override field must be set for ANY interface that uses a
+    // registry-routed sender, and cleared for any that does not.
+    // This test verifies the field is not gated on interface strings.
+    const conversation = makeConversation();
+    const registrySender = () => {};
+
+    // Simulate chrome-extension setting the override.
+    conversation.hostBrowserSenderOverride = registrySender;
+    expect(conversation.hostBrowserSenderOverride).toBe(registrySender);
+
+    // Simulate macOS-with-extension setting the same override.
+    // The field value is the same registry sender, not gated by interface.
+    const macosRegistrySender = () => {};
+    conversation.hostBrowserSenderOverride = macosRegistrySender;
+    expect(conversation.hostBrowserSenderOverride).toBe(macosRegistrySender);
+
+    // Simulate macOS-without-extension clearing the override.
+    conversation.hostBrowserSenderOverride = undefined;
+    expect(conversation.hostBrowserSenderOverride).toBeUndefined();
+  });
+
+  test("queue-drain restore path preserves registry-routed sender for macOS turns", () => {
+    // When a macOS turn with an active extension connection has its
+    // messages queued and later drained, the drain-queue path calls
+    // restoreBrowserProxyAvailability(). With the override set, the
+    // proxy must be restored with the registry sender, not the SSE hub.
+    const sseHub: ServerMessage[] = [];
+    const registry: ServerMessage[] = [];
+    const conversation = makeConversation((msg) => sseHub.push(msg));
+    const browserProxy = new HostBrowserProxy(() => {});
+    conversation.setHostBrowserProxy(browserProxy);
+
+    // macOS interactive turn with extension connectivity.
+    conversation.updateClient((msg) => sseHub.push(msg), false);
+    const registrySender = (msg: ServerMessage) => registry.push(msg);
+    conversation.hostBrowserSenderOverride = registrySender;
+    conversation.restoreBrowserProxyAvailability();
+    expect(browserProxy.isAvailable()).toBe(true);
+
+    // Simulate drain-queue clearing all proxies for a non-interactive
+    // queued message, then restoring for the next macOS turn.
+    conversation.clearProxyAvailability();
+    expect(browserProxy.isAvailable()).toBe(false);
+
+    // Drain restore — override is still set from the POST handler.
+    conversation.restoreBrowserProxyAvailability();
+    expect(browserProxy.isAvailable()).toBe(true);
+
+    // Verify the registry sender was preserved, not the SSE hub.
+    const internalSend = (
+      browserProxy as unknown as {
+        sendToClient: (msg: ServerMessage) => void;
+      }
+    ).sendToClient;
+    const probe: ServerMessage = {
+      type: "host_browser_cancel",
+      requestId: "probe-drain-macos",
+    } as ServerMessage;
+    internalSend(probe);
+    expect(registry).toHaveLength(1);
+    expect(sseHub.some((m) => m === probe)).toBe(false);
+  });
+});

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

@@ -6,6 +6,10 @@ import {
   classifyConversationError,
   isUserCancellation,
 } from "../daemon/conversation-error.js";
+import {
+  type AbortReasonKind,
+  createAbortReason,
+} from "../util/abort-reasons.js";
 import { ProviderError, ProviderNotConfiguredError } from "../util/errors.js";
 
 describe("isUserCancellation", () => {
@@ -117,7 +121,7 @@ describe("classifyConversationError", () => {
 
     it("classifies Anthropic overloaded_error (no statusCode) as PROVIDER_OVERLOADED", () => {
       const err = new ProviderError(
-        'Anthropic API error (undefined): {"type":"error","error":{"type":"overloaded_error","message":"Overloaded"}}',
+        'Anthropic API error: {"type":"error","error":{"type":"overloaded_error","message":"Overloaded"}}',
         "anthropic",
       );
       const result = classifyConversationError(err, baseCtx);
@@ -309,6 +313,37 @@ describe("classifyConversationError", () => {
     });
   });
 
+  describe("stale web-search encrypted_content errors", () => {
+    const cases = [
+      "messages.205.content.0: Invalid `encrypted_content` in `search_result` block",
+      "Invalid encrypted_content in search_result block",
+      "Invalid `encrypted_content` in `web_search_result` block",
+    ];
+
+    for (const msg of cases) {
+      it(`classifies "${msg.slice(0, 50)}…" as PROVIDER_WEB_SEARCH / stale_web_search_content`, () => {
+        const result = classifyConversationError(new Error(msg), baseCtx);
+        expect(result.code).toBe("PROVIDER_WEB_SEARCH");
+        expect(result.retryable).toBe(true);
+        expect(result.errorCategory).toBe("stale_web_search_content");
+        expect(result.userMessage).toBe(
+          "Stale web-search results in conversation history. Please try again.",
+        );
+      });
+    }
+
+    it("classifies 400 ProviderError with stale encrypted_content payload", () => {
+      const err = new ProviderError(
+        'Anthropic API error (400): 400 {"error":{"message":"Provider returned error","code":400,"metadata":{"raw":"{\\"type\\":\\"error\\",\\"error\\":{\\"type\\":\\"invalid_request_error\\",\\"message\\":\\"messages.205.content.0: Invalid `encrypted_content` in `search_result` block\\"}}","provider_name":"Anthropic","is_byok":false}}}',
+        "anthropic",
+        400,
+      );
+      const result = classifyConversationError(err, baseCtx);
+      expect(result.code).toBe("PROVIDER_WEB_SEARCH");
+      expect(result.errorCategory).toBe("stale_web_search_content");
+    });
+  });
+
   describe("provider not configured errors", () => {
     it("classifies ProviderNotConfiguredError as PROVIDER_NOT_CONFIGURED", () => {
       const err = new ProviderNotConfiguredError("anthropic", []);
@@ -563,6 +598,72 @@ describe("classifyConversationError", () => {
       expect(isUserCancellation(err, aborted)).toBe(true);
     });
   });
+
+  describe("wrapped ProviderError carrying tagged abort reason", () => {
+    const abortedCtx: ErrorContext = { phase: "agent_loop", aborted: true };
+    const taggedKinds: AbortReasonKind[] = [
+      "user_cancel",
+      "preempted_by_new_message",
+      "conversation_disposed",
+      "subagent_aborted",
+      "signal_cancel",
+      "voice_session_aborted",
+      "work_item_aborted",
+    ];
+
+    for (const kind of taggedKinds) {
+      it(`treats ProviderError with abortReason kind="${kind}" as user cancellation`, () => {
+        const wrapped = new ProviderError(
+          "Anthropic API error: Request was aborted.",
+          "anthropic",
+          undefined,
+          { abortReason: createAbortReason(kind, `test:${kind}`) },
+        );
+        expect(isUserCancellation(wrapped, abortedCtx)).toBe(true);
+      });
+    }
+
+    it("does NOT treat tagged ProviderError as cancellation when ctx.aborted is false", () => {
+      const wrapped = new ProviderError(
+        "Anthropic API error: Request was aborted.",
+        "anthropic",
+        undefined,
+        { abortReason: createAbortReason("user_cancel", "test") },
+      );
+      const notAborted: ErrorContext = { phase: "agent_loop", aborted: false };
+      expect(isUserCancellation(wrapped, notAborted)).toBe(false);
+    });
+
+    it("does NOT treat ProviderError without abortReason as cancellation", () => {
+      const wrapped = new ProviderError(
+        "Anthropic API error: Request was aborted.",
+        "anthropic",
+        undefined,
+      );
+      expect(isUserCancellation(wrapped, abortedCtx)).toBe(false);
+    });
+
+    it("does NOT treat ProviderError with foreign reason as cancellation", () => {
+      const wrapped = new ProviderError(
+        "Anthropic API error: Request was aborted.",
+        "anthropic",
+        undefined,
+        { abortReason: { kind: "user_cancel", source: "spoofed" } },
+      );
+      expect(isUserCancellation(wrapped, abortedCtx)).toBe(false);
+    });
+
+    it("falls through to CONVERSATION_ABORTED when wrapped ProviderError has no tagged reason", () => {
+      const wrapped = new ProviderError(
+        "Anthropic API error: Request was aborted.",
+        "anthropic",
+        undefined,
+      );
+      const result = classifyConversationError(wrapped, abortedCtx);
+      expect(result.code).toBe("CONVERSATION_ABORTED");
+      expect(result.errorCategory).toBe("session_aborted");
+    });
+  });
 });
 
 describe("buildConversationErrorMessage", () => {

package/src/__tests__/conversation-history-web-search.test.ts

@@ -753,10 +753,17 @@ describe("web_search_tool_result structural guard", () => {
     // It has a separate isWebSearchToolResultBlock for the other type.
     "providers/anthropic/client.ts",
 
-    // OpenAI provider converts Anthropic-style messages to OpenAI format.
-    // OpenAI API does not support web_search_tool_result natively; those
-    // blocks are handled upstream before reaching the OpenAI client.
-    "providers/openai/client.ts",
+    // Chat-completions transport used by OpenAI-compatible providers
+    // (OpenRouter, Fireworks, Ollama). These APIs do not support
+    // web_search_tool_result natively; those blocks are handled upstream
+    // before reaching the chat-completions provider.
+    "providers/openai/chat-completions-provider.ts",
+
+    // OpenAI Responses API transport (used for direct OpenAI inference).
+    // Converts Anthropic-style messages to Responses API input format.
+    // web_search_tool_result blocks are handled upstream before reaching
+    // the responses provider.
+    "providers/openai/responses-provider.ts",
 
     // Renders tool_result blocks for client display. web_search_tool_result
     // blocks are rendered by the client via their own display path.
@@ -788,6 +795,12 @@ describe("web_search_tool_result structural guard", () => {
     // image/file blocks. web_search_tool_result has opaque content with no
     // contentBlocks property, so it cannot contain nested media.
     "daemon/context-overflow-reducer.ts",
+
+    // Final orphan-pair safety pass in the Slack transcript renderer.
+    // Server-side block types (`server_tool_use`, `web_search_tool_result`)
+    // are stripped earlier by `buildMessageContentBlocks` and cannot reach
+    // this filter, so only `tool_use` ↔ `tool_result` pairing is relevant.
+    "messaging/providers/slack/render-transcript.ts",
   ]);
 
   /**

package/src/__tests__/conversation-init.benchmark.test.ts

@@ -44,7 +44,6 @@ writeFileSync(
   "# Test Identity\nYou are a test assistant.",
 );
 writeFileSync(join(testDir, "SOUL.md"), "# Test Soul\nBe helpful.");
-writeFileSync(join(testDir, "USER.md"), "# Test User\nName: Benchmark Runner");
 
 // Create real skill directories so projectSkillTools can load them from the catalog
 const testSkillIds = ["bench-skill-a", "bench-skill-b", "bench-skill-c"];
@@ -108,6 +107,24 @@ const mockConfig = {
     summaryBudgetRatio: 0.05,
   },
   thinking: { enabled: false },
+  llm: {
+    default: {
+      provider: "mock",
+      model: "mock-model",
+      speed: "standard",
+      thinking: { enabled: false, streamThinking: false },
+      effort: "medium",
+      contextWindow: {
+        enabled: true,
+        maxInputTokens: 180000,
+        targetBudgetRatio: 0.3,
+        compactThreshold: 0.8,
+        summaryBudgetRatio: 0.05,
+      },
+    },
+    profiles: {},
+    callSites: {},
+  },
 };
 
 mock.module("../config/loader.js", () => ({
@@ -121,6 +138,7 @@ mock.module("../config/loader.js", () => ({
     "perplexity",
   ],
   getConfig: () => mockConfig,
+  getConfigReadOnly: () => mockConfig,
   loadConfig: () => mockConfig,
   saveConfig: () => {},
   invalidateConfigCache: () => {},
@@ -128,6 +146,10 @@ mock.module("../config/loader.js", () => ({
   saveRawConfig: () => {},
   getNestedValue: () => undefined,
   setNestedValue: () => {},
+  applyNestedDefaults: (c: unknown) => c,
+  deepMergeMissing: () => {},
+  deepMergeOverwrite: () => {},
+  mergeDefaultWorkspaceConfig: () => {},
 }));
 
 // Additional mocks required for Conversation constructor and end-to-end tests
@@ -135,6 +157,7 @@ mock.module("../config/loader.js", () => ({
 mock.module("../memory/conversation-crud.js", () => ({
   addMessage: () => ({ id: "msg-1" }),
   getMessages: () => [],
+  hasMessages: () => false,
   getMessageById: () => null,
   getConversation: () => null,
   createConversation: () => ({
@@ -149,9 +172,16 @@ mock.module("../memory/conversation-crud.js", () => ({
   getConversationOriginChannel: () => null,
   getConversationOriginInterface: () => null,
   getConversationType: () => "standard",
+  getConversationSource: () => null,
+  findAnalysisConversationFor: () => null,
   getConversationMemoryScopeId: () => "default",
+  getConversationHostAccess: () => false,
+  getConversationGroupId: () => null,
   getConversationRecentProvenanceTrustClass: () => null,
   provenanceFromTrustContext: () => ({}),
+  updateConversationHostAccess: () => {},
+  updateMessageMetadata: () => {},
+  getLastUserTimestampBefore: () => null,
   relinkAttachments: () => 0,
   setConversationOriginChannelIfUnset: () => {},
   setConversationOriginInterfaceIfUnset: () => {},
@@ -159,6 +189,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   updateConversationTitle: () => {},
   updateConversationUsage: () => {},
   updateMessageContent: () => {},
+  updateMessageContentAndMetadata: () => {},
   batchSetDisplayOrders: () => {},
   getDisplayMetaForConversations: () => [],
   messageMetadataSchema: {
@@ -171,6 +202,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   getTurnTimeBounds: () => null,
   PRIVATE_CONVERSATION_FORK_ERROR: "Cannot fork a private conversation",
   countConversationsByScheduleJobId: () => 0,
+  countMessagesWithSlackMeta: () => 0,
   forkConversation: () => null,
   wipeConversation: () => ({
     conversations: 0,
@@ -185,14 +217,20 @@ mock.module("../memory/conversation-crud.js", () => ({
   }),
   getMessagesPaginated: () => ({ messages: [], hasMore: false }),
   getLastAssistantTimestampBefore: () => null,
+  archiveConversation: () => false,
+  unarchiveConversation: () => false,
+  clearPkbSystemReminderMetadataForConversation: () => {},
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({
+  buildFtsMatchQuery: () => "",
   countConversations: () => 0,
   listConversations: () => [],
+  listPinnedConversations: () => [],
   getLatestConversation: () => null,
   isLastUserMessageToolResult: () => false,
   searchConversations: () => [],
+  buildExcerpt: () => "",
 }));
 
 mock.module("../hooks/manager.js", () => ({
@@ -251,11 +289,14 @@ mock.module("../calls/call-store.js", () => ({
   recordProcessedCallback: () => {},
   claimCallback: () => true,
   releaseCallbackClaim: () => {},
+  finalizeCallbackClaim: () => true,
 }));
 
 mock.module("../daemon/watch-handler.js", () => ({
   lastCommentaryByConversation: new Map(),
   lastSummaryByConversation: new Map(),
+  handleWatchObservation: () => Promise.resolve(),
+  generateSummary: () => Promise.resolve(),
 }));
 
 mock.module("../tools/browser/browser-screencast.js", () => ({

package/src/__tests__/conversation-launcher-skill-regression.test.ts

@@ -0,0 +1,51 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { describe, expect, test } from "bun:test";
+
+const REPO_ROOT = resolve(import.meta.dirname ?? __dirname, "..", "..", "..");
+const SKILL_PATH = resolve(
+  REPO_ROOT,
+  "skills",
+  "conversation-launcher",
+  "SKILL.md",
+);
+const skillContent = readFileSync(SKILL_PATH, "utf-8");
+
+describe("conversation-launcher skill regression", () => {
+  test("describes the direct surface-action contract the daemon dispatches on", () => {
+    // The skill must render one `ui_show` card whose actions carry the wire
+    // contract that `handleSurfaceAction`'s `launch_conversation` branch reads.
+    // These tokens are the minimum the model needs to produce a valid card.
+    const requiredTokens = [
+      "ui_show",
+      "persistent: true",
+      '_action: "launch_conversation"',
+      "title",
+      "seedPrompt",
+      '"await_action": false',
+    ];
+    for (const token of requiredTokens) {
+      expect(skillContent).toContain(token);
+    }
+  });
+
+  test("does not resurrect the deprecated bash + signal-file launch flow", () => {
+    // The skill must not reference signal files, HOME-based workspace paths,
+    // or shell-based plumbing — it dispatches surface actions directly.
+    const forbiddenTokens = [
+      "bash",
+      "curl",
+      "signals/",
+      "jq ",
+      // Assembled from parts so this literal does not appear in repo grep
+      // results — the forbidden-tokens check would otherwise match this file.
+      ["launch", "conversation."].join("-"),
+      "VELLUM_WORKSPACE_DIR",
+      "INTERNAL_GATEWAY_BASE_URL",
+      "emit-event",
+    ];
+    for (const token of forbiddenTokens) {
+      expect(skillContent).not.toContain(token);
+    }
+  });
+});