@vellumai/assistant 0.12.2 → 0.12.3-staging.1

package/src/__tests__/db-conversation-tool-surface.test.ts

@@ -0,0 +1,221 @@
+/**
+ * Tests for the per-conversation wire surface record
+ * (`persistence/conversation-tool-surface.ts`): the send-boundary recorder
+ * stores the tools array a live turn sends with the delegation-section state
+ * its prompt rendered, fork wakes read both back verbatim, and an unchanged
+ * surface is never rewritten.
+ */
+
+import { Database } from "bun:sqlite";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import {
+  getConversationToolSurface as getConversationToolSurfaceViaPluginApi,
+  getRecordedConversationToolSurface,
+} from "../persistence/conversation-plugin-facade.js";
+import {
+  type ConversationToolSurface,
+  getConversationToolSurface,
+  hashConversationToolSurface,
+  recordConversationToolSurface,
+} from "../persistence/conversation-tool-surface.js";
+import { clearStoredDb, setStoredDb } from "../persistence/db-singleton.js";
+import { migrateCreateConversationToolSurfaces } from "../persistence/migrations/378-create-conversation-tool-surfaces.js";
+import { migrateConversationToolSurfacesDelegateIndependentTasks } from "../persistence/migrations/380-conversation-tool-surfaces-delegate-independent-tasks.js";
+import * as schema from "../persistence/schema/index.js";
+import type { ToolDefinition } from "../providers/types.js";
+
+let sqlite: Database;
+
+beforeEach(() => {
+  sqlite = new Database(":memory:");
+  sqlite.run("PRAGMA foreign_keys = ON");
+  sqlite.run(/*sql*/ `CREATE TABLE conversations (id TEXT PRIMARY KEY)`);
+  sqlite.query(`INSERT INTO conversations (id) VALUES (?)`).run("conv-1");
+  const db = drizzle(sqlite, { schema });
+  migrateCreateConversationToolSurfaces(db);
+  migrateConversationToolSurfacesDelegateIndependentTasks(db);
+  setStoredDb("main", db, () => sqlite.close());
+});
+
+afterEach(() => {
+  clearStoredDb("main");
+});
+
+const TOOLS: ToolDefinition[] = [
+  {
+    name: "remember",
+    description: "Save a fact",
+    input_schema: { type: "object", properties: { content: {} } },
+  },
+  { name: "bell_jingle", description: "Ring", input_schema: {} },
+];
+
+const SURFACE: ConversationToolSurface = {
+  tools: TOOLS,
+  delegateIndependentTasks: true,
+};
+
+function storedRow(): { tools_hash: string; updated_at: number } | null {
+  return sqlite
+    .query(
+      `SELECT tools_hash, updated_at FROM conversation_tool_surfaces WHERE conversation_id = ?`,
+    )
+    .get("conv-1") as { tools_hash: string; updated_at: number } | null;
+}
+
+describe("recordConversationToolSurface", () => {
+  test("stores the surface and returns its content hash", () => {
+    const hash = recordConversationToolSurface("conv-1", SURFACE);
+
+    expect(hash).toBe(hashConversationToolSurface(SURFACE));
+    expect(storedRow()?.tools_hash).toBe(hash);
+    expect(getConversationToolSurface("conv-1")).toEqual(SURFACE);
+  });
+
+  test("replays the exact array, including key order and extra fields", () => {
+    const serverTool = {
+      type: "web_search_20250305",
+      name: "web_search",
+      max_uses: 5,
+    } as unknown as ToolDefinition;
+    const tools = [...TOOLS, serverTool];
+
+    recordConversationToolSurface("conv-1", {
+      tools,
+      delegateIndependentTasks: false,
+    });
+
+    expect(JSON.stringify(getConversationToolSurface("conv-1")?.tools)).toBe(
+      JSON.stringify(tools),
+    );
+  });
+
+  test("the delegation-section state round-trips, unknown included", () => {
+    for (const delegateIndependentTasks of [true, false, null]) {
+      recordConversationToolSurface("conv-1", {
+        tools: TOOLS,
+        delegateIndependentTasks,
+      });
+
+      expect(
+        getConversationToolSurface("conv-1")?.delegateIndependentTasks,
+      ).toBe(delegateIndependentTasks);
+    }
+  });
+
+  test("an unchanged surface with a known hash skips the write", () => {
+    const hash = recordConversationToolSurface("conv-1", SURFACE);
+    const before = storedRow()!.updated_at;
+    sqlite
+      .query(
+        `UPDATE conversation_tool_surfaces SET updated_at = ? WHERE conversation_id = ?`,
+      )
+      .run(before - 1000, "conv-1");
+
+    recordConversationToolSurface("conv-1", SURFACE, hash);
+
+    expect(storedRow()!.updated_at).toBe(before - 1000);
+  });
+
+  test("an unchanged surface with no known hash compares against the stored row before writing", () => {
+    recordConversationToolSurface("conv-1", SURFACE);
+    const marker = 42;
+    sqlite
+      .query(
+        `UPDATE conversation_tool_surfaces SET updated_at = ? WHERE conversation_id = ?`,
+      )
+      .run(marker, "conv-1");
+
+    // A freshly loaded conversation knows no hash yet; the stored row matches,
+    // so nothing is rewritten.
+    recordConversationToolSurface("conv-1", SURFACE, undefined);
+
+    expect(storedRow()!.updated_at).toBe(marker);
+  });
+
+  test("a changed array overwrites the stored surface", () => {
+    const first = recordConversationToolSurface("conv-1", SURFACE);
+    const changed = { ...SURFACE, tools: TOOLS.slice(0, 1) };
+
+    const second = recordConversationToolSurface("conv-1", changed, first);
+
+    expect(second).not.toBe(first);
+    expect(storedRow()?.tools_hash).toBe(second);
+    expect(getConversationToolSurface("conv-1")).toEqual(changed);
+  });
+
+  test("a change to the delegation-section state alone overwrites it too", () => {
+    // The state is part of the hash: a turn whose scope flips the section
+    // (a background run's allowlist after an interactive turn) records it.
+    const first = recordConversationToolSurface("conv-1", SURFACE);
+    const changed = { ...SURFACE, delegateIndependentTasks: false };
+
+    const second = recordConversationToolSurface("conv-1", changed, first);
+
+    expect(second).not.toBe(first);
+    expect(storedRow()?.tools_hash).toBe(second);
+    expect(getConversationToolSurface("conv-1")).toEqual(changed);
+  });
+
+  test("a row recorded before the state existed reads unknown and is replaced on the next record", () => {
+    sqlite
+      .query(
+        /*sql*/ `INSERT INTO conversation_tool_surfaces (conversation_id, tools_json, tools_hash, updated_at) VALUES (?, ?, ?, ?)`,
+      )
+      .run("conv-1", JSON.stringify(TOOLS), "pre-upgrade-hash", 1);
+
+    expect(getConversationToolSurface("conv-1")).toEqual({
+      tools: TOOLS,
+      delegateIndependentTasks: null,
+    });
+
+    // The stored hash predates the state, so the next live turn's record
+    // rewrites the row with it.
+    const hash = recordConversationToolSurface("conv-1", SURFACE, undefined);
+
+    expect(storedRow()?.tools_hash).toBe(hash);
+    expect(getConversationToolSurface("conv-1")).toEqual(SURFACE);
+  });
+});
+
+describe("getConversationToolSurface", () => {
+  test("returns null when no turn has recorded a surface", () => {
+    expect(getConversationToolSurface("conv-1")).toBeNull();
+  });
+
+  test("returns null for an unreadable stored payload", () => {
+    sqlite
+      .query(
+        /*sql*/ `INSERT INTO conversation_tool_surfaces (conversation_id, tools_json, tools_hash, updated_at) VALUES (?, ?, ?, ?)`,
+      )
+      .run("conv-1", "not json", "h", 1);
+
+    expect(getConversationToolSurface("conv-1")).toBeNull();
+  });
+
+  test("the row cascades with its conversation", () => {
+    recordConversationToolSurface("conv-1", SURFACE);
+
+    sqlite.query(`DELETE FROM conversations WHERE id = ?`).run("conv-1");
+
+    expect(getConversationToolSurface("conv-1")).toBeNull();
+  });
+});
+
+describe("plugin facade", () => {
+  test("the array accessor is a projection of the recorded surface", async () => {
+    expect(await getConversationToolSurfaceViaPluginApi("conv-1")).toBeNull();
+    expect(await getRecordedConversationToolSurface("conv-1")).toBeNull();
+
+    recordConversationToolSurface("conv-1", SURFACE);
+
+    expect(await getRecordedConversationToolSurface("conv-1")).toEqual(SURFACE);
+    // The array shape the public `@vellumai/plugin-api` accessor returns.
+    expect(await getConversationToolSurfaceViaPluginApi("conv-1")).toEqual(
+      TOOLS,
+    );
+  });
+});

package/src/__tests__/events-tail-route.test.ts

@@ -85,6 +85,39 @@ describe("GET events/tail", () => {
     expect(body.frontier).toBe(5);
   });
 
+  test("returns terminal attachment provenance without rewriting the event", () => {
+    stampAndBuffer(
+      mkEvent({
+        message: {
+          type: "message_complete",
+          conversationId: CONV,
+          messageId: "reply-1",
+          attachments: [
+            {
+              id: "screenshot-1",
+              filename: "computer-use-click.png",
+              mimeType: "image/png",
+              data: "c2NyZWVuc2hvdA==",
+              computerUseScreenshot: true,
+            },
+          ],
+        },
+      }),
+    );
+
+    const body = callTail({ conversationId: CONV, fromSeq: "0" });
+
+    expect(body.events[0]?.message).toMatchObject({
+      type: "message_complete",
+      attachments: [
+        {
+          id: "screenshot-1",
+          computerUseScreenshot: true,
+        },
+      ],
+    });
+  });
+
   test("an up-to-date anchor yields an empty but complete tail", () => {
     // GIVEN three buffered events (seq 1..3)
     for (let i = 0; i < 3; i++) {

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

@@ -643,6 +643,59 @@ describe("repairHistory", () => {
     ]);
   });
 
+  test("deferred mixed tail answered by a tool_result plus trailing text gets a synthetic result", () => {
+    // Text after the client result closes the assistant turn on the provider
+    // side, which then rejects the unanswered search as unpaired. The search
+    // is an orphan here, so the synthetic error result keeps the request
+    // valid at the cost of that one search. `deepRepairHistory` is the loop's
+    // recovery path for that rejection.
+    const messages: Message[] = [
+      { role: "user", content: [{ type: "text", text: "Check both" }] },
+      {
+        role: "assistant",
+        content: [
+          { type: "tool_use", id: "tu_a", name: "web_fetch", input: {} },
+          {
+            type: "server_tool_use",
+            id: "stu_deferred",
+            name: "web_search",
+            input: { query: "news" },
+          },
+        ],
+      },
+      {
+        role: "user",
+        content: [
+          {
+            type: "tool_result",
+            tool_use_id: "tu_a",
+            content: "Error: HTTP 404",
+            is_error: true,
+          },
+          { type: "text", text: "<system_notice>retry</system_notice>" },
+        ],
+      },
+    ];
+
+    const { messages: repaired, stats } = deepRepairHistory(messages);
+
+    expect(stats.missingToolResultsInserted).toBe(1);
+    expect(repaired).toHaveLength(3);
+    expect(repaired[1].content.map((b) => b.type)).toEqual([
+      "tool_use",
+      "server_tool_use",
+      "web_search_tool_result",
+    ]);
+    expect(repaired[1].content[2]).toMatchObject({
+      type: "web_search_tool_result",
+      tool_use_id: "stu_deferred",
+    });
+    expect(repaired[2].content.map((b) => b.type)).toEqual([
+      "tool_result",
+      "text",
+    ]);
+  });
+
   test("cross-message server tool pair from a completed deferred execution survives a reload untouched", () => {
     const messages: Message[] = [
       { role: "user", content: [{ type: "text", text: "Check both" }] },

package/src/__tests__/inference-profile-session-handler.test.ts

@@ -383,6 +383,32 @@ describe("setInferenceProfileSession", () => {
     );
   });
 
+  test("open with a non-text catalog model — refuses the pin", async () => {
+    const conv = createConversation("sess-handler-jev-profile");
+    setConfig("llm", {
+      profiles: {
+        jev: {
+          source: "user",
+          provider: "jev",
+          model: "jev-latest",
+          status: "active",
+        },
+      },
+    });
+    try {
+      const promise = setInferenceProfileSession({
+        conversationId: conv.id,
+        profile: "jev",
+      });
+      await expect(promise).rejects.toThrow(
+        /structured answers rather than chat text/,
+      );
+      expect(getConversation(conv.id)?.inferenceProfile).toBeNull();
+    } finally {
+      setConfig("llm", {});
+    }
+  });
+
   test("open with an unavailable profile — refuses the pin and names the fix", async () => {
     const conv = createConversation("sess-handler-unavailable-profile");
     managedProxyEnabled = false;

package/src/__tests__/list-messages-tool-merge.test.ts

@@ -14,10 +14,17 @@ import { setConfig } from "./helpers/set-config.js";
 // background indexing kicks in.
 setConfig("memory", { enabled: false, v2: { enabled: false } });
 
+import {
+  linkAttachmentToMessage,
+  uploadAttachment,
+} from "../persistence/attachments-store.js";
 import {
   addMessage,
   createConversation,
+  getMessageById,
+  updateMessageMetadata,
 } from "../persistence/conversation-crud.js";
+import { COMPUTER_USE_SCREENSHOT_ATTACHMENT_IDS_KEY } from "../persistence/conversation-types.js";
 import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
 import { handleListMessages } from "../runtime/routes/conversation-routes.js";
@@ -50,7 +57,15 @@ interface MessagePayload {
   toolCalls?: ToolCallPayload[];
   textSegments?: string[];
   contentOrder?: string[];
-  contentBlocks?: Array<{ type: string; [key: string]: unknown }>;
+  contentBlocks?: Array<{
+    type: string;
+    attachment?: { id: string; computerUseScreenshot?: boolean };
+    [key: string]: unknown;
+  }>;
+  attachments?: Array<{
+    id: string;
+    computerUseScreenshot?: boolean;
+  }>;
 }
 
 describe("handleListMessages tool_result merging", () => {
@@ -217,6 +232,75 @@ describe("handleListMessages tool_result merging", () => {
     });
   });
 
+  test("preserves donor automatic screenshot provenance during consolidation", async () => {
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([{ type: "text", text: "inspect this" }]),
+    );
+    const anchor = await addMessage(
+      conv.id,
+      "assistant",
+      JSON.stringify([{ type: "text", text: "Working." }]),
+      { metadata: { anchorContext: "kept" } },
+    );
+    const explicit = await uploadAttachment(
+      "notes.pdf",
+      "application/pdf",
+      "JVBERg==",
+    );
+    linkAttachmentToMessage(anchor.id, explicit.id, 0);
+
+    const donor = await addMessage(
+      conv.id,
+      "assistant",
+      JSON.stringify([{ type: "text", text: "Done." }]),
+    );
+    const screenshot = await uploadAttachment(
+      "computer-use-click.png",
+      "image/png",
+      "c2NyZWVuc2hvdA==",
+    );
+    linkAttachmentToMessage(donor.id, screenshot.id, 0);
+    updateMessageMetadata(donor.id, {
+      [COMPUTER_USE_SCREENSHOT_ATTACHMENT_IDS_KEY]: [screenshot.id],
+    });
+
+    const anchorBefore = getMessageById(anchor.id)?.metadata;
+    const donorBefore = getMessageById(donor.id)?.metadata;
+    const response = await handleListMessages(createTestArgs(conv.id));
+    const body = response as { messages: MessagePayload[] };
+    const merged = body.messages[1]!;
+
+    expect(merged.attachments?.map((attachment) => attachment.id)).toEqual([
+      explicit.id,
+      screenshot.id,
+    ]);
+    expect(merged.attachments?.[0]?.computerUseScreenshot).toBeUndefined();
+    expect(merged.attachments?.[1]?.computerUseScreenshot).toBe(true);
+    const attachmentBlocks = merged.contentBlocks?.filter(
+      (block) => block.type === "attachment",
+    );
+    expect(
+      attachmentBlocks?.map((block) =>
+        block.type === "attachment" ? block.attachment?.id : undefined,
+      ),
+    ).toEqual([explicit.id, screenshot.id]);
+    expect(
+      attachmentBlocks?.[0]?.type === "attachment"
+        ? attachmentBlocks[0].attachment?.computerUseScreenshot
+        : undefined,
+    ).toBeUndefined();
+    expect(
+      attachmentBlocks?.[1]?.type === "attachment"
+        ? attachmentBlocks[1].attachment?.computerUseScreenshot
+        : undefined,
+    ).toBe(true);
+    expect(getMessageById(anchor.id)?.metadata).toBe(anchorBefore);
+    expect(getMessageById(donor.id)?.metadata).toBe(donorBefore);
+  });
+
   test("orphan tool_result at pagination boundary is suppressed entirely", async () => {
     const conv = createConversation();
     // Orphan tool_result with no preceding assistant in this page. The

package/src/__tests__/llm-catalog-parity.test.ts

@@ -2,7 +2,9 @@ import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { describe, expect, test } from "bun:test";
 
+import { DEFAULT_PROVIDER_CHOICES } from "../config/schemas/llm.js";
 import {
+  catalogModelSupportsText,
   getCatalogProviderForModel,
   isModelInCatalog,
   PROVIDER_CATALOG,
@@ -56,6 +58,7 @@ interface ClientCatalogModel {
   supportsCaching?: boolean;
   supportsVision?: boolean;
   supportsToolUse?: boolean;
+  supportsText?: boolean;
   pricing?: {
     inputPer1mTokens: number;
     outputPer1mTokens: number;
@@ -204,6 +207,7 @@ describe("LLM catalog parity: daemon vs client", () => {
         expect(clientModel.supportsCaching).toBe(daemonModel.supportsCaching);
         expect(clientModel.supportsVision).toBe(daemonModel.supportsVision);
         expect(clientModel.supportsToolUse).toBe(daemonModel.supportsToolUse);
+        expect(clientModel.supportsText).toBe(daemonModel.supportsText);
         expect(clientModel.pricing).toEqual(daemonModel.pricing);
         expect(clientModel.featureFlag).toBe(daemonModel.featureFlag);
       }
@@ -229,6 +233,16 @@ describe("LLM catalog parity: daemon vs client", () => {
     }
   });
 
+  test("jev-latest opts out of chat text generation", () => {
+    expect(catalogModelSupportsText("jev", "jev-latest")).toBe(false);
+    expect(catalogModelSupportsText("anthropic", "claude-opus-4-8")).toBe(true);
+    expect(catalogModelSupportsText("openai-compatible", "local-model")).toBe(
+      true,
+    );
+    expect(DEFAULT_PROVIDER_CHOICES).not.toContain("jev");
+    expect(DEFAULT_PROVIDER_CHOICES).toContain("poolside");
+  });
+
   test("cache pricing rates are positive when defined", () => {
     for (const entry of PROVIDER_CATALOG) {
       for (const model of entry.models) {
@@ -252,7 +266,9 @@ describe("LLM catalog parity: daemon vs client", () => {
   });
 
   test("OpenRouter supportsCaching requires cache-read pricing", () => {
-    const openrouter = PROVIDER_CATALOG.find((entry) => entry.id === "openrouter");
+    const openrouter = PROVIDER_CATALOG.find(
+      (entry) => entry.id === "openrouter",
+    );
     expect(openrouter).toBeDefined();
 
     for (const model of openrouter!.models) {
@@ -266,7 +282,9 @@ describe("LLM catalog parity: daemon vs client", () => {
   });
 
   test("OpenRouter cache-read pricing implies supportsCaching except xAI", () => {
-    const openrouter = PROVIDER_CATALOG.find((entry) => entry.id === "openrouter");
+    const openrouter = PROVIDER_CATALOG.find(
+      (entry) => entry.id === "openrouter",
+    );
     expect(openrouter).toBeDefined();
 
     for (const model of openrouter!.models) {
@@ -288,7 +306,9 @@ describe("LLM catalog parity: daemon vs client", () => {
   });
 
   test("OpenRouter catalog drops ids OpenRouter no longer serves", () => {
-    const openrouter = PROVIDER_CATALOG.find((entry) => entry.id === "openrouter");
+    const openrouter = PROVIDER_CATALOG.find(
+      (entry) => entry.id === "openrouter",
+    );
     expect(openrouter).toBeDefined();
     const ids = new Set(openrouter!.models.map((model) => model.id));
     expect(ids.has("deepseek/deepseek-v3.2-speciale")).toBe(false);
@@ -554,7 +574,10 @@ describe("LLM catalog parity: daemon vs client", () => {
 
   test("forced tool choice with thinking is scoped to OpenRouter Kimi K2.6", () => {
     expect(
-      supportsForcedToolChoiceWithThinking("openrouter", "moonshotai/kimi-k2.6"),
+      supportsForcedToolChoiceWithThinking(
+        "openrouter",
+        "moonshotai/kimi-k2.6",
+      ),
     ).toBe(false);
     expect(
       supportsForcedToolChoiceWithThinking(

package/src/__tests__/oauth-apps-routes.test.ts

@@ -75,6 +75,7 @@ mock.module("../oauth/oauth-store.js", () => ({
           identityBody: null,
           identityFormat: null,
           identityOkField: null,
+          responseOkField: null,
           featureFlag: null,
           createdAt: 1735689500000,
           updatedAt: 1735689550000,