@vellumai/assistant 0.8.0 → 0.8.2

package/src/tools/filesystem/edit.ts

@@ -41,7 +41,7 @@ class FileEditTool implements Tool {
           activity: {
             type: "string",
             description:
-              "Brief non-technical explanation of what you are doing and why, shown to the user as a status update.",
+              "Brief non-technical explanation of what you are doing and why, shown as a status update.",
           },
         },
         required: ["path", "old_string", "new_string", "activity"],

package/src/tools/filesystem/list.ts

@@ -30,7 +30,7 @@ class FileListTool implements Tool {
           activity: {
             type: "string",
             description:
-              "Brief non-technical explanation of what you are doing and why, shown to the user as a status update.",
+              "Brief non-technical explanation of what you are doing and why, shown as a status update.",
           },
         },
         required: ["path", "activity"],

package/src/tools/filesystem/read.ts

@@ -41,7 +41,7 @@ class FileReadTool implements Tool {
           activity: {
             type: "string",
             description:
-              "Brief non-technical explanation of what you are doing and why, shown to the user as a status update.",
+              "Brief non-technical explanation of what you are doing and why, shown as a status update.",
           },
         },
         required: ["path", "activity"],

package/src/tools/filesystem/write.ts

@@ -56,7 +56,7 @@ class FileWriteTool implements Tool {
           activity: {
             type: "string",
             description:
-              "Brief non-technical explanation of what you are doing and why, shown to the user as a status update.",
+              "Brief non-technical explanation of what you are doing and why, shown as a status update.",
           },
         },
         required: ["path", "content", "activity"],
@@ -121,7 +121,10 @@ class FileWriteTool implements Tool {
       // Indexing `pkb/*.json` (or any other extension) here would produce
       // chunks the reconciler can't see, leading to orphaned vectors and
       // pointless embedding work.
-      if (filePath.toLowerCase().endsWith(".md") && isInsidePkbRoot(filePath, pkbRoot)) {
+      if (
+        filePath.toLowerCase().endsWith(".md") &&
+        isInsidePkbRoot(filePath, pkbRoot)
+      ) {
         enqueuePkbIndexJob({
           pkbRoot,
           absPath: filePath,

package/src/tools/host-filesystem/transfer.ts

@@ -13,7 +13,7 @@ import type { Tool, ToolContext, ToolExecutionResult } from "../types.js";
 class HostFileTransferTool implements Tool {
   name = "host_file_transfer";
   description =
-    "Copy a file between the assistant's workspace and the user's host machine. Set direction to 'to_host' to send a workspace file to the host, or 'to_sandbox' to pull a host file into the workspace. When multiple clients support host_file, specify which one to use with target_client_id.";
+    "Copy a file between the assistant's workspace and the host machine. Set direction to 'to_host' to send a workspace file to the host, or 'to_sandbox' to pull a host file into the workspace. When multiple clients support host_file, specify which one to use with target_client_id.";
   category = "host-filesystem";
   defaultRiskLevel = RiskLevel.Medium;
 

package/src/tools/host-terminal/host-shell.ts

@@ -95,7 +95,7 @@ function buildHostBashProxyEnv(
 class HostShellTool implements Tool {
   name = "host_bash";
   description =
-    "LAST RESORT — Execute a shell command directly on the user's host machine. You MUST strongly prefer the regular `bash` tool for all commands. Only use `host_bash` when you are absolutely certain the command MUST run on the user's host machine and CANNOT run in the workspace (e.g., managing host-level system services, accessing host-only peripherals, or interacting with host paths outside the workspace). If in doubt, use `bash` instead. Approval-gated: your user must allow each invocation. Do not use for commands that require injected credentials or secrets.";
+    "LAST RESORT — Execute a shell command directly on the host machine. You MUST strongly prefer the regular `bash` tool for all commands. Only use `host_bash` when you are absolutely certain the command MUST run on the host machine and CANNOT run in the workspace (e.g., managing host-level system services, accessing host-only peripherals, or interacting with host paths outside the workspace). If in doubt, use `bash` instead. Approval-gated: each invocation must be explicitly approved. Do not use for commands that require injected credentials or secrets.";
   category = "host-terminal";
   // host_bash is a weaker-tier escape hatch under CES lockdown. It remains
   // Medium risk by default but persistent approvals are disabled for

package/src/tools/memory/register.test.ts

@@ -126,7 +126,7 @@ describe("recallTool definition", () => {
       type: "array",
       items: {
         type: "string",
-        enum: ["memory", "pkb", "conversations", "workspace"],
+        enum: ["memory", "conversations", "workspace"],
       },
     });
     expect(properties.max_results).toMatchObject({
@@ -179,7 +179,7 @@ describe("recallTool.execute", () => {
     const result = await recallTool.execute(
       {
         query: "release notes",
-        sources: ["pkb", "workspace"],
+        sources: ["memory", "workspace"],
         max_results: 4,
         depth: "deep",
       },
@@ -193,7 +193,7 @@ describe("recallTool.execute", () => {
     expect(recallCalls).toHaveLength(1);
     expect(recallCalls[0]?.input).toEqual({
       query: "release notes",
-      sources: ["pkb", "workspace"],
+      sources: ["memory", "workspace"],
       max_results: 4,
       depth: "deep",
     });

package/src/tools/memory/register.ts

@@ -6,6 +6,7 @@ import {
   type RememberInput,
 } from "../../memory/graph/tool-handlers.js";
 import {
+  getRememberDescription,
   graphRecallDefinition,
   graphRememberDefinition,
 } from "../../memory/graph/tools.js";
@@ -18,12 +19,19 @@ import type { Tool, ToolContext, ToolExecutionResult } from "../types.js";
 
 class RememberTool implements Tool {
   name = "remember";
+  // Surfaced in registry listings. The flag-aware description used during
+  // actual tool dispatch is computed lazily in `getDefinition()` below so it
+  // tracks config changes across daemon lifetime without needing a tool
+  // re-registration pass.
   description = graphRememberDefinition.description;
   category = "memory";
   defaultRiskLevel = RiskLevel.Low;
 
   getDefinition(): ToolDefinition {
-    return graphRememberDefinition;
+    return {
+      ...graphRememberDefinition,
+      description: getRememberDescription(getConfig()),
+    };
   }
 
   async execute(

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

@@ -4,6 +4,7 @@ import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 let mockWebSearchProvider: string | undefined = "perplexity";
 let mockBraveSecureKey: string | undefined;
 let mockPerplexitySecureKey: string | undefined;
+let mockTavilySecureKey: string | undefined;
 
 // Capture the registered tool
 let capturedTool: any = null;
@@ -26,6 +27,7 @@ mock.module("../../../security/secure-keys.js", () => ({
   getProviderKeyAsync: async (provider: string) => {
     if (provider === "brave") return mockBraveSecureKey;
     if (provider === "perplexity") return mockPerplexitySecureKey;
+    if (provider === "tavily") return mockTavilySecureKey;
     return undefined;
   },
 }));
@@ -52,6 +54,7 @@ describe("web_search tool", () => {
     mockWebSearchProvider = "perplexity";
     mockBraveSecureKey = undefined;
     mockPerplexitySecureKey = undefined;
+    mockTavilySecureKey = undefined;
   });
 
   afterEach(() => {
@@ -347,6 +350,125 @@ describe("web_search tool", () => {
     expect(callCount).toBe(4);
   });
 
+  // ---- Tavily provider ----------------------------------------------------
+
+  test("executes Tavily search successfully", async () => {
+    mockWebSearchProvider = "tavily";
+    mockTavilySecureKey = "tvly-test-key";
+    globalThis.fetch = (async () => {
+      return new Response(
+        JSON.stringify({
+          results: [
+            {
+              title: "Tavily Result 1",
+              url: "https://example.com/tavily-1",
+              content: "First Tavily result",
+              score: 0.91,
+            },
+            {
+              title: "Tavily Result 2",
+              url: "https://example.com/tavily-2",
+              content: "Second Tavily result",
+            },
+          ],
+        }),
+        { status: 200, headers: { "content-type": "application/json" } },
+      );
+    }) as any;
+
+    const result = await execute({ query: "what is TypeScript" });
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("Tavily Result 1");
+    expect(result.content).toContain("https://example.com/tavily-1");
+    expect(result.content).toContain("Score: 0.910");
+  });
+
+  test("Tavily sends correct request format", async () => {
+    mockWebSearchProvider = "tavily";
+    mockTavilySecureKey = "tvly-test-key";
+    let capturedUrl = "";
+    let capturedBody: any = null;
+    let capturedHeaders: any = null;
+    globalThis.fetch = (async (url: string, init?: RequestInit) => {
+      capturedUrl = url;
+      capturedBody = JSON.parse(init?.body as string);
+      capturedHeaders = new Headers(init?.headers);
+      return new Response(JSON.stringify({ results: [] }), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      });
+    }) as any;
+
+    await execute({ query: "test query", count: 50, freshness: "pm" });
+    expect(capturedUrl).toContain("api.tavily.com/search");
+    expect(capturedBody.query).toBe("test query");
+    expect(capturedBody.search_depth).toBe("advanced");
+    expect(capturedBody.max_results).toBe(20);
+    expect(capturedBody.time_range).toBe("month");
+    expect(capturedHeaders.get("authorization")).toBe("Bearer tvly-test-key");
+  });
+
+  test("Tavily skips invalid freshness values", async () => {
+    mockWebSearchProvider = "tavily";
+    mockTavilySecureKey = "tvly-key";
+    let capturedBody: any = null;
+    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 any;
+
+    await execute({ query: "test", freshness: "invalid" });
+    expect(capturedBody.time_range).toBeUndefined();
+  });
+
+  test("Tavily returns no results message when response is empty", async () => {
+    mockWebSearchProvider = "tavily";
+    mockTavilySecureKey = "tvly-key";
+    globalThis.fetch = (async () => {
+      return new Response(JSON.stringify({ results: [] }), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      });
+    }) as any;
+
+    const result = await execute({ query: "obscure query" });
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("No results found");
+  });
+
+  test.each([401, 403])("Tavily handles %d auth error", async (status) => {
+    mockWebSearchProvider = "tavily";
+    mockTavilySecureKey = "bad-key";
+    globalThis.fetch = (async () => {
+      return new Response("Auth error", { status });
+    }) as any;
+
+    const result = await execute({ query: "test" });
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("Invalid or expired Tavily API key");
+  });
+
+  test("Tavily handles 429 rate limit after max retries", async () => {
+    mockWebSearchProvider = "tavily";
+    mockTavilySecureKey = "tvly-key";
+    let callCount = 0;
+    globalThis.fetch = (async () => {
+      callCount++;
+      return new Response("Too Many Requests", {
+        status: 429,
+        headers: { "retry-after": "0" },
+      });
+    }) as any;
+
+    const result = await execute({ query: "test" });
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("rate limit exceeded");
+    expect(callCount).toBe(4);
+  });
+
   // ---- Provider fallback --------------------------------------------------
 
   test("falls back from perplexity to brave when perplexity has no key", async () => {
@@ -385,6 +507,40 @@ describe("web_search tool", () => {
     expect(capturedUrl).toContain("perplexity");
   });
 
+  test("falls back to tavily when earlier providers have no key", async () => {
+    mockWebSearchProvider = "perplexity";
+    mockTavilySecureKey = "tvly-fallback-key";
+    let capturedUrl = "";
+    globalThis.fetch = (async (url: string) => {
+      capturedUrl = url;
+      return new Response(JSON.stringify({ results: [] }), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      });
+    }) as any;
+
+    const result = await execute({ query: "fallback test" });
+    expect(result.isError).toBe(false);
+    expect(capturedUrl).toContain("tavily");
+  });
+
+  test("falls back from tavily to perplexity when tavily has no key", async () => {
+    mockWebSearchProvider = "tavily";
+    mockPerplexitySecureKey = "pplx-fallback-key";
+    let capturedUrl = "";
+    globalThis.fetch = (async (url: string) => {
+      capturedUrl = url;
+      return new Response(
+        JSON.stringify({ choices: [{ message: { content: "fallback" } }] }),
+        { status: 200, headers: { "content-type": "application/json" } },
+      );
+    }) as any;
+
+    const result = await execute({ query: "fallback test" });
+    expect(result.isError).toBe(false);
+    expect(capturedUrl).toContain("perplexity");
+  });
+
   test("maps inference-provider-native to perplexity", async () => {
     mockWebSearchProvider = "inference-provider-native";
     mockPerplexitySecureKey = "pplx-key";