@vellumai/assistant 0.11.7 → 0.11.8-staging.1

package/src/__tests__/reaction-persistence.test.ts

@@ -79,10 +79,7 @@ import { initializeDb } from "../persistence/db-init.js";
 import { linkMessage, recordInbound } from "../persistence/delivery-crud.js";
 import { messages } from "../persistence/schema/conversations.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
-import {
-  isSlackReactionEvent,
-  parseSlackReactionCallbackData,
-} from "../runtime/routes/inbound-stages/reaction-intercept.js";
+import { isReactionEvent } from "../runtime/routes/inbound-stages/reaction-intercept.js";
 import {
   handleChannelInbound,
   seedContactChannel,
@@ -109,6 +106,7 @@ function resetState(): void {
   db.run("DELETE FROM contact_channels");
   db.run("DELETE FROM contacts");
   gatewayGuardians = [];
+  _conversationMocks.clear();
 }
 
 function seedActiveMember(): void {
@@ -202,70 +200,26 @@ function readPersistedMessages(): Array<{
 // Helper unit tests
 // ---------------------------------------------------------------------------
 
-describe("isSlackReactionEvent", () => {
-  test("returns true for reaction added", () => {
-    expect(
-      isSlackReactionEvent({
-        sourceChannel: "slack",
-        callbackData: "reaction:thumbsup",
-      }),
-    ).toBe(true);
-  });
-
-  test("returns true for reaction removed", () => {
-    expect(
-      isSlackReactionEvent({
-        sourceChannel: "slack",
-        callbackData: "reaction_removed:eyes",
-      }),
-    ).toBe(true);
+describe("isReactionEvent", () => {
+  test("returns true for a stamped reaction kind", () => {
+    expect(isReactionEvent({ eventKind: "reaction" })).toBe(true);
   });
 
-  test("returns false for non-Slack source", () => {
-    expect(
-      isSlackReactionEvent({
-        sourceChannel: "telegram",
-        callbackData: "reaction:thumbsup",
-      }),
-    ).toBe(false);
+  test("returns true for replayed reaction sentinels, added and removed", () => {
+    expect(isReactionEvent({ callbackData: "reaction:thumbsup" })).toBe(true);
+    expect(isReactionEvent({ callbackData: "reaction_removed:eyes" })).toBe(
+      true,
+    );
   });
 
   test("returns false for non-reaction callback data", () => {
-    expect(
-      isSlackReactionEvent({
-        sourceChannel: "slack",
-        callbackData: "apr:req-1:approve_once",
-      }),
-    ).toBe(false);
-  });
-
-  test("returns false when callbackData missing", () => {
-    expect(isSlackReactionEvent({ sourceChannel: "slack" })).toBe(false);
-  });
-});
-
-describe("parseSlackReactionCallbackData", () => {
-  test("parses reaction:<emoji> as added", () => {
-    expect(parseSlackReactionCallbackData("reaction:thumbsup")).toEqual({
-      op: "added",
-      emoji: "thumbsup",
-    });
-  });
-
-  test("parses reaction_removed:<emoji> as removed", () => {
-    expect(parseSlackReactionCallbackData("reaction_removed:eyes")).toEqual({
-      op: "removed",
-      emoji: "eyes",
-    });
-  });
-
-  test("returns null for empty emoji portion", () => {
-    expect(parseSlackReactionCallbackData("reaction:")).toBeNull();
-    expect(parseSlackReactionCallbackData("reaction_removed:")).toBeNull();
+    expect(isReactionEvent({ callbackData: "apr:req-1:approve_once" })).toBe(
+      false,
+    );
   });
 
-  test("returns null for unrelated callback data", () => {
-    expect(parseSlackReactionCallbackData("apr:req-1:approve")).toBeNull();
+  test("returns false for a plain message", () => {
+    expect(isReactionEvent({})).toBe(false);
   });
 });
 
@@ -311,6 +265,10 @@ describe("Slack reaction event persistence", () => {
     expect(row.content).toBe("[reaction]");
 
     const envelope = JSON.parse(row.metadata!) as Record<string, unknown>;
+    // Provenance keeps the row visible to actor-scoped history loads:
+    // filterMessagesForUntrustedActor drops rows with no trust class.
+    expect(envelope.provenanceTrustClass).toBe("trusted_contact");
+    expect(envelope.provenanceSourceChannel).toBe("slack");
     const slackMetaRaw = envelope.slackMeta;
     expect(typeof slackMetaRaw).toBe("string");
 
@@ -323,6 +281,9 @@ describe("Slack reaction event persistence", () => {
     // Slack sends no thread on a reaction, so the row claims none.
     expect(slackMeta!.threadTs).toBeUndefined();
     expect(slackMeta!.displayName).toBe(SLACK_DISPLAY_NAME);
+    // Stable identity, not the sender-controlled label: the history
+    // renderer attributes the fenced line's origin by this id.
+    expect(slackMeta!.actorExternalUserId).toBe(SLACK_USER_ID);
     expect(slackMeta!.reaction).toEqual({
       emoji: "thumbsup",
       actorDisplayName: SLACK_DISPLAY_NAME,
@@ -356,8 +317,10 @@ describe("Slack reaction event persistence", () => {
     });
     const resp = await handleChannelInbound(req, undefined, TEST_BEARER_TOKEN);
     expect(resp.status).toBe(200);
+    // The payload resolver requires a target message id, so the dispatch
+    // drops the event before the intercept and it never reads as a message.
     expect(((await resp.json()) as Record<string, unknown>).reaction).toBe(
-      "dropped_unknown_target",
+      "dropped_unresolvable_payload",
     );
 
     const rows = readPersistedMessages();
@@ -459,6 +422,39 @@ describe("Slack reaction event persistence", () => {
     expect(rows.length).toBe(1);
   });
 
+  test("a persisted reaction stale-marks the resident conversation", async () => {
+    const conversationId = seedStoredMessage("1700000000.111111");
+    const markHistoryStale = mock(() => {});
+    _conversationMocks.set(conversationId, {
+      markHistoryStale,
+    } as unknown as Conversation);
+
+    const resp = await handleChannelInbound(
+      buildReactionRequest("reaction:thumbsup"),
+      undefined,
+      TEST_BEARER_TOKEN,
+    );
+    expect(resp.status).toBe(200);
+    expect(markHistoryStale).toHaveBeenCalledTimes(1);
+  });
+
+  test("a duplicate reaction does not stale-mark again", async () => {
+    const conversationId = seedStoredMessage("1700000000.111111");
+    const markHistoryStale = mock(() => {});
+    _conversationMocks.set(conversationId, {
+      markHistoryStale,
+    } as unknown as Conversation);
+    const sharedExternalMessageId = `${SLACK_CHANNEL_ID}:1700000000.777777:bob`;
+    const makeReq = () =>
+      buildReactionRequest("reaction:tada", {
+        externalMessageId: sharedExternalMessageId,
+      });
+
+    await handleChannelInbound(makeReq(), undefined, TEST_BEARER_TOKEN);
+    await handleChannelInbound(makeReq(), undefined, TEST_BEARER_TOKEN);
+    expect(markHistoryStale).toHaveBeenCalledTimes(1);
+  });
+
   test("reaction on the assistant's own post lands in that conversation", async () => {
     // An outbound post opens no inbound event, so the only record of its ts
     // is the `slackMeta` on the assistant row. Seeded here the way the

package/src/__tests__/retry-thinking-adaptive-only.test.ts

@@ -148,6 +148,73 @@ describe("retry normalization: adaptive-only thinking models", () => {
     expect(lastConfig()?.thinking).toEqual({ type: "adaptive" });
   });
 
+  test("preserves effort when dropping stale disabled thinking for Fireworks GLM 5.3", async () => {
+    // GIVEN a profile that kept `thinking: { enabled: false }` after switching
+    // to an always-on GLM 5.3 model, plus an explicit effort
+    setLlmConfig({
+      callSites: {
+        memoryExtraction: {
+          provider: "fireworks",
+          model: "accounts/fireworks/models/glm-5p3",
+          thinking: { enabled: false },
+          effort: "high",
+        },
+      },
+    });
+    const { provider, lastConfig } = makePipeline("fireworks");
+
+    // WHEN a request resolves through the call-site config
+    await provider.sendMessage([userMessage], {
+      config: { callSite: "memoryExtraction" },
+    });
+
+    // THEN the disabled thinking is dropped BEFORE it can be encoded as
+    // `effort: "none"` (which GLM 5.3 rejects), and the chosen effort survives
+    expect(lastConfig()?.thinking).toBeUndefined();
+    expect(lastConfig()?.effort).toBe("high");
+  });
+
+  test("does not generate the opt-out effort for GLM 5.3 Flash with disabled thinking", async () => {
+    // GIVEN a pass-through caller with the wire-shape disabled config and no
+    // explicit effort
+    const { provider, lastConfig } = makePipeline("fireworks");
+
+    // WHEN sending against the always-on Flash model
+    await provider.sendMessage([userMessage], {
+      config: {
+        model: "accounts/fireworks/models/glm-5p3-flash",
+        thinking: { type: "disabled" },
+      },
+    });
+
+    // THEN no `effort: "none"` is synthesized: the model runs at its own
+    // default instead of tripping the reasoning opt-out rejection retry
+    expect(lastConfig()?.thinking).toBeUndefined();
+    expect(lastConfig()?.effort).toBeUndefined();
+  });
+
+  test("still encodes the opt-out for Fireworks models that support disabling thinking", async () => {
+    // GIVEN a disabled thinking config on GLM 5.2, which is not adaptive-only
+    setLlmConfig({
+      callSites: {
+        memoryExtraction: {
+          provider: "fireworks",
+          model: "accounts/fireworks/models/glm-5p2",
+          thinking: { enabled: false },
+        },
+      },
+    });
+    const { provider, lastConfig } = makePipeline("fireworks");
+
+    // WHEN a request resolves through the call-site config
+    await provider.sendMessage([userMessage], {
+      config: { callSite: "memoryExtraction" },
+    });
+
+    // THEN the opt-out is still encoded through the effort knob
+    expect(lastConfig()?.effort).toBe("none");
+  });
+
   test("preserves disabled thinking for models that support disabling it", async () => {
     // GIVEN a call-site config disabling thinking for a non-adaptive-only model
     setLlmConfig({

package/src/__tests__/server-history-render.test.ts

@@ -161,6 +161,28 @@ describe("renderHistoryContent", () => {
     expect(output.textSegments[1]).toContain("[File attachment] dream-015.md");
   });
 
+  test("an image block's _attachmentId contributes no attachment ref", () => {
+    // Chip positioning joins DB attachment rows against the refs collected
+    // here, and only `file` blocks are collected. An image carrying the same
+    // internal id must stay out of that join, or a user upload would gain a
+    // second, duplicate chip.
+    const output = renderHistoryContent([
+      { type: "text", text: "what is this" },
+      {
+        type: "image",
+        source: {
+          type: "base64",
+          media_type: "image/jpeg",
+          data: Buffer.from("img").toString("base64"),
+        },
+        _attachmentId: "att-image-1",
+      },
+    ]);
+
+    expect(output.attachments).toEqual([]);
+    expect(output.contentOrder).toEqual(["text:0"]);
+  });
+
   test("omits attachmentId when file block has no _attachmentId", () => {
     const output = renderHistoryContent([
       {

package/src/__tests__/sight-frame-retention.test.ts

@@ -0,0 +1,362 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  KEEP_LATEST_SIGHT_FRAMES,
+  MAX_SIGHT_KEEP_LATEST_FRAMES,
+} from "../config/schemas/sight.js";
+import { applySightFrameRetention } from "../daemon/conversation-runtime-assembly.js";
+import {
+  getAttachmentMetadataForMessage,
+  linkAttachmentToMessage,
+  uploadAttachment,
+} from "../persistence/attachments-store.js";
+import {
+  addMessage,
+  createConversation,
+  forkConversation,
+  getMessages,
+  selectSightFrameCaptureTimes,
+} from "../persistence/conversation-crud.js";
+import { getDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+import { conversations } from "../persistence/schema.js";
+import type { ContentBlock, Message } from "../providers/types.js";
+import { setConfig } from "./helpers/set-config.js";
+
+await initializeDb();
+
+function ensureConversation(id: string): void {
+  const db = getDb();
+  const now = Date.now();
+  db.insert(conversations)
+    .values({
+      id,
+      title: "test",
+      createdAt: now,
+      updatedAt: now,
+      lastMessageAt: now,
+    })
+    .onConflictDoNothing()
+    .run();
+}
+
+function frameContent(attachmentId: string): string {
+  return JSON.stringify([
+    { type: "text", text: "what am I looking at" },
+    {
+      type: "image",
+      source: {
+        type: "workspace_ref",
+        media_type: "image/jpeg",
+        attachmentId,
+        sizeBytes: 1024,
+      },
+    },
+  ]);
+}
+
+function referenceImage(
+  attachmentId: string,
+): Extract<ContentBlock, { type: "image" }> {
+  return {
+    type: "image",
+    source: {
+      type: "workspace_ref",
+      media_type: "image/jpeg",
+      attachmentId,
+      sizeBytes: 1024,
+    },
+  };
+}
+
+describe("selectSightFrameCaptureTimes", () => {
+  const conversationId = "conv-sight-frame-times";
+
+  beforeEach(() => {
+    ensureConversation(conversationId);
+  });
+
+  test("maps tagged attachment ids to the row that carried them", async () => {
+    const first = await addMessage(
+      conversationId,
+      "user",
+      frameContent("att-1"),
+      { metadata: { sightFrameAttachmentIds: ["att-1"] } },
+    );
+    const second = await addMessage(
+      conversationId,
+      "user",
+      frameContent("att-2"),
+      { metadata: { sightFrameAttachmentIds: ["att-2", "att-3"] } },
+    );
+
+    const rows = getMessages(conversationId);
+    const createdAtById = new Map(rows.map((r) => [r.id, r.createdAt]));
+    const captureTimes = selectSightFrameCaptureTimes(conversationId);
+
+    expect(captureTimes.get("att-1")).toBe(createdAtById.get(first.id)!);
+    expect(captureTimes.get("att-2")).toBe(createdAtById.get(second.id)!);
+    expect(captureTimes.get("att-3")).toBe(createdAtById.get(second.id)!);
+  });
+
+  test("is empty for a conversation whose rows carry no tag", async () => {
+    const untaggedId = "conv-sight-frame-untagged";
+    ensureConversation(untaggedId);
+    await addMessage(untaggedId, "user", frameContent("att-9"), {
+      metadata: { voiceSessionTurn: true },
+    });
+    await addMessage(untaggedId, "assistant", "sure");
+
+    expect(selectSightFrameCaptureTimes(untaggedId).size).toBe(0);
+  });
+
+  test("drops a row that only mentions the key in an unrelated value", async () => {
+    const mentionId = "conv-sight-frame-mention";
+    ensureConversation(mentionId);
+    await addMessage(mentionId, "user", "hello", {
+      metadata: { backgroundEventSource: "sightFrameAttachmentIds" },
+    });
+
+    expect(selectSightFrameCaptureTimes(mentionId).size).toBe(0);
+  });
+});
+
+describe("applySightFrameRetention", () => {
+  test("stubs the aged frames of a tagged conversation", async () => {
+    const conversationId = "conv-sight-frame-retention";
+    ensureConversation(conversationId);
+    for (const attachmentId of ["att-a", "att-b", "att-c"]) {
+      await addMessage(conversationId, "user", frameContent(attachmentId), {
+        metadata: { sightFrameAttachmentIds: [attachmentId] },
+      });
+    }
+
+    const assembled: Message[] = [
+      { role: "user", content: [referenceImage("att-a")] },
+      { role: "assistant", content: [{ type: "text", text: "ok" }] },
+      { role: "user", content: [referenceImage("att-b")] },
+      { role: "user", content: [referenceImage("att-c")] },
+    ];
+
+    const retained = applySightFrameRetention(assembled, conversationId);
+
+    expect(retained[0].content[0].type).toBe("text");
+    expect(retained[2].content[0]).toEqual(referenceImage("att-b"));
+    expect(retained[3].content[0]).toEqual(referenceImage("att-c"));
+  });
+
+  test("reaches live inline frames that never reloaded from the DB", async () => {
+    const conversationId = "conv-sight-frame-retention-live";
+    ensureConversation(conversationId);
+    for (const attachmentId of ["live-a", "live-b", "live-c"]) {
+      await addMessage(conversationId, "user", frameContent(attachmentId), {
+        metadata: { sightFrameAttachmentIds: [attachmentId] },
+      });
+    }
+
+    // What `persistQueuedMessageBody` pushes into `ctx.messages`: inline bytes
+    // carrying the id of the row persisted as a reference.
+    const liveImage = (
+      attachmentId: string,
+    ): Extract<ContentBlock, { type: "image" }> => ({
+      type: "image",
+      source: { type: "base64", media_type: "image/jpeg", data: "AAAAAAAA" },
+      _attachmentId: attachmentId,
+    });
+    const assembled: Message[] = [
+      { role: "user", content: [liveImage("live-a")] },
+      { role: "assistant", content: [{ type: "text", text: "ok" }] },
+      { role: "user", content: [liveImage("live-b")] },
+      { role: "user", content: [liveImage("live-c")] },
+    ];
+
+    const retained = applySightFrameRetention(assembled, conversationId);
+
+    expect(retained[0].content[0].type).toBe("text");
+    expect(retained[2].content[0]).toEqual(liveImage("live-b"));
+    expect(retained[3].content[0]).toEqual(liveImage("live-c"));
+  });
+
+  test("returns the same array for a conversation with no tagged rows", async () => {
+    const conversationId = "conv-sight-frame-retention-untagged";
+    ensureConversation(conversationId);
+    await addMessage(conversationId, "user", frameContent("att-z"));
+
+    const assembled: Message[] = [
+      { role: "user", content: [referenceImage("att-z")] },
+    ];
+
+    expect(applySightFrameRetention(assembled, conversationId)).toBe(assembled);
+  });
+});
+
+describe("configured retention budget", () => {
+  afterEach(() => {
+    setConfig("sight", {});
+  });
+
+  /** One tagged standalone frame per row, the shape a keep stream leaves. */
+  async function seedFrames(
+    conversationId: string,
+    count: number,
+  ): Promise<Message[]> {
+    ensureConversation(conversationId);
+    const assembled: Message[] = [];
+    for (let index = 0; index < count; index += 1) {
+      const attachmentId = `${conversationId}-att-${index}`;
+      await addMessage(conversationId, "user", frameContent(attachmentId), {
+        metadata: { sightFrameAttachmentIds: [attachmentId] },
+      });
+      assembled.push({
+        role: "user",
+        content: [referenceImage(attachmentId)],
+      });
+    }
+    return assembled;
+  }
+
+  function imageCount(messages: Message[]): number {
+    return messages.filter((message) => message.content[0].type === "image")
+      .length;
+  }
+
+  test("keeps the number of frames the workspace configured", async () => {
+    setConfig("sight", { keepLatestFrames: 4 });
+    const conversationId = "conv-sight-budget-configured";
+    const assembled = await seedFrames(conversationId, 6);
+
+    const retained = applySightFrameRetention(assembled, conversationId);
+
+    expect(imageCount(retained)).toBe(4);
+    expect(retained.length - imageCount(retained)).toBe(2);
+    // The survivors are the newest, which is what recency buys the model.
+    expect(retained.slice(2).every((m) => m.content[0].type === "image")).toBe(
+      true,
+    );
+  });
+
+  test("caps a configured value above the ceiling", async () => {
+    setConfig("sight", { keepLatestFrames: 99 });
+    const conversationId = "conv-sight-budget-capped";
+    const assembled = await seedFrames(conversationId, 8);
+
+    const retained = applySightFrameRetention(assembled, conversationId);
+
+    expect(imageCount(retained)).toBe(MAX_SIGHT_KEEP_LATEST_FRAMES);
+  });
+
+  test("falls back to the default when the workspace configures nothing", async () => {
+    const conversationId = "conv-sight-budget-default";
+    const assembled = await seedFrames(conversationId, 5);
+
+    const retained = applySightFrameRetention(assembled, conversationId);
+
+    expect(imageCount(retained)).toBe(KEEP_LATEST_SIGHT_FRAMES);
+  });
+});
+
+describe("forked conversations", () => {
+  test("a fork's tag covers both its source and cloned attachment ids", async () => {
+    // A fork copies `messages.content` verbatim, so its blocks still name the
+    // SOURCE attachment ids, while `message_attachments` is re-linked to
+    // freshly CLONED rows. The compactor reads the link side and stamps cloned
+    // ids onto the frames it rebuilds, so a tag naming only one vocabulary
+    // goes blind on the other.
+    const db = getDb();
+    db.run("DELETE FROM message_attachments");
+    db.run("DELETE FROM attachments");
+
+    const source = createConversation("camera call");
+    const uploaded = await uploadAttachment(
+      "frame.png",
+      "image/png",
+      "iVBORw0K",
+    );
+    const row = await addMessage(
+      source.id,
+      "user",
+      JSON.stringify([
+        {
+          type: "image",
+          source: {
+            type: "workspace_ref",
+            media_type: "image/png",
+            attachmentId: uploaded.id,
+            sizeBytes: 8,
+          },
+        },
+      ]),
+      {
+        metadata: { sightFrameAttachmentIds: [uploaded.id] },
+        skipIndexing: true,
+      },
+    );
+    linkAttachmentToMessage(row.id, uploaded.id, 0);
+
+    const fork = forkConversation({ conversationId: source.id });
+    const forkRow = getMessages(fork.id)[0];
+    const clonedId = getAttachmentMetadataForMessage(forkRow.id)[0]?.id;
+
+    // The fork really did clone the attachment under a new id.
+    expect(clonedId).toBeDefined();
+    expect(clonedId).not.toBe(uploaded.id);
+
+    const captureTimes = selectSightFrameCaptureTimes(fork.id);
+    // Both vocabularies resolve, so a frame is matchable whether it arrived
+    // through the copied content or through the compactor's manifest.
+    expect(captureTimes.has(uploaded.id)).toBe(true);
+    expect(captureTimes.has(clonedId!)).toBe(true);
+
+    // The source conversation is untouched by the widening.
+    expect([...selectSightFrameCaptureTimes(source.id).keys()]).toEqual([
+      uploaded.id,
+    ]);
+  });
+
+  test("retention still matches the frames a fork holds directly", async () => {
+    const db = getDb();
+    db.run("DELETE FROM message_attachments");
+    db.run("DELETE FROM attachments");
+
+    const source = createConversation("camera call 2");
+    const ids: string[] = [];
+    for (const name of ["a.png", "b.png", "c.png"]) {
+      const uploaded = await uploadAttachment(name, "image/png", "iVBORw0K");
+      const row = await addMessage(
+        source.id,
+        "user",
+        JSON.stringify([
+          {
+            type: "image",
+            source: {
+              type: "workspace_ref",
+              media_type: "image/png",
+              attachmentId: uploaded.id,
+              sizeBytes: 8,
+            },
+          },
+        ]),
+        {
+          metadata: { sightFrameAttachmentIds: [uploaded.id] },
+          skipIndexing: true,
+        },
+      );
+      linkAttachmentToMessage(row.id, uploaded.id, 0);
+      ids.push(uploaded.id);
+    }
+
+    const fork = forkConversation({ conversationId: source.id });
+    // The fork's own rows, exactly as its history assembles them.
+    const assembled: Message[] = getMessages(fork.id).map((r) => ({
+      role: "user" as const,
+      content: r.content,
+    }));
+
+    const retained = applySightFrameRetention(assembled, fork.id);
+
+    // Oldest of the three is stubbed; the newest two survive.
+    expect(retained[0].content[0].type).toBe("text");
+    expect(retained[1].content[0].type).toBe("image");
+    expect(retained[2].content[0].type).toBe("image");
+  });
+});