@vellumai/assistant 0.11.2 → 0.11.3-staging.2

package/src/__tests__/prompt-cache-cross-turn-stability.test.ts

@@ -0,0 +1,593 @@
+/**
+ * Cross-turn prompt-cache stability, end to end.
+ *
+ * Prompt caching only pays off when the bytes a provider marks in turn N are
+ * still there, at the same position, in turn N+1. That invariant spans three
+ * layers that are otherwise tested in isolation: the render pipeline decides
+ * which injected blocks persist into history, the agent loop decides whether to
+ * flag the latest user message as volatile, and each provider decides where to
+ * put its cache breakpoints. A regression in any one of them is invisible to
+ * the others' unit tests.
+ *
+ * So this file drives two consecutive turns through the REAL render path (a
+ * live `Conversation` + `AgentLoop`, with only the provider HTTP boundary
+ * mocked), captures what the provider actually received, and then replays those
+ * exact histories through the real Anthropic and OpenAI transports to assert on
+ * the wire: turn 1's payload recurs byte-identically as a prefix of turn 2's,
+ * and every boundary marked in turn 1 is marked again in turn 2 so its written
+ * prefix stays readable.
+ */
+
+import { beforeAll, describe, expect, mock, test } from "bun:test";
+
+import type { Message } from "../providers/types.js";
+
+// ---------------------------------------------------------------------------
+// Provider SDK mocks: must be registered before the transports are imported
+// ---------------------------------------------------------------------------
+
+let lastAnthropicParams: Record<string, unknown> | null = null;
+
+mock.module("@anthropic-ai/sdk", () => {
+  const streamImpl = (params: Record<string, unknown>) => {
+    lastAnthropicParams = JSON.parse(JSON.stringify(params));
+    return {
+      on() {
+        return this;
+      },
+      async finalMessage() {
+        return {
+          content: [{ type: "text", text: "ok" }],
+          model: "claude-sonnet-4-6",
+          usage: { input_tokens: 100, output_tokens: 20 },
+          stop_reason: "end_turn",
+        };
+      },
+    };
+  };
+  return {
+    default: class MockAnthropic {
+      static APIError = class extends Error {};
+      messages = { stream: streamImpl };
+      beta = { messages: { stream: streamImpl } };
+    },
+  };
+});
+
+interface FakeStreamEvent {
+  type: string;
+  [key: string]: unknown;
+}
+
+let lastOpenAIParams: Record<string, unknown> | null = null;
+
+mock.module("openai", () => ({
+  default: class MockOpenAI {
+    responses = {
+      create: async (params: Record<string, unknown>) => {
+        lastOpenAIParams = JSON.parse(JSON.stringify(params));
+        const events: FakeStreamEvent[] = [
+          { type: "response.output_text.delta", delta: "ok" },
+          {
+            type: "response.completed",
+            response: {
+              model: "gpt-5.6-sol",
+              status: "completed",
+              output: [],
+              usage: { input_tokens: 10, output_tokens: 5 },
+            },
+          },
+        ];
+        return {
+          [Symbol.asyncIterator]: async function* () {
+            for (const event of events) {
+              yield event;
+            }
+          },
+        };
+      },
+    };
+  },
+}));
+
+// ---------------------------------------------------------------------------
+// Daemon-surface mocks: keep a real turn hermetic and fast. The agent loop is
+// deliberately NOT mocked: it is part of what this test exercises.
+// ---------------------------------------------------------------------------
+
+mock.module("../providers/registry.js", () => ({
+  getProvider: () => ({ name: "mock-provider" }),
+  initializeProviders: async () => {},
+}));
+
+mock.module("../prompts/system-prompt.js", () => ({
+  buildSystemPrompt: () => "system prompt",
+}));
+mock.module("../config/skills.js", () => ({
+  loadSkillCatalog: () => [],
+  loadSkillBySelector: () => ({ skill: null }),
+  ensureSkillIcon: async () => null,
+}));
+mock.module("../config/skill-state.js", () => ({
+  resolveSkillStates: () => [],
+}));
+mock.module("../permissions/trust-store.js", () => ({
+  addRule: () => {},
+  findHighestPriorityRule: () => null,
+  clearCache: () => {},
+}));
+mock.module("../security/secret-allowlist.js", () => ({
+  resetAllowlist: () => {},
+}));
+
+mock.module("../persistence/conversation-crud.js", () => ({
+  setConversationProcessingStartedAt: () => {},
+  isConversationProcessing: () => false,
+  setConversationOriginChannelIfUnset: () => {},
+  setConversationHistoryStrippedAt: () => {},
+  provenanceFromTrustContext: () => ({
+    source: "user",
+    trustContext: undefined,
+  }),
+  getConversationOriginInterface: () => null,
+  getConversationOriginChannel: () => null,
+  getMessages: () => [],
+  getConversation: () => ({
+    id: "conv-1",
+    createdAt: Date.parse("2026-03-19T12:00:00.000Z"),
+    contextSummary: null,
+    contextCompactedMessageCount: 0,
+    contextCompactedAt: null,
+    totalInputTokens: 0,
+    totalOutputTokens: 0,
+    totalEstimatedCost: 0,
+  }),
+  addMessage: () => ({ id: "msg-1" }),
+  updateConversationUsage: () => {},
+  updateConversationTitle: () => {},
+  updateConversationContextWindow: () => {},
+  deleteMessageById: () => ({ segmentIds: [], deletedSummaryIds: [] }),
+  deleteLastExchange: () => 0,
+  getMessageById: () => null,
+  getLastUserTimestampBefore: () => 0,
+  setLastNotifiedInferenceProfile: () => {},
+  resolveOverrideProfile: () => undefined,
+  updateMessageMetadata: () => {},
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
+  updateMessageContent: mock(() => {}),
+}));
+
+mock.module("../persistence/conversation-queries.js", () => ({
+  isLastUserMessageToolResult: () => false,
+}));
+
+mock.module("../persistence/attachments-store.js", () => ({
+  uploadAttachment: () => ({ id: "att-1" }),
+  linkAttachmentToMessage: () => {},
+}));
+mock.module("../memory/retriever.js", () => ({
+  buildMemoryRecall: async () => ({
+    enabled: false,
+    degraded: false,
+    reason: null,
+    provider: "mock",
+    model: "mock",
+    injectedText: "",
+    semanticHits: 0,
+    mergedCount: 0,
+    selectedCount: 0,
+    injectedTokens: 0,
+    latencyMs: 0,
+    topCandidates: [],
+  }),
+  injectMemoryRecallAsUserBlock: (msgs: Message[]) => msgs,
+}));
+mock.module("../memory/query-builder.js", () => ({
+  buildMemoryQuery: () => "",
+}));
+mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
+  ContextWindowManager: class {
+    estimateInputTokens() {
+      return 0;
+    }
+    get tokenCountInputs() {
+      return { systemPrompt: "", tools: undefined };
+    }
+    updateConfig() {}
+    shouldCompact() {
+      return { needed: false, estimatedTokens: 0 };
+    }
+    async maybeCompact() {
+      return { compacted: false };
+    }
+    resetOverflowRecovery() {}
+  },
+  createContextSummaryMessage: () => ({
+    role: "user",
+    content: [{ type: "text", text: "summary" }],
+  }),
+  getSummaryFromContextMessage: () => null,
+}));
+mock.module("../persistence/llm-usage-store.js", () => ({
+  recordUsageEvent: () => ({ id: "usage-1", createdAt: Date.now() }),
+}));
+mock.module("../apps/app-store.js", () => ({
+  getApp: () => null,
+  updateApp: () => {},
+}));
+
+mock.module("../workspace/top-level-scanner.js", () => ({
+  MAX_TOP_LEVEL_ENTRIES: 120,
+  scanTopLevelDirectories: (rootPath: string) => ({
+    rootPath,
+    directories: ["src", "tests", "docs"],
+    files: ["README.md", "package.json"],
+    truncated: false,
+  }),
+}));
+
+// Avoid real workspace-git initialization on /tmp: `git add -A` there hits
+// permission errors on CI runners' systemd-private dirs.
+mock.module("../workspace/git-service.js", () => ({
+  getWorkspaceGitService: () => ({
+    ensureInitialized: async () => {},
+  }),
+}));
+
+mock.module("../workspace/turn-commit.js", () => ({
+  commitTurnChanges: async () => {},
+}));
+
+// Import after mocking
+import { Conversation } from "../daemon/conversation.js";
+import {
+  clearConversations,
+  setConversation,
+} from "../daemon/conversation-registry.js";
+import { resetPluginRegistryAndRegisterDefaults } from "../plugins/defaults/index.js";
+import { AnthropicProvider } from "../providers/anthropic/client.js";
+import { OpenAIResponsesProvider } from "../providers/openai/responses-provider.js";
+import {
+  createMockProvider,
+  type RecordedProviderCall,
+  textResponse,
+} from "./helpers/mock-provider.js";
+
+// A GPT-5.6 model id from `PROMPT_CACHE_BREAKPOINT_MODEL_IDS`: explicit
+// prompt-cache mode only engages for those.
+const EXPLICIT_CACHE_MODEL = "gpt-5.6-sol";
+
+// ---------------------------------------------------------------------------
+// Wire helpers
+// ---------------------------------------------------------------------------
+
+type WireItem = {
+  type?: string;
+  role?: string;
+  content?: Array<Record<string, unknown>>;
+};
+
+/** A Responses input item with every cache marker removed. */
+function withoutOpenAIMarkers(item: WireItem): WireItem {
+  const clone = JSON.parse(JSON.stringify(item)) as WireItem;
+  for (const part of clone.content ?? []) {
+    delete part.prompt_cache_breakpoint;
+  }
+  return clone;
+}
+
+/** Indexes of Responses input items carrying a cache marker. */
+function openAIMarkedIndexes(params: Record<string, unknown> | null): number[] {
+  const input = (params?.input ?? []) as WireItem[];
+  const marked: number[] = [];
+  input.forEach((item, idx) => {
+    if (item.content?.some((p) => p.prompt_cache_breakpoint !== undefined)) {
+      marked.push(idx);
+    }
+  });
+  return marked;
+}
+
+type AnthropicWireMessage = {
+  role: string;
+  content: Array<Record<string, unknown>>;
+};
+
+/** An Anthropic message with every `cache_control` block marker removed. */
+function withoutAnthropicMarkers(
+  message: AnthropicWireMessage,
+): AnthropicWireMessage {
+  const clone = JSON.parse(JSON.stringify(message)) as AnthropicWireMessage;
+  for (const block of clone.content ?? []) {
+    delete block.cache_control;
+  }
+  return clone;
+}
+
+/** Indexes of Anthropic messages carrying a `cache_control` marker. */
+function anthropicMarkedIndexes(
+  params: Record<string, unknown> | null,
+): number[] {
+  const messages = (params?.messages ?? []) as AnthropicWireMessage[];
+  const marked: number[] = [];
+  messages.forEach((message, idx) => {
+    if (message.content?.some((b) => b.cache_control !== undefined)) {
+      marked.push(idx);
+    }
+  });
+  return marked;
+}
+
+/**
+ * TTLs marked on the turn-starting user message, the last user message
+ * carrying text, which is the boundary the Anthropic client anchors on.
+ */
+function anthropicTurnStartTtls(
+  params: Record<string, unknown> | null,
+): string[] {
+  const messages = (params?.messages ?? []) as AnthropicWireMessage[];
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (message.role !== "user") {
+      continue;
+    }
+    if (!message.content?.some((b) => b.type === "text")) {
+      continue;
+    }
+    return (message.content ?? [])
+      .map((b) => (b.cache_control as { ttl?: string } | undefined)?.ttl)
+      .filter((ttl): ttl is string => ttl !== undefined);
+  }
+  return [];
+}
+
+// ---------------------------------------------------------------------------
+// Two real turns through the render pipeline
+// ---------------------------------------------------------------------------
+
+let calls: RecordedProviderCall[] = [];
+
+beforeAll(async () => {
+  clearConversations();
+  resetPluginRegistryAndRegisterDefaults();
+
+  const { provider, calls: recorded } = createMockProvider([
+    textResponse("ok"),
+    textResponse("ok2"),
+  ]);
+  const conversation = new Conversation(
+    "conv-1",
+    provider,
+    "system prompt",
+    () => {},
+    "/tmp",
+    { maxTokens: 4096 },
+  );
+  setConversation(conversation.conversationId, conversation);
+  await conversation.loadFromDb();
+
+  await conversation.processMessage({ content: "Hello", attachments: [] });
+  await conversation.processMessage({ content: "Follow up", attachments: [] });
+
+  calls = recorded;
+});
+
+describe("prompt cache cross-turn stability: render pipeline", () => {
+  test("turn 2 resends every turn-1 message byte-identically, at the same index", () => {
+    expect(calls).toHaveLength(2);
+
+    const turn1 = calls[0].messages;
+    const turn2 = calls[1].messages;
+    expect(turn1.length).toBeGreaterThan(0);
+    expect(turn2.length).toBeGreaterThan(turn1.length);
+
+    // Exact-bytes prefix check. Anything a provider cached in turn 1 is only
+    // readable in turn 2 if the prefix it covers is unchanged, so a single
+    // re-rendered injected block anywhere in this range is a full cache miss.
+    turn1.forEach((message, idx) => {
+      expect(JSON.stringify(turn2[idx])).toBe(JSON.stringify(message));
+    });
+  });
+
+  test("no spotlight in play means neither turn flags the latest user message as volatile", () => {
+    for (const call of calls) {
+      const config = call.options?.config as
+        | Record<string, unknown>
+        | undefined;
+      expect(config?.mutableLatestUserMessage).toBeUndefined();
+    }
+  });
+});
+
+describe("prompt cache cross-turn stability: OpenAI Responses wire", () => {
+  let turn1Params: Record<string, unknown> | null = null;
+  let turn2Params: Record<string, unknown> | null = null;
+
+  beforeAll(async () => {
+    const provider = new OpenAIResponsesProvider(
+      "sk-test",
+      EXPLICIT_CACHE_MODEL,
+      { codexSubscription: false },
+    );
+    await provider.sendMessage(calls[0].messages, {
+      config: { promptCacheKey: "conv-1" },
+    });
+    turn1Params = lastOpenAIParams;
+    await provider.sendMessage(calls[1].messages, {
+      config: { promptCacheKey: "conv-1" },
+    });
+    turn2Params = lastOpenAIParams;
+  });
+
+  test("turn 1 marks at least one boundary", () => {
+    expect(turn1Params?.prompt_cache_options).toEqual({ mode: "explicit" });
+    expect(openAIMarkedIndexes(turn1Params).length).toBeGreaterThan(0);
+  });
+
+  test("turn 1's input items recur identically as a prefix of turn 2's", () => {
+    const input1 = (turn1Params?.input ?? []) as WireItem[];
+    const input2 = (turn2Params?.input ?? []) as WireItem[];
+    expect(input1.length).toBeGreaterThan(0);
+    expect(input2.length).toBeGreaterThan(input1.length);
+
+    input1.forEach((item, idx) => {
+      expect(JSON.stringify(withoutOpenAIMarkers(input2[idx]))).toBe(
+        JSON.stringify(withoutOpenAIMarkers(item)),
+      );
+    });
+  });
+
+  test("every boundary marked in turn 1 is marked again in turn 2", () => {
+    // Reads only consider markers present in the current request, so a
+    // boundary written last turn is unreachable unless it is re-marked.
+    const marked1 = openAIMarkedIndexes(turn1Params);
+    const marked2 = openAIMarkedIndexes(turn2Params);
+    for (const idx of marked1) {
+      expect(marked2).toContain(idx);
+    }
+  });
+});
+
+describe("prompt cache cross-turn stability: Anthropic wire", () => {
+  let turn1Params: Record<string, unknown> | null = null;
+  let turn2Params: Record<string, unknown> | null = null;
+
+  beforeAll(async () => {
+    const provider = new AnthropicProvider("sk-ant-test", "claude-sonnet-4-6");
+    await provider.sendMessage(calls[0].messages, {
+      systemPrompt: "system prompt",
+    });
+    turn1Params = lastAnthropicParams;
+    await provider.sendMessage(calls[1].messages, {
+      systemPrompt: "system prompt",
+    });
+    turn2Params = lastAnthropicParams;
+  });
+
+  test("turn 1 anchors at least one message", () => {
+    expect(anthropicMarkedIndexes(turn1Params).length).toBeGreaterThan(0);
+  });
+
+  test("turn 1's messages recur identically as a prefix of turn 2's", () => {
+    const messages1 = (turn1Params?.messages ?? []) as AnthropicWireMessage[];
+    const messages2 = (turn2Params?.messages ?? []) as AnthropicWireMessage[];
+    expect(messages1.length).toBeGreaterThan(0);
+    expect(messages2.length).toBeGreaterThan(messages1.length);
+
+    messages1.forEach((message, idx) => {
+      expect(JSON.stringify(withoutAnthropicMarkers(messages2[idx]))).toBe(
+        JSON.stringify(withoutAnthropicMarkers(message)),
+      );
+    });
+  });
+
+  test("turn 2 re-anchors turn 1's turn-start message", () => {
+    // Anthropic matches the cache only at breakpoints present in the current
+    // request, so the previous turn's anchor must be re-placed for its written
+    // prefix to stay reachable.
+    const marked1 = anthropicMarkedIndexes(turn1Params);
+    const marked2 = anthropicMarkedIndexes(turn2Params);
+    expect(marked2).toContain(marked1[marked1.length - 1]);
+  });
+});
+
+describe("prompt cache cross-turn stability: volatile first turn", () => {
+  // A memory-v3 spotlight on the opening message makes it volatile across
+  // turns, but it is still fixed within its own turn. The system prompt, the
+  // tools, and the message itself must therefore still be written once, so
+  // that turn's tool-loop iterations read the prefix back instead of
+  // re-billing it. Leaving the request unmarked spends a full-prompt write on
+  // every iteration and yields zero reads.
+  test("OpenAI: a volatile opening message still gets a breakpoint", async () => {
+    const provider = new OpenAIResponsesProvider(
+      "sk-test",
+      EXPLICIT_CACHE_MODEL,
+      { codexSubscription: false },
+    );
+    await provider.sendMessage(calls[0].messages, {
+      config: { mutableLatestUserMessage: true, promptCacheKey: "conv-1" },
+    });
+
+    expect(lastOpenAIParams?.prompt_cache_options).toEqual({
+      mode: "explicit",
+    });
+    expect(openAIMarkedIndexes(lastOpenAIParams).length).toBeGreaterThan(0);
+  });
+
+  test("Anthropic: a volatile opening message still gets a breakpoint", async () => {
+    const provider = new AnthropicProvider("sk-ant-test", "claude-sonnet-4-6");
+    await provider.sendMessage(calls[0].messages, {
+      systemPrompt: "system prompt",
+      config: { mutableLatestUserMessage: true },
+    });
+
+    expect(anthropicMarkedIndexes(lastAnthropicParams).length).toBeGreaterThan(
+      0,
+    );
+  });
+
+  test("Anthropic: a volatile turn start keeps one TTL across its tool loop", async () => {
+    // Marking one boundary at two TTLs bills two writes for a single reusable
+    // prefix. A volatile turn start can only ever be read back within its own
+    // turn, so it takes the short TTL on the opening request and must keep it
+    // once tool results arrive, rather than being upgraded to the long TTL.
+    const provider = new AnthropicProvider("sk-ant-test", "claude-sonnet-4-6");
+    const opening = calls[0].messages;
+
+    await provider.sendMessage(opening, {
+      systemPrompt: "system prompt",
+      config: { mutableLatestUserMessage: true, cacheTtl: "1h" },
+    });
+    const openingTtls = anthropicTurnStartTtls(lastAnthropicParams);
+
+    await provider.sendMessage(
+      [
+        ...opening,
+        {
+          role: "assistant",
+          content: [{ type: "tool_use", id: "t1", name: "echo", input: {} }],
+        },
+        {
+          role: "user",
+          content: [{ type: "tool_result", tool_use_id: "t1", content: "ok" }],
+        },
+      ] as unknown as Message[],
+      {
+        systemPrompt: "system prompt",
+        config: { mutableLatestUserMessage: true, cacheTtl: "1h" },
+      },
+    );
+    const toolLoopTtls = anthropicTurnStartTtls(lastAnthropicParams);
+
+    expect(openingTtls).toEqual(["5m"]);
+    expect(toolLoopTtls).toEqual(openingTtls);
+  });
+
+  test("Anthropic: a stable turn start still takes the long TTL", async () => {
+    const provider = new AnthropicProvider("sk-ant-test", "claude-sonnet-4-6");
+    await provider.sendMessage(calls[0].messages, {
+      systemPrompt: "system prompt",
+      config: { cacheTtl: "1h" },
+    });
+
+    expect(anthropicTurnStartTtls(lastAnthropicParams)).toEqual(["1h"]);
+  });
+});
+
+// Known cache-stability gap, documented pending a fix:
+//
+// Daemon-restart divergence: several per-turn blocks are injected into
+// in-memory history but never persisted to message metadata
+// (voice_call_control, active_workspace / active_dynamic_page,
+// channel_command_context, transport_hints, active_subagents, active_thread,
+// active_documents; injection at conversation-runtime-assembly.ts, capture
+// switch omits them). After a daemon restart or conversation eviction,
+// loadFromDb re-renders history without those blocks, so the first request of
+// the next turn diverges from the cached prefix and re-writes it in full.
+// Conversations that never use those features are unaffected.
+describe("prompt cache stability across daemon restart", () => {
+  test.todo(
+    "history re-rendered via loadFromDb is byte-identical to the in-memory history the provider cached (non-persisted per-turn blocks survive or are stripped consistently)",
+    () => {},
+  );
+});

package/src/__tests__/proxy-approval-callback.test.ts

@@ -20,7 +20,7 @@ mock.module("../security/redaction.js", () => ({
 // Import after mocks are registered.
 // ---------------------------------------------------------------------------
 
-import type { ToolSetupContext } from "../daemon/conversation-tool-setup.js";
+import type { Conversation } from "../daemon/conversation.js";
 import { createProxyApprovalCallback } from "../daemon/conversation-tool-setup.js";
 import { PermissionPrompter } from "../permissions/prompter.js";
 
@@ -28,7 +28,7 @@ import { PermissionPrompter } from "../permissions/prompter.js";
 // Helpers
 // ---------------------------------------------------------------------------
 
-function makeContext(overrides?: Partial<ToolSetupContext>): ToolSetupContext {
+function makeContext(overrides?: Partial<Conversation>): Conversation {
   return {
     conversationId: "conv-test",
     workingDir: "/tmp/test-project",
@@ -36,7 +36,7 @@ function makeContext(overrides?: Partial<ToolSetupContext>): ToolSetupContext {
     sendToClient: () => {},
     surfacesByAppId: new Map(),
     ...overrides,
-  } as ToolSetupContext;
+  } as unknown as Conversation;
 }
 
 function makeAskMissingCredentialRequest(