@vellumai/assistant 0.12.3-staging.1 → 0.12.3-staging.2

package/src/__tests__/image-credentials.test.ts

@@ -136,6 +136,34 @@ describe("resolveImageGenCredentials", () => {
       expect(result.errorHint).toBeDefined();
       expect(result.errorHint).toContain("OpenAI API key");
     });
+
+    test("returns direct credentials for openrouter when key is present", async () => {
+      mockProviderKey = "openrouter-api-key";
+
+      const result = await resolveImageGenCredentials({
+        provider: "openrouter",
+        managed: false,
+      });
+
+      expect(result.errorHint).toBeUndefined();
+      expect(result.credentials).toEqual({
+        type: "direct",
+        apiKey: "openrouter-api-key",
+      });
+    });
+
+    test("returns errorHint mentioning 'OpenRouter API key' when no key is set", async () => {
+      mockProviderKey = undefined;
+
+      const result = await resolveImageGenCredentials({
+        provider: "openrouter",
+        managed: false,
+      });
+
+      expect(result.credentials).toBeUndefined();
+      expect(result.errorHint).toBeDefined();
+      expect(result.errorHint).toContain("OpenRouter API key");
+    });
   });
 });
 
@@ -173,6 +201,27 @@ describe("resolveImageGenRouting", () => {
     ).toEqual({ backendProvider: "openai", managed: false });
   });
 
+  test("OpenRouter keeps ownership for google/ and openai/ slugs", () => {
+    expect(
+      resolveImageGenRouting({
+        provider: "openrouter",
+        model: "google/gemini-3.1-flash-image-preview",
+      }),
+    ).toEqual({ backendProvider: "openrouter", managed: false });
+    expect(
+      resolveImageGenRouting(
+        { provider: "openrouter", model: "google/gemini-3.1-flash-image-preview" },
+        "openai/gpt-image-2",
+      ),
+    ).toEqual({ backendProvider: "openrouter", managed: false });
+    expect(
+      resolveImageGenRouting(
+        { provider: "openrouter", model: "google/gemini-3.1-flash-image-preview" },
+        "gpt-image-2",
+      ),
+    ).toEqual({ backendProvider: "openrouter", managed: false });
+  });
+
   test("vellum with an unavailable platform is a hard error, not a BYOK fallback", async () => {
     // Billing rule: an explicit vellum choice never silently spends a stored
     // provider key.

package/src/__tests__/image-service-dispatcher.test.ts

@@ -17,8 +17,10 @@ interface GenerateCall {
 
 let geminiCalls: GenerateCall[] = [];
 let openaiCalls: GenerateCall[] = [];
+let openrouterCalls: GenerateCall[] = [];
 let geminiErrorCalls: unknown[] = [];
 let openaiErrorCalls: unknown[] = [];
+let openrouterErrorCalls: unknown[] = [];
 
 let geminiResult: ImageGenerationResult = {
   images: [],
@@ -28,6 +30,10 @@ let openaiResult: ImageGenerationResult = {
   images: [],
   resolvedModel: "openai-mock",
 };
+let openrouterResult: ImageGenerationResult = {
+  images: [],
+  resolvedModel: "openrouter-mock",
+};
 
 // ---------------------------------------------------------------------------
 // Mock underlying services — must run before the module under test is imported
@@ -61,6 +67,20 @@ mock.module("../media/openai-image-service.js", () => ({
   },
 }));
 
+mock.module("../media/openrouter-image-service.js", () => ({
+  generateImageOpenRouter: async (
+    credentials: ImageGenCredentials,
+    request: ImageGenerationRequest,
+  ): Promise<ImageGenerationResult> => {
+    openrouterCalls.push({ credentials, request });
+    return openrouterResult;
+  },
+  mapOpenRouterError: (error: unknown): string => {
+    openrouterErrorCalls.push(error);
+    return "openrouter-mapped";
+  },
+}));
+
 // Import after mocking
 import {
   generateImage,
@@ -90,8 +110,10 @@ describe("image-service dispatcher", () => {
   beforeEach(() => {
     geminiCalls = [];
     openaiCalls = [];
+    openrouterCalls = [];
     geminiErrorCalls = [];
     openaiErrorCalls = [];
+    openrouterErrorCalls = [];
     geminiResult = {
       images: [{ mimeType: "image/png", dataBase64: "gemini-bytes" }],
       resolvedModel: "gemini-3.1-flash-image-preview",
@@ -100,6 +122,10 @@ describe("image-service dispatcher", () => {
       images: [{ mimeType: "image/png", dataBase64: "openai-bytes" }],
       resolvedModel: "gpt-image-2",
     };
+    openrouterResult = {
+      images: [{ mimeType: "image/png", dataBase64: "openrouter-bytes" }],
+      resolvedModel: "google/gemini-3.1-flash-image-preview",
+    };
   });
 
   test("generateImage('gemini', ...) delegates to the Gemini implementation", async () => {
@@ -131,6 +157,17 @@ describe("image-service dispatcher", () => {
     expect(mapped).toBe("gemini-mapped");
   });
 
+  test("generateImage('openrouter', ...) delegates to the OpenRouter implementation", async () => {
+    const result = await generateImage("openrouter", directCreds, request);
+
+    expect(openrouterCalls).toHaveLength(1);
+    expect(openrouterCalls[0]?.credentials).toBe(directCreds);
+    expect(openrouterCalls[0]?.request).toBe(request);
+    expect(geminiCalls).toHaveLength(0);
+    expect(openaiCalls).toHaveLength(0);
+    expect(result).toEqual(openrouterResult);
+  });
+
   test("mapImageGenError('openai', err) delegates to mapOpenAIError", () => {
     const err = new Error("kapow");
     const mapped = mapImageGenError("openai", err);
@@ -139,6 +176,14 @@ describe("image-service dispatcher", () => {
     expect(geminiErrorCalls).toEqual([]);
     expect(mapped).toBe("openai-mapped");
   });
+
+  test("mapImageGenError('openrouter', err) delegates to mapOpenRouterError", () => {
+    const err = new Error("or-boom");
+    const mapped = mapImageGenError("openrouter", err);
+
+    expect(openrouterErrorCalls).toEqual([err]);
+    expect(mapped).toBe("openrouter-mapped");
+  });
 });
 
 describe("providerForModel", () => {

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

@@ -389,7 +389,7 @@ describe("setInferenceProfileSession", () => {
       profiles: {
         jev: {
           source: "user",
-          provider: "jev",
+          provider: "typesafe",
           model: "jev-latest",
           status: "active",
         },

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__/llm-catalog-parity.test.ts

@@ -234,12 +234,12 @@ 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("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("jev");
+    expect(DEFAULT_PROVIDER_CHOICES).not.toContain("typesafe");
     expect(DEFAULT_PROVIDER_CHOICES).toContain("poolside");
   });
 

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