@vellumai/assistant 0.4.26 → 0.4.30

package/src/__tests__/session-init.benchmark.test.ts

@@ -153,7 +153,7 @@ const mockConfig = {
     preserveRecentUserTurns: 8,
     summaryMaxTokens: 1200,
   },
-  thinking: { enabled: false, budgetTokens: 10000 },
+  thinking: { enabled: false },
 };
 
 mock.module("../config/loader.js", () => ({
@@ -199,7 +199,7 @@ mock.module("../memory/conversation-store.js", () => ({
   getConversationThreadType: () => "standard",
   getConversationMemoryScopeId: () => "default",
   isLastUserMessageToolResult: () => false,
-  provenanceFromGuardianContext: () => ({}),
+  provenanceFromTrustContext: () => ({}),
   relinkAttachments: () => 0,
   searchConversations: () => [],
   setConversationOriginChannelIfUnset: () => {},

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

@@ -67,9 +67,9 @@ mock.module("../memory/conversation-store.js", () => ({
   deleteMessageById: () => {},
   updateConversationTitle: () => {},
   updateConversationUsage: () => {},
-  provenanceFromGuardianContext: () => ({
+  provenanceFromTrustContext: () => ({
     source: "user",
-    guardianContext: undefined,
+    trustContext: undefined,
   }),
   getConversationOriginInterface: () => null,
   getConversationOriginChannel: () => null,
@@ -362,7 +362,7 @@ describe("loadFromDb history repair", () => {
     ];
 
     const session = makeSession();
-    session.setGuardianContext({
+    session.setTrustContext({
       trustClass: "unknown",
       sourceChannel: "telegram",
     });
@@ -430,14 +430,14 @@ describe("loadFromDb history repair", () => {
 
     const session = makeSession();
 
-    session.setGuardianContext({
+    session.setTrustContext({
       trustClass: "guardian",
       sourceChannel: "telegram",
     });
     await session.ensureActorScopedHistory();
     expect(session.getMessages()).toHaveLength(4);
 
-    session.setGuardianContext({
+    session.setTrustContext({
       trustClass: "unknown",
       sourceChannel: "telegram",
     });
@@ -506,14 +506,14 @@ describe("loadFromDb history repair", () => {
 
     const session = makeSession();
 
-    session.setGuardianContext({
+    session.setTrustContext({
       trustClass: "unknown",
       sourceChannel: "telegram",
     });
     await session.ensureActorScopedHistory();
     expect(session.getMessages()).toHaveLength(2);
 
-    session.setGuardianContext({
+    session.setTrustContext({
       trustClass: "guardian",
       sourceChannel: "telegram",
     });

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

@@ -0,0 +1,147 @@
+import { describe, expect, test } from "bun:test";
+
+import { createContextSummaryMessage } from "../context/window-manager.js";
+import { stripMediaPayloadsForRetry } from "../daemon/session-media-retry.js";
+import type { ContentBlock, Message } from "../providers/types.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeImageBlock(
+  data = "AAAA",
+  mediaType = "image/png",
+): Extract<ContentBlock, { type: "image" }> {
+  return {
+    type: "image",
+    source: { type: "base64", media_type: mediaType, data },
+  };
+}
+
+function makeUserMessage(...blocks: ContentBlock[]): Message {
+  return { role: "user", content: blocks };
+}
+
+function makeAssistantMessage(...blocks: ContentBlock[]): Message {
+  return { role: "assistant", content: blocks };
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("stripMediaPayloadsForRetry", () => {
+  test("keeps images in the latest user message", () => {
+    const img = makeImageBlock();
+    const messages: Message[] = [
+      makeUserMessage({ type: "text", text: "hello" }, img),
+    ];
+
+    const result = stripMediaPayloadsForRetry(messages);
+    expect(result.modified).toBe(false);
+    expect(result.replacedBlocks).toBe(0);
+  });
+
+  test("strips images from older user messages", () => {
+    const messages: Message[] = [
+      makeUserMessage({ type: "text", text: "old" }, makeImageBlock()),
+      makeAssistantMessage({ type: "text", text: "response" }),
+      makeUserMessage({ type: "text", text: "new" }),
+    ];
+
+    const result = stripMediaPayloadsForRetry(messages);
+    expect(result.modified).toBe(true);
+    expect(result.replacedBlocks).toBe(1);
+    // 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");
+    expect(
+      (firstMsg.content[1] as { type: "text"; text: string }).text,
+    ).toContain("Image omitted");
+  });
+
+  test("keeps images in summary message when it is the only user message", () => {
+    // This is the bug scenario: forced compaction with minKeepRecentUserTurns: 0
+    // compacts everything, preserving images into the summary message. Media
+    // stubbing should NOT strip those images since there's no other user message.
+    const img = makeImageBlock();
+    const summaryMsg = createContextSummaryMessage(
+      "Prior conversation summary",
+    );
+    summaryMsg.content.push(
+      {
+        type: "text",
+        text: "[The following images were uploaded by the user in earlier messages and are preserved for reference.]",
+      },
+      img,
+    );
+
+    const messages: Message[] = [summaryMsg];
+
+    const result = stripMediaPayloadsForRetry(messages);
+    expect(result.modified).toBe(false);
+    expect(result.replacedBlocks).toBe(0);
+    // The image should still be present
+    const imageBlocks = result.messages[0].content.filter(
+      (b) => b.type === "image",
+    );
+    expect(imageBlocks.length).toBe(1);
+  });
+
+  test("keeps images in summary message when only other user messages are tool-result-only", () => {
+    const img = makeImageBlock();
+    const summaryMsg = createContextSummaryMessage("Summary");
+    summaryMsg.content.push(img);
+
+    const toolResultMsg: Message = {
+      role: "user",
+      content: [
+        {
+          type: "tool_result",
+          tool_use_id: "tool-1",
+          content: "result text",
+        },
+      ],
+    };
+
+    const messages: Message[] = [
+      summaryMsg,
+      makeAssistantMessage({ type: "text", text: "ok" }),
+      toolResultMsg,
+    ];
+
+    const result = stripMediaPayloadsForRetry(messages);
+    expect(result.modified).toBe(false);
+    expect(result.replacedBlocks).toBe(0);
+  });
+
+  test("prefers non-summary user message over summary when both exist", () => {
+    const summaryImg = makeImageBlock("BBBB");
+    const summaryMsg = createContextSummaryMessage("Summary");
+    summaryMsg.content.push(summaryImg);
+
+    const userImg = makeImageBlock("CCCC");
+    const userMsg = makeUserMessage({ type: "text", text: "latest" }, userImg);
+
+    const messages: Message[] = [
+      summaryMsg,
+      makeAssistantMessage({ type: "text", text: "response" }),
+      userMsg,
+    ];
+
+    const result = stripMediaPayloadsForRetry(messages);
+    // Summary image should be stripped, user image should be kept
+    expect(result.modified).toBe(true);
+    expect(result.replacedBlocks).toBe(1);
+
+    // Summary message image → stubbed
+    const summaryBlocks = result.messages[0].content;
+    const summaryImageBlocks = summaryBlocks.filter((b) => b.type === "image");
+    expect(summaryImageBlocks.length).toBe(0);
+
+    // Latest user message image → kept
+    const userBlocks = result.messages[2].content;
+    const userImageBlocks = userBlocks.filter((b) => b.type === "image");
+    expect(userImageBlocks.length).toBe(1);
+  });
+});

package/src/__tests__/session-pre-run-repair.test.ts

@@ -39,9 +39,23 @@ mock.module("../config/loader.js", () => ({
       preserveRecentMessages: 6,
       summaryModel: "mock-model",
       maxSummaryTokens: 512,
+      overflowRecovery: {
+        enabled: true,
+        safetyMarginRatio: 0.05,
+        maxAttempts: 3,
+        interactiveLatestTurnCompression: "summarize",
+        nonInteractiveLatestTurnCompression: "truncate",
+      },
     },
     rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
     apiKeys: {},
+    daemon: {
+      startupSocketWaitMs: 5000,
+      stopTimeoutMs: 5000,
+      sigkillGracePeriodMs: 2000,
+      titleGenerationMaxTokens: 30,
+      standaloneRecording: true,
+    },
   }),
   loadRawConfig: () => ({}),
   saveRawConfig: () => {},
@@ -81,9 +95,9 @@ mock.module("../memory/conversation-store.js", () => ({
   setConversationOriginChannelIfUnset: () => {},
   updateConversationContextWindow: () => {},
   deleteMessageById: () => {},
-  provenanceFromGuardianContext: () => ({
+  provenanceFromTrustContext: () => ({
     source: "user",
-    guardianContext: undefined,
+    trustContext: undefined,
   }),
   getConversationOriginInterface: () => null,
   getConversationOriginChannel: () => null,
@@ -155,6 +169,7 @@ mock.module("../context/window-manager.js", () => ({
 mock.module("../memory/canonical-guardian-store.js", () => ({
   listPendingCanonicalGuardianRequestsByDestinationConversation: () => [],
   listCanonicalGuardianRequests: () => [],
+  listPendingRequestsByConversationScope: () => [],
   createCanonicalGuardianRequest: () => ({
     id: "mock-cg-id",
     code: "MOCK",

package/src/__tests__/session-profile-injection.test.ts

@@ -56,9 +56,23 @@ mock.module("../config/loader.js", () => ({
       preserveRecentUserTurns: 8,
       summaryMaxTokens: 512,
       chunkTokens: 12000,
+      overflowRecovery: {
+        enabled: true,
+        safetyMarginRatio: 0.05,
+        maxAttempts: 3,
+        interactiveLatestTurnCompression: "summarize",
+        nonInteractiveLatestTurnCompression: "truncate",
+      },
     },
     rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
     apiKeys: {},
+    daemon: {
+      startupSocketWaitMs: 5000,
+      stopTimeoutMs: 5000,
+      sigkillGracePeriodMs: 2000,
+      titleGenerationMaxTokens: 30,
+      standaloneRecording: true,
+    },
     memory: {
       enabled: memoryEnabled,
       retrieval: {
@@ -122,9 +136,9 @@ mock.module("../security/secret-allowlist.js", () => ({
 mock.module("../memory/conversation-store.js", () => ({
   getConversationThreadType: () => "default",
   setConversationOriginChannelIfUnset: () => {},
-  provenanceFromGuardianContext: () => ({
+  provenanceFromTrustContext: () => ({
     source: "user",
-    guardianContext: undefined,
+    trustContext: undefined,
   }),
   getConversationOriginInterface: () => null,
   getConversationOriginChannel: () => null,
@@ -284,6 +298,7 @@ mock.module("../agent/loop.js", () => ({
 mock.module("../memory/canonical-guardian-store.js", () => ({
   listPendingCanonicalGuardianRequestsByDestinationConversation: () => [],
   listCanonicalGuardianRequests: () => [],
+  listPendingRequestsByConversationScope: () => [],
   createCanonicalGuardianRequest: () => ({
     id: "mock-cg-id",
     code: "MOCK",
@@ -319,7 +334,7 @@ function makeSession(memoryPolicy?: SessionMemoryPolicy): Session {
       };
     },
   };
-  return new Session(
+  const session = new Session(
     "conv-1",
     provider,
     "system prompt",
@@ -329,6 +344,8 @@ function makeSession(memoryPolicy?: SessionMemoryPolicy): Session {
     undefined,
     memoryPolicy,
   );
+  session.setTrustContext({ trustClass: "guardian", sourceChannel: "vellum" });
+  return session;
 }
 
 function messageText(message: Message): string {

package/src/__tests__/session-provider-retry-repair.test.ts

@@ -41,6 +41,13 @@ mock.module("../config/loader.js", () => ({
       preserveRecentUserTurns: 6,
       summaryMaxTokens: 512,
       chunkTokens: 12000,
+      overflowRecovery: {
+        enabled: true,
+        safetyMarginRatio: 0.05,
+        maxAttempts: 3,
+        interactiveLatestTurnCompression: "summarize",
+        nonInteractiveLatestTurnCompression: "truncate",
+      },
     },
     rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
     apiKeys: {},
@@ -50,6 +57,76 @@ mock.module("../config/loader.js", () => ({
   invalidateConfigCache: () => {},
 }));
 
+// Token estimator: return a small value (well within budget) so preflight
+// does not trigger in existing tests.
+mock.module("../context/token-estimator.js", () => ({
+  estimatePromptTokens: () => 1000,
+}));
+
+// Overflow recovery module mocks — the convergence loop delegates to these
+// but these tests exercise the Session-level flow, not the reducer internals.
+// The reducer mock delegates to the compactFn to simulate a forced compaction
+// tier, matching the real reducer's behavior for Tier 1.
+mock.module("../daemon/context-overflow-reducer.js", () => ({
+  createInitialReducerState: () => ({
+    appliedTiers: [],
+    injectionMode: "full" as const,
+    exhausted: false,
+  }),
+  reduceContextOverflow: async (
+    msgs: Message[],
+    _cfg: unknown,
+    _state: unknown,
+    compactFn?: (
+      m: Message[],
+      s: AbortSignal | undefined,
+      o: Record<string, unknown>,
+    ) => Promise<{
+      compacted: boolean;
+      messages: Message[];
+      compactedPersistedMessages?: number;
+      summaryText?: string;
+      [k: string]: unknown;
+    }>,
+    signal?: AbortSignal,
+  ) => {
+    let resultMessages = msgs;
+    let compactionResult;
+    if (compactFn) {
+      const cr = await compactFn(msgs, signal, { force: true });
+      if (cr.compacted) {
+        resultMessages = cr.messages;
+        compactionResult = cr;
+      }
+    }
+    return {
+      messages: resultMessages,
+      tier: "forced_compaction",
+      state: {
+        appliedTiers: [
+          "forced_compaction",
+          "tool_result_truncation",
+          "media_stubbing",
+          "injection_downgrade",
+        ],
+        injectionMode: "full",
+        exhausted: true,
+      },
+      estimatedTokens: 1000,
+      compactionResult,
+    };
+  },
+}));
+
+mock.module("../daemon/context-overflow-policy.js", () => ({
+  resolveOverflowAction: () => "fail_gracefully",
+}));
+
+mock.module("../daemon/context-overflow-approval.js", () => ({
+  requestCompressionApproval: async () => ({ approved: false }),
+  CONTEXT_OVERFLOW_TOOL_NAME: "context_overflow_compression",
+}));
+
 mock.module("../config/system-prompt.js", () => ({
   buildSystemPrompt: () => "system prompt",
 }));
@@ -95,7 +172,7 @@ mock.module("../memory/conversation-store.js", () => ({
   updateConversationContextWindow: () => {},
   getConversationOriginChannel: () => null,
   getConversationOriginInterface: () => null,
-  provenanceFromGuardianContext: () => ({}),
+  provenanceFromTrustContext: () => ({}),
 }));
 
 mock.module("../memory/retriever.js", () => ({
@@ -280,6 +357,7 @@ mock.module("../agent/loop.js", () => ({
 mock.module("../memory/canonical-guardian-store.js", () => ({
   listPendingCanonicalGuardianRequestsByDestinationConversation: () => [],
   listCanonicalGuardianRequests: () => [],
+  listPendingRequestsByConversationScope: () => [],
   createCanonicalGuardianRequest: () => ({
     id: "mock-cg-id",
     code: "MOCK",
@@ -447,12 +525,14 @@ describe("provider ordering error retry", () => {
       events.push(msg as unknown as Record<string, unknown>),
     );
 
-    expect(agentLoopRunCount).toBe(1);
+    // The convergence loop attempts one reducer tier (which calls compactFn
+    // via force:true but compaction returns compacted:false), then retries the
+    // agent loop. The mock agent loop succeeds on the second call, so the
+    // convergence loop recovers. agentLoopRunCount is 2: initial + one retry.
+    expect(agentLoopRunCount).toBe(2);
     expect(maybeCompactCalls).toEqual([{ force: false }, { force: true }]);
-    const sessionError = events.find((e) => e.type === "session_error") as
-      | { code?: string }
-      | undefined;
-    expect(sessionError?.code).toBe("CONTEXT_TOO_LARGE");
+    // Recovery succeeded — no session_error surfaced
+    expect(events.some((e) => e.type === "message_complete")).toBe(true);
   });
 
   test("context-too-large phrase also triggers one forced-compaction retry", async () => {

package/src/__tests__/session-queue.test.ts

@@ -63,6 +63,13 @@ mock.module("../config/loader.js", () => ({
       preserveRecentMessages: 6,
       summaryModel: "mock-model",
       maxSummaryTokens: 512,
+      overflowRecovery: {
+        enabled: true,
+        safetyMarginRatio: 0.05,
+        maxAttempts: 3,
+        interactiveLatestTurnCompression: "summarize",
+        nonInteractiveLatestTurnCompression: "truncate",
+      },
     },
     rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
     timeouts: { permissionTimeoutSec: 1 },
@@ -70,6 +77,13 @@ mock.module("../config/loader.js", () => ({
     skills: { entries: {}, allowBundled: true },
     memory: { retrieval: { injectionStrategy: "inline" } },
     permissions: { mode: "legacy" },
+    daemon: {
+      startupSocketWaitMs: 5000,
+      stopTimeoutMs: 5000,
+      sigkillGracePeriodMs: 2000,
+      titleGenerationMaxTokens: 30,
+      standaloneRecording: true,
+    },
   }),
   loadRawConfig: () => ({}),
   saveRawConfig: () => {},
@@ -124,9 +138,9 @@ mock.module("../memory/conversation-store.js", () => ({
   setConversationOriginChannelIfUnset: () => {},
   updateConversationContextWindow: () => {},
   deleteMessageById: () => {},
-  provenanceFromGuardianContext: () => ({
+  provenanceFromTrustContext: () => ({
     source: "user",
-    guardianContext: undefined,
+    trustContext: undefined,
   }),
   getConversationOriginInterface: () => null,
   getConversationOriginChannel: () => null,
@@ -259,6 +273,7 @@ mock.module("../agent/loop.js", () => ({
 mock.module("../memory/canonical-guardian-store.js", () => ({
   listPendingCanonicalGuardianRequestsByDestinationConversation: () => [],
   listCanonicalGuardianRequests: () => [],
+  listPendingRequestsByConversationScope: () => [],
   createCanonicalGuardianRequest: () => ({
     id: "mock-cg-id",
     code: "MOCK",
@@ -458,7 +473,7 @@ describe("Session message queue", () => {
 
     // Complete the second run
     resolveRun(1);
-    await new Promise((r) => setTimeout(r, 50));
+    await new Promise((r) => setTimeout(r, 10));
   });
 
   test("[experimental] queued messages are processed in FIFO order", async () => {
@@ -496,7 +511,7 @@ describe("Session message queue", () => {
 
     // Complete third
     resolveRun(2);
-    await new Promise((r) => setTimeout(r, 50));
+    await new Promise((r) => setTimeout(r, 10));
 
     expect(processedOrder).toEqual(["msg-1", "msg-2", "msg-3"]);
   });
@@ -536,7 +551,7 @@ describe("Session message queue", () => {
 
     // Complete second run so the session finishes cleanly
     resolveRun(1);
-    await new Promise((r) => setTimeout(r, 50));
+    await new Promise((r) => setTimeout(r, 10));
   });
 
   test("abort() clears the queue and sends generation_cancelled for each queued message", async () => {
@@ -657,7 +672,7 @@ describe("Session message queue", () => {
 
     // Complete fourth (final queued message)
     resolveRun(3);
-    await new Promise((r) => setTimeout(r, 50));
+    await new Promise((r) => setTimeout(r, 10));
   });
 
   test("[experimental] drain continues after a queued message fails to persist", async () => {
@@ -703,7 +718,7 @@ describe("Session message queue", () => {
 
     // Complete the third message's run
     resolveRun(1);
-    await new Promise((r) => setTimeout(r, 50));
+    await new Promise((r) => setTimeout(r, 10));
 
     // msg-3 should have completed successfully
     expect(events3.some((e) => e.type === "message_complete")).toBe(true);
@@ -776,7 +791,7 @@ describe("Session queue policy helpers", () => {
     resolveRun(0);
     await waitForPendingRun(2);
     resolveRun(1);
-    await new Promise((r) => setTimeout(r, 50));
+    await new Promise((r) => setTimeout(r, 10));
   });
 
   test("canHandoffAtCheckpoint() returns false when not processing", async () => {
@@ -801,7 +816,7 @@ describe("Session queue policy helpers", () => {
 
     // Cleanup
     resolveRun(0);
-    await new Promise((r) => setTimeout(r, 50));
+    await new Promise((r) => setTimeout(r, 10));
   });
 
   test("canHandoffAtCheckpoint() returns true when processing and queue has messages", async () => {
@@ -823,7 +838,7 @@ describe("Session queue policy helpers", () => {
     resolveRun(0);
     await waitForPendingRun(2);
     resolveRun(1);
-    await new Promise((r) => setTimeout(r, 50));
+    await new Promise((r) => setTimeout(r, 10));
   });
 
   test("QueueDrainReason type accepts expected values", () => {
@@ -902,7 +917,7 @@ describe("Session checkpoint handoff", () => {
     // The queued message should now be draining (second run started)
     await waitForPendingRun(2);
     resolveRun(1);
-    await new Promise((r) => setTimeout(r, 50));
+    await new Promise((r) => setTimeout(r, 10));
   });
 
   test("onCheckpoint returns continue when queue is empty", async () => {
@@ -980,7 +995,7 @@ describe("Session checkpoint handoff", () => {
 
     // Complete third run (msg-3)
     resolveRun(2);
-    await new Promise((r) => setTimeout(r, 50));
+    await new Promise((r) => setTimeout(r, 10));
 
     // FIFO order: msg-1 completes first, then msg-2, then msg-3
     expect(processedOrder).toEqual(["msg-1", "msg-2", "msg-3"]);
@@ -1086,7 +1101,7 @@ describe("Session checkpoint handoff", () => {
 
     // Complete the second run
     resolveRun(1);
-    await new Promise((r) => setTimeout(r, 50));
+    await new Promise((r) => setTimeout(r, 10));
   });
 
   test("queued messages still drain FIFO under multiple handoffs", async () => {
@@ -1154,7 +1169,7 @@ describe("Session checkpoint handoff", () => {
     ).toBe("continue");
 
     resolveRun(3);
-    await new Promise((r) => setTimeout(r, 50));
+    await new Promise((r) => setTimeout(r, 10));
 
     // Verify FIFO dequeue order
     expect(dequeueOrder).toEqual(["B", "C", "D"]);
@@ -1201,7 +1216,7 @@ describe("Session checkpoint handoff", () => {
 
     // Complete C's run
     resolveRun(1);
-    await new Promise((r) => setTimeout(r, 50));
+    await new Promise((r) => setTimeout(r, 10));
 
     // C should have completed successfully
     expect(eventsC.some((e) => e.type === "message_complete")).toBe(true);
@@ -1314,7 +1329,7 @@ describe("Terminal trace events on rejection/failure", () => {
 
     // Cleanup
     resolveRun(1);
-    await new Promise((r) => setTimeout(r, 50));
+    await new Promise((r) => setTimeout(r, 10));
   });
 });
 
@@ -1656,7 +1671,7 @@ describe("Session attachment event payloads", () => {
 
     await waitForPendingRun(2);
     resolveRun(1);
-    await new Promise((r) => setTimeout(r, 50));
+    await new Promise((r) => setTimeout(r, 10));
   });
 });
 
@@ -1861,7 +1876,7 @@ describe("Regression: cancel semantics and error channel split", () => {
       // Complete the second run so the test can clean up
       turnCommitHangForever = false;
       resolveRun(1);
-      await new Promise((r) => setTimeout(r, 50));
+      await new Promise((r) => setTimeout(r, 10));
     } finally {
       turnCommitHangForever = false;
     }