@vellumai/assistant 0.8.0 → 0.8.1

package/src/__tests__/web-search.test.ts

@@ -43,6 +43,17 @@ describe("WebSearchTool", () => {
       expect(result.isError).toBe(true);
       expect(result.content).toContain("No web search API key configured");
     });
+
+    test("returns error when no API key is configured (tavily)", async () => {
+      delete process.env.TAVILY_API_KEY;
+      const result = await executeWebSearch(
+        { query: "test" },
+        undefined,
+        "tavily",
+      );
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain("No web search API key configured");
+    });
   });
 
   describe("input validation", () => {
@@ -508,6 +519,159 @@ describe("WebSearchTool", () => {
       expect(result.content).toContain("Network unreachable");
     });
   });
+
+  describe("Tavily API responses", () => {
+    test("formats results", async () => {
+      const mockResponse = {
+        results: [
+          {
+            title: "Tavily Result",
+            url: "https://example.com/tavily",
+            content: "A Tavily search snippet.",
+            score: 0.9234,
+          },
+        ],
+      };
+
+      globalThis.fetch = (async () =>
+        new Response(JSON.stringify(mockResponse), {
+          status: 200,
+          headers: { "Content-Type": "application/json" },
+        })) as unknown as typeof fetch;
+
+      const result = await executeWebSearch(
+        { query: "test" },
+        "tvly-key",
+        "tavily",
+      );
+      expect(result.isError).toBe(false);
+      expect(result.content).toContain("Tavily Result");
+      expect(result.content).toContain("https://example.com/tavily");
+      expect(result.content).toContain("A Tavily search snippet");
+      expect(result.content).toContain("Score: 0.923");
+    });
+
+    test("handles empty response", async () => {
+      globalThis.fetch = (async () =>
+        new Response(JSON.stringify({ results: [] }), {
+          status: 200,
+          headers: { "Content-Type": "application/json" },
+        })) as unknown as typeof fetch;
+
+      const result = await executeWebSearch(
+        { query: "noresults" },
+        "tvly-key",
+        "tavily",
+      );
+      expect(result.isError).toBe(false);
+      expect(result.content).toContain("No results found");
+    });
+
+    test("maps count and freshness into Tavily request body", async () => {
+      let capturedHeaders: Record<string, string> = {};
+      let capturedBody: Record<string, unknown> = {};
+      globalThis.fetch = (async (_url: string, init: RequestInit) => {
+        capturedHeaders = Object.fromEntries(
+          Object.entries(init.headers as Record<string, string>),
+        );
+        capturedBody = JSON.parse(init.body as string);
+        return new Response(JSON.stringify({ results: [] }), {
+          status: 200,
+          headers: { "Content-Type": "application/json" },
+        });
+      }) as unknown as typeof fetch;
+
+      await executeWebSearch(
+        { query: "test query", count: 50, freshness: "pw" },
+        "tvly-my-key",
+        "tavily",
+      );
+      expect(capturedHeaders.Authorization).toBe("Bearer tvly-my-key");
+      expect(capturedHeaders["Content-Type"]).toBe("application/json");
+      expect(capturedBody.query).toBe("test query");
+      expect(capturedBody.search_depth).toBe("advanced");
+      expect(capturedBody.max_results).toBe(20);
+      expect(capturedBody.time_range).toBe("week");
+    });
+
+    test("omits invalid freshness values", async () => {
+      let capturedBody: Record<string, unknown> = {};
+      globalThis.fetch = (async (_url: string, init: RequestInit) => {
+        capturedBody = JSON.parse(init.body as string);
+        return new Response(JSON.stringify({ results: [] }), {
+          status: 200,
+          headers: { "Content-Type": "application/json" },
+        });
+      }) as unknown as typeof fetch;
+
+      await executeWebSearch(
+        { query: "test query", freshness: "invalid" },
+        "tvly-my-key",
+        "tavily",
+      );
+      expect(capturedBody.time_range).toBeUndefined();
+    });
+
+    test("handles 401 unauthorized", async () => {
+      globalThis.fetch = (async () =>
+        new Response("Unauthorized", {
+          status: 401,
+        })) as unknown as typeof fetch;
+
+      const result = await executeWebSearch(
+        { query: "test" },
+        "bad-key",
+        "tavily",
+      );
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain("Invalid or expired");
+    });
+
+    test("retries on 429 and succeeds", async () => {
+      let callCount = 0;
+      globalThis.fetch = (async () => {
+        callCount++;
+        if (callCount <= 2) {
+          return new Response("Too Many Requests", { status: 429 });
+        }
+        return new Response(
+          JSON.stringify({
+            results: [
+              {
+                title: "Found it",
+                url: "https://example.com/found",
+                content: "Found it with Tavily",
+              },
+            ],
+          }),
+          { status: 200, headers: { "Content-Type": "application/json" } },
+        );
+      }) as unknown as typeof fetch;
+
+      const result = await executeWebSearch(
+        { query: "test" },
+        "tvly-key",
+        "tavily",
+      );
+      expect(result.isError).toBe(false);
+      expect(result.content).toContain("Found it with Tavily");
+      expect(callCount).toBe(3);
+    });
+
+    test("handles network errors", async () => {
+      globalThis.fetch = (async () => {
+        throw new Error("Network unreachable");
+      }) as unknown as typeof fetch;
+
+      const result = await executeWebSearch(
+        { query: "test" },
+        "tvly-key",
+        "tavily",
+      );
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain("Network unreachable");
+    });
+  });
 });
 
 interface BraveSearchResult {
@@ -527,6 +691,17 @@ interface PerplexityResponse {
   citations?: string[];
 }
 
+interface TavilySearchResult {
+  title?: string;
+  url?: string;
+  content?: string;
+  score?: number;
+}
+
+interface TavilySearchResponse {
+  results?: TavilySearchResult[];
+}
+
 /**
  * Helper that exercises the web search logic directly, bypassing module
  * registration concerns. This replicates the core execute path from
@@ -535,7 +710,7 @@ interface PerplexityResponse {
 async function executeWebSearch(
   input: Record<string, unknown>,
   apiKey?: string,
-  provider: "brave" | "perplexity" = "brave",
+  provider: "brave" | "perplexity" | "tavily" = "brave",
 ): Promise<{ content: string; isError: boolean }> {
   const query = input.query;
   if (!query || typeof query !== "string") {
@@ -548,7 +723,7 @@ async function executeWebSearch(
   if (!apiKey) {
     return {
       content:
-        "Error: No web search API key configured. Set it via `keys set perplexity <key>` or `keys set brave <key>`, or configure it from the Settings page under API Keys.",
+        "Error: No web search API key configured. Set it via `keys set perplexity <key>`, `keys set brave <key>`, or `keys set tavily <key>`, or configure it from the Settings page under API Keys.",
       isError: true,
     };
   }
@@ -557,6 +732,10 @@ async function executeWebSearch(
     return executePerplexitySearchHelper(query as string, apiKey);
   }
 
+  if (provider === "tavily") {
+    return executeTavilySearchHelper(input, query as string, apiKey);
+  }
+
   return executeBraveSearchHelper(input, query as string, apiKey);
 }
 
@@ -764,3 +943,125 @@ async function executePerplexitySearchHelper(
     return { content: `Error: Web search failed: ${msg}`, isError: true };
   }
 }
+
+function tavilyTimeRangeForFreshness(
+  freshness: string | undefined,
+): "day" | "week" | "month" | "year" | undefined {
+  switch (freshness) {
+    case "pd":
+      return "day";
+    case "pw":
+      return "week";
+    case "pm":
+      return "month";
+    case "py":
+      return "year";
+    default:
+      return undefined;
+  }
+}
+
+async function executeTavilySearchHelper(
+  input: Record<string, unknown>,
+  query: string,
+  apiKey: string,
+): Promise<{ content: string; isError: boolean }> {
+  const count =
+    typeof input.count === "number"
+      ? Math.min(20, Math.max(1, Math.round(input.count)))
+      : 10;
+  const timeRange = tavilyTimeRangeForFreshness(
+    typeof input.freshness === "string" ? input.freshness : undefined,
+  );
+  const body: Record<string, unknown> = {
+    query,
+    search_depth: "advanced",
+    max_results: count,
+  };
+  if (timeRange) body.time_range = timeRange;
+
+  const MAX_RETRIES = 3;
+  const BASE_DELAY_MS = 1;
+
+  try {
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+      const response = await fetch("https://api.tavily.com/search", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`,
+          "X-Client-Source": "vellum-assistant",
+        },
+        body: JSON.stringify(body),
+      });
+
+      if (response.ok) {
+        const data = (await response.json()) as TavilySearchResponse;
+        const results = data.results ?? [];
+
+        if (results.length === 0) {
+          return {
+            content: `No results found for "${query}".`,
+            isError: false,
+          };
+        }
+
+        const lines: string[] = [`Web search results for "${query}":\n`];
+
+        for (let i = 0; i < results.length; i++) {
+          const r = results[i];
+          const title = r.title?.trim() || r.url?.trim() || "Untitled result";
+          lines.push(`${i + 1}. ${title}`);
+          if (r.url) lines.push(`   URL: ${r.url}`);
+          if (r.content) lines.push(`   ${r.content}`);
+          if (typeof r.score === "number") {
+            lines.push(`   Score: ${r.score.toFixed(3)}`);
+          }
+          lines.push("");
+        }
+
+        return { content: lines.join("\n"), isError: false };
+      }
+
+      await response.text();
+
+      if (response.status === 401 || response.status === 403) {
+        return {
+          content: "Error: Invalid or expired Tavily API key",
+          isError: true,
+        };
+      }
+
+      if (response.status === 429 && attempt < MAX_RETRIES) {
+        const retryAfter = response.headers.get("retry-after");
+        const delayMs =
+          retryAfter && !isNaN(Number(retryAfter))
+            ? Number(retryAfter) * 1000
+            : BASE_DELAY_MS * Math.pow(2, attempt);
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+        continue;
+      }
+
+      if (response.status === 429) {
+        return {
+          content:
+            "Error: Tavily Search rate limit exceeded after retries. Try again shortly.",
+          isError: true,
+        };
+      }
+      return {
+        content: `Error: Tavily Search API returned status ${response.status}`,
+        isError: true,
+      };
+    }
+
+    return {
+      content:
+        "Error: Tavily Search rate limit exceeded after retries. Try again shortly.",
+      isError: true,
+    };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { content: `Error: Web search failed: ${msg}`, isError: true };
+  }
+}

package/src/__tests__/workspace-migration-039-drop-legacy-llm-keys.test.ts

@@ -176,11 +176,10 @@ describe("039-drop-legacy-llm-keys migration", () => {
     expect(config.contextWindow).toBeUndefined();
     expect(config.pricingOverrides).toBeUndefined();
 
-    // services.inference: provider/model stripped, mode preserved
+    // services.inference: provider/model stripped
     const services = config.services as { inference: Record<string, unknown> };
     expect(services.inference.provider).toBeUndefined();
     expect(services.inference.model).toBeUndefined();
-    expect(services.inference.mode).toBe("your-own");
 
     // heartbeat / filing
     const heartbeat = config.heartbeat as Record<string, unknown>;
@@ -248,31 +247,12 @@ describe("039-drop-legacy-llm-keys migration", () => {
     expect(config.speed).toBeUndefined();
     const services = config.services as { inference: Record<string, unknown> };
     expect(services.inference.provider).toBeUndefined();
-    expect(services.inference.mode).toBe("managed");
     expect(
       (config.notifications as Record<string, unknown>).decisionModelIntent,
     ).toBeUndefined();
     expect(config.maxStepsPerSession).toBe(50);
   });
 
-  // ─── services.inference.mode preservation ──────────────────────────────
-
-  test("preserves services.inference.mode while stripping provider/model", () => {
-    writeConfig({
-      services: {
-        inference: { mode: "your-own", provider: "openai", model: "gpt-5.4" },
-      },
-    });
-
-    dropLegacyLlmKeysMigration.run(workspaceDir);
-
-    const config = readConfig();
-    const services = config.services as { inference: Record<string, unknown> };
-    expect(services.inference.mode).toBe("your-own");
-    expect(services.inference.provider).toBeUndefined();
-    expect(services.inference.model).toBeUndefined();
-  });
-
   // ─── Idempotency ───────────────────────────────────────────────────────
 
   test("idempotency: re-running the migration yields no further mutation", () => {

package/src/__tests__/workspace-migration-057-repair-stale-gemini-model-ids.test.ts

@@ -217,6 +217,64 @@ describe("057-repair-stale-gemini-model-ids migration", () => {
     expect(config.llm.profiles.balanced.model).toBe("gemini-3-flash-preview");
   });
 
+  test("does not rewrite blocks whose effective provider is not Gemini", () => {
+    writeConfig({
+      llm: {
+        default: {
+          provider: "ollama",
+          model: "gemini-3-flash",
+        },
+        callSites: {
+          analyzeConversation: {
+            provider: "openrouter",
+            model: "gemini-3-flash",
+          },
+          recall: {
+            model: "gemini-3-flash",
+          },
+        },
+        profiles: {
+          custom: {
+            provider: "ollama",
+            model: "gemini-3-flash",
+          },
+        },
+      },
+    });
+    const before = readFileSync(configPath(), "utf-8");
+
+    repairStaleGeminiModelIdsMigration.run(workspaceDir);
+
+    expect(readFileSync(configPath(), "utf-8")).toBe(before);
+  });
+
+  test("rewrites call-site/profile blocks without local provider when default is Gemini", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "gemini", model: "gemini-3-flash-preview" },
+        callSites: {
+          memoryRetrieval: { model: "gemini-3-flash" },
+        },
+        profiles: {
+          balanced: { model: "gemini-3-flash" },
+        },
+      },
+    });
+
+    repairStaleGeminiModelIdsMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: {
+        callSites: Record<string, { model: string }>;
+        profiles: Record<string, { model: string }>;
+      };
+    };
+    expect(config.llm.callSites.memoryRetrieval.model).toBe(
+      "gemini-3.1-flash-lite-preview",
+    );
+    expect(config.llm.profiles.balanced.model).toBe("gemini-3-flash-preview");
+  });
+
   test("no-ops when config.json is missing or invalid", () => {
     repairStaleGeminiModelIdsMigration.run(workspaceDir);
     expect(existsSync(configPath())).toBe(false);

package/src/__tests__/workspace-migration-069-seed-onboarding-threads.test.ts

@@ -2,8 +2,11 @@
  * Tests for workspace migration `069-seed-onboarding-threads`.
  *
  * The migration writes onboarding bullet content to `memory/threads.md` only
- * when the file exists and is empty (or whitespace-only). It must preserve
- * any existing content and must be idempotent.
+ * for newly-created workspaces (`ctx.isNewWorkspace === true`) when the file
+ * exists and is empty (or whitespace-only). For upgrading workspaces it must
+ * be a no-op even if `threads.md` is currently empty (the user may have
+ * cleaned it up themselves). It must preserve any existing content and be
+ * idempotent.
  */
 
 import {
@@ -20,6 +23,10 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
 import { memoryV2InitMigration } from "../workspace/migrations/060-memory-v2-init.js";
 import { seedOnboardingThreadsMigration } from "../workspace/migrations/069-seed-onboarding-threads.js";
+import type { MigrationRunContext } from "../workspace/migrations/types.js";
+
+const NEW_WORKSPACE_CTX: MigrationRunContext = { isNewWorkspace: true };
+const UPGRADE_CTX: MigrationRunContext = { isNewWorkspace: false };
 
 let workspaceDir: string;
 
@@ -48,18 +55,44 @@ describe("069-seed-onboarding-threads migration", () => {
   test.each([
     ["empty file", ""],
     ["whitespace-only file", "   \n\n"],
-  ])("seeds onboarding bullets when memory/threads.md is %s", (_, initial) => {
-    mkdirSync(join(workspaceDir, "memory"), { recursive: true });
-    writeFileSync(join(workspaceDir, "memory", "threads.md"), initial, "utf-8");
+  ])(
+    "seeds onboarding bullets when new workspace and memory/threads.md is %s",
+    (_, initial) => {
+      mkdirSync(join(workspaceDir, "memory"), { recursive: true });
+      writeFileSync(
+        join(workspaceDir, "memory", "threads.md"),
+        initial,
+        "utf-8",
+      );
+
+      seedOnboardingThreadsMigration.run(workspaceDir, NEW_WORKSPACE_CTX);
+
+      const content = readThreads();
+      expect(content).toContain("Figure out what kind of personality");
+      expect(content).toContain("data/avatar/avatar-image.png");
+      expect(content).toContain("ChatGPT, Claude");
+      expect(content).toContain("Slack or Telegram");
+    },
+  );
 
-    seedOnboardingThreadsMigration.run(workspaceDir);
-
-    const content = readThreads();
-    expect(content).toContain("Figure out what kind of personality");
-    expect(content).toContain("data/avatar/avatar-image.png");
-    expect(content).toContain("ChatGPT, Claude");
-    expect(content).toContain("Slack or Telegram");
-  });
+  test.each([
+    ["empty file", ""],
+    ["whitespace-only file", "   \n\n"],
+  ])(
+    "no-op on upgrade when memory/threads.md is %s (user may have cleared it)",
+    (_, initial) => {
+      mkdirSync(join(workspaceDir, "memory"), { recursive: true });
+      writeFileSync(
+        join(workspaceDir, "memory", "threads.md"),
+        initial,
+        "utf-8",
+      );
+
+      seedOnboardingThreadsMigration.run(workspaceDir, UPGRADE_CTX);
+
+      expect(readThreads()).toBe(initial);
+    },
+  );
 
   test("preserves existing content when memory/threads.md is non-empty", () => {
     mkdirSync(join(workspaceDir, "memory"), { recursive: true });
@@ -70,13 +103,13 @@ describe("069-seed-onboarding-threads migration", () => {
       "utf-8",
     );
 
-    seedOnboardingThreadsMigration.run(workspaceDir);
+    seedOnboardingThreadsMigration.run(workspaceDir, NEW_WORKSPACE_CTX);
 
     expect(readThreads()).toBe(existing);
   });
 
   test("no-op when memory/threads.md does not exist", () => {
-    seedOnboardingThreadsMigration.run(workspaceDir);
+    seedOnboardingThreadsMigration.run(workspaceDir, NEW_WORKSPACE_CTX);
     expect(existsSync(join(workspaceDir, "memory", "threads.md"))).toBe(false);
   });
 
@@ -84,18 +117,18 @@ describe("069-seed-onboarding-threads migration", () => {
     mkdirSync(join(workspaceDir, "memory"), { recursive: true });
     writeFileSync(join(workspaceDir, "memory", "threads.md"), "", "utf-8");
 
-    seedOnboardingThreadsMigration.run(workspaceDir);
+    seedOnboardingThreadsMigration.run(workspaceDir, NEW_WORKSPACE_CTX);
     const afterFirst = readThreads();
 
-    seedOnboardingThreadsMigration.run(workspaceDir);
+    seedOnboardingThreadsMigration.run(workspaceDir, NEW_WORKSPACE_CTX);
     const afterSecond = readThreads();
 
     expect(afterSecond).toBe(afterFirst);
   });
 
   test("composes with 060: fresh workspace -> 060 -> 069 produces seeded threads.md", () => {
-    memoryV2InitMigration.run(workspaceDir);
-    seedOnboardingThreadsMigration.run(workspaceDir);
+    memoryV2InitMigration.run(workspaceDir, NEW_WORKSPACE_CTX);
+    seedOnboardingThreadsMigration.run(workspaceDir, NEW_WORKSPACE_CTX);
 
     expect(readThreads()).toContain("Figure out what kind of personality");
     // The other v2 prose files are untouched (still empty).
@@ -110,7 +143,7 @@ describe("069-seed-onboarding-threads migration", () => {
     mkdirSync(join(workspaceDir, "memory"), { recursive: true });
     writeFileSync(join(workspaceDir, "memory", "threads.md"), "", "utf-8");
 
-    seedOnboardingThreadsMigration.run(workspaceDir);
+    seedOnboardingThreadsMigration.run(workspaceDir, NEW_WORKSPACE_CTX);
     const seeded = readThreads();
 
     seedOnboardingThreadsMigration.down(workspaceDir);