@vellumai/assistant 0.8.3 → 0.8.5

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__/checker.test.ts

@@ -133,13 +133,10 @@ const mockSkillTool: Tool = {
   description: "A test skill tool",
   category: "skill",
   defaultRiskLevel: RiskLevel.Low,
+  executionTarget: "sandbox",
   origin: "skill",
   ownerSkillId: "test-skill",
-  getDefinition: () => ({
-    name: "skill_test_tool",
-    description: "A test skill tool",
-    input_schema: { type: "object" as const, properties: {} },
-  }),
+  input_schema: { type: "object" as const, properties: {} },
   execute: async () => ({ content: "ok", isError: false }),
 };
 registerTool(mockSkillTool);
@@ -150,14 +147,11 @@ const mockBundledSkillTool: Tool = {
   description: "A test bundled skill tool",
   category: "skill",
   defaultRiskLevel: RiskLevel.Low,
+  executionTarget: "sandbox",
   origin: "skill",
   ownerSkillId: "gmail",
   ownerSkillBundled: true,
-  getDefinition: () => ({
-    name: "skill_bundled_test_tool",
-    description: "A test bundled skill tool",
-    input_schema: { type: "object" as const, properties: {} },
-  }),
+  input_schema: { type: "object" as const, properties: {} },
   execute: async () => ({ content: "ok", isError: false }),
 };
 registerTool(mockBundledSkillTool);
@@ -391,13 +385,10 @@ describe("Permission Checker", () => {
         description: "A medium-risk skill tool",
         category: "skill",
         defaultRiskLevel: RiskLevel.Medium,
+        executionTarget: "sandbox",
         origin: "skill",
         ownerSkillId: "test-skill",
-        getDefinition: () => ({
-          name: "skill_medium_tool",
-          description: "A medium-risk skill tool",
-          input_schema: { type: "object" as const, properties: {} },
-        }),
+        input_schema: { type: "object" as const, properties: {} },
         execute: async () => ({ content: "ok", isError: false }),
       };
       registerTool(mediumSkillTool);

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", () => ({
@@ -129,6 +129,7 @@ mock.module("../security/secret-allowlist.js", () => ({
 mock.module("../memory/conversation-crud.js", () => ({
   setConversationOriginChannelIfUnset: () => {},
   updateConversationContextWindow: () => {},
+  setConversationHistoryStrippedAt: () => {},
   deleteMessageById: () => {},
   provenanceFromTrustContext: () => ({
     source: "user",

package/src/__tests__/compactor-call-site-logging.test.ts

@@ -0,0 +1,214 @@
+/**
+ * Tests that successful compaction LLM calls land an `llm_request_logs`
+ * row with `call_site = "compactionAgent"`. The compactor opts out of
+ * automatic usage tracking (`usageTracking: "manual"`), so its calls
+ * otherwise never reach `recordRequestLog` via the agent-loop
+ * dispatcher. This test pins the explicit instrumentation in
+ * `compactor.ts` so visibility doesn't silently regress.
+ */
+import { beforeEach, 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,
+}));
+
+const recordRequestLogCalls: Array<{
+  conversationId: string;
+  requestPayload: string;
+  responsePayload: string;
+  messageId: string | undefined;
+  provider: string | undefined;
+  callSite: string | undefined;
+}> = [];
+
+mock.module("../memory/llm-request-log-store.js", () => ({
+  recordRequestLog: (
+    conversationId: string,
+    requestPayload: string,
+    responsePayload: string,
+    messageId?: string,
+    provider?: string,
+    callSite?: string,
+  ): string => {
+    recordRequestLogCalls.push({
+      conversationId,
+      requestPayload,
+      responsePayload,
+      messageId,
+      provider,
+      callSite,
+    });
+    return `mock-log-${recordRequestLogCalls.length}`;
+  },
+}));
+
+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>
+`;
+
+const RAW_REQUEST = { model: "mock-model", messages: [] };
+const RAW_RESPONSE = { id: "resp-1", content: compactionResponse };
+
+function makeProvider(): Provider {
+  return {
+    name: "mock-provider",
+    sendMessage: async () => ({
+      content: [{ type: "text", text: compactionResponse }],
+      model: "mock-model",
+      actualProvider: "actual-mock-provider",
+      usage: { inputTokens: 100, outputTokens: 50 },
+      stopReason: "end_turn",
+      rawRequest: RAW_REQUEST,
+      rawResponse: RAW_RESPONSE,
+    }),
+  };
+}
+
+function makeProviderWithoutRaw(): Provider {
+  return {
+    name: "mock-provider",
+    sendMessage: async () => ({
+      content: [{ type: "text", text: compactionResponse }],
+      model: "mock-model",
+      usage: { inputTokens: 100, outputTokens: 50 },
+      stopReason: "end_turn",
+      // rawRequest/rawResponse intentionally absent — best-effort skip path.
+    }),
+  };
+}
+
+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 }],
+});
+
+function buildMessages(): Message[] {
+  return [
+    userText("old user turn 1"),
+    assistantText("old assistant reply 1"),
+    userText("old user turn 2"),
+    assistantText("old assistant reply 2"),
+    userTextWithTurnContext("tail anchor message", TAIL_TIMESTAMP),
+    assistantText("tail assistant reply"),
+  ];
+}
+
+const args = (provider: Provider) => ({
+  conversationId: "conv-compaction-log-1",
+  messages: buildMessages(),
+  provider,
+  systemPrompt: "you are a test assistant",
+  compaction: { enabled: true, autoThreshold: 0.7 },
+  maxInputTokens: 1000,
+  // Above threshold so the auto-check fires.
+  previousEstimatedInputTokens: 900,
+});
+
+describe("compactor records llm_request_logs with call_site=compactionAgent", () => {
+  beforeEach(() => {
+    recordRequestLogCalls.length = 0;
+  });
+
+  test("successful compaction call stamps call_site = compactionAgent", async () => {
+    await runAssistantDrivenCompaction(args(makeProvider()));
+
+    expect(recordRequestLogCalls.length).toBe(1);
+    expect(recordRequestLogCalls[0]!.callSite).toBe("compactionAgent");
+    expect(recordRequestLogCalls[0]!.conversationId).toBe(
+      "conv-compaction-log-1",
+    );
+    // Provider name comes from actualProvider when present.
+    expect(recordRequestLogCalls[0]!.provider).toBe("actual-mock-provider");
+    // Payloads should be JSON-stringified.
+    expect(recordRequestLogCalls[0]!.requestPayload).toBe(
+      JSON.stringify(RAW_REQUEST),
+    );
+    expect(recordRequestLogCalls[0]!.responsePayload).toBe(
+      JSON.stringify(RAW_RESPONSE),
+    );
+  });
+
+  test("skips persistence when provider returns no rawRequest/rawResponse", async () => {
+    await runAssistantDrivenCompaction(args(makeProviderWithoutRaw()));
+
+    // Helper short-circuits when raw payloads are absent — non-fatal.
+    expect(recordRequestLogCalls.length).toBe(0);
+  });
+
+  test("uses provider.name when actualProvider is absent", async () => {
+    const provider: Provider = {
+      name: "fallback-provider-name",
+      sendMessage: async () => ({
+        content: [{ type: "text", text: compactionResponse }],
+        model: "mock-model",
+        usage: { inputTokens: 100, outputTokens: 50 },
+        stopReason: "end_turn",
+        rawRequest: RAW_REQUEST,
+        rawResponse: RAW_RESPONSE,
+      }),
+    };
+
+    await runAssistantDrivenCompaction(args(provider));
+
+    expect(recordRequestLogCalls.length).toBe(1);
+    expect(recordRequestLogCalls[0]!.provider).toBe("fallback-provider-name");
+    expect(recordRequestLogCalls[0]!.callSite).toBe("compactionAgent");
+  });
+});

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