@vellumai/assistant 0.8.3 → 0.8.5

package/src/__tests__/computer-use-skill-manifest-regression.test.ts

@@ -78,12 +78,11 @@ describe("computer-use skill manifest regression", () => {
     await initializeTools();
 
     for (const cuTool of allComputerUseTools) {
-      const def = cuTool.getDefinition();
       const manifestTool = manifest.tools.find(
-        (t: { name: string }) => t.name === def.name,
+        (t: { name: string }) => t.name === cuTool.name,
       );
       expect(manifestTool).toBeDefined();
-      expect(manifestTool.description).toBe(def.description);
+      expect(manifestTool.description).toBe(cuTool.description);
     }
   });
 
@@ -91,12 +90,11 @@ describe("computer-use skill manifest regression", () => {
     await initializeTools();
 
     for (const cuTool of allComputerUseTools) {
-      const def = cuTool.getDefinition();
       const manifestTool = manifest.tools.find(
-        (t: { name: string }) => t.name === def.name,
+        (t: { name: string }) => t.name === cuTool.name,
       );
       expect(manifestTool).toBeDefined();
-      expect(manifestTool.input_schema).toEqual(def.input_schema);
+      expect(manifestTool.input_schema).toEqual(cuTool.input_schema);
     }
   });
 
@@ -121,15 +119,11 @@ describe("computer-use skill manifest regression", () => {
       (entry: { name: string; description: string }) => ({
         name: entry.name,
         description: entry.description,
+        input_schema: { type: "object" as const, properties: {} },
         category: "computer-use",
         defaultRiskLevel: RiskLevel.Low,
         origin: "skill" as const,
         ownerSkillId: "computer-use",
-        getDefinition: () => ({
-          name: entry.name,
-          description: entry.description,
-          input_schema: { type: "object" as const, properties: {} },
-        }),
         execute: async () => ({ content: "stub", isError: false }),
       }),
     );

package/src/__tests__/computer-use-tools.test.ts

@@ -23,10 +23,8 @@ interface JsonSchema {
 }
 
 /** Cast a tool definition's input_schema to a usable JSON Schema shape. */
-function schema(tool: {
-  getDefinition(): { input_schema: object };
-}): JsonSchema {
-  return tool.getDefinition().input_schema as JsonSchema;
+function schema(tool: { input_schema: object }): JsonSchema {
+  return tool.input_schema as JsonSchema;
 }
 
 const ctx: ToolContext = {

package/src/__tests__/config-watcher.test.ts

@@ -117,7 +117,7 @@ mock.module("../providers/registry.js", () => ({
   getProvider: () => undefined,
   listProviders: () => [],
   getProviderRoutingSource: () => undefined,
-  initializeProviders: () => {},
+  initializeProviders: async () => {},
   // Required by `providers/inference/connections.ts` and
   // `providers/connection-resolution.ts`, both loaded transitively when
   // ConfigWatcher's deps resolve. Without these, the import chain throws

package/src/__tests__/confirmation-request-guardian-bridge.test.ts

@@ -50,7 +50,6 @@ mock.module("../notifications/emit-signal.js", () => ({
       ],
     };
   },
-  registerBroadcastFn: () => {},
 }));
 
 // Mock channel guardian service — provide a guardian binding for 'self' + 'telegram'

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

@@ -256,7 +256,12 @@ describe("token estimator", () => {
     // tokens = ceil(1461 * 822 / 750) = ceil(1601.26) = ~1,602
     // 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"]) {
+    for (const providerName of [
+      "anthropic",
+      "openai",
+      "openrouter",
+      "gemini",
+    ]) {
       const tokens = estimateContentBlockTokens(
         {
           type: "image",
@@ -294,6 +299,91 @@ describe("token estimator", () => {
     }
   });
 
+  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: makePngBase64(3000, 3000),
+        },
+      },
+      { 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);
+  });
+
+  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", () => {
     // Build two PNG headers with the same dimensions (800x600) but different payload sizes
     function makePng(

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-disk-pressure.test.ts

@@ -86,7 +86,6 @@ mock.module("../daemon/disk-pressure-guard.js", () => ({
 }));
 
 mock.module("../memory/conversation-crud.js", () => ({
-  clearStrippedInjectionMetadataForConversation: () => {},
   getConversation: () => ({
     id: "conv-123",
     conversationType: "background",
@@ -98,6 +97,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   getConversationOriginInterface: () => null,
   getConversationOverrideProfileFromRow: () => null,
   provenanceFromTrustContext: () => ({}),
+  setConversationHistoryStrippedAt: () => {},
   updateConversationContextWindow: () => {},
   updateConversationSlackContextWatermark: () => {},
 }));

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: [],
     },
@@ -141,9 +145,9 @@ let mockConversationRow: {
 
 mock.module("../memory/conversation-crud.js", () => ({
   setConversationOriginChannelIfUnset: () => {},
+  setConversationHistoryStrippedAt: () => {},
   updateConversationUsage: () => {},
   updateMessageMetadata: () => {},
-  clearStrippedInjectionMetadataForConversation: () => {},
   getMessages: () => [],
   getConversation: () => mockConversationRow,
   getConversationOverrideProfileFromRow: (
@@ -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

@@ -170,6 +170,7 @@ mock.module("../daemon/context-overflow-policy.js", () => ({
 
 mock.module("../memory/conversation-crud.js", () => ({
   setConversationOriginChannelIfUnset: () => {},
+  setConversationHistoryStrippedAt: () => {},
   updateConversationUsage: () => {},
   getMessages: () => [],
   getConversation: () => ({
@@ -186,7 +187,7 @@ mock.module("../memory/conversation-crud.js", () => ({
     trustContext: undefined,
   }),
   getConversationOriginInterface: () => null,
-  addMessage: () => ({ id: "mock-msg-id" }),
+  addMessage: (...args: unknown[]) => addMessageMock(...args),
   deleteMessageById: () => {},
   updateConversationContextWindow: () => {},
   updateConversationTitle: () => {},
@@ -194,7 +195,9 @@ mock.module("../memory/conversation-crud.js", () => ({
   getMessageById: () => null,
   updateMessageContent: () => {},
   updateMessageMetadata: () => {},
-  clearStrippedInjectionMetadataForConversation: () => {},
+  setLastNotifiedInferenceProfile: () => {},
+  getLastUserTimestampBefore: () => 0,
+  getConversationOverrideProfileFromRow: () => undefined,
 }));
 
 afterAll(() => {
@@ -301,6 +304,10 @@ mock.module("../daemon/history-repair.js", () => ({
 }));
 
 const recordUsageMock = mock((..._args: unknown[]) => {});
+const setAgentLoopExitReasonOnLatestLogMock = mock(() => {});
+const addMessageMock = mock(
+  (..._args: unknown[]) => ({ id: "mock-msg-id" }) as { id: string },
+);
 mock.module("../daemon/conversation-usage.js", () => ({
   recordUsage: recordUsageMock,
 }));
@@ -349,12 +356,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 +412,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 +635,8 @@ beforeEach(() => {
   mockOverflowAction = "fail_gracefully";
   mockApplyRuntimeInjections = (msgs) => msgs;
   recordUsageMock.mockClear();
+  setAgentLoopExitReasonOnLatestLogMock.mockClear();
+  addMessageMock.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 +1928,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 +2093,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 ────────────────────────────────────────────────────────
@@ -2209,4 +2238,195 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
     );
     expect(conversationError).toBeUndefined();
   });
+
+  // ── Test 9 ────────────────────────────────────────────────────────
+  // When the `auto_compress_latest_turn` rerun (the last layer of the
+  // overflow-recovery ladder) still yields at the mid-loop checkpoint,
+  // the turn cannot proceed. Before PR 1 of the Compaction Visibility
+  // workstream this terminated silently — no `agent_loop_exit_reason`,
+  // no client notice, no durable transcript row. Now the loop must:
+  //   1. emit a `conversation_error` event with code
+  //      `BUDGET_YIELD_UNRECOVERED`,
+  //   2. persist a `role="assistant"` notice via the persistence
+  //      pipeline (so reloads keep the message),
+  //   3. stamp `budget_yield_unrecovered` onto the latest llm_request_logs
+  //      row.
+  test("budget_yield_unrecovered: classified error emitted, persisted, and stamped", async () => {
+    const events: ServerMessage[] = [];
+
+    // Every estimate after the very first preflight is above the mid-loop
+    // threshold (190_000 × 0.85 = 161_500). This makes every checkpoint
+    // yield, including the one inside the auto_compress rerun.
+    let estimateCallCount = 0;
+    mockEstimateTokens = () => {
+      estimateCallCount++;
+      if (estimateCallCount === 1) return 100_000;
+      return 170_000;
+    };
+
+    // Convergence reducer becomes exhausted on the second tier so the
+    // loop escalates from convergence to the action-resolution block.
+    let reducerCallCount = 0;
+    mockReducerStepFn = (msgs: Message[]) => {
+      reducerCallCount++;
+      const exhausted = reducerCallCount >= 2;
+      return {
+        messages: msgs,
+        tier: exhausted ? "tool_result_truncation" : "forced_compaction",
+        state: {
+          appliedTiers: exhausted
+            ? ["forced_compaction", "tool_result_truncation"]
+            : ["forced_compaction"],
+          injectionMode: "full" as const,
+          exhausted,
+        },
+        estimatedTokens: exhausted ? 60_000 : 80_000,
+      };
+    };
+
+    // The overflow policy directs us into auto_compress_latest_turn so the
+    // emergency compaction + final agentLoop.run path executes.
+    mockOverflowAction = "auto_compress_latest_turn";
+
+    let agentLoopCallCount = 0;
+    const agentLoopRun: AgentLoopRun = async (
+      messages,
+      onEvent,
+      _signal,
+      _requestId,
+      onCheckpoint,
+    ) => {
+      agentLoopCallCount++;
+
+      const withProgress: Message[] = [
+        ...messages,
+        {
+          role: "assistant" as const,
+          content: [
+            { type: "text", text: `tool call ${agentLoopCallCount}` },
+            {
+              type: "tool_use",
+              id: `tu-${agentLoopCallCount}`,
+              name: "bash",
+              input: { command: "ls" },
+            },
+          ] as ContentBlock[],
+        },
+        {
+          role: "user" as const,
+          content: [
+            {
+              type: "tool_result",
+              tool_use_id: `tu-${agentLoopCallCount}`,
+              content: "output",
+              is_error: false,
+            },
+          ] as ContentBlock[],
+        },
+      ];
+
+      onEvent({
+        type: "message_complete",
+        message: {
+          role: "assistant",
+          content: [
+            { type: "text", text: `tool call ${agentLoopCallCount}` },
+            {
+              type: "tool_use",
+              id: `tu-${agentLoopCallCount}`,
+              name: "bash",
+              input: { command: "ls" },
+            },
+          ],
+        },
+      });
+      onEvent({
+        type: "usage",
+        inputTokens: 100,
+        outputTokens: 50,
+        model: "test-model",
+        providerDurationMs: 100,
+      });
+
+      // Every checkpoint yields — including the final auto_compress rerun.
+      if (onCheckpoint) {
+        const decision = await onCheckpoint({
+          turnIndex: 0,
+          toolCount: 1,
+          hasToolUse: true,
+          history: withProgress,
+        });
+        if (decision === "yield") {
+          return withProgress;
+        }
+      }
+
+      return withProgress;
+    };
+
+    const ctx = makeCtx({
+      agentLoopRun,
+      contextWindowManager: {
+        shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
+        // The compaction pipeline (default terminal) routes through this
+        // for the emergency `auto_compress_latest_turn` path.
+        maybeCompact: async () => ({
+          compacted: true,
+          messages: [
+            {
+              role: "user" as const,
+              content: [{ type: "text", text: "compacted" }],
+            },
+          ] as Message[],
+          compactedPersistedMessages: 5,
+          summaryText: "Emergency summary",
+          previousEstimatedInputTokens: 170_000,
+          estimatedInputTokens: 90_000,
+          maxInputTokens: 200_000,
+          thresholdTokens: 160_000,
+          compactedMessages: 10,
+          summaryCalls: 1,
+          summaryInputTokens: 500,
+          summaryOutputTokens: 200,
+          summaryModel: "mock-model",
+        }),
+      } as unknown as AgentLoopConversationContext["contextWindowManager"],
+    });
+
+    await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
+
+    // The classified error is emitted to the client.
+    const errorEvents = events.filter((e) => e.type === "conversation_error");
+    expect(errorEvents).toHaveLength(1);
+    const errorEvent = errorEvents[0];
+    if (errorEvent && "code" in errorEvent) {
+      expect(errorEvent.code).toBe("BUDGET_YIELD_UNRECOVERED");
+      expect(errorEvent.retryable).toBe(true);
+      expect(errorEvent.errorCategory).toBe("budget_yield_unrecovered");
+    } else {
+      throw new Error("conversation_error event missing `code` field");
+    }
+
+    // The exit reason is stamped onto the latest llm_request_logs row.
+    expect(setAgentLoopExitReasonOnLatestLogMock).toHaveBeenCalledWith(
+      "test-conv",
+      "budget_yield_unrecovered",
+    );
+
+    // A `role="assistant"` notice is persisted via the persistence pipeline.
+    // The default persistence terminal calls
+    // `addMessage(conversationId, role, content, metadata, addOptions)` —
+    // we look for the call whose role positional arg is "assistant" and
+    // whose content positional arg mentions compaction.
+    const assistantPersistCall = addMessageMock.mock.calls.find((call) => {
+      const role = call[1];
+      const content = call[2];
+      return (
+        role === "assistant" &&
+        typeof content === "string" &&
+        content.includes("compact")
+      );
+    });
+    expect(assistantPersistCall).toBeDefined();
+  });
 });