@vellumai/assistant 0.11.7 → 0.11.8-staging.1

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

@@ -263,19 +263,6 @@ afterAll(() => {
   );
 });
 
-mock.module("../memory/retriever.js", () => ({
-  buildMemoryRecall: async () => ({
-    enabled: false,
-    degraded: false,
-    injectedText: "",
-
-    semanticHits: 0,
-    injectedTokens: 0,
-    latencyMs: 0,
-  }),
-  injectMemoryRecallAsUserBlock: (msgs: Message[]) => msgs,
-}));
-
 mock.module("../apps/app-store.js", () => ({
   getApp: () => null,
   listAppFiles: () => [],

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

@@ -346,6 +346,10 @@ mock.module("../persistence/conversation-crud.js", () => ({
   updateMessageMetadata: updateMessageMetadataMock,
   setConversationHistoryStrippedAt: setConversationHistoryStrippedAtMock,
   getMessages: () => mockStoredMessages,
+  // Read by the pre-run camera-frame retention pass for any history holding
+  // attachment references. This suite seeds none, so an empty map is the same
+  // answer the real accessor would give.
+  selectSightFrameCaptureTimes: () => new Map<string, number>(),
   getConversation: () => mockConversationRow,
   provenanceFromTrustContext: () => ({
     source: "user",
@@ -421,19 +425,6 @@ mock.module("../persistence/conversation-disk-view.js", () => ({
     rebuildConversationDiskViewFromDbStateMock,
 }));
 
-mock.module("../memory/retriever.js", () => ({
-  buildMemoryRecall: async () => ({
-    enabled: false,
-    degraded: false,
-    injectedText: "",
-
-    semanticHits: 0,
-    injectedTokens: 0,
-    latencyMs: 0,
-  }),
-  injectMemoryRecallAsUserBlock: (msgs: Message[]) => msgs,
-}));
-
 mock.module("../apps/app-store.js", () => ({
   getApp: () => null,
   listAppFiles: () => [],
@@ -1708,6 +1699,91 @@ describe("session-agent-loop", () => {
       expect(call[1]).toBe(JSON.stringify(rawRequest));
       expect(call[2]).toBe(JSON.stringify(rawResponse));
     });
+
+    test("request log and usage event share the turn call site", async () => {
+      const rawRequest = {
+        model: "gpt-4.1",
+        messages: [{ role: "user", content: "Hello" }],
+      };
+      const rawResponse = {
+        model: "gpt-4.1-2026-03-01",
+        choices: [
+          {
+            finish_reason: "stop",
+            message: { role: "assistant", content: "Hi there." },
+          },
+        ],
+      };
+      const ctx = makeCtx({
+        providerResponses: [
+          {
+            content: [{ type: "text", text: "Hi there." }],
+            model: "gpt-4.1-2026-03-01",
+            usage: { inputTokens: 12, outputTokens: 3 },
+            stopReason: "end_turn",
+            actualProvider: "openai",
+            rawRequest,
+            rawResponse,
+          },
+        ],
+      });
+
+      await runAgentLoopImpl(ctx, "hello", "msg-1", () => {}, {
+        callSite: "callAgent",
+      });
+
+      expect(recordRequestLogMock).toHaveBeenCalledTimes(1);
+      const call = recordRequestLogMock.mock.calls[0] as unknown as unknown[];
+      expect(call[5]).toBe("callAgent");
+
+      const usageCall = recordUsageMock.mock.calls.find(
+        (entry) => (entry as unknown[])[5] === "main_agent",
+      ) as unknown[] | undefined;
+      expect(usageCall).toBeDefined();
+      const attribution = usageCall?.[12] as UsageAttributionInput;
+      expect(attribution.callSite).toBe("callAgent");
+    });
+
+    test("stamps voiceFrontDoor on the request log for a front-door turn", async () => {
+      const ctx = makeCtx({
+        providerResponses: [
+          {
+            content: [{ type: "text", text: "Hi." }],
+            model: "mock-model",
+            usage: { inputTokens: 8, outputTokens: 2 },
+            stopReason: "end_turn",
+            rawRequest: { model: "mock-model", messages: [] },
+            rawResponse: { id: "resp-1" },
+          },
+        ],
+      });
+
+      await runAgentLoopImpl(ctx, "hello", "msg-1", () => {}, {
+        callSite: "voiceFrontDoor",
+      });
+
+      const call = recordRequestLogMock.mock.calls[0] as unknown as unknown[];
+      expect(call[5]).toBe("voiceFrontDoor");
+    });
+
+    test("provider-error request logs carry the turn call site", async () => {
+      const ctx = makeCtx({
+        loopProvider: {
+          name: "mock-provider",
+          async sendMessage() {
+            throw new Error("upstream 500");
+          },
+        } as unknown as Provider,
+      });
+
+      await runAgentLoopImpl(ctx, "hello", "msg-1", () => {}, {
+        callSite: "callAgent",
+      });
+
+      expect(recordRequestLogMock).toHaveBeenCalledTimes(1);
+      const call = recordRequestLogMock.mock.calls[0] as unknown as unknown[];
+      expect(call[5]).toBe("callAgent");
+    });
   });
 
   describe("usage accounting", () => {
@@ -4164,6 +4240,7 @@ describe("session-agent-loop", () => {
           summaryModel: "claude-sonnet-5",
           summaryText: "summary",
           summaryCallSite: "compactionAgent",
+          summaryResolutionCallSite: "mainAgent",
           // What the compactor resolved before the call...
           summaryOverrideProfile: "primaryProfile",
           // ...and what the reroute actually served.
@@ -4184,6 +4261,7 @@ describe("session-agent-loop", () => {
       expect(compactorCall?.[3]).toBe("claude-sonnet-5");
       expect(compactorCall?.[12]).toEqual({
         callSite: "compactionAgent",
+        profileResolutionCallSite: "mainAgent",
         overrideProfile: "backupProfile",
         forceOverrideProfile: true,
       });
@@ -4210,6 +4288,7 @@ describe("session-agent-loop", () => {
           summaryModel: "mock-model",
           summaryText: "summary",
           summaryCallSite: "compactionAgent",
+          summaryResolutionCallSite: "mainAgent",
           summaryOverrideProfile: "primaryProfile",
           summaryActualProvider: "openai",
         },
@@ -4226,6 +4305,7 @@ describe("session-agent-loop", () => {
       expect(compactorCall?.[3]).toBe("mock-model");
       expect(compactorCall?.[12]).toEqual({
         callSite: "compactionAgent",
+        profileResolutionCallSite: "mainAgent",
         overrideProfile: "primaryProfile",
       });
     });
@@ -4255,6 +4335,7 @@ describe("session-agent-loop", () => {
           summaryModel: "mock-model",
           summaryText: "summary",
           summaryCallSite: "compactionAgent",
+          summaryResolutionCallSite: "mainAgent",
           summaryOverrideProfile: "primaryProfile",
         },
         () => {},
@@ -4271,6 +4352,7 @@ describe("session-agent-loop", () => {
       });
       expect(compactorCall?.[12]).toEqual({
         callSite: "compactionAgent",
+        profileResolutionCallSite: "mainAgent",
         overrideProfile: "primaryProfile",
       });
     });

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

@@ -86,19 +86,6 @@ mock.module("../persistence/attachments-store.js", () => ({
   linkAttachmentToMessage: () => {},
 }));
 
-mock.module("../memory/retriever.js", () => ({
-  buildMemoryRecall: async () => ({
-    enabled: false,
-    degraded: false,
-    injectedText: "",
-
-    semanticHits: 0,
-    injectedTokens: 0,
-    latencyMs: 0,
-  }),
-  injectMemoryRecallAsUserBlock: (msgs: Message[]) => msgs,
-}));
-
 mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
   ContextWindowManager: class {
     estimateInputTokens() {

package/src/__tests__/conversation-load-history-repair.test.ts

@@ -435,6 +435,424 @@ describe("loadFromDb history repair", () => {
     ]);
   });
 
+  test("a stored reaction row loads as rendered text, not the sentinel", async () => {
+    mockConversation = {
+      id: "conv-1",
+      contextSummary: null,
+      contextCompactedMessageCount: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalEstimatedCost: 0,
+    };
+    mockDbMessages = [
+      {
+        id: "m1",
+        role: "user",
+        content: [{ type: "text", text: "Deploy is done" }],
+        metadata: JSON.stringify({
+          providerMeta: JSON.stringify({
+            source: "discord",
+            conversationExternalId: "chan-1",
+            messageId: "555.1",
+            eventKind: "message",
+          }),
+        }),
+      },
+      {
+        id: "m2",
+        role: "user",
+        content: [{ type: "text", text: "[reaction]" }],
+        metadata: JSON.stringify({
+          providerMeta: JSON.stringify({
+            source: "discord",
+            conversationExternalId: "chan-1",
+            eventKind: "reaction",
+            reaction: {
+              targetMessageId: "555.1",
+              emoji: "thumbsup",
+              op: "added",
+              actorDisplayName: "Alice",
+            },
+          }),
+        }),
+      },
+    ];
+
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+    const messages = conversation.getMessages();
+
+    // History repair merges the two adjacent user rows into one message;
+    // what matters is that the model reads the rendered fact, never the
+    // sentinel.
+    const allText = messages
+      .flatMap((m) => m.content)
+      .filter((b) => b.type === "text")
+      .map((b) => (b.type === "text" ? b.text : ""))
+      .join("\n");
+    expect(allText).not.toContain("[reaction]");
+    expect(allText).toContain(
+      'Alice reacted with :thumbsup: to the message "Deploy is done"',
+    );
+    expect(allText).toContain("<external_content");
+  });
+
+  test("markHistoryStale makes the next ensureActorScopedHistory reload", async () => {
+    mockConversation = {
+      id: "conv-1",
+      contextSummary: null,
+      contextCompactedMessageCount: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalEstimatedCost: 0,
+    };
+    mockDbMessages = [
+      {
+        id: "m1",
+        role: "user",
+        content: [{ type: "text", text: "Hello" }],
+      },
+      {
+        id: "m2",
+        role: "assistant",
+        content: [{ type: "text", text: "Hi" }],
+      },
+    ];
+
+    const conversation = makeConversation();
+    conversation.setTrustContext({
+      trustClass: "guardian",
+      sourceChannel: "telegram",
+    });
+    await conversation.loadFromDb();
+    expect(conversation.getMessages()).toHaveLength(2);
+
+    // A channel event lands straight in the store while the conversation
+    // stays resident.
+    mockDbMessages.push({
+      id: "m3",
+      role: "user",
+      content: [{ type: "text", text: "[reaction]" }],
+    });
+
+    // Same actor, no stale mark: the resident history is reused.
+    await conversation.ensureActorScopedHistory();
+    expect(conversation.getMessages()).toHaveLength(2);
+
+    conversation.markHistoryStale();
+    await conversation.ensureActorScopedHistory();
+    expect(conversation.getMessages()).toHaveLength(3);
+  });
+
+  test("a deleted row loads as the deletion marker, not its original text", async () => {
+    mockConversation = {
+      id: "conv-1",
+      contextSummary: null,
+      contextCompactedMessageCount: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalEstimatedCost: 0,
+    };
+    mockDbMessages = [
+      {
+        id: "m1",
+        role: "user",
+        content: [
+          { type: "text", text: "Please forget this password: hunter2" },
+        ],
+        metadata: JSON.stringify({
+          providerMeta: JSON.stringify({
+            source: "discord",
+            conversationExternalId: "chan-1",
+            messageId: "555.1",
+            eventKind: "message",
+            deletedAt: 1700000001000,
+          }),
+        }),
+      },
+      {
+        id: "m2",
+        role: "assistant",
+        content: [{ type: "text", text: "Understood" }],
+      },
+    ];
+
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+    const allText = conversation
+      .getMessages()
+      .flatMap((m) => m.content)
+      .filter((b) => b.type === "text")
+      .map((b) => (b.type === "text" ? b.text : ""))
+      .join("\n");
+    expect(allText).toContain("[This message was deleted]");
+    expect(allText).not.toContain("hunter2");
+  });
+
+  test("a reaction never quotes a target that was later deleted", async () => {
+    mockConversation = {
+      id: "conv-1",
+      contextSummary: null,
+      contextCompactedMessageCount: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalEstimatedCost: 0,
+    };
+    mockDbMessages = [
+      {
+        id: "m1",
+        role: "user",
+        content: [{ type: "text", text: "secret text" }],
+        metadata: JSON.stringify({
+          providerMeta: JSON.stringify({
+            source: "discord",
+            conversationExternalId: "chan-1",
+            messageId: "555.1",
+            eventKind: "message",
+            deletedAt: 1700000001000,
+          }),
+        }),
+      },
+      {
+        id: "m2",
+        role: "user",
+        content: [{ type: "text", text: "[reaction]" }],
+        metadata: JSON.stringify({
+          providerMeta: JSON.stringify({
+            source: "discord",
+            conversationExternalId: "chan-1",
+            eventKind: "reaction",
+            reaction: {
+              targetMessageId: "555.1",
+              emoji: "thumbsup",
+              op: "added",
+              actorDisplayName: "Alice",
+            },
+          }),
+        }),
+      },
+    ];
+
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+    const allText = conversation
+      .getMessages()
+      .flatMap((m) => m.content)
+      .filter((b) => b.type === "text")
+      .map((b) => (b.type === "text" ? b.text : ""))
+      .join("\n");
+    expect(allText).toContain("reacted with :thumbsup: to an earlier message");
+    expect(allText).not.toContain("secret text");
+  });
+
+  test("a reaction naming a later post of a split reply still quotes it", async () => {
+    mockConversation = {
+      id: "conv-1",
+      contextSummary: null,
+      contextCompactedMessageCount: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalEstimatedCost: 0,
+    };
+    mockDbMessages = [
+      {
+        id: "m1",
+        role: "assistant",
+        content: [{ type: "text", text: "Deploy finished cleanly." }],
+        metadata: JSON.stringify({
+          providerMeta: JSON.stringify({
+            source: "discord",
+            conversationExternalId: "chan-1",
+            messageId: "555.1",
+            additionalMessageIds: ["555.2"],
+            eventKind: "message",
+          }),
+        }),
+      },
+      {
+        id: "m2",
+        role: "user",
+        content: [{ type: "text", text: "[reaction]" }],
+        metadata: JSON.stringify({
+          providerMeta: JSON.stringify({
+            source: "discord",
+            conversationExternalId: "chan-1",
+            eventKind: "reaction",
+            reaction: {
+              targetMessageId: "555.2",
+              emoji: "tada",
+              op: "added",
+              actorDisplayName: "Alice",
+            },
+          }),
+        }),
+      },
+    ];
+
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+    const allText = conversation
+      .getMessages()
+      .flatMap((m) => m.content)
+      .filter((b) => b.type === "text")
+      .map((b) => (b.type === "text" ? b.text : ""))
+      .join("\n");
+    expect(allText).toContain(":tada:");
+    // The quote resolves through the split reply's later post id: the line
+    // never degrades to the unresolved "an earlier message" form.
+    expect(allText).not.toContain("an earlier message");
+  });
+
+  test("the assistant's own reaction row renders second-person", async () => {
+    mockConversation = {
+      id: "conv-1",
+      contextSummary: null,
+      contextCompactedMessageCount: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalEstimatedCost: 0,
+    };
+    mockDbMessages = [
+      {
+        id: "m1",
+        role: "user",
+        content: [{ type: "text", text: "great work" }],
+        metadata: JSON.stringify({
+          providerMeta: JSON.stringify({
+            source: "discord",
+            conversationExternalId: "chan-1",
+            messageId: "555.9",
+            eventKind: "message",
+          }),
+        }),
+      },
+      {
+        id: "m2",
+        role: "assistant",
+        content: [{ type: "text", text: "[reaction]" }],
+        metadata: JSON.stringify({
+          messageKind: "reaction",
+          providerMeta: JSON.stringify({
+            source: "discord",
+            conversationExternalId: "chan-1",
+            eventKind: "reaction",
+            reaction: {
+              targetMessageId: "555.9",
+              emoji: "🎉",
+              op: "added",
+            },
+          }),
+        }),
+      },
+    ];
+
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+    const allText = conversation
+      .getMessages()
+      .flatMap((m) => m.content)
+      .filter((b) => b.type === "text")
+      .map((b) => (b.type === "text" ? b.text : ""))
+      .join("\n");
+    expect(allText).not.toContain("[reaction]");
+    expect(allText).toContain("You reacted with 🎉 to this message:");
+    // The quoted target is sender text and stays fenced even in the
+    // assistant's own row.
+    expect(allText).toContain("great work");
+    expect(allText).toContain("<external_content");
+  });
+
+  test("a reaction row does not count as a turn on rehydration", async () => {
+    mockConversation = {
+      id: "conv-1",
+      contextSummary: null,
+      contextCompactedMessageCount: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalEstimatedCost: 0,
+    };
+    mockDbMessages = [
+      {
+        id: "m1",
+        role: "user",
+        content: [{ type: "text", text: "Hello" }],
+      },
+      {
+        id: "m2",
+        role: "assistant",
+        content: [{ type: "text", text: "Hi" }],
+      },
+      {
+        id: "m3",
+        role: "user",
+        content: [{ type: "text", text: "[reaction]" }],
+        metadata: JSON.stringify({
+          providerMeta: JSON.stringify({
+            source: "discord",
+            conversationExternalId: "chan-1",
+            eventKind: "reaction",
+            reaction: {
+              targetMessageId: "555.1",
+              emoji: "thumbsup",
+              op: "added",
+            },
+          }),
+        }),
+      },
+    ];
+
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+    // One real user message; the reaction row never dispatched a turn, so
+    // the rehydrated counter must match the live counter's one increment.
+    expect(conversation.turnCount).toBe(1);
+  });
+
+  test("a slackMeta-shaped reaction row renders with its actor id as origin", async () => {
+    mockConversation = {
+      id: "conv-1",
+      contextSummary: null,
+      contextCompactedMessageCount: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalEstimatedCost: 0,
+    };
+    mockDbMessages = [
+      {
+        id: "m1",
+        role: "user",
+        content: [{ type: "text", text: "[reaction]" }],
+        metadata: JSON.stringify({
+          slackMeta: JSON.stringify({
+            source: "slack",
+            channelId: "C123",
+            channelTs: "1700000000.111111",
+            eventKind: "reaction",
+            actorExternalUserId: "U_REACTOR",
+            displayName: "Alice",
+            reaction: {
+              emoji: "tada",
+              targetChannelTs: "1700000000.111111",
+              op: "added",
+              actorDisplayName: "Alice",
+            },
+          }),
+        }),
+      },
+    ];
+
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+    const allText = conversation
+      .getMessages()
+      .flatMap((m) => m.content)
+      .filter((b) => b.type === "text")
+      .map((b) => (b.type === "text" ? b.text : ""))
+      .join("\n");
+    expect(allText).toContain("Alice reacted with :tada:");
+    expect(allText).toContain('origin="U_REACTOR"');
+  });
+
   test("persistUserMessage reloads actor-scoped history before persisting on role switch", async () => {
     mockConversation = {
       id: "conv-1",

package/src/__tests__/conversation-media-retry.test.ts

@@ -68,9 +68,40 @@ describe("stripMediaPayloadsForRetry", () => {
     // The image in the first message should be replaced with a text stub
     const firstMsg = result.messages[0];
     expect(firstMsg.content[1].type).toBe("text");
+    // Pinned whole, not just the prefix: the descriptor half comes from the
+    // shared `mediaSourceDescriptor`, and this is what keeps this stub and the
+    // camera-frame stub describing dropped media the same way. `makeImageBlock`
+    // carries 4 base64 chars, which decode to 3 bytes.
+    expect((firstMsg.content[1] as { type: "text"; text: string }).text).toBe(
+      "[Image omitted from retry context: image/png, 3 bytes]",
+    );
+  });
+
+  test("a stripped file block reports the same descriptor as an image", () => {
+    const fileBlock: ContentBlock = {
+      type: "file",
+      source: {
+        type: "workspace_ref",
+        media_type: "application/pdf",
+        attachmentId: "att-1",
+        sizeBytes: 2048,
+        filename: "notes.pdf",
+      },
+    };
+    const messages: Message[] = [
+      makeUserMessage({ type: "text", text: "old" }, fileBlock),
+      makeAssistantMessage({ type: "text", text: "response" }),
+      makeUserMessage({ type: "text", text: "new" }),
+    ];
+
+    const result = stripMediaPayloadsForRetry(messages);
+
+    expect(result.replacedBlocks).toBe(1);
     expect(
-      (firstMsg.content[1] as { type: "text"; text: string }).text,
-    ).toContain("Image omitted");
+      (result.messages[0].content[1] as { type: "text"; text: string }).text,
+    ).toBe(
+      "[File omitted from retry context: notes.pdf (application/pdf, 2048 bytes)]",
+    );
   });
 
   test("strips images from older user turns, keeps images in latest kept turn", () => {