@vellumai/assistant 0.8.3 → 0.8.4

package/src/__tests__/channel-retry-sweep.test.ts

@@ -1,6 +1,6 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-import { eq } from "drizzle-orm";
+import { asc, eq } from "drizzle-orm";
 
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
@@ -9,6 +9,66 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
+const deliveryCalls: Array<{
+  conversationId: string;
+  externalChatId: string;
+  callbackUrl: string;
+  assistantId?: string;
+  messageId?: string;
+  startFromSegment?: number;
+}> = [];
+let deliverReplyViaCallbackImpl: (
+  ...args: unknown[]
+) => Promise<void> = async () => {};
+
+mock.module("../runtime/channel-reply-delivery.js", () => ({
+  deliverReplyViaCallback: async (
+    conversationId: string,
+    externalChatId: string,
+    callbackUrl: string,
+    assistantId?: string,
+    options?: { messageId?: string; startFromSegment?: number },
+  ) => {
+    deliveryCalls.push({
+      conversationId,
+      externalChatId,
+      callbackUrl,
+      assistantId,
+      messageId: options?.messageId,
+      startFromSegment: options?.startFromSegment,
+    });
+    return deliverReplyViaCallbackImpl(
+      conversationId,
+      externalChatId,
+      callbackUrl,
+      assistantId,
+      options,
+    );
+  },
+  findAssistantReplyMessageIdForTurn: (
+    conversationId: string,
+    userMessageId: string,
+  ): string | undefined => {
+    const rows = getDb()
+      .select()
+      .from(messages)
+      .where(eq(messages.conversationId, conversationId))
+      .orderBy(asc(messages.createdAt))
+      .all();
+    const userIndex = rows.findIndex((row) => row.id === userMessageId);
+    if (userIndex === -1) return undefined;
+    let candidate: string | undefined;
+    for (let i = userIndex + 1; i < rows.length; i++) {
+      const row = rows[i];
+      if (row.role === "user") break;
+      if (row.role === "assistant") {
+        candidate = row.id;
+      }
+    }
+    return candidate;
+  },
+}));
+
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import * as deliveryCrud from "../memory/delivery-crud.js";
@@ -97,6 +157,8 @@ function seedFailedEventWithActorRoleOnly(
 describe("channel-retry-sweep", () => {
   beforeEach(() => {
     resetTables();
+    deliveryCalls.length = 0;
+    deliverReplyViaCallbackImpl = async () => {};
   });
 
   test("replays canonical payloads with trustClass correctly", async () => {
@@ -296,4 +358,215 @@ describe("channel-retry-sweep", () => {
     expect(capturedOptions?.trustContext?.sourceChannel).toBe("telegram");
     expect(capturedOptions?.isInteractive).toBe(false);
   });
+
+  test("delivery failure after successful replay does not requeue processing", async () => {
+    const inbound = deliveryCrud.recordInbound(
+      "telegram",
+      "chat-delivery-fails",
+      "msg-delivery-fails",
+    );
+    deliveryCrud.storePayload(inbound.eventId, {
+      content: "retry me",
+      sourceChannel: "telegram",
+      interface: "telegram",
+      externalChatId: "chat-delivery-fails",
+      replyCallbackUrl: "https://example.test/deliver/telegram",
+      trustCtx: {
+        trustClass: "unknown",
+        sourceChannel: "telegram",
+        requesterChatId: "chat-delivery-fails",
+      },
+    });
+
+    const db = getDb();
+    db.update(channelInboundEvents)
+      .set({
+        processingStatus: "failed",
+        processingAttempts: 1,
+        retryAfter: Date.now() - 1,
+      })
+      .where(eq(channelInboundEvents.id, inbound.eventId))
+      .run();
+    deliverReplyViaCallbackImpl = async () => {
+      throw new Error("fetch failed");
+    };
+
+    let processMessageCalls = 0;
+    await sweepFailedEvents(async (conversationId, _content, _ids, options) => {
+      processMessageCalls++;
+      options?.onEvent?.({
+        type: "message_complete",
+        conversationId,
+        messageId: "assistant-delivery-fails",
+      });
+      const messageId = "message-delivery-fails";
+      db.insert(messages)
+        .values({
+          id: messageId,
+          conversationId,
+          role: "user",
+          content: JSON.stringify([{ type: "text", text: "retry me" }]),
+          createdAt: Date.now(),
+        })
+        .run();
+      return { messageId };
+    });
+
+    const row = db
+      .select()
+      .from(channelInboundEvents)
+      .where(eq(channelInboundEvents.id, inbound.eventId))
+      .get();
+    expect(processMessageCalls).toBe(1);
+    expect(deliveryCalls).toHaveLength(1);
+    expect(row?.processingStatus).toBe("processed");
+    expect(row?.deliveryStatus).toBe("failed");
+    expect(row?.messageId).toBe("message-delivery-fails");
+    expect(
+      row?.rawPayload ? JSON.parse(row.rawPayload).replyMessageId : undefined,
+    ).toBe("assistant-delivery-fails");
+  });
+
+  test("delivery retry for processed events resumes delivery without processing", async () => {
+    const inbound = deliveryCrud.recordInbound(
+      "telegram",
+      "chat-delivery-only",
+      "msg-delivery-only",
+    );
+    deliveryCrud.storePayload(inbound.eventId, {
+      content: "already processed",
+      sourceChannel: "telegram",
+      interface: "telegram",
+      externalChatId: "chat-delivery-only",
+      replyCallbackUrl: "https://example.test/deliver/telegram",
+      assistantId: "assistant-1",
+      replyMessageId: "assistant-delivery-only",
+    });
+
+    const db = getDb();
+    db.update(channelInboundEvents)
+      .set({
+        processingStatus: "processed",
+        deliveryStatus: "failed",
+        processingAttempts: 1,
+        retryAfter: Date.now() - 1,
+        deliveredSegmentCount: 2,
+      })
+      .where(eq(channelInboundEvents.id, inbound.eventId))
+      .run();
+
+    let processMessageCalls = 0;
+    await sweepFailedEvents(async () => {
+      processMessageCalls++;
+      throw new Error("processMessage should not be called");
+    });
+
+    const row = db
+      .select()
+      .from(channelInboundEvents)
+      .where(eq(channelInboundEvents.id, inbound.eventId))
+      .get();
+    expect(processMessageCalls).toBe(0);
+    expect(deliveryCalls).toEqual([
+      {
+        conversationId: inbound.conversationId,
+        externalChatId: "chat-delivery-only",
+        callbackUrl: "https://example.test/deliver/telegram",
+        assistantId: "assistant-1",
+        messageId: "assistant-delivery-only",
+        startFromSegment: 2,
+      },
+    ]);
+    expect(row?.processingStatus).toBe("processed");
+    expect(row?.deliveryStatus).toBe("delivered");
+    expect(row?.retryAfter).toBeNull();
+  });
+
+  test("delivery retry resolves missing reply id from the linked user turn", async () => {
+    const inbound = deliveryCrud.recordInbound(
+      "telegram",
+      "chat-delivery-fallback",
+      "msg-delivery-fallback",
+    );
+    deliveryCrud.storePayload(inbound.eventId, {
+      content: "already processed",
+      sourceChannel: "telegram",
+      interface: "telegram",
+      externalChatId: "chat-delivery-fallback",
+      replyCallbackUrl: "https://example.test/deliver/telegram",
+      assistantId: "assistant-1",
+    });
+
+    const db = getDb();
+    db.insert(messages)
+      .values([
+        {
+          id: "user-delivery-fallback",
+          conversationId: inbound.conversationId,
+          role: "user",
+          content: JSON.stringify([
+            { type: "text", text: "already processed" },
+          ]),
+          createdAt: 1_000,
+        },
+        {
+          id: "assistant-delivery-fallback",
+          conversationId: inbound.conversationId,
+          role: "assistant",
+          content: JSON.stringify([{ type: "text", text: "reply" }]),
+          createdAt: 1_001,
+        },
+        {
+          id: "user-unrelated",
+          conversationId: inbound.conversationId,
+          role: "user",
+          content: JSON.stringify([{ type: "text", text: "newer turn" }]),
+          createdAt: 1_002,
+        },
+        {
+          id: "assistant-unrelated",
+          conversationId: inbound.conversationId,
+          role: "assistant",
+          content: JSON.stringify([{ type: "text", text: "newer reply" }]),
+          createdAt: 1_003,
+        },
+      ])
+      .run();
+    deliveryCrud.linkMessage(inbound.eventId, "user-delivery-fallback");
+    db.update(channelInboundEvents)
+      .set({
+        processingStatus: "processed",
+        deliveryStatus: "failed",
+        retryAfter: Date.now() - 1,
+      })
+      .where(eq(channelInboundEvents.id, inbound.eventId))
+      .run();
+
+    let processMessageCalls = 0;
+    await sweepFailedEvents(async () => {
+      processMessageCalls++;
+      throw new Error("processMessage should not be called");
+    });
+
+    const row = db
+      .select()
+      .from(channelInboundEvents)
+      .where(eq(channelInboundEvents.id, inbound.eventId))
+      .get();
+    expect(processMessageCalls).toBe(0);
+    expect(deliveryCalls).toEqual([
+      {
+        conversationId: inbound.conversationId,
+        externalChatId: "chat-delivery-fallback",
+        callbackUrl: "https://example.test/deliver/telegram",
+        assistantId: "assistant-1",
+        messageId: "assistant-delivery-fallback",
+        startFromSegment: 0,
+      },
+    ]);
+    expect(
+      row?.rawPayload ? JSON.parse(row.rawPayload).replyMessageId : undefined,
+    ).toBe("assistant-delivery-fallback");
+    expect(row?.deliveryStatus).toBe("delivered");
+  });
 });

package/src/__tests__/compaction-events.test.ts

@@ -52,7 +52,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__/compactor-preserved-tail-count.test.ts

@@ -0,0 +1,110 @@
+import { describe, expect, mock, test } from "bun:test";
+
+function makeLoggerStub(): Record<string, unknown> {
+  const stub: Record<string, unknown> = {};
+  for (const m of [
+    "info",
+    "warn",
+    "error",
+    "debug",
+    "trace",
+    "fatal",
+    "silent",
+    "child",
+  ]) {
+    stub[m] = m === "child" ? () => makeLoggerStub() : () => {};
+  }
+  return stub;
+}
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => makeLoggerStub(),
+}));
+
+mock.module("../memory/conversation-crud.js", () => ({
+  getMessages: () => [],
+}));
+
+mock.module("../memory/attachments-store.js", () => ({
+  getAttachmentMetadataForMessage: () => [],
+  getAttachmentContent: () => null,
+}));
+
+import { runAssistantDrivenCompaction } from "../context/compactor.js";
+import type { Message, Provider } from "../providers/types.js";
+
+const TAIL_TIMESTAMP =
+  "2026-05-21 (Thursday) 10:00:00 -05:00 (America/Chicago)";
+
+const compactionResponse = `
+<compaction_result>
+<summary>
+Earlier turns summarized here.
+</summary>
+
+<key_state>
+- Nothing critical pending.
+</key_state>
+
+<tail_start timestamp="${TAIL_TIMESTAMP}" preview="tail anchor message" />
+</compaction_result>
+`;
+
+function makeProvider(): Provider {
+  return {
+    name: "mock-provider",
+    sendMessage: async () => ({
+      content: [{ type: "text", text: compactionResponse }],
+      model: "mock-model",
+      usage: { inputTokens: 100, outputTokens: 50 },
+      stopReason: "end_turn",
+    }),
+  };
+}
+
+const userText = (text: string): Message => ({
+  role: "user",
+  content: [{ type: "text", text }],
+});
+
+const userTextWithTurnContext = (text: string, timestamp: string): Message => ({
+  role: "user",
+  content: [
+    {
+      type: "text",
+      text: `<turn_context>\ncurrent_time: ${timestamp}\n</turn_context>\n${text}`,
+    },
+  ],
+});
+
+const assistantText = (text: string): Message => ({
+  role: "assistant",
+  content: [{ type: "text", text }],
+});
+
+describe("runAssistantDrivenCompaction — preservedTailMessages count", () => {
+  test("reflects the pre-strip tail size so the reported cut point matches the user-visible split", async () => {
+    const messages: Message[] = [
+      userText("old user turn 1"),
+      assistantText("old assistant reply 1"),
+      userText("old user turn 2"),
+      userTextWithTurnContext("tail anchor message", TAIL_TIMESTAMP),
+      userText("<system_reminder>\nstale reminder\n</system_reminder>"),
+      userText("<knowledge_base>\nstale pkb\n</knowledge_base>"),
+      assistantText("most recent assistant reply"),
+    ];
+
+    const result = await runAssistantDrivenCompaction({
+      conversationId: "conv-test",
+      messages,
+      provider: makeProvider(),
+      systemPrompt: "system",
+      compaction: { enabled: true, autoThreshold: 0.7 },
+      maxInputTokens: 1000,
+      previousEstimatedInputTokens: 900,
+    });
+
+    expect(result.compacted).toBe(true);
+    expect(result.preservedTailMessages).toBe(4);
+  });
+});

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__/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-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();
+  });
 });