@vellumai/assistant 0.6.5 → 0.6.6

package/src/cli/commands/__tests__/image-generation.test.ts

@@ -11,6 +11,7 @@
  *   - Edit mode with --source (source images passed through)
  *   - --variants passed through
  *   - --model override
+ *   - Provider dispatch (gemini vs openai)
  */
 
 import { existsSync, readFileSync } from "node:fs";
@@ -29,15 +30,12 @@ let mockConfig = {
   services: {
     "image-generation": {
       mode: "your-own" as "managed" | "your-own",
-      provider: "gemini" as const,
+      provider: "gemini" as "gemini" | "openai",
       model: "gemini-3.1-flash-image-preview",
     },
   },
 };
 
-/** Result returned by buildManagedBaseUrl() */
-let mockManagedBaseUrl: string | undefined = undefined;
-
 /** Context returned by resolveManagedProxyContext() */
 let mockManagedProxyContext = {
   enabled: false,
@@ -45,8 +43,8 @@ let mockManagedProxyContext = {
   assistantApiKey: "",
 };
 
-/** Key returned by getProviderKeyAsync() */
-let mockProviderKey: string | undefined = undefined;
+/** Key returned by getProviderKeyAsync(). Keyed by provider. */
+let mockProviderKeys: Record<string, string | undefined> = {};
 
 /** Result returned by generateImage() */
 let mockGenerateResult: {
@@ -68,6 +66,7 @@ let mockGenerateError: Error | undefined = undefined;
 
 /** Captured generateImage call args */
 let lastGenerateCall: {
+  provider: unknown;
   credentials: unknown;
   request: unknown;
 } | null = null;
@@ -82,24 +81,35 @@ mock.module("../../../config/loader.js", () => ({
 }));
 
 mock.module("../../../providers/managed-proxy/context.js", () => ({
-  buildManagedBaseUrl: async () => mockManagedBaseUrl,
   resolveManagedProxyContext: async () => mockManagedProxyContext,
 }));
 
 mock.module("../../../security/secure-keys.js", () => ({
-  getProviderKeyAsync: async () => mockProviderKey,
+  getProviderKeyAsync: async (provider: string) => mockProviderKeys[provider],
 }));
 
-mock.module("../../../media/gemini-image-service.js", () => ({
-  generateImage: async (credentials: unknown, request: unknown) => {
-    lastGenerateCall = { credentials, request };
+mock.module("../../../media/image-service.js", () => ({
+  generateImage: async (
+    provider: unknown,
+    credentials: unknown,
+    request: unknown,
+  ) => {
+    lastGenerateCall = { provider, credentials, request };
     if (mockGenerateError) throw mockGenerateError;
     return mockGenerateResult;
   },
-  mapGeminiError: (error: unknown) => {
-    if (error instanceof Error) return `Mapped error: ${error.message}`;
+  mapImageGenError: (provider: unknown, error: unknown) => {
+    if (error instanceof Error)
+      return `Mapped error (${String(provider)}): ${error.message}`;
     return "An unexpected error occurred during image generation.";
   },
+  providerForModel: (model: string | undefined, fallback: string) => {
+    if (!model) return fallback;
+    if (model.startsWith("gpt-") || model.startsWith("dall-e-"))
+      return "openai";
+    if (model.startsWith("gemini-")) return "gemini";
+    return fallback;
+  },
 }));
 
 mock.module("../../../util/logger.js", () => ({
@@ -188,13 +198,12 @@ beforeEach(() => {
       },
     },
   };
-  mockManagedBaseUrl = undefined;
   mockManagedProxyContext = {
     enabled: false,
     platformBaseUrl: "",
     assistantApiKey: "",
   };
-  mockProviderKey = undefined;
+  mockProviderKeys = {};
   mockGenerateResult = {
     images: [
       {
@@ -221,6 +230,10 @@ describe("help text", () => {
     expect(stdout).toContain("your-own");
     expect(stdout).toContain("Examples:");
     expect(stdout).toContain("generate");
+    // Both providers mentioned and gpt-image-2 listed as a supported model.
+    expect(stdout).toContain("Gemini");
+    expect(stdout).toContain("OpenAI");
+    expect(stdout).toContain("gpt-image-2");
   });
 
   test("image-generation generate --help renders argument docs and examples", async () => {
@@ -245,7 +258,7 @@ describe("help text", () => {
 
 describe("required arguments", () => {
   test("generate requires --prompt", async () => {
-    mockProviderKey = "test-key";
+    mockProviderKeys.gemini = "test-key";
     const { exitCode } = await runCommand(["image-generation", "generate"]);
     expect(exitCode).not.toBe(0);
   });
@@ -258,7 +271,7 @@ describe("required arguments", () => {
 describe("credential errors", () => {
   test("exits with code 1 when no credentials in your-own mode", async () => {
     mockConfig.services["image-generation"].mode = "your-own";
-    mockProviderKey = undefined;
+    mockProviderKeys.gemini = undefined;
 
     const { exitCode } = await runCommand([
       "image-generation",
@@ -271,7 +284,6 @@ describe("credential errors", () => {
 
   test("exits with code 1 when no credentials in managed mode", async () => {
     mockConfig.services["image-generation"].mode = "managed";
-    mockManagedBaseUrl = undefined;
 
     const { exitCode } = await runCommand([
       "image-generation",
@@ -282,9 +294,10 @@ describe("credential errors", () => {
     expect(exitCode).toBe(1);
   });
 
-  test("--json outputs error when no credentials in your-own mode", async () => {
+  test("--json outputs error when no credentials in your-own mode (gemini)", async () => {
     mockConfig.services["image-generation"].mode = "your-own";
-    mockProviderKey = undefined;
+    mockConfig.services["image-generation"].provider = "gemini";
+    mockProviderKeys.gemini = undefined;
 
     const { exitCode, stdout } = await runCommand([
       "image-generation",
@@ -297,11 +310,34 @@ describe("credential errors", () => {
     const parsed = JSON.parse(stdout.trim());
     expect(parsed.ok).toBe(false);
     expect(parsed.error).toContain("Gemini API key");
+    // CLI prepends the actionable `assistant keys set` command with the
+    // resolved provider — the shared hint is UI-neutral ("Settings") so
+    // without this prefix CLI users get no copy-pasteable next step.
+    expect(parsed.error).toContain("Run: assistant keys set gemini <key>");
+  });
+
+  test("--json outputs OpenAI-specific hint when provider=openai and no key set", async () => {
+    mockConfig.services["image-generation"].mode = "your-own";
+    mockConfig.services["image-generation"].provider = "openai";
+    mockConfig.services["image-generation"].model = "gpt-image-2";
+    mockProviderKeys.openai = undefined;
+
+    const { exitCode, stdout } = await runCommand([
+      "image-generation",
+      "generate",
+      "--prompt",
+      "A sunset",
+      "--json",
+    ]);
+    expect(exitCode).toBe(1);
+    const parsed = JSON.parse(stdout.trim());
+    expect(parsed.ok).toBe(false);
+    expect(parsed.error).toContain("OpenAI API key");
+    expect(parsed.error).toContain("Run: assistant keys set openai <key>");
   });
 
   test("--json outputs error when no credentials in managed mode", async () => {
     mockConfig.services["image-generation"].mode = "managed";
-    mockManagedBaseUrl = undefined;
 
     const { exitCode, stdout } = await runCommand([
       "image-generation",
@@ -313,7 +349,39 @@ describe("credential errors", () => {
     expect(exitCode).toBe(1);
     const parsed = JSON.parse(stdout.trim());
     expect(parsed.ok).toBe(false);
+    // Base hint from image-credentials.ts is preserved.
     expect(parsed.error).toContain("Managed proxy");
+    // CLI augments the hint with CLI-specific recovery guidance so users
+    // know how to resolve the problem from the CLI (the shared hint is
+    // tool-flavored and only mentions the Vellum app).
+    expect(parsed.error).toContain("assistant auth login");
+    expect(parsed.error).toContain(
+      "services.image-generation.mode to 'your-own'",
+    );
+  });
+
+  test("your-own mode hint is NOT augmented with CLI auth guidance", async () => {
+    // The CLI-specific `assistant auth login` guidance only makes sense when
+    // the user is trying to use managed mode. In your-own mode, the shared
+    // hint (pointing at Settings > Models & Services for the API key) is
+    // already actionable from the CLI perspective (the key is in secure
+    // storage, the user just hasn't set it). Augmenting here would confuse
+    // the user into thinking they need to authenticate to Vellum.
+    mockConfig.services["image-generation"].mode = "your-own";
+    mockConfig.services["image-generation"].provider = "gemini";
+    mockProviderKeys.gemini = undefined;
+
+    const { exitCode, stdout } = await runCommand([
+      "image-generation",
+      "generate",
+      "--prompt",
+      "A sunset",
+      "--json",
+    ]);
+    expect(exitCode).toBe(1);
+    const parsed = JSON.parse(stdout.trim());
+    expect(parsed.ok).toBe(false);
+    expect(parsed.error).not.toContain("assistant auth login");
   });
 });
 
@@ -324,7 +392,7 @@ describe("credential errors", () => {
 describe("credential resolution", () => {
   test("your-own mode uses getProviderKeyAsync for direct credentials", async () => {
     mockConfig.services["image-generation"].mode = "your-own";
-    mockProviderKey = "test-gemini-key";
+    mockProviderKeys.gemini = "test-gemini-key";
 
     await runCommand([
       "image-generation",
@@ -344,9 +412,8 @@ describe("credential resolution", () => {
     expect(creds.apiKey).toBe("test-gemini-key");
   });
 
-  test("managed mode uses buildManagedBaseUrl + resolveManagedProxyContext", async () => {
+  test("managed mode uses resolveManagedProxyContext", async () => {
     mockConfig.services["image-generation"].mode = "managed";
-    mockManagedBaseUrl = "https://platform.example.com/proxy/gemini";
     mockManagedProxyContext = {
       enabled: true,
       platformBaseUrl: "https://platform.example.com",
@@ -370,7 +437,160 @@ describe("credential resolution", () => {
     };
     expect(creds.type).toBe("managed-proxy");
     expect(creds.assistantApiKey).toBe("managed-api-key");
-    expect(creds.baseUrl).toBe("https://platform.example.com/proxy/gemini");
+    expect(creds.baseUrl).toBe(
+      "https://platform.example.com/v1/runtime-proxy/gemini",
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Provider dispatch
+// ---------------------------------------------------------------------------
+
+describe("provider dispatch", () => {
+  test("provider=gemini is forwarded to the dispatcher", async () => {
+    mockConfig.services["image-generation"].mode = "your-own";
+    mockConfig.services["image-generation"].provider = "gemini";
+    mockProviderKeys.gemini = "test-gemini-key";
+    const outDir = join(os.tmpdir(), `img-dispatch-gemini-${Date.now()}`);
+
+    const { exitCode } = await runCommand([
+      "image-generation",
+      "generate",
+      "--prompt",
+      "Test",
+      "--output-dir",
+      outDir,
+    ]);
+
+    expect(exitCode).toBe(0);
+    expect(lastGenerateCall).toBeDefined();
+    expect(lastGenerateCall!.provider).toBe("gemini");
+  });
+
+  test("provider=openai with --model gpt-image-2 is forwarded to the dispatcher", async () => {
+    mockConfig.services["image-generation"].mode = "your-own";
+    mockConfig.services["image-generation"].provider = "openai";
+    mockConfig.services["image-generation"].model = "gpt-image-2";
+    mockProviderKeys.openai = "test-openai-key";
+    mockGenerateResult = {
+      images: [
+        {
+          mimeType: "image/png",
+          dataBase64: Buffer.from("fake-png-data").toString("base64"),
+        },
+      ],
+      resolvedModel: "gpt-image-2",
+    };
+    const outDir = join(os.tmpdir(), `img-dispatch-openai-${Date.now()}`);
+
+    const { exitCode } = await runCommand([
+      "image-generation",
+      "generate",
+      "--prompt",
+      "Test",
+      "--model",
+      "gpt-image-2",
+      "--output-dir",
+      outDir,
+    ]);
+
+    expect(exitCode).toBe(0);
+    expect(lastGenerateCall).toBeDefined();
+    expect(lastGenerateCall!.provider).toBe("openai");
+    const req = lastGenerateCall!.request as { model: string };
+    expect(req.model).toBe("gpt-image-2");
+    const creds = lastGenerateCall!.credentials as {
+      type: string;
+      apiKey: string;
+    };
+    expect(creds.type).toBe("direct");
+    expect(creds.apiKey).toBe("test-openai-key");
+  });
+
+  test("cross-provider override: config=gemini + --model gpt-image-2 dispatches to openai", async () => {
+    // Config still points at gemini (the user's Settings default), but the
+    // CLI caller explicitly picks gpt-image-2. The command must dispatch to
+    // OpenAI and resolve OpenAI credentials, not fall back to Gemini's
+    // default model.
+    mockConfig.services["image-generation"].mode = "your-own";
+    mockConfig.services["image-generation"].provider = "gemini";
+    mockConfig.services["image-generation"].model =
+      "gemini-3.1-flash-image-preview";
+    mockProviderKeys.openai = "test-openai-key";
+    mockGenerateResult = {
+      images: [
+        {
+          mimeType: "image/png",
+          dataBase64: Buffer.from("fake-png-data").toString("base64"),
+        },
+      ],
+      resolvedModel: "gpt-image-2",
+    };
+    const outDir = join(os.tmpdir(), `img-cross-openai-${Date.now()}`);
+
+    const { exitCode } = await runCommand([
+      "image-generation",
+      "generate",
+      "--prompt",
+      "Test",
+      "--model",
+      "gpt-image-2",
+      "--output-dir",
+      outDir,
+    ]);
+
+    expect(exitCode).toBe(0);
+    expect(lastGenerateCall).toBeDefined();
+    expect(lastGenerateCall!.provider).toBe("openai");
+    const req = lastGenerateCall!.request as { model: string };
+    expect(req.model).toBe("gpt-image-2");
+    const creds = lastGenerateCall!.credentials as {
+      type: string;
+      apiKey: string;
+    };
+    expect(creds.type).toBe("direct");
+    expect(creds.apiKey).toBe("test-openai-key");
+  });
+
+  test("cross-provider override: config=openai + --model gemini-3-pro-image-preview dispatches to gemini", async () => {
+    mockConfig.services["image-generation"].mode = "your-own";
+    mockConfig.services["image-generation"].provider = "openai";
+    mockConfig.services["image-generation"].model = "gpt-image-2";
+    mockProviderKeys.gemini = "test-gemini-key";
+    mockGenerateResult = {
+      images: [
+        {
+          mimeType: "image/png",
+          dataBase64: Buffer.from("fake-png-data").toString("base64"),
+        },
+      ],
+      resolvedModel: "gemini-3-pro-image-preview",
+    };
+    const outDir = join(os.tmpdir(), `img-cross-gemini-${Date.now()}`);
+
+    const { exitCode } = await runCommand([
+      "image-generation",
+      "generate",
+      "--prompt",
+      "Test",
+      "--model",
+      "gemini-3-pro-image-preview",
+      "--output-dir",
+      outDir,
+    ]);
+
+    expect(exitCode).toBe(0);
+    expect(lastGenerateCall).toBeDefined();
+    expect(lastGenerateCall!.provider).toBe("gemini");
+    const req = lastGenerateCall!.request as { model: string };
+    expect(req.model).toBe("gemini-3-pro-image-preview");
+    const creds = lastGenerateCall!.credentials as {
+      type: string;
+      apiKey: string;
+    };
+    expect(creds.type).toBe("direct");
+    expect(creds.apiKey).toBe("test-gemini-key");
   });
 });
 
@@ -380,7 +600,7 @@ describe("credential resolution", () => {
 
 describe("generate mode", () => {
   test("generates image and prints file path to stdout", async () => {
-    mockProviderKey = "test-key";
+    mockProviderKeys.gemini = "test-key";
     const outDir = join(os.tmpdir(), `img-gen-test-${Date.now()}`);
 
     const { exitCode, stdout } = await runCommand([
@@ -407,7 +627,7 @@ describe("generate mode", () => {
   });
 
   test("--json produces structured output with paths, MIME types, and sizes", async () => {
-    mockProviderKey = "test-key";
+    mockProviderKeys.gemini = "test-key";
     mockGenerateResult = {
       images: [
         {
@@ -449,7 +669,7 @@ describe("generate mode", () => {
 
 describe("edit mode", () => {
   test("exits with code 1 when --mode edit is used without --source", async () => {
-    mockProviderKey = "test-key";
+    mockProviderKeys.gemini = "test-key";
 
     const { exitCode, stdout } = await runCommand([
       "image-generation",
@@ -470,7 +690,7 @@ describe("edit mode", () => {
   });
 
   test("passes source images to generateImage in edit mode", async () => {
-    mockProviderKey = "test-key";
+    mockProviderKeys.gemini = "test-key";
 
     // Use a real temp file for the source image
     const sourceDir = join(os.tmpdir(), `img-src-test-${Date.now()}`);
@@ -515,7 +735,7 @@ describe("edit mode", () => {
 
 describe("variants", () => {
   test("non-numeric --variants defaults to 1", async () => {
-    mockProviderKey = "test-key";
+    mockProviderKeys.gemini = "test-key";
     const outDir = join(os.tmpdir(), `img-nan-variants-${Date.now()}`);
 
     const { exitCode } = await runCommand([
@@ -536,7 +756,7 @@ describe("variants", () => {
   });
 
   test("--variants is passed through to generateImage", async () => {
-    mockProviderKey = "test-key";
+    mockProviderKeys.gemini = "test-key";
     mockGenerateResult = {
       images: [
         {
@@ -587,7 +807,7 @@ describe("variants", () => {
 
 describe("model override", () => {
   test("--model overrides config model", async () => {
-    mockProviderKey = "test-key";
+    mockProviderKeys.gemini = "test-key";
     const outDir = join(os.tmpdir(), `img-model-test-${Date.now()}`);
 
     await runCommand([
@@ -607,7 +827,7 @@ describe("model override", () => {
   });
 
   test("falls back to config model when --model is not provided", async () => {
-    mockProviderKey = "test-key";
+    mockProviderKeys.gemini = "test-key";
     mockConfig.services["image-generation"].model =
       "gemini-3.1-flash-image-preview";
     const outDir = join(os.tmpdir(), `img-model-fallback-${Date.now()}`);
@@ -633,7 +853,7 @@ describe("model override", () => {
 
 describe("error handling", () => {
   test("maps generateImage error and exits with code 1", async () => {
-    mockProviderKey = "test-key";
+    mockProviderKeys.gemini = "test-key";
     mockGenerateError = new Error("API rate limit exceeded");
 
     const { exitCode } = await runCommand([
@@ -647,7 +867,7 @@ describe("error handling", () => {
   });
 
   test("--json outputs mapped error on generateImage failure", async () => {
-    mockProviderKey = "test-key";
+    mockProviderKeys.gemini = "test-key";
     mockGenerateError = new Error("Connection timeout");
 
     const { exitCode, stdout } = await runCommand([

package/src/cli/commands/__tests__/inference-send.test.ts

@@ -138,6 +138,14 @@ async function runCommand(
   const stdoutChunks: string[] = [];
   const stderrChunks: string[] = [];
 
+  // Mock isTTY to undefined so the stdin fallback path is reachable even
+  // when tests run from an interactive terminal (where isTTY === true).
+  const originalIsTTY = process.stdin.isTTY;
+  Object.defineProperty(process.stdin, "isTTY", {
+    value: undefined,
+    configurable: true,
+  });
+
   process.stdout.write = ((chunk: unknown) => {
     stdoutChunks.push(typeof chunk === "string" ? chunk : String(chunk));
     return true;
@@ -164,6 +172,10 @@ async function runCommand(
   } finally {
     process.stdout.write = originalStdoutWrite;
     process.stderr.write = originalStderrWrite;
+    Object.defineProperty(process.stdin, "isTTY", {
+      value: originalIsTTY,
+      configurable: true,
+    });
   }
 
   const exitCode = process.exitCode ?? 0;

package/src/cli/commands/__tests__/tts-synthesize.test.ts

@@ -128,6 +128,14 @@ async function runCommand(
   const stdoutChunks: string[] = [];
   const stderrChunks: string[] = [];
 
+  // Mock isTTY to undefined so the stdin fallback path is reachable even
+  // when tests run from an interactive terminal (where isTTY === true).
+  const originalIsTTY = process.stdin.isTTY;
+  Object.defineProperty(process.stdin, "isTTY", {
+    value: undefined,
+    configurable: true,
+  });
+
   process.stdout.write = ((chunk: unknown) => {
     stdoutChunks.push(typeof chunk === "string" ? chunk : String(chunk));
     return true;
@@ -161,6 +169,10 @@ async function runCommand(
     process.stdout.write = originalStdoutWrite;
     process.stderr.write = originalStderrWrite;
     process.exit = originalExit;
+    Object.defineProperty(process.stdin, "isTTY", {
+      value: originalIsTTY,
+      configurable: true,
+    });
   }
 
   const exitCode = process.exitCode ?? 0;

package/src/cli/commands/backup.ts

@@ -699,7 +699,7 @@ plaintext — plaintext only makes sense when the user owns physical access to
 the medium (e.g. an external SSD).
 
 Examples:
-  $ vellum backup enable --interval 6 --retention 7
+  $ vellum backup enable --interval 6 --retention 3
   $ vellum backup destinations add /Volumes/BackupSSD/vellum --plaintext
   $ vellum backup status
   $ vellum backup list
@@ -717,7 +717,7 @@ Examples:
     )
     .option(
       "--retention <n>",
-      "Snapshots to retain per destination (1-100). Defaults to 7.",
+      "Snapshots to retain per destination (1-100). Defaults to 3.",
     )
     .option(
       "--no-offsite",