@vellumai/assistant 0.4.37 → 0.4.41

package/src/__tests__/avatar-router.test.ts

@@ -0,0 +1,186 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Mock state
+// ---------------------------------------------------------------------------
+
+let mockStrategy: string | undefined;
+let mockGeminiKey: string | undefined = "test-gemini-key";
+let mockManagedAvailable = true;
+let mockManagedResult: unknown;
+let mockManagedError: Error | undefined;
+let mockGeminiResult: unknown;
+
+const generateManagedAvatarFn = mock(async () => {
+  if (mockManagedError) throw mockManagedError;
+  return mockManagedResult;
+});
+
+const generateImageFn = mock(async () => mockGeminiResult);
+
+const isManagedAvailableFn = mock(() => mockManagedAvailable);
+
+// ---------------------------------------------------------------------------
+// Mock modules — before importing module under test
+// ---------------------------------------------------------------------------
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    apiKeys: { gemini: mockGeminiKey },
+    avatar: { generationStrategy: mockStrategy ?? "local_only" },
+  }),
+}));
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => ({
+    debug: () => {},
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+  }),
+}));
+
+mock.module("../media/managed-avatar-client.js", () => ({
+  isManagedAvailable: isManagedAvailableFn,
+  generateManagedAvatar: generateManagedAvatarFn,
+}));
+
+mock.module("../media/gemini-image-service.js", () => ({
+  generateImage: generateImageFn,
+}));
+
+// Import after mocking
+import {
+  getAvatarStrategy,
+  routedGenerateAvatar,
+} from "../media/avatar-router.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function managedResponse() {
+  return {
+    image: {
+      mime_type: "image/png",
+      data_base64: "base64data",
+      bytes: 1024,
+      sha256: "abc",
+    },
+    usage: { billable: false, class_name: "assistant_avatar_system" },
+    generation_source: "vertex",
+    profile: "avatar_v1",
+    correlation_id: "test-correlation-id",
+  };
+}
+
+function geminiResponse() {
+  return {
+    images: [{ mimeType: "image/png", dataBase64: "base64data" }],
+    resolvedModel: "gemini-2.5-flash-image",
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("avatar-router", () => {
+  beforeEach(() => {
+    mockStrategy = undefined;
+    mockGeminiKey = "test-gemini-key";
+    mockManagedAvailable = true;
+    mockManagedResult = managedResponse();
+    mockManagedError = undefined;
+    mockGeminiResult = geminiResponse();
+    generateManagedAvatarFn.mockClear();
+    generateImageFn.mockClear();
+    isManagedAvailableFn.mockClear();
+  });
+
+  // 1. managed_required — managed success
+  test("managed_required returns pathUsed managed on success", async () => {
+    mockStrategy = "managed_required";
+    const result = await routedGenerateAvatar("a cute cat");
+    expect(result.pathUsed).toBe("managed");
+    expect(result.imageBase64).toBe("base64data");
+    expect(result.mimeType).toBe("image/png");
+    expect(generateManagedAvatarFn).toHaveBeenCalledTimes(1);
+    expect(generateImageFn).not.toHaveBeenCalled();
+  });
+
+  // 2. managed_required — managed failure throws, no fallback
+  test("managed_required throws on managed failure without fallback", async () => {
+    mockStrategy = "managed_required";
+    mockManagedError = new Error("upstream error");
+    await expect(routedGenerateAvatar("a cute cat")).rejects.toThrow(
+      "upstream error",
+    );
+    expect(generateImageFn).not.toHaveBeenCalled();
+  });
+
+  // 3. local_only — calls local Gemini, never managed
+  test("local_only calls local Gemini and never managed", async () => {
+    mockStrategy = "local_only";
+    const result = await routedGenerateAvatar("a cute cat");
+    expect(result.pathUsed).toBe("local");
+    expect(result.imageBase64).toBe("base64data");
+    expect(generateImageFn).toHaveBeenCalledTimes(1);
+    expect(generateManagedAvatarFn).not.toHaveBeenCalled();
+  });
+
+  // 4. local_only — missing Gemini API key throws
+  test("local_only throws when Gemini API key is missing", async () => {
+    mockStrategy = "local_only";
+    mockGeminiKey = undefined;
+    // Also clear the env var to ensure no fallback
+    const saved = process.env.GEMINI_API_KEY;
+    delete process.env.GEMINI_API_KEY;
+    try {
+      await expect(routedGenerateAvatar("a cute cat")).rejects.toThrow(
+        "Gemini API key is not configured",
+      );
+      expect(generateImageFn).not.toHaveBeenCalled();
+    } finally {
+      if (saved !== undefined) process.env.GEMINI_API_KEY = saved;
+    }
+  });
+
+  // 5. managed_prefer — managed success
+  test("managed_prefer returns pathUsed managed on success", async () => {
+    mockStrategy = "managed_prefer";
+    const result = await routedGenerateAvatar("a cute cat");
+    expect(result.pathUsed).toBe("managed");
+    expect(generateManagedAvatarFn).toHaveBeenCalledTimes(1);
+    expect(generateImageFn).not.toHaveBeenCalled();
+  });
+
+  // 6. managed_prefer — managed failure falls back to local
+  test("managed_prefer falls back to local on managed failure", async () => {
+    mockStrategy = "managed_prefer";
+    mockManagedError = new Error("managed failed");
+    const result = await routedGenerateAvatar("a cute cat");
+    expect(result.pathUsed).toBe("local");
+    expect(generateManagedAvatarFn).toHaveBeenCalledTimes(1);
+    expect(generateImageFn).toHaveBeenCalledTimes(1);
+  });
+
+  // 7. managed_prefer — managed unavailable goes directly to local
+  test("managed_prefer goes to local when managed unavailable", async () => {
+    mockStrategy = "managed_prefer";
+    mockManagedAvailable = false;
+    const result = await routedGenerateAvatar("a cute cat");
+    expect(result.pathUsed).toBe("local");
+    expect(generateManagedAvatarFn).not.toHaveBeenCalled();
+    expect(generateImageFn).toHaveBeenCalledTimes(1);
+  });
+
+  // 8. Default strategy is local_only when config key absent
+  test("defaults to local_only when config key is absent", () => {
+    mockStrategy = undefined;
+    expect(getAvatarStrategy()).toBe("local_only");
+  });
+
+  // 9. Removed: Invalid strategy values are now rejected at config parse time
+  // by the Zod schema, so they cannot reach getAvatarStrategy().
+});

package/src/__tests__/browser-download-timeout.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, it } from "bun:test";
+
+import { withTimeout } from "../tools/browser/browser-manager.js";
+
+describe("withTimeout", () => {
+  it("resolves normally for a fast promise", async () => {
+    const result = await withTimeout(Promise.resolve("ok"), 1_000, "fast");
+    expect(result).toBe("ok");
+  });
+
+  it("rejects with timeout error for a hanging promise", async () => {
+    const hanging = new Promise<string>(() => {
+      // never resolves
+    });
+
+    await expect(withTimeout(hanging, 50, "slow op")).rejects.toThrow(
+      "slow op timed out after 50ms",
+    );
+  });
+
+  it("propagates the original rejection if it happens before the timeout", async () => {
+    const failing = Promise.reject(new Error("original error"));
+
+    await expect(withTimeout(failing, 1_000, "failing")).rejects.toThrow(
+      "original error",
+    );
+  });
+});

package/src/__tests__/bundled-skill-retrieval-guard.test.ts

@@ -90,16 +90,16 @@ const GATEWAY_RETRIEVAL_BANLIST: Array<{
   {
     skillPath: "voice-setup/SKILL.md",
     bannedSnippets: [
-      "vellum config get elevenlabs.voiceId",
-      "vellum config get calls.enabled",
+      "assistant config get elevenlabs.voiceId",
+      "assistant config get calls.enabled",
     ],
   },
   {
     skillPath: "email-setup/SKILL.md",
     bannedSnippets: [
       "host_bash",
-      "vellum email create",
-      "vellum config set email.address",
+      "assistant email create",
+      "assistant config set email.address",
     ],
   },
 ];
@@ -118,11 +118,11 @@ const HOST_BASH_RETRIEVAL_ALLOWLIST = new Set<string>([
 ]);
 
 const RETRIEVAL_MARKERS = [
-  "vellum integrations ",
-  "vellum config get",
-  "vellum email status",
-  "vellum email inbox list",
-  "vellum email provider get",
+  "assistant integrations ",
+  "assistant config get",
+  "assistant email status",
+  "assistant email inbox list",
+  "assistant email provider get",
 ];
 
 describe("bundled skill retrieval guard", () => {

package/src/__tests__/call-domain.test.ts

@@ -207,16 +207,12 @@ describe("resolveCallerIdentity — strict implicit-default policy", () => {
     }
   });
 
-  test("assistant_number resolves from assistant-scoped Twilio number when assistantId is provided", async () => {
-    const result = await resolveCallerIdentity(
-      makeConfig(),
-      undefined,
-      "ast-alpha",
-    );
+  test("assistant_number resolves from twilio config phone number", async () => {
+    const result = await resolveCallerIdentity(makeConfig());
     expect(result.ok).toBe(true);
     if (result.ok) {
       expect(result.mode).toBe("assistant_number");
-      expect(result.fromNumber).toBe("+15550003333");
+      expect(result.fromNumber).toBe("+15550001111");
       expect(result.source).toBe("implicit_default");
     }
   });

package/src/__tests__/credential-security-e2e.test.ts

@@ -30,23 +30,30 @@ mock.module("../util/logger.js", () => ({
 
 // Track keychain writes
 const storedKeys = new Map<string, string>();
-mock.module("../security/secure-keys.js", () => ({
-  getSecureKey: (key: string) => storedKeys.get(key) ?? null,
-  setSecureKey: (key: string, value: string) => {
+mock.module("../security/secure-keys.js", () => {
+  const syncSet = (key: string, value: string) => {
     storedKeys.set(key, value);
     return true;
-  },
-  deleteSecureKey: (key: string) => {
+  };
+  const syncDelete = (key: string) => {
     if (storedKeys.has(key)) {
       storedKeys.delete(key);
-      return "deleted";
+      return "deleted" as const;
     }
-    return "not-found";
-  },
-  listSecureKeys: () => [...storedKeys.keys()],
-  getBackendType: () => "encrypted",
-  isDowngradedFromKeychain: () => false,
-}));
+    return "not-found" as const;
+  };
+  return {
+    getSecureKey: (key: string) => storedKeys.get(key) ?? null,
+    setSecureKey: syncSet,
+    setSecureKeyAsync: async (key: string, value: string) =>
+      syncSet(key, value),
+    deleteSecureKey: syncDelete,
+    deleteSecureKeyAsync: async (key: string) => syncDelete(key),
+    listSecureKeys: () => [...storedKeys.keys()],
+    getBackendType: () => "encrypted",
+    isDowngradedFromKeychain: () => false,
+  };
+});
 
 // In-memory metadata store that mirrors storedKeys for list/get operations
 const metadataStore = new Map<

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

@@ -39,17 +39,43 @@ mock.module("../security/secure-keys.js", () => ({
     secureKeyStore.set(account, value);
     return true;
   },
-  deleteSecureKey: (account: string) => {
+  setSecureKeyAsync: async (
+    account: string,
+    value: string,
+  ): Promise<boolean> => {
+    _setSecureKeyCalls += 1;
+    secureKeyStore.set(account, value);
+    return true;
+  },
+  deleteSecureKey: (account: string): "deleted" | "not-found" | "error" => {
+    _deleteSecureKeyCalls += 1;
+    if (secureKeyStore.has(account)) {
+      secureKeyStore.delete(account);
+      return "deleted";
+    }
+    return "not-found";
+  },
+  deleteSecureKeyAsync: async (
+    account: string,
+  ): Promise<"deleted" | "not-found" | "error"> => {
     _deleteSecureKeyCalls += 1;
     if (secureKeyStore.has(account)) {
       secureKeyStore.delete(account);
-      return "deleted" as const;
+      return "deleted";
     }
-    return "not-found" as const;
+    return "not-found";
   },
   listSecureKeys: (): string[] => {
     return [...secureKeyStore.keys()];
   },
+  getSecureKeyAsync: async (account: string): Promise<string | undefined> => {
+    _getSecureKeyCalls += 1;
+    return secureKeyStore.get(account);
+  },
+  getBackendType: (): "broker" | "encrypted" | null => null,
+  isDowngradedFromKeychain: (): boolean => false,
+  _resetBackend: (): void => {},
+  _setBackend: (): void => {},
 }));
 
 // ---------------------------------------------------------------------------
@@ -243,7 +269,7 @@ function seedMetadataOnly(
 // Tests
 // ---------------------------------------------------------------------------
 
-describe("vellum credentials CLI", () => {
+describe("assistant credentials CLI", () => {
   beforeEach(() => {
     secureKeyStore = new Map();
     metadataStore = [];

package/src/__tests__/guardian-verify-setup-skill-regression.test.ts

@@ -55,7 +55,7 @@ describe("guardian-verify-setup skill — voice auto-followup", () => {
         .split("## Voice Auto-Check Polling")[1]
         ?.split("## Step 6")[0] ?? "";
     expect(pollingSection).toContain(
-      "vellum integrations guardian status --channel voice --json",
+      "assistant integrations guardian status --channel voice --json",
     );
   });
 

package/src/__tests__/handlers-slack-config.test.ts

@@ -55,33 +55,9 @@ mock.module("../util/logger.js", () => ({
   }),
 }));
 
-// Mock app-store so getApp returns a fake app for share tests
-mock.module("../memory/app-store.js", () => ({
-  queryAppRecords: () => [],
-  createAppRecord: () => {},
-  updateAppRecord: () => {},
-  deleteAppRecord: () => {},
-  listApps: () => [],
-  getApp: (id: string) =>
-    id === "test-app"
-      ? { id: "test-app", name: "Test App", description: "A test app" }
-      : undefined,
-  createApp: () => {},
-  updateApp: () => {},
-}));
-
-// Mock Slack webhook poster
-const postedWebhooks: { url: string; name: string }[] = [];
-mock.module("../slack/slack-webhook.js", () => ({
-  postToSlackWebhook: async (url: string, name: string) => {
-    postedWebhooks.push({ url, name });
-  },
-}));
-
 import { handleMessage, type HandlerContext } from "../daemon/handlers.js";
 import type {
   ServerMessage,
-  ShareToSlackRequest,
   SlackWebhookConfigRequest,
 } from "../daemon/ipc-contract.js";
 import { DebouncerMap } from "../util/debounce.js";
@@ -161,52 +137,4 @@ describe("Slack handlers use workspace config (not hardcoded path)", () => {
       "https://hooks.slack.com/new",
     );
   });
-
-  test("share_to_slack reads webhook URL from loadRawConfig", async () => {
-    rawConfigStore = { slackWebhookUrl: "https://hooks.slack.com/share" };
-    postedWebhooks.length = 0;
-
-    const msg: ShareToSlackRequest = {
-      type: "share_to_slack",
-      appId: "test-app",
-    };
-
-    const { ctx, sent } = createTestContext();
-    await handleMessage(msg, {} as net.Socket, ctx);
-
-    // Wait a tick for async handler to complete
-    await new Promise((r) => setTimeout(r, 50));
-
-    const res = sent.find(
-      (m) => (m as { type: string }).type === "share_to_slack_response",
-    ) as { type: string; success: boolean } | undefined;
-    expect(res).toBeDefined();
-    expect(res!.success).toBe(true);
-
-    // Verify the webhook was posted with the URL from loadRawConfig
-    expect(postedWebhooks).toHaveLength(1);
-    expect(postedWebhooks[0]!.url).toBe("https://hooks.slack.com/share");
-    expect(postedWebhooks[0]!.name).toBe("Test App");
-  });
-
-  test("share_to_slack fails gracefully when no webhook URL configured", async () => {
-    rawConfigStore = {};
-
-    const msg: ShareToSlackRequest = {
-      type: "share_to_slack",
-      appId: "test-app",
-    };
-
-    const { ctx, sent } = createTestContext();
-    await handleMessage(msg, {} as net.Socket, ctx);
-
-    await new Promise((r) => setTimeout(r, 50));
-
-    const res = sent.find(
-      (m) => (m as { type: string }).type === "share_to_slack_response",
-    ) as { type: string; success: boolean; error?: string } | undefined;
-    expect(res).toBeDefined();
-    expect(res!.success).toBe(false);
-    expect(res!.error).toContain("No Slack webhook URL configured");
-  });
 });

package/src/__tests__/handlers-telegram-config.test.ts

@@ -66,20 +66,27 @@ let secureKeyStore: Record<string, string> = {};
 let setSecureKeyOverride: ((account: string, value: string) => boolean) | null =
   null;
 
+function syncSet(account: string, value: string): boolean {
+  if (setSecureKeyOverride) return setSecureKeyOverride(account, value);
+  secureKeyStore[account] = value;
+  return true;
+}
+
+function syncDelete(account: string): "deleted" | "not-found" {
+  if (account in secureKeyStore) {
+    delete secureKeyStore[account];
+    return "deleted";
+  }
+  return "not-found";
+}
+
 mock.module("../security/secure-keys.js", () => ({
   getSecureKey: (account: string) => secureKeyStore[account] ?? undefined,
-  setSecureKey: (account: string, value: string) => {
-    if (setSecureKeyOverride) return setSecureKeyOverride(account, value);
-    secureKeyStore[account] = value;
-    return true;
-  },
-  deleteSecureKey: (account: string) => {
-    if (account in secureKeyStore) {
-      delete secureKeyStore[account];
-      return "deleted";
-    }
-    return "not-found";
-  },
+  setSecureKey: syncSet,
+  deleteSecureKey: syncDelete,
+  setSecureKeyAsync: async (account: string, value: string) =>
+    syncSet(account, value),
+  deleteSecureKeyAsync: async (account: string) => syncDelete(account),
   listSecureKeys: () => Object.keys(secureKeyStore),
   getBackendType: () => "encrypted",
   isDowngradedFromKeychain: () => false,