@vellumai/assistant 0.4.43 → 0.4.45

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

@@ -201,7 +201,7 @@ describe("classifySessionError", () => {
       );
       const result = classifySessionError(err, baseCtx);
       expect(result.code).toBe("PROVIDER_API");
-      expect(result.retryable).toBe(false);
+      expect(result.retryable).toBe(true);
     });
   });
 
@@ -225,15 +225,6 @@ describe("classifySessionError", () => {
     });
   });
 
-  describe("queue phase", () => {
-    it("always returns QUEUE_FULL regardless of message content", () => {
-      const ctx: ErrorContext = { phase: "queue" };
-      const result = classifySessionError(new Error("random error"), ctx);
-      expect(result.code).toBe("QUEUE_FULL");
-      expect(result.retryable).toBe(true);
-    });
-  });
-
   describe("regenerate phase", () => {
     it("returns REGENERATE_FAILED with nested classification info", () => {
       const ctx: ErrorContext = { phase: "regenerate" };
@@ -323,18 +314,18 @@ describe("classifySessionError", () => {
       expect(result.retryable).toBe(true);
     });
 
-    it("classifies ProviderError with 401 as PROVIDER_API (not retryable)", () => {
+    it("classifies ProviderError with 401 as PROVIDER_BILLING (non-retryable)", () => {
       const err = new ProviderError("Unauthorized", "anthropic", 401);
       const result = classifySessionError(err, baseCtx);
-      expect(result.code).toBe("PROVIDER_API");
+      expect(result.code).toBe("PROVIDER_BILLING");
       expect(result.retryable).toBe(false);
     });
 
-    it("classifies ProviderError with 400 as PROVIDER_API (not retryable)", () => {
+    it("classifies ProviderError with 400 as PROVIDER_API (retryable)", () => {
       const err = new ProviderError("Bad request", "anthropic", 400);
       const result = classifySessionError(err, baseCtx);
       expect(result.code).toBe("PROVIDER_API");
-      expect(result.retryable).toBe(false);
+      expect(result.retryable).toBe(true);
     });
 
     it("ProviderError without statusCode falls back to regex", () => {

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

@@ -91,7 +91,6 @@ mock.module("../util/platform.js", () => ({
   getWorkspaceSkillsDir: () => join(testDir, "skills"),
   getWorkspaceHooksDir: () => join(testDir, "hooks"),
   getWorkspacePromptPath: (file: string) => join(testDir, file),
-  getSocketPath: () => join(testDir, "test.sock"),
   getSessionTokenPath: () => join(testDir, "session-token"),
   getPidPath: () => join(testDir, "test.pid"),
   getDbPath: () => join(testDir, "data", "test.db"),
@@ -142,10 +141,9 @@ const mockConfig = {
   contextWindow: {
     enabled: true,
     maxInputTokens: 180000,
-    targetInputTokens: 110000,
+    targetBudgetRatio: 0.3,
     compactThreshold: 0.8,
-    preserveRecentUserTurns: 8,
-    summaryMaxTokens: 1200,
+    summaryBudgetRatio: 0.05,
   },
   thinking: { enabled: false },
 };
@@ -506,7 +504,7 @@ describe("End-to-end session creation benchmark", () => {
       if (i === 0) {
         expect(session.conversationId).toBe(id);
         expect(session.getMessages()).toHaveLength(0);
-        expect(projection.toolDefinitions.length).toBe(testSkillIds.length);
+        expect(projection.allowedToolNames.size).toBe(testSkillIds.length);
       }
       resetSkillToolProjection(session.skillProjectionState);
       session.dispose();

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

@@ -9,7 +9,6 @@ mock.module("../util/logger.js", () => ({
 }));
 
 mock.module("../util/platform.js", () => ({
-  getSocketPath: () => "/tmp/test.sock",
   getDataDir: () => "/tmp",
 }));
 

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

@@ -60,88 +60,26 @@ describe("stripMediaPayloadsForRetry", () => {
     ).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);
-
+  test("strips images from older user turns, keeps images in latest kept turn", () => {
+    // After compaction, images only exist in kept turns (not in summary messages).
+    // Media retry should keep images in the latest user message and strip older ones.
     const messages: Message[] = [
-      summaryMsg,
+      createContextSummaryMessage("Summary"),
+      makeUserMessage({ type: "text", text: "older kept turn" }, makeImageBlock("AAAA")),
       makeAssistantMessage({ type: "text", text: "response" }),
-      userMsg,
+      makeUserMessage({ type: "text", text: "latest kept turn" }, makeImageBlock("BBBB")),
     ];
 
     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);
+    // Older kept turn image → stubbed
+    const olderBlocks = result.messages[1].content;
+    expect(olderBlocks.filter((b) => b.type === "image").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);
+    // Latest kept turn image → kept
+    const latestBlocks = result.messages[3].content;
+    expect(latestBlocks.filter((b) => b.type === "image").length).toBe(1);
   });
 });

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

@@ -11,7 +11,6 @@ mock.module("../util/logger.js", () => ({
 }));
 
 mock.module("../util/platform.js", () => ({
-  getSocketPath: () => "/tmp/test.sock",
   getDataDir: () => "/tmp",
 }));
 

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

@@ -26,7 +26,6 @@ mock.module("../util/logger.js", () => ({
 }));
 
 mock.module("../util/platform.js", () => ({
-  getSocketPath: () => "/tmp/test.sock",
   getDataDir: () => "/tmp",
 }));
 
@@ -51,11 +50,8 @@ mock.module("../config/loader.js", () => ({
     contextWindow: {
       enabled: true,
       maxInputTokens: 100000,
-      targetInputTokens: 80000,
-      compactThreshold: 0.8,
-      preserveRecentUserTurns: 8,
-      summaryMaxTokens: 512,
-      chunkTokens: 12000,
+      targetBudgetRatio: 0.30,
+      compactThreshold: 0.8,      summaryBudgetRatio: 0.05,
       overflowRecovery: {
         enabled: true,
         safetyMarginRatio: 0.05,

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

@@ -11,7 +11,6 @@ mock.module("../util/logger.js", () => ({
 }));
 
 mock.module("../util/platform.js", () => ({
-  getSocketPath: () => "/tmp/test.sock",
   getDataDir: () => "/tmp",
 }));
 
@@ -36,11 +35,8 @@ mock.module("../config/loader.js", () => ({
     contextWindow: {
       enabled: true,
       maxInputTokens: 100000,
-      targetInputTokens: 70000,
-      compactThreshold: 0.8,
-      preserveRecentUserTurns: 6,
-      summaryMaxTokens: 512,
-      chunkTokens: 12000,
+      targetBudgetRatio: 0.30,
+      compactThreshold: 0.8,      summaryBudgetRatio: 0.05,
       overflowRecovery: {
         enabled: true,
         safetyMarginRatio: 0.05,

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

@@ -35,7 +35,6 @@ mock.module("../util/logger.js", () => ({
 }));
 
 mock.module("../util/platform.js", () => ({
-  getSocketPath: () => "/tmp/test.sock",
   getDataDir: () => "/tmp",
 }));
 
@@ -302,7 +301,8 @@ mock.module("../memory/canonical-guardian-store.js", () => ({
 // ---------------------------------------------------------------------------
 
 import type { QueueDrainReason, QueuePolicy } from "../daemon/session.js";
-import { MAX_QUEUE_DEPTH, Session } from "../daemon/session.js";
+import { Session } from "../daemon/session.js";
+import { MessageQueue } from "../daemon/session-queue-manager.js";
 
 type SessionWithWorkspaceDeps = Session & {
   getWorkspaceGitService?: (_workspaceDir: string) => {
@@ -731,40 +731,6 @@ describe("Session message queue", () => {
     expect(events3.some((e) => e.type === "message_complete")).toBe(true);
   });
 
-  test("queue rejects when at max depth", async () => {
-    const session = makeSession();
-    await session.loadFromDb();
-
-    // Start first message to make session busy
-    session.processMessage("msg-1", [], () => {}, "req-1");
-    await waitForPendingRun(1);
-
-    // Fill the queue to MAX_QUEUE_DEPTH
-    for (let i = 0; i < MAX_QUEUE_DEPTH; i++) {
-      const result = session.enqueueMessage(
-        `msg-${i + 2}`,
-        [],
-        () => {},
-        `req-${i + 2}`,
-      );
-      expect(result.queued).toBe(true);
-      expect(result.rejected).toBeUndefined();
-    }
-    expect(session.getQueueDepth()).toBe(MAX_QUEUE_DEPTH);
-
-    // Next enqueue should be rejected
-    const rejected = session.enqueueMessage(
-      "overflow",
-      [],
-      () => {},
-      "req-overflow",
-    );
-    expect(rejected.queued).toBe(false);
-    expect(rejected.rejected).toBe(true);
-
-    // Queue depth should not have increased
-    expect(session.getQueueDepth()).toBe(MAX_QUEUE_DEPTH);
-  });
 });
 
 // ---------------------------------------------------------------------------
@@ -1008,47 +974,6 @@ describe("Session checkpoint handoff", () => {
     expect(processedOrder).toEqual(["msg-1", "msg-2", "msg-3"]);
   });
 
-  test("queue-full rejection still works during checkpoint handoff", async () => {
-    const session = makeSession();
-    await session.loadFromDb();
-
-    // Start processing
-    session.processMessage("msg-1", [], () => {}, "req-1");
-    await waitForPendingRun(1);
-
-    // Fill the queue to MAX_QUEUE_DEPTH
-    for (let i = 0; i < MAX_QUEUE_DEPTH; i++) {
-      const result = session.enqueueMessage(
-        `queued-${i}`,
-        [],
-        () => {},
-        `req-q-${i}`,
-      );
-      expect(result.queued).toBe(true);
-    }
-    expect(session.getQueueDepth()).toBe(MAX_QUEUE_DEPTH);
-
-    // Verify checkpoint would yield (there are queued messages)
-    const run = pendingRuns[0];
-    expect(run.onCheckpoint).toBeDefined();
-    expect(
-      run.onCheckpoint!({ turnIndex: 0, toolCount: 1, hasToolUse: true }),
-    ).toBe("yield");
-
-    // Next enqueue should still be rejected
-    const rejected = session.enqueueMessage(
-      "overflow",
-      [],
-      () => {},
-      "req-overflow",
-    );
-    expect(rejected.queued).toBe(false);
-    expect(rejected.rejected).toBe(true);
-
-    // Queue depth unchanged
-    expect(session.getQueueDepth()).toBe(MAX_QUEUE_DEPTH);
-  });
-
   test("[experimental] active run with repeated tool turns + queued message triggers checkpoint handoff", async () => {
     const session = makeSession();
     await session.loadFromDb();
@@ -1340,68 +1265,6 @@ describe("Terminal trace events on rejection/failure", () => {
   });
 });
 
-// ---------------------------------------------------------------------------
-// Surface-action queue-full trace emission
-// ---------------------------------------------------------------------------
-
-describe("Surface-action queue-full trace", () => {
-  beforeEach(() => {
-    pendingRuns = [];
-  });
-
-  test("surface-action queue-full rejection emits request_error trace", async () => {
-    const traceEvents: ServerMessage[] = [];
-    const session = makeSession((msg) => {
-      if ("type" in msg && msg.type === "trace_event") traceEvents.push(msg);
-    });
-    await session.loadFromDb();
-
-    // Start processing to make the session busy
-    session.processMessage("msg-1", [], () => {}, "req-1");
-    await waitForPendingRun(1);
-
-    // Fill the queue to MAX_QUEUE_DEPTH
-    for (let i = 0; i < MAX_QUEUE_DEPTH; i++) {
-      const result = session.enqueueMessage(
-        `queued-${i}`,
-        [],
-        () => {},
-        `req-q-${i}`,
-      );
-      expect(result.queued).toBe(true);
-    }
-    expect(session.getQueueDepth()).toBe(MAX_QUEUE_DEPTH);
-
-    // Register a pending surface action so handleSurfaceAction doesn't bail early
-
-    (session as any).pendingSurfaceActions.set("surf-1", {
-      surfaceType: "confirmation",
-    });
-
-    // Trigger the surface action — queue is full, should be rejected
-    session.handleSurfaceAction("surf-1", "confirm");
-
-    // Should have a request_received trace followed by a request_error trace
-    const receivedTrace = traceEvents.find(
-      (e) => "kind" in e && e.kind === "request_received",
-    );
-    expect(receivedTrace).toBeDefined();
-
-    const errorTrace = traceEvents.find(
-      (e) => "kind" in e && e.kind === "request_error",
-    );
-    expect(errorTrace).toBeDefined();
-    expect(errorTrace).toHaveProperty("attributes");
-
-    const attrs = (errorTrace as any).attributes;
-    expect(attrs.reason).toBe("queue_full");
-    expect(attrs.source).toBe("surface_action");
-
-    // Queue depth should not have increased
-    expect(session.getQueueDepth()).toBe(MAX_QUEUE_DEPTH);
-  });
-});
-
 // ---------------------------------------------------------------------------
 // Host attachment approval tests
 // ---------------------------------------------------------------------------
@@ -1889,3 +1752,95 @@ describe("Regression: cancel semantics and error channel split", () => {
     }
   }, 15_000);
 });
+
+// ---------------------------------------------------------------------------
+// MessageQueue byte budget
+// ---------------------------------------------------------------------------
+
+describe("MessageQueue byte budget", () => {
+  function makeItem(
+    content: string,
+    requestId = "r",
+    attachments: { data: string }[] = [],
+  ) {
+    return {
+      content,
+      attachments: attachments.map((a) => ({
+        id: "a",
+        filename: "f",
+        mimeType: "text/plain",
+        data: a.data,
+      })),
+      requestId,
+      onEvent: () => {},
+    };
+  }
+
+  test("accepts messages within budget", () => {
+    const q = new MessageQueue(10_000);
+    expect(q.push(makeItem("hello", "r1"))).toBe(true);
+    expect(q.length).toBe(1);
+  });
+
+  test("rejects message that would exceed byte budget", () => {
+    // Budget of 2000 bytes — a single message with ~500 chars of content
+    // uses ~1512 bytes (500*2 + 512 overhead). A second should be rejected.
+    const q = new MessageQueue(2_000);
+    expect(q.push(makeItem("x".repeat(500), "r1"))).toBe(true);
+    expect(q.push(makeItem("y".repeat(500), "r2"))).toBe(false);
+    expect(q.length).toBe(1);
+  });
+
+  test("always accepts first message even if it alone exceeds budget", () => {
+    const q = new MessageQueue(100); // tiny budget
+    expect(q.push(makeItem("x".repeat(1000), "r1"))).toBe(true);
+    expect(q.length).toBe(1);
+  });
+
+  test("reclaims budget when messages are shifted", () => {
+    const q = new MessageQueue(3_000);
+    expect(q.push(makeItem("x".repeat(500), "r1"))).toBe(true);
+    expect(q.push(makeItem("y".repeat(500), "r2"))).toBe(false);
+
+    q.shift(); // free up space
+    expect(q.push(makeItem("y".repeat(500), "r2"))).toBe(true);
+    expect(q.length).toBe(1);
+  });
+
+  test("reclaims budget when messages are removed by requestId", () => {
+    // Each 500-char item ≈ 1512 bytes (500*2 + 512 overhead).
+    // Budget of 4000 fits two items (3024) but not three (4536).
+    const q = new MessageQueue(4_000);
+    expect(q.push(makeItem("a".repeat(500), "r1"))).toBe(true);
+    expect(q.push(makeItem("b".repeat(500), "r2"))).toBe(true);
+    expect(q.push(makeItem("c".repeat(500), "r3"))).toBe(false);
+
+    q.removeByRequestId("r1"); // frees 1512 bytes → 1512 remaining
+    expect(q.push(makeItem("c".repeat(500), "r3"))).toBe(true);
+  });
+
+  test("clear resets byte budget to zero", () => {
+    const q = new MessageQueue(3_000);
+    q.push(makeItem("x".repeat(500), "r1"));
+    q.clear();
+    expect(q.totalBytes).toBe(0);
+    expect(q.push(makeItem("y".repeat(500), "r2"))).toBe(true);
+  });
+
+  test("accounts for attachment data in byte estimate", () => {
+    // 1000 chars content = 2512 bytes. Add a 2000 char attachment = +4000 bytes.
+    // Total ~6512 bytes. Budget of 5000 should reject.
+    const q = new MessageQueue(5_000);
+    expect(
+      q.push(
+        makeItem("x".repeat(1000), "r1", [{ data: "a".repeat(2000) }]),
+      ),
+    ).toBe(true); // first message always accepted
+    // Second message of same size should be rejected
+    expect(
+      q.push(
+        makeItem("y".repeat(100), "r2", [{ data: "b".repeat(100) }]),
+      ),
+    ).toBe(false);
+  });
+});