@vellumai/assistant 0.8.2 → 0.8.4

package/src/__tests__/context-token-estimator.test.ts

@@ -219,36 +219,7 @@ describe("token estimator", () => {
     expect(largeFileTokens).toBe(smallFileTokens);
   });
 
-  // Non-Anthropic providers use base64 payload size for image estimation
-  test("scales image token estimate with base64 payload size (non-Anthropic)", () => {
-    const smallImageTokens = estimateContentBlockTokens(
-      {
-        type: "image",
-        source: {
-          type: "base64",
-          media_type: "image/png",
-          data: "a".repeat(64),
-        },
-      },
-      { providerName: "openai" },
-    );
-    const largeImageTokens = estimateContentBlockTokens(
-      {
-        type: "image",
-        source: {
-          type: "base64",
-          media_type: "image/png",
-          data: "a".repeat(60_000),
-        },
-      },
-      { providerName: "openai" },
-    );
-
-    expect(largeImageTokens).toBeGreaterThan(smallImageTokens);
-    expect(largeImageTokens - smallImageTokens).toBeGreaterThan(1000);
-  });
-
-  test("estimates Anthropic image tokens from dimensions, not base64 size", () => {
+  test("estimates image tokens from dimensions, not base64 size", () => {
     // Build a minimal valid PNG header encoding 1920x1080 dimensions.
     // PNG header: 8-byte signature + 4-byte IHDR length + 4-byte "IHDR" + 4-byte width + 4-byte height = 24 bytes minimum
     const pngHeader = Buffer.alloc(24);
@@ -278,55 +249,139 @@ describe("token estimator", () => {
     const fullPayload = Buffer.concat([pngHeader, padding]);
     const base64Data = fullPayload.toString("base64");
 
-    const anthropicTokens = estimateContentBlockTokens(
-      {
-        type: "image",
-        source: { type: "base64", media_type: "image/png", data: base64Data },
-      },
-      { providerName: "anthropic" },
-    );
-
     // 1920x1080 scaled to fit 1568px bounding box: dimScale = 1568/1920 = 0.8167
     // scaledWidth = round(1920 * 0.8167) = 1568, scaledHeight = round(1080 * 0.8167) = 882
     // pixels = 1568 * 882 = 1,382,976 > 1,200,000 → mpScale = sqrt(1200000/1382976) = 0.9315
     // scaledWidth = round(1568 * 0.9315) = 1461, scaledHeight = round(882 * 0.9315) = 822
     // tokens = ceil(1461 * 822 / 750) = ceil(1601.26) = ~1,602
-    // With IMAGE_BLOCK_OVERHEAD_TOKENS and media_type overhead, still well under 5000
-    expect(anthropicTokens).toBeLessThan(5_000);
-
-    // Verify it's NOT using base64 size (which would be ~50,000+ tokens)
-    const nonAnthropicTokens = estimateContentBlockTokens(
-      {
-        type: "image",
-        source: { type: "base64", media_type: "image/png", data: base64Data },
-      },
-      { providerName: "openai" },
-    );
-    expect(nonAnthropicTokens).toBeGreaterThan(50_000);
+    // With IMAGE_BLOCK_OVERHEAD_TOKENS and media_type overhead, still well under 5000.
+    // Same result for every provider — dimension-based estimate is universal.
+    for (const providerName of [
+      "anthropic",
+      "openai",
+      "openrouter",
+      "gemini",
+    ]) {
+      const tokens = estimateContentBlockTokens(
+        {
+          type: "image",
+          source: { type: "base64", media_type: "image/png", data: base64Data },
+        },
+        { providerName },
+      );
+      expect(tokens).toBeLessThan(5_000);
+    }
   });
 
-  test("falls back to max tokens when Anthropic image dimensions can't be parsed", () => {
+  test("falls back to max tokens when image dimensions can't be parsed", () => {
     // Corrupted base64 that won't parse as a valid image header
     const corruptedData = Buffer.from(
       "not-a-valid-image-header-at-all",
     ).toString("base64");
 
+    for (const providerName of ["anthropic", "openai", "openrouter"]) {
+      const tokens = estimateContentBlockTokens(
+        {
+          type: "image",
+          source: {
+            type: "base64",
+            media_type: "image/png",
+            data: corruptedData,
+          },
+        },
+        { providerName },
+      );
+
+      // Falls back to the per-image cap (1,600 tokens). Total = 16 (block
+      // overhead) + ceil(9/4) (media_type) + 1600 = 1619.
+      expect(tokens).toBeGreaterThanOrEqual(1_600);
+      expect(tokens).toBeLessThan(2_000);
+    }
+  });
+
+  test("Gemini falls back to its max-tile budget for unparseable / HEIC images", () => {
+    // HEIC/HEIF coming from iOS attachments aren't parsed by
+    // parseImageDimensions, so the estimator sees null dims. The generic
+    // 1,600-token cap would under-count by ~2.5x for a typical iPhone photo
+    // that ends up at Gemini's 16-tile / 4,128-token ceiling. Use the
+    // Gemini-specific cap instead to avoid skipping compaction.
+    for (const mediaType of [
+      "image/heic",
+      "image/heif",
+      "image/png", // corrupted PNG also exercises the fallback
+    ]) {
+      const data = Buffer.from("not-a-valid-image-header-at-all").toString(
+        "base64",
+      );
+      const tokens = estimateContentBlockTokens(
+        {
+          type: "image",
+          source: { type: "base64", media_type: mediaType, data },
+        },
+        { providerName: "gemini" },
+      );
+      // 4128 (16 tiles * 258) + 16 (block overhead) + ceil(mediaType len / 4)
+      expect(tokens).toBeGreaterThanOrEqual(4_128);
+      expect(tokens).toBeLessThan(4_200);
+    }
+  });
+
+  test("Gemini image tokens scale with image area via 768x768 tiling", () => {
+    // Per Google's docs, Gemini tiles images larger than 384px into 768x768
+    // chunks at 258 tokens each, after resizing the longest side to ≤3072px.
+    // 3000x3000 (under the cap) → ceil(3000/768)^2 = 4*4 = 16 tiles → 4,128
+    // image tokens.
     const tokens = estimateContentBlockTokens(
       {
         type: "image",
         source: {
           type: "base64",
           media_type: "image/png",
-          data: corruptedData,
+          data: makePngBase64(3000, 3000),
         },
       },
-      { providerName: "anthropic" },
+      { providerName: "gemini" },
+    );
+    expect(tokens).toBeGreaterThanOrEqual(4_128);
+    expect(tokens).toBeLessThan(4_200);
+  });
+
+  test("Gemini clamps image dimensions to 3072px before tiling", () => {
+    // Google's docs state images are resized to a 3072px max side before
+    // tiling. Without the clamp, a 4000x4000 image would be counted as
+    // ceil(4000/768)^2 = 36 tiles (~9,288 tokens) instead of the actual
+    // ceil(3072/768)^2 = 16 tiles (~4,128 tokens), over-counting by ~2.25x
+    // and triggering spurious compaction.
+    const tokens = estimateContentBlockTokens(
+      {
+        type: "image",
+        source: {
+          type: "base64",
+          media_type: "image/png",
+          data: makePngBase64(4000, 4000),
+        },
+      },
+      { providerName: "gemini" },
     );
+    expect(tokens).toBeGreaterThanOrEqual(4_128);
+    expect(tokens).toBeLessThan(4_200);
+  });
 
-    // Should fall back to ANTHROPIC_IMAGE_MAX_TOKENS (1,600)
-    // Total = 16 (block overhead) + ceil(9/4) (media_type) + 1600 = 1619
-    expect(tokens).toBeGreaterThanOrEqual(1_600);
-    expect(tokens).toBeLessThan(2_000);
+  test("Gemini images ≤384px on both sides count as a single 258-token tile", () => {
+    const tokens = estimateContentBlockTokens(
+      {
+        type: "image",
+        source: {
+          type: "base64",
+          media_type: "image/png",
+          data: makePngBase64(200, 200),
+        },
+      },
+      { providerName: "gemini" },
+    );
+    // 258 (tile) + 16 (block overhead) + 3 (media type) = 277
+    expect(tokens).toBeGreaterThanOrEqual(258);
+    expect(tokens).toBeLessThan(300);
   });
 
   test("Anthropic image tokens are the same for same-dimension images regardless of payload size", () => {

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

@@ -19,7 +19,7 @@ mock.module("../memory/guardian-action-store.js", () => ({
 
 mock.module("../providers/registry.js", () => ({
   getProvider: () => ({ name: "mock-provider" }),
-  initializeProviders: () => {},
+  initializeProviders: async () => {},
 }));
 
 mock.module("../config/loader.js", () => ({

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

@@ -78,7 +78,11 @@ mock.module("../config/loader.js", () => ({
           },
         },
       },
-      profiles: {},
+      profiles: {
+        "quality-optimized": {
+          contextWindow: { maxInputTokens: 50000 },
+        },
+      },
       callSites: {},
       pricingOverrides: [],
     },
@@ -165,6 +169,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   getConversationOriginChannel: () => null,
   getMessageById: () => null,
   getLastUserTimestampBefore: () => 0,
+  setLastNotifiedInferenceProfile: () => {},
 }));
 
 mock.module("../memory/conversation-disk-view.js", () => ({
@@ -350,12 +355,17 @@ import {
 
 // Captures every positional argument the loop passes to `agentLoop.run`.
 // The 8th positional argument is the per-turn `overrideProfile`, which is
-// what these tests assert on.
+// what most tests assert on. The 10th and 11th positional arguments re-resolve
+// that profile and its max-token budget between provider calls.
 interface CapturedAgentLoopRun {
   callSite: LLMCallSite | undefined;
   overrideProfile: string | undefined;
+  resolvedOverrideProfile: string | undefined;
+  resolvedEffectiveMaxInputTokens: number | undefined;
 }
 
+let mutateBeforeResolveOverrideProfile: (() => void) | undefined;
+
 function makeCtx(
   captured: CapturedAgentLoopRun[],
   overrides?: Partial<AgentLoopConversationContext>,
@@ -371,8 +381,17 @@ function makeCtx(
     callSite?: LLMCallSite,
     _turnContext?: unknown,
     overrideProfile?: string,
+    _effectiveMaxInputTokens?: number,
+    resolveOverrideProfile?: () => string | undefined,
+    resolveEffectiveMaxInputTokens?: () => number | undefined,
   ): Promise<Message[]> => {
-    captured.push({ callSite, overrideProfile });
+    mutateBeforeResolveOverrideProfile?.();
+    captured.push({
+      callSite,
+      overrideProfile,
+      resolvedOverrideProfile: resolveOverrideProfile?.(),
+      resolvedEffectiveMaxInputTokens: resolveEffectiveMaxInputTokens?.(),
+    });
     return [
       ...messages,
       {
@@ -511,6 +530,7 @@ beforeEach(() => {
     totalEstimatedCost: 0,
     title: null,
   };
+  mutateBeforeResolveOverrideProfile = undefined;
   resetPluginRegistryAndRegisterDefaults();
 });
 
@@ -631,4 +651,35 @@ describe("runAgentLoopImpl — per-conversation inferenceProfile", () => {
       expect(call.overrideProfile).toBe("fast");
     }
   });
+
+  test("re-resolves inferenceProfile when a tool changes it mid-turn", async () => {
+    mockConversationRow = {
+      id: "conv-1",
+      conversationType: "standard",
+      inferenceProfile: null,
+      contextSummary: null,
+      contextCompactedMessageCount: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalEstimatedCost: 0,
+      title: null,
+    };
+    mutateBeforeResolveOverrideProfile = () => {
+      mockConversationRow = {
+        ...mockConversationRow!,
+        inferenceProfile: "quality-optimized",
+      };
+    };
+
+    const captured: CapturedAgentLoopRun[] = [];
+    const ctx = makeCtx(captured);
+
+    await runAgentLoopImpl(ctx, "hello", "msg-1", () => {});
+
+    expect(captured.length).toBeGreaterThan(0);
+    expect(captured[0].overrideProfile).toBeUndefined();
+    expect(captured[0].resolvedOverrideProfile).toBe("quality-optimized");
+    expect(captured[0].resolvedEffectiveMaxInputTokens).toBe(50000);
+    expect(ctx.currentTurnOverrideProfile).toBeUndefined();
+  });
 });

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

@@ -195,6 +195,9 @@ mock.module("../memory/conversation-crud.js", () => ({
   updateMessageContent: () => {},
   updateMessageMetadata: () => {},
   clearStrippedInjectionMetadataForConversation: () => {},
+  setLastNotifiedInferenceProfile: () => {},
+  getLastUserTimestampBefore: () => 0,
+  getConversationOverrideProfileFromRow: () => undefined,
 }));
 
 afterAll(() => {
@@ -301,6 +304,7 @@ mock.module("../daemon/history-repair.js", () => ({
 }));
 
 const recordUsageMock = mock((..._args: unknown[]) => {});
+const setAgentLoopExitReasonOnLatestLogMock = mock(() => {});
 mock.module("../daemon/conversation-usage.js", () => ({
   recordUsage: recordUsageMock,
 }));
@@ -349,12 +353,23 @@ mock.module("../workspace/git-service.js", () => ({
 }));
 
 mock.module("../daemon/conversation-error.js", () => ({
-  classifyConversationError: (_err: unknown, _ctx: unknown) => ({
-    code: "CONVERSATION_PROCESSING_FAILED",
-    userMessage: "Something went wrong processing your message.",
-    retryable: false,
-    errorCategory: "processing_failed",
-  }),
+  classifyConversationError: (err: unknown, _ctx: unknown) => {
+    const message = err instanceof Error ? err.message : String(err);
+    if (/context.?length.?exceeded/i.test(message)) {
+      return {
+        code: "CONTEXT_TOO_LARGE",
+        userMessage: "Context too large.",
+        retryable: false,
+        errorCategory: "context_too_large",
+      };
+    }
+    return {
+      code: "CONVERSATION_PROCESSING_FAILED",
+      userMessage: "Something went wrong processing your message.",
+      retryable: false,
+      errorCategory: "processing_failed",
+    };
+  },
   isUserCancellation: (err: unknown, ctx: { aborted?: boolean }) => {
     if (!ctx.aborted) return false;
     if (err instanceof DOMException && err.name === "AbortError") return true;
@@ -394,6 +409,7 @@ mock.module("../agent/message-types.js", () => ({
 mock.module("../memory/llm-request-log-store.js", () => ({
   recordRequestLog: () => {},
   backfillMessageIdOnLogs: () => {},
+  setAgentLoopExitReasonOnLatestLog: setAgentLoopExitReasonOnLatestLogMock,
 }));
 
 mock.module("../memory/archive-store.js", () => ({
@@ -616,6 +632,7 @@ beforeEach(() => {
   mockOverflowAction = "fail_gracefully";
   mockApplyRuntimeInjections = (msgs) => msgs;
   recordUsageMock.mockClear();
+  setAgentLoopExitReasonOnLatestLogMock.mockClear();
   // Reset the plugin registry and re-register every default so the
   // orchestrator's pipelines (`overflowReduce`, `persistence`, …) dispatch to
   // the default middleware, which in turn hits the mocked collaborators
@@ -1907,6 +1924,10 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
     // After exhausting mid-loop attempts, the convergence loop should
     // have been triggered (contextTooLargeDetected set to true)
     expect(convergenceReducerCalled).toBe(true);
+    expect(setAgentLoopExitReasonOnLatestLogMock).toHaveBeenCalledWith(
+      "test-conv",
+      "context_too_large",
+    );
   });
 
   // ── Test 9 ────────────────────────────────────────────────────────
@@ -2068,6 +2089,10 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
 
     // Agent loop: 1 initial + 3 mid-loop re-entries + 2 convergence re-runs = 6 calls
     expect(agentLoopCallCount).toBe(6);
+    expect(setAgentLoopExitReasonOnLatestLogMock).toHaveBeenCalledWith(
+      "test-conv",
+      "context_too_large",
+    );
   });
 
   // ── Test 8 ────────────────────────────────────────────────────────

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

@@ -283,6 +283,7 @@ let mockSlackChronologicalContext: {
   renderedMessages: Array<{
     message: Message;
     sourceChannelTs: string | null;
+    tagLineProvenance: "none" | "slack-reaction" | "slack-timezone-message";
   }>;
   messages: Message[];
   compactableStartIndex: number;
@@ -386,6 +387,8 @@ mock.module("../daemon/history-repair.js", () => ({
 
 const recordUsageMock = mock(() => {});
 const recordRequestLogMock = mock(() => {});
+const backfillMessageIdOnLogsMock = mock(() => {});
+const setAgentLoopExitReasonOnLatestLogMock = mock(() => {});
 mock.module("../daemon/conversation-usage.js", () => ({
   recordUsage: recordUsageMock,
 }));
@@ -482,7 +485,8 @@ mock.module("../memory/archive-store.js", () => ({
 
 mock.module("../memory/llm-request-log-store.js", () => ({
   recordRequestLog: recordRequestLogMock,
-  backfillMessageIdOnLogs: () => {},
+  backfillMessageIdOnLogs: backfillMessageIdOnLogsMock,
+  setAgentLoopExitReasonOnLatestLog: setAgentLoopExitReasonOnLatestLogMock,
 }));
 
 let mockHasProactiveArtifactCompleted = true;
@@ -658,6 +662,8 @@ beforeEach(() => {
   mockInjectionBlocks = {};
   recordUsageMock.mockClear();
   recordRequestLogMock.mockClear();
+  backfillMessageIdOnLogsMock.mockClear();
+  setAgentLoopExitReasonOnLatestLogMock.mockClear();
   syncMessageToDiskMock.mockClear();
   rebuildConversationDiskViewFromDbStateMock.mockClear();
   updateMessageMetadataMock.mockClear();
@@ -2298,6 +2304,10 @@ describe("session-agent-loop", () => {
 
       const handoff = events.find((e) => e.type === "generation_handoff");
       expect(handoff).toBeDefined();
+      expect(setAgentLoopExitReasonOnLatestLogMock).toHaveBeenCalledWith(
+        "test-conv",
+        "checkpoint_handoff",
+      );
     });
 
     test("continues when canHandoffAtCheckpoint returns false", async () => {
@@ -2357,6 +2367,10 @@ describe("session-agent-loop", () => {
 
       const handoff = events.find((e) => e.type === "generation_handoff");
       expect(handoff).toBeUndefined();
+      expect(setAgentLoopExitReasonOnLatestLogMock).not.toHaveBeenCalledWith(
+        "test-conv",
+        "checkpoint_handoff",
+      );
       const complete = events.find((e) => e.type === "message_complete");
       expect(complete).toBeDefined();
     });
@@ -2855,6 +2869,57 @@ describe("session-agent-loop", () => {
       );
       expect(conversationErrors.length).toBeGreaterThanOrEqual(1);
     });
+
+    test("pipes synthetic assistant message id into provider-error log rows via backfill", async () => {
+      // Codex P1 regression test: the provider-failure turn must not leave
+      // its `llm_request_logs` row orphaned. Without the backfill call in
+      // the synthetic-message branch, a later turn's `handleMessageComplete`
+      // sweep would wrong-attach this row to the wrong assistant message.
+      const events: ServerMessage[] = [];
+
+      const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
+        // 1) handleProviderError -> writes an `llm_request_logs` row with
+        //    messageId=null (the orphan we are trying to link).
+        onEvent({
+          type: "provider_error",
+          error: new Error("upstream 500"),
+          rawRequest: { model: "gpt-4.1", messages: [] },
+          actualProvider: "openai",
+        });
+        // 2) handleError -> sets `state.providerErrorUserMessage`, which
+        //    activates the synthetic-message branch below the loop.
+        onEvent({
+          type: "error",
+          error: new Error("upstream 500"),
+        });
+        // Provider returned no assistant content — same messages back.
+        return messages;
+      };
+
+      const ctx = makeCtx({ agentLoopRun });
+      await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
+
+      // The orphan was written with messageId=undefined.
+      expect(recordRequestLogMock).toHaveBeenCalledTimes(1);
+      const recordCall = recordRequestLogMock.mock.calls[0] as unknown as [
+        string,
+        string,
+        string,
+        string | undefined,
+        string | undefined,
+      ];
+      expect(recordCall[0]).toBe("test-conv");
+      expect(recordCall[3]).toBeUndefined();
+
+      // The synthetic-message branch then piped the assigned message id
+      // (from the mocked `addMessage` -> `{ id: "mock-msg-id" }`) into the
+      // backfill primitive, scoped to this conversation.
+      expect(backfillMessageIdOnLogsMock).toHaveBeenCalledTimes(1);
+      const backfillCall = backfillMessageIdOnLogsMock.mock
+        .calls[0] as unknown as [string, string];
+      expect(backfillCall[0]).toBe("test-conv");
+      expect(backfillCall[1]).toBe("mock-msg-id");
+    });
   });
 
   describe("pkbSystemReminderBlock metadata persistence", () => {
@@ -2967,6 +3032,7 @@ describe("session-agent-loop", () => {
             "1700000020.000000",
             "1700000030.000000",
           ][index]!,
+          tagLineProvenance: "none",
         })),
         compactableStartIndex: 0,
       };
@@ -3066,6 +3132,7 @@ describe("session-agent-loop", () => {
             "1700000020.000000",
             "1700000030.000000",
           ][index]!,
+          tagLineProvenance: "none",
         })),
         compactableStartIndex: 0,
       };
@@ -3182,6 +3249,7 @@ describe("session-agent-loop", () => {
             "1700000030.000000",
             "1700000040.000000",
           ][index]!,
+          tagLineProvenance: "none",
         })),
         compactableStartIndex: 0,
       };
@@ -3287,9 +3355,10 @@ describe("session-agent-loop", () => {
               {
                 message: firstSummaryMessage,
                 sourceChannelTs: null,
+                tagLineProvenance: "none",
               },
-              mockSlackChronologicalContext.renderedMessages[2],
-              mockSlackChronologicalContext.renderedMessages[3],
+              mockSlackChronologicalContext!.renderedMessages[2],
+              mockSlackChronologicalContext!.renderedMessages[3],
             ],
             messages: firstCompactedMessages,
             compactableStartIndex: 1,
@@ -3328,6 +3397,7 @@ describe("session-agent-loop", () => {
             "1700000020.000000",
             "1700000030.000000",
           ][index]!,
+          tagLineProvenance: "none",
         })),
         compactableStartIndex: 0,
       };
@@ -3485,6 +3555,7 @@ describe("session-agent-loop", () => {
               ],
             },
             sourceChannelTs: null,
+            tagLineProvenance: "none",
           },
           {
             message: {
@@ -3492,6 +3563,7 @@ describe("session-agent-loop", () => {
               content: [{ type: "text", text: "after watermark reply" }],
             },
             sourceChannelTs: "1700000020.000000",
+            tagLineProvenance: "none",
           },
         ],
         compactableStartIndex: 1,
@@ -3586,6 +3658,7 @@ describe("session-agent-loop", () => {
               ],
             },
             sourceChannelTs: null,
+            tagLineProvenance: "none",
           },
           {
             message: {
@@ -3598,6 +3671,7 @@ describe("session-agent-loop", () => {
               ],
             },
             sourceChannelTs: "1700000121.000000",
+            tagLineProvenance: "none",
           },
         ],
         compactableStartIndex: 1,

package/src/__tests__/conversation-app-control-lifecycle.test.ts

@@ -22,7 +22,7 @@ mock.module("../util/logger.js", () => ({
 
 mock.module("../providers/registry.js", () => ({
   getProvider: () => ({ name: "mock-provider" }),
-  initializeProviders: () => {},
+  initializeProviders: async () => {},
 }));
 
 mock.module("../config/loader.js", () => ({