@vellumai/assistant 0.6.2 → 0.6.4

package/src/__tests__/context-overflow-approval.test.ts

@@ -1,5 +1,6 @@
-import { describe, expect, mock, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
 import {
   CONTEXT_OVERFLOW_TOOL_NAME,
   requestCompressionApproval,
@@ -20,8 +21,22 @@ function createMockPrompter(decision: UserDecision): PermissionPrompter {
 }
 
 describe("requestCompressionApproval", () => {
+  beforeEach(() => {
+    _setOverridesForTesting({});
+  });
+
   // ── Prompt shape ──
 
+  test("auto-approves without prompting under v2", async () => {
+    _setOverridesForTesting({ "permission-controls-v2": true });
+
+    const prompter = createMockPrompter("deny");
+    const result = await requestCompressionApproval(prompter);
+
+    expect(result).toEqual({ approved: true });
+    expect(prompter.prompt).not.toHaveBeenCalled();
+  });
+
   test("uses the reserved pseudo tool name", async () => {
     const prompter = createMockPrompter("allow");
     await requestCompressionApproval(prompter);

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

@@ -212,7 +212,7 @@ mock.module("../daemon/conversation-runtime-assembly.js", () => ({
 }));
 
 mock.module("../daemon/date-context.js", () => ({
-  formatTurnTimestamp: () => "2026-01-01 (Thu) 00:00:00 +00:00 (UTC)",
+  formatTurnTimestamp: () => "2026-01-01 (Thursday) 00:00:00 +00:00 (UTC)",
 }));
 
 mock.module("../daemon/history-repair.js", () => ({
@@ -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(() => {});
@@ -201,7 +203,7 @@ mock.module("../daemon/conversation-runtime-assembly.js", () => ({
 }));
 
 mock.module("../daemon/date-context.js", () => ({
-  formatTurnTimestamp: () => "2026-01-01 (Thu) 00:00:00 +00:00 (UTC)",
+  formatTurnTimestamp: () => "2026-01-01 (Thursday) 00:00:00 +00:00 (UTC)",
 }));
 
 mock.module("../daemon/history-repair.js", () => ({
@@ -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-analysis-routes.test.ts

@@ -121,7 +121,7 @@ describe("POST /v1/conversations/:id/analyze", () => {
     );
   });
 
-  test("marks analysis interactive when a matching subscriber is already connected", async () => {
+  test("keeps analysis non-interactive even when a matching subscriber is connected", async () => {
     const conversation = makeConversation();
     const assistantEventHub = new AssistantEventHub();
     assistantEventHub.subscribe(
@@ -163,7 +163,7 @@ describe("POST /v1/conversations/:id/analyze", () => {
       expect.any(String),
       "msg-1",
       expect.any(Function),
-      expect.objectContaining({ isInteractive: true, isUserMessage: true }),
+      expect.objectContaining({ isInteractive: false, isUserMessage: true }),
     );
   });
 });

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

@@ -1,6 +1,8 @@
 import { existsSync } from "node:fs";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
+
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
@@ -25,15 +27,18 @@ mock.module("../daemon/video-thumbnail.js", () => ({
 }));
 
 // Stub out permission checker / trust store
+const checkSpy = mock(() => Promise.resolve({ decision: "allow" }));
+const addRuleSpy = mock(() => {});
+
 mock.module("../permissions/checker.js", () => ({
-  check: () => Promise.resolve({ decision: "allow" }),
+  check: checkSpy,
   classifyRisk: () => Promise.resolve("low"),
   generateAllowlistOptions: () => Promise.resolve([]),
   generateScopeOptions: () => [],
 }));
 
 mock.module("../permissions/trust-store.js", () => ({
-  addRule: () => {},
+  addRule: addRuleSpy,
 }));
 
 mock.module("../permissions/types.js", () => ({
@@ -47,7 +52,11 @@ mock.module("../permissions/types.js", () => ({
 
 import type { AssistantAttachmentDraft } from "../daemon/assistant-attachments.js";
 import { getFilePathForAttachment } from "../memory/attachments-store.js";
-import { addMessage, createConversation } from "../memory/conversation-crud.js";
+import {
+  addMessage,
+  createConversation,
+  updateConversationHostAccess,
+} from "../memory/conversation-crud.js";
 import { getDb, initializeDb } from "../memory/db.js";
 
 initializeDb();
@@ -73,7 +82,12 @@ function makeBase64(bytes: number): string {
 // ---------------------------------------------------------------------------
 
 describe("resolveAssistantAttachments", () => {
-  beforeEach(resetTables);
+  beforeEach(() => {
+    resetTables();
+    _setOverridesForTesting({});
+    checkSpy.mockClear();
+    addRuleSpy.mockClear();
+  });
 
   test("small attachments are stored on disk via uploadAttachment", async () => {
     const conv = createConversation("test-conv");
@@ -196,3 +210,65 @@ describe("resolveAssistantAttachments", () => {
     expect(emitted.fileBacked).toBe(true);
   });
 });
+
+describe("approveHostAttachmentRead", () => {
+  beforeEach(() => {
+    resetTables();
+    _setOverridesForTesting({});
+    checkSpy.mockClear();
+    addRuleSpy.mockClear();
+  });
+
+  test("uses the conversation-scoped host-access prompt under v2", async () => {
+    _setOverridesForTesting({ "permission-controls-v2": true });
+    const conversation = createConversation("attachment-host-gate");
+    const promptSpy = mock(() =>
+      Promise.resolve({ decision: "allow" as const }),
+    );
+
+    const { approveHostAttachmentRead } =
+      await import("../daemon/conversation-attachments.js");
+
+    const allowed = await approveHostAttachmentRead(
+      "/tmp/example.txt",
+      "/tmp",
+      { prompt: promptSpy } as never,
+      conversation.id,
+      false,
+    );
+
+    expect(allowed).toBe(true);
+    expect(checkSpy).not.toHaveBeenCalled();
+    expect(addRuleSpy).not.toHaveBeenCalled();
+    const call = promptSpy.mock.calls[0] as unknown as unknown[];
+    expect(call[3]).toEqual([]);
+    expect(call[4]).toEqual([]);
+    expect(call[8]).toBe(false);
+    expect(call[10]).toBeUndefined();
+    expect(call[12]).toBe(true);
+  });
+
+  test("auto-allows host attachment reads when the conversation already has host access", async () => {
+    _setOverridesForTesting({ "permission-controls-v2": true });
+    const conversation = createConversation("attachment-host-allowed");
+    updateConversationHostAccess(conversation.id, true);
+    const promptSpy = mock(() =>
+      Promise.resolve({ decision: "deny" as const }),
+    );
+
+    const { approveHostAttachmentRead } =
+      await import("../daemon/conversation-attachments.js");
+
+    const allowed = await approveHostAttachmentRead(
+      "/tmp/example.txt",
+      "/tmp",
+      { prompt: promptSpy } as never,
+      conversation.id,
+      false,
+    );
+
+    expect(allowed).toBe(true);
+    expect(promptSpy).not.toHaveBeenCalled();
+    expect(checkSpy).not.toHaveBeenCalled();
+  });
+});