@vellumai/assistant 0.12.2 → 0.12.3-staging.2

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: "typesafe",
+          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__/interrupt-on-send.test.ts

@@ -21,6 +21,7 @@ import {
   abortedToolResultText,
   CANCELLED_TOOL_RESULT_TEXT,
   createAbortReason,
+  INTERRUPTED_TURN_NOTE_TEXT,
   PREEMPTED_TOOL_RESULT_TEXT,
 } from "../util/abort-reasons.js";
 
@@ -378,8 +379,8 @@ describe("interruptRunningTurn", () => {
 
   test("arms the interrupted-turn note when the abort caught no tool call", async () => {
     // The abort landed during the provider call, so there is no `tool_use` to
-    // answer and nothing in the history says the turn was cut off. The note
-    // rides on the interrupting user message instead.
+    // answer. The note on the interrupting user message is the only thing that
+    // tells the model what happened.
     const turn = registerBusyTurn({
       messages: [
         { role: "user", content: [{ type: "text", text: "research this" }] },
@@ -393,9 +394,9 @@ describe("interruptRunningTurn", () => {
     expect(persisted).toEqual([]);
   });
 
-  test("leaves the note disarmed when the repair answered a tool call", async () => {
-    // The preempted `tool_result` already tells the model a message cut it
-    // off, so repeating that in a note on the message is noise.
+  test("arms the note alongside the fact-only result of a stopped tool call", async () => {
+    // The two texts do different jobs: the `tool_result` states what happened
+    // to that one call, the note says what to do about the interruption.
     const turn = registerBusyTurn({
       messages: [assistantWithToolUse("tool-1")],
     });
@@ -404,13 +405,36 @@ describe("interruptRunningTurn", () => {
 
     expect(persisted).toHaveLength(1);
     expect(persisted[0].content).toContain(PREEMPTED_TOOL_RESULT_TEXT);
-    expect(turn.conversation.pendingInterruptNote).toBe(false);
+    expect(turn.conversation.pendingInterruptNote).toBe(true);
+  });
+
+  test("arms exactly one note however many parallel calls were stopped", async () => {
+    // Every stopped call gets its own fact-only result; the behavior
+    // instruction is read once, off the interrupting message.
+    const turn = registerBusyTurn({
+      messages: [assistantWithToolUse("tool-1", "tool-2", "tool-3")],
+    });
+
+    await interruptRunningTurn(turn.conversation, { origin: "test" });
+
+    const results = JSON.parse(persisted[0].content) as Array<{
+      tool_use_id: string;
+      content: string;
+    }>;
+    expect(results.map((block) => block.tool_use_id)).toEqual([
+      "tool-1",
+      "tool-2",
+      "tool-3",
+    ]);
+    for (const block of results) {
+      expect(block.content).toBe(PREEMPTED_TOOL_RESULT_TEXT);
+    }
+    expect(turn.conversation.pendingInterruptNote).toBe(true);
   });
 
-  test("leaves the note disarmed when the loop wrote its own preempted result", async () => {
+  test("arms the note when the loop wrote its own preempted result", async () => {
     // The agent loop's abort handler unwound cleanly and answered the batch
-    // itself, so the repair finds nothing to do and the notice is already
-    // there.
+    // itself, so the repair finds nothing to do. The note is owed all the same.
     const turn = registerBusyTurn({
       messages: [
         assistantWithToolUse("tool-1"),
@@ -421,12 +445,10 @@ describe("interruptRunningTurn", () => {
     await interruptRunningTurn(turn.conversation, { origin: "test" });
 
     expect(persisted).toEqual([]);
-    expect(turn.conversation.pendingInterruptNote).toBe(false);
+    expect(turn.conversation.pendingInterruptNote).toBe(true);
   });
 
   test("arms the note when the cut-off tool call was an ordinary cancel", async () => {
-    // A tail answered with the plain cancel wording is a stop the user made
-    // earlier, not this interrupt's notice, so the note is still owed.
     const turn = registerBusyTurn({
       messages: [
         assistantWithToolUse("tool-1"),
@@ -633,6 +655,9 @@ describe("interruptRunningTurn", () => {
     // Armed instead, so the drain that runs the queued message repairs it.
     expect(turn.conversation.pendingInterruptRepair).toBe(true);
     expect(turn.activityEvents).toEqual([]);
+    // The message joins the queue rather than replacing the turn, so it is not
+    // the message that interrupted anything and carries no note.
+    expect(turn.conversation.pendingInterruptNote).toBe(false);
   });
 
   test("a second interrupt stops the turn the first one started", async () => {
@@ -932,7 +957,7 @@ describe("repairInterruptedToolUseBlocks", () => {
     } as unknown as Conversation;
   }
 
-  test("writes one result per abandoned call, worded for a preemption", async () => {
+  test("writes one fact-only result per abandoned call", async () => {
     const messages: Message[] = [assistantWithToolUse("tool-1", "tool-2")];
 
     await repairInterruptedToolUseBlocks(fakeConversation(messages), {
@@ -961,31 +986,6 @@ describe("repairInterruptedToolUseBlocks", () => {
     );
   });
 
-  test("reports the preempted result it wrote", async () => {
-    const messages: Message[] = [assistantWithToolUse("tool-1")];
-
-    const result = await repairInterruptedToolUseBlocks(
-      fakeConversation(messages),
-      { force: true },
-    );
-
-    expect(result.preemptedToolResultOnTail).toBe(true);
-  });
-
-  test("reports no preempted result on a history that ends on plain text", async () => {
-    const messages: Message[] = [
-      { role: "user", content: [{ type: "text", text: "hi" }] },
-      { role: "assistant", content: [{ type: "text", text: "hello" }] },
-    ];
-
-    const result = await repairInterruptedToolUseBlocks(
-      fakeConversation(messages),
-      { force: true },
-    );
-
-    expect(result.preemptedToolResultOnTail).toBe(false);
-  });
-
   test("adds nothing when the loop already wrote its own results", async () => {
     // The agent loop's abort handler synthesizes results of its own when it
     // unwinds cleanly, so exactly one result per call exists either way.
@@ -994,14 +994,12 @@ describe("repairInterruptedToolUseBlocks", () => {
       toolResult("tool-1", PREEMPTED_TOOL_RESULT_TEXT),
     ];
 
-    const result = await repairInterruptedToolUseBlocks(
-      fakeConversation(messages),
-      { force: true },
-    );
+    await repairInterruptedToolUseBlocks(fakeConversation(messages), {
+      force: true,
+    });
 
     expect(messages).toHaveLength(2);
     expect(persisted).toEqual([]);
-    expect(result.preemptedToolResultOnTail).toBe(true);
   });
 
   test("does nothing on a history that ends on an ordinary assistant reply", async () => {
@@ -1083,3 +1081,19 @@ describe("abortedToolResultText", () => {
     );
   });
 });
+
+describe("the interrupt texts", () => {
+  test("the tool result states the fact and nothing more", () => {
+    // Repeated once per stopped call in a parallel batch, so an instruction
+    // here is read as many times as the batch was wide.
+    expect(PREEMPTED_TOOL_RESULT_TEXT).toBe(
+      "Stopped early because the user sent a new message. This call may have completed anyway; check before repeating it.",
+    );
+  });
+
+  test("the note carries the behavior and leads with the reply", () => {
+    expect(INTERRUPTED_TURN_NOTE_TEXT).toBe(
+      "<interrupted_turn>The user sent this while you were still working, so that work stopped. Reply right away, in a line or two, before any more thinking or tool calls, so the user knows you heard them. Then pick the earlier work back up only if it is still wanted. Never apologize for or mention the interruption.</interrupted_turn>",
+    );
+  });
+});

package/src/__tests__/interrupt-turn-note.test.ts

@@ -1,10 +1,9 @@
 /**
- * An interrupt whose abort landed during the provider call leaves no
- * `tool_use` to answer, so nothing in the history tells the model its turn was
- * cut off. The interrupting user message carries the notice instead, on its
- * LLM-facing content only: the persisted row stays exactly what the user
- * typed, so no client renders it, and `interruptedPriorTurn` in the row's
- * metadata is what rebuilds the identical block on every later load.
+ * The message that interrupted a turn carries the note saying what to do about
+ * the interruption, on its LLM-facing content only: the persisted row stays
+ * exactly what the user typed, so no client renders it, and
+ * `interruptedPriorTurn` in the row's metadata is what rebuilds the identical
+ * block on every later load.
  */
 import { beforeEach, describe, expect, test } from "bun:test";
 

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("typesafe", "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("typesafe");
+    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__/media-generate-image.test.ts

@@ -21,6 +21,7 @@ import { setConfig } from "./helpers/set-config.js";
 
 let mockGeminiKey: string | undefined = "test-gemini-key";
 let mockOpenAIKey: string | undefined = "test-openai-key";
+let mockOpenRouterKey: string | undefined = "test-openrouter-key";
 let mockGenerateResult = {
   images: [{ mimeType: "image/png", dataBase64: "generated-data" }],
   text: "A beautiful image",
@@ -40,7 +41,7 @@ let mockGenerateDelayMs = 0;
  */
 function seedImageGenService(
   overrides: {
-    provider?: "vellum" | "gemini" | "openai";
+    provider?: "vellum" | "gemini" | "openai" | "openrouter";
     model?: string;
   } = {},
 ): void {
@@ -64,6 +65,9 @@ mock.module("../security/secure-keys.js", () => ({
     if (provider === "openai") {
       return mockOpenAIKey;
     }
+    if (provider === "openrouter") {
+      return mockOpenRouterKey;
+    }
     return undefined;
   },
 }));
@@ -143,6 +147,7 @@ const CONFIG_DIR = join(
 beforeEach(() => {
   mockGeminiKey = "test-gemini-key";
   mockOpenAIKey = "test-openai-key";
+  mockOpenRouterKey = "test-openrouter-key";
   seedImageGenService();
   mockGenerateResult = {
     images: [{ mimeType: "image/png", dataBase64: "generated-data" }],
@@ -308,6 +313,49 @@ describe("image-studio skill script wrapper", () => {
     expect(result.content).not.toContain("No Gemini API key");
   });
 
+  test("OpenRouter accepts an arbitrary slug and keeps OpenRouter ownership", async () => {
+    seedImageGenService({
+      provider: "openrouter",
+      model: "google/gemini-3.1-flash-image-preview",
+    });
+
+    const result = await run(
+      { prompt: "a nebula", model: "black-forest-labs/flux" },
+      fakeContext,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(lastGenerateProvider).toBe("openrouter");
+    expect(lastGenerateCredentials).toEqual({
+      type: "direct",
+      apiKey: "test-openrouter-key",
+    });
+    expect(lastGenerateRequest?.model).toBe("black-forest-labs/flux");
+  });
+
+  test("OpenRouter qualifies a built-in alias and keeps OpenRouter ownership", async () => {
+    seedImageGenService({ provider: "openrouter" });
+
+    const result = await run({ prompt: "a robot", model: "openai" }, fakeContext);
+
+    expect(result.isError).toBe(false);
+    expect(lastGenerateProvider).toBe("openrouter");
+    expect(lastGenerateRequest?.model).toBe("openai/gpt-image-2");
+  });
+
+  test("OpenRouter returns a missing-key hint without falling back to Gemini", async () => {
+    seedImageGenService({ provider: "openrouter" });
+    mockOpenRouterKey = undefined;
+    mockGeminiKey = "gemini-key-should-not-be-used";
+
+    const result = await run({ prompt: "a cat" }, fakeContext);
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("OpenRouter API key");
+    expect(result.content).not.toContain("No Gemini API key");
+    expect(lastGenerateProvider).toBeNull();
+  });
+
   test("explicit model override routes to owning provider (gemini config → openai call)", async () => {
     // Config says the user's default provider is gemini, but the LLM
     // explicitly requests a gpt-* model. The tool must dispatch to OpenAI

package/src/__tests__/message-provenance-contact-id.test.ts

@@ -0,0 +1,69 @@
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { actorAuthorProvenance } from "../daemon/message-provenance.js";
+import type { TrustContext } from "../daemon/trust-context-types.js";
+import {
+  addMessage,
+  createConversation,
+  getMessageById,
+  parseMessageMetadata,
+  provenanceFromTrustContext,
+} from "../persistence/conversation-crud.js";
+import { getDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+
+await initializeDb();
+
+const ALICE: TrustContext = {
+  sourceChannel: "slack",
+  trustClass: "trusted_contact",
+  requesterIdentifier: "@alice",
+  requesterContactId: "contact-alice",
+};
+
+async function persistWith(
+  role: "user" | "assistant",
+  metadata: Record<string, unknown>,
+): Promise<ReturnType<typeof parseMessageMetadata>> {
+  const conversation = createConversation("provenance-contact-id");
+  const row = await addMessage(conversation.id, role, "hello", { metadata });
+  const stored = getMessageById(row.id, conversation.id);
+  return parseMessageMetadata(stored?.metadata ?? null);
+}
+
+describe("message provenance contact id", () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run(`DELETE FROM messages`);
+    db.run(`DELETE FROM conversations`);
+  });
+
+  test("a person's own row names them as its author", async () => {
+    const metadata = await persistWith("user", {
+      ...provenanceFromTrustContext(ALICE),
+      ...actorAuthorProvenance(ALICE),
+    });
+
+    expect(metadata?.provenanceTrustClass).toBe("trusted_contact");
+    expect(metadata?.provenanceContactId).toBe("contact-alice");
+  });
+
+  test("a row written during their turn carries the turn's trust but no author", async () => {
+    // The assistant's replies, tool results, and notices are stamped with the
+    // turn's provenance alone.
+    const metadata = await persistWith(
+      "assistant",
+      provenanceFromTrustContext(ALICE),
+    );
+
+    expect(metadata?.provenanceTrustClass).toBe("trusted_contact");
+    expect(metadata?.provenanceContactId).toBeUndefined();
+  });
+
+  test("an actor with no resolved contact names no author", () => {
+    expect(
+      actorAuthorProvenance({ sourceChannel: "slack", trustClass: "unknown" }),
+    ).toEqual({});
+    expect(actorAuthorProvenance(undefined)).toEqual({});
+  });
+});