@vellumai/assistant 0.6.3 → 0.6.4

package/src/__tests__/context-window-manager.test.ts

@@ -1052,4 +1052,92 @@ describe("ContextWindowManager", () => {
       normalResult.compactedMessages,
     );
   });
+
+  test("subtracts summaryOffset only when summary at index 0 was injected from parent", async () => {
+    const provider = createProvider(() => ({
+      content: [{ type: "text", text: "## Goals\n- new child summary" }],
+      model: "mock-model",
+      usage: { inputTokens: 75, outputTokens: 20 },
+      stopReason: "end_turn",
+    }));
+    const manager = new ContextWindowManager({
+      provider,
+      systemPrompt: "system prompt",
+      config: makeConfig({
+        maxInputTokens: 320,
+        targetBudgetRatio: 0.58,
+      }),
+    });
+    const long = "k".repeat(220);
+    // Parent-injected summary at index 0, plus 2 injected non-persisted
+    // messages, plus 3 child-persisted messages. nonPersistedPrefixCount
+    // includes the summary (set by injectInheritedContext).
+    const history: Message[] = [
+      createContextSummaryMessage("parent summary"),
+      message("user", `injected-u ${long}`),
+      message("assistant", `injected-a ${long}`),
+      message("user", `persisted-u1 ${long}`),
+      message("assistant", `persisted-a1 ${long}`),
+      message("user", `persisted-u2 ${long}`),
+    ];
+    manager.nonPersistedPrefixCount = 3;
+    manager.summaryIsInjected = true;
+
+    const result = await manager.maybeCompact(history, undefined, {
+      force: true,
+    });
+    expect(result.compacted).toBe(true);
+    // 4 messages compacted (2 injected + 2 child-persisted), but only the
+    // 2 child-persisted ones count as DB-persisted.
+    expect(result.compactedMessages).toBe(4);
+    expect(result.compactedPersistedMessages).toBe(2);
+    // Flag clears and prefix drains (both injected messages + summary slot).
+    expect(manager.summaryIsInjected).toBe(false);
+    expect(manager.nonPersistedPrefixCount).toBe(0);
+  });
+
+  test("does not subtract summaryOffset when summary at index 0 is child-owned from prior compaction", async () => {
+    const provider = createProvider(() => ({
+      content: [{ type: "text", text: "## Goals\n- next child summary" }],
+      model: "mock-model",
+      usage: { inputTokens: 75, outputTokens: 20 },
+      stopReason: "end_turn",
+    }));
+    const manager = new ContextWindowManager({
+      provider,
+      systemPrompt: "system prompt",
+      config: makeConfig({
+        maxInputTokens: 320,
+        targetBudgetRatio: 0.58,
+      }),
+    });
+    const long = "k".repeat(220);
+    // Post-first-compaction state: child-owned summary at index 0, 2
+    // still-injected messages that survived the first compaction's keep
+    // region, 3 child-persisted messages. nonPersistedPrefixCount reflects
+    // only the 2 remaining injected messages — the summary slot was already
+    // consumed when the flag-gated decrement ran on the prior compaction.
+    const history: Message[] = [
+      createContextSummaryMessage("prior child summary"),
+      message("user", `injected-u ${long}`),
+      message("assistant", `injected-a ${long}`),
+      message("user", `persisted-u1 ${long}`),
+      message("assistant", `persisted-a1 ${long}`),
+      message("user", `persisted-u2 ${long}`),
+    ];
+    manager.nonPersistedPrefixCount = 2;
+    manager.summaryIsInjected = false;
+
+    const result = await manager.maybeCompact(history, undefined, {
+      force: true,
+    });
+    expect(result.compacted).toBe(true);
+    expect(result.compactedMessages).toBe(4);
+    // Regression guard: without the flag gate, the subtraction from the
+    // #24353 fix would double-apply here (nonPersistedPrefixCount - 1),
+    // undercounting injectedInCompactable and inflating
+    // compactedPersistedMessages by 1 (to 3).
+    expect(result.compactedPersistedMessages).toBe(2);
+    expect(manager.nonPersistedPrefixCount).toBe(0);
+  });
 });

package/src/__tests__/conversation-abort-tool-results.test.ts

@@ -112,6 +112,8 @@ mock.module("../memory/conversation-crud.js", () => ({
   },
   updateConversationUsage: () => {},
   updateConversationTitle: () => {},
+  getMessageById: () => null,
+  getLastUserTimestampBefore: () => 0,
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({

package/src/__tests__/conversation-agent-loop-overflow.test.ts

@@ -462,6 +462,7 @@ function makeCtx(
         runMessages: messages,
         injectedTokens: 0,
       }),
+      retrackCachedNodes: () => {},
     } as unknown as AgentLoopConversationContext["graphMemory"],
 
     ...overrides,

package/src/__tests__/conversation-agent-loop.test.ts

@@ -137,6 +137,8 @@ mock.module("../memory/conversation-crud.js", () => ({
   updateConversationContextWindow: () => {},
   updateConversationTitle: () => {},
   getConversationOriginChannel: () => null,
+  getMessageById: () => null,
+  getLastUserTimestampBefore: () => 0,
 }));
 
 const syncMessageToDiskMock = mock(() => {});
@@ -444,11 +446,17 @@ function makeCtx(
 
     graphMemory: {
       onCompacted: () => {},
-      prepareMemory: async () => ({ runMessages: [], injectedTokens: 0, latencyMs: 0, mode: "none" as const }),
+      prepareMemory: async () => ({
+        runMessages: [],
+        injectedTokens: 0,
+        latencyMs: 0,
+        mode: "none" as const,
+      }),
       reinjectCachedMemory: (messages: Message[]) => ({
         runMessages: messages,
         injectedTokens: 0,
       }),
+      retrackCachedNodes: () => {},
     } as unknown as AgentLoopConversationContext["graphMemory"],
 
     ...overrides,
@@ -763,6 +771,95 @@ describe("session-agent-loop", () => {
       ];
       expect(call[4]).toBe("openrouter");
     });
+
+    test("record request log handles Responses API shaped payloads", async () => {
+      const events: ServerMessage[] = [];
+      const rawRequest = {
+        model: "gpt-5.4",
+        instructions: "Be helpful.",
+        input: [
+          {
+            role: "user",
+            content: [{ type: "input_text", text: "Hello" }],
+            type: "message",
+          },
+        ],
+      };
+      const rawResponse = {
+        id: "resp_test",
+        model: "gpt-5.4",
+        output: [
+          {
+            type: "message",
+            role: "assistant",
+            content: [{ type: "output_text", text: "Hi there." }],
+          },
+        ],
+        usage: {
+          input_tokens: 12,
+          output_tokens: 3,
+        },
+        status: "completed",
+      };
+
+      const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
+        onEvent({
+          type: "message_complete",
+          message: {
+            role: "assistant",
+            content: [{ type: "text", text: "Hi there." }],
+          },
+        });
+        onEvent({
+          type: "usage",
+          inputTokens: 12,
+          outputTokens: 3,
+          model: "gpt-5.4",
+          actualProvider: "openai",
+          providerDurationMs: 45,
+          rawRequest,
+          rawResponse,
+        });
+        return [
+          ...messages,
+          {
+            role: "assistant" as const,
+            content: [{ type: "text", text: "Hi there." }] as ContentBlock[],
+          },
+        ];
+      };
+
+      const ctx = makeCtx({
+        agentLoopRun,
+        provider: {
+          name: "openai",
+          sendMessage: async () => ({
+            content: [{ type: "text", text: "title" }],
+            model: "mock",
+            usage: { inputTokens: 0, outputTokens: 0 },
+            stopReason: "end_turn",
+          }),
+        } as unknown as AgentLoopConversationContext["provider"],
+      });
+
+      await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
+
+      expect(recordRequestLogMock).toHaveBeenCalledTimes(1);
+      const call = recordRequestLogMock.mock.calls[0] as unknown as [
+        string,
+        string,
+        string,
+        undefined,
+        string,
+      ];
+      expect(call).toEqual([
+        "test-conv",
+        JSON.stringify(rawRequest),
+        JSON.stringify(rawResponse),
+        undefined,
+        "openai",
+      ]);
+    });
   });
 
   describe("usage accounting", () => {
@@ -1938,7 +2035,6 @@ describe("session-agent-loop", () => {
 
       expect(drainReason).toBe("loop_complete");
     });
-
   });
 
   describe("stale pending surface cleanup", () => {

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

@@ -713,3 +713,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", () => {
@@ -563,6 +567,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 (undefined): 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 (undefined): 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 (undefined): 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 (undefined): 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 (undefined): 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.

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"];
@@ -150,8 +149,13 @@ mock.module("../memory/conversation-crud.js", () => ({
   getConversationOriginInterface: () => null,
   getConversationType: () => "standard",
   getConversationMemoryScopeId: () => "default",
+  getConversationHostAccess: () => false,
+  getConversationGroupId: () => null,
   getConversationRecentProvenanceTrustClass: () => null,
   provenanceFromTrustContext: () => ({}),
+  updateConversationHostAccess: () => {},
+  updateMessageMetadata: () => {},
+  getLastUserTimestampBefore: () => null,
   relinkAttachments: () => 0,
   setConversationOriginChannelIfUnset: () => {},
   setConversationOriginInterfaceIfUnset: () => {},
@@ -251,6 +255,7 @@ mock.module("../calls/call-store.js", () => ({
   recordProcessedCallback: () => {},
   claimCallback: () => true,
   releaseCallbackClaim: () => {},
+  finalizeCallbackClaim: () => true,
 }));
 
 mock.module("../daemon/watch-handler.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);
+    }
+  });
+});