@vellumai/assistant 0.8.2 → 0.8.4

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

@@ -1,8 +1,13 @@
 import { getConfig } from "../../config/loader.js";
+import type {
+  WebSearchMetadata,
+  WebSearchResultItem,
+} from "../../daemon/message-types/web-activity.js";
 import { RiskLevel } from "../../permissions/types.js";
 import type { ToolDefinition } from "../../providers/types.js";
 import { getProviderKeyAsync } from "../../security/secure-keys.js";
 import { wrapUntrustedContent } from "../../security/untrusted-content.js";
+import { faviconUrlForDomain } from "../../util/favicon.js";
 import { getLogger } from "../../util/logger.js";
 import {
   DEFAULT_BASE_DELAY_MS,
@@ -12,6 +17,7 @@ import {
 } from "../../util/retry.js";
 import { registerTool } from "../registry.js";
 import type { Tool, ToolContext, ToolExecutionResult } from "../types.js";
+import { extractDomain } from "./domain-normalize.js";
 
 const log = getLogger("web-search");
 
@@ -201,6 +207,85 @@ function formatTavilyResults(
   return lines.join("\n");
 }
 
+function buildBraveMetadata(
+  results: BraveSearchResult[],
+  query: string,
+  durationMs: number,
+): WebSearchMetadata {
+  const items: WebSearchResultItem[] = results.map((r, i) => {
+    const domain = extractDomain(r.url);
+    return {
+      rank: i + 1,
+      title: r.title,
+      url: r.url,
+      domain,
+      faviconUrl: faviconUrlForDomain(domain),
+      snippet: r.description,
+      age: r.age,
+    };
+  });
+  return {
+    query,
+    provider: "brave",
+    resultCount: items.length,
+    durationMs,
+    results: items,
+  };
+}
+
+function buildPerplexityMetadata(
+  data: PerplexityResponse,
+  query: string,
+  durationMs: number,
+): WebSearchMetadata {
+  const citations = data.citations ?? [];
+  const items: WebSearchResultItem[] = citations.map((url, i) => {
+    const domain = extractDomain(url);
+    return {
+      rank: i + 1,
+      title: "",
+      url,
+      domain,
+      faviconUrl: faviconUrlForDomain(domain),
+    };
+  });
+  return {
+    query,
+    provider: "perplexity",
+    resultCount: items.length,
+    durationMs,
+    results: items,
+  };
+}
+
+function buildTavilyMetadata(
+  data: TavilySearchResponse,
+  query: string,
+  durationMs: number,
+): WebSearchMetadata {
+  const results = data.results ?? [];
+  const items: WebSearchResultItem[] = results.map((r, i) => {
+    const url = r.url ?? "";
+    const domain = extractDomain(url);
+    return {
+      rank: i + 1,
+      title: r.title?.trim() || url.trim() || "Untitled result",
+      url,
+      domain,
+      faviconUrl: r.favicon ?? faviconUrlForDomain(domain),
+      snippet: r.content,
+      score: r.score,
+    };
+  });
+  return {
+    query,
+    provider: "tavily",
+    resultCount: items.length,
+    durationMs,
+    results: items,
+  };
+}
+
 function tavilyTimeRangeForFreshness(
   freshness: string | undefined,
 ): "day" | "week" | "month" | "year" | undefined {
@@ -218,6 +303,28 @@ function tavilyTimeRangeForFreshness(
   }
 }
 
+function errorResult(
+  query: string,
+  provider: WebSearchProvider,
+  startedAt: number,
+  errorMessage: string,
+): ToolExecutionResult {
+  return {
+    content: `Error: ${errorMessage}`,
+    isError: true,
+    activityMetadata: {
+      webSearch: {
+        query,
+        provider,
+        resultCount: 0,
+        durationMs: Date.now() - startedAt,
+        results: [],
+        errorMessage,
+      },
+    },
+  };
+}
+
 async function executeBraveSearch(
   query: string,
   count: number,
@@ -238,6 +345,7 @@ async function executeBraveSearch(
   }
 
   const url = `${BRAVE_API_URL}?${params.toString()}`;
+  const startedAt = Date.now();
 
   for (let attempt = 0; attempt <= DEFAULT_MAX_RETRIES; attempt++) {
     const response = await fetch(url, {
@@ -252,6 +360,7 @@ async function executeBraveSearch(
     if (response.ok) {
       const data = (await response.json()) as BraveSearchResponse;
       const results = data.web?.results ?? [];
+      const durationMs = Date.now() - startedAt;
       return {
         content:
           wrapUntrustedContent(formatBraveResults(results, query), {
@@ -259,16 +368,21 @@ async function executeBraveSearch(
             sourceDetail: "brave",
           }) + CITATION_INSTRUCTION,
         isError: false,
+        activityMetadata: {
+          webSearch: buildBraveMetadata(results, query, durationMs),
+        },
       };
     }
 
     await response.text();
 
     if (response.status === 401 || response.status === 403) {
-      return {
-        content: "Error: Invalid or expired Brave Search API key",
-        isError: true,
-      };
+      return errorResult(
+        query,
+        "brave",
+        startedAt,
+        "Invalid or expired Brave Search API key",
+      );
     }
 
     if (response.status === 429 && attempt < DEFAULT_MAX_RETRIES) {
@@ -286,24 +400,22 @@ async function executeBraveSearch(
     }
 
     log.warn({ status: response.status }, "Brave Search API error");
-    if (response.status === 429) {
-      return {
-        content:
-          "Error: Brave Search rate limit exceeded after retries. Try again shortly.",
-        isError: true,
-      };
-    }
-    return {
-      content: `Error: Brave Search API returned status ${response.status}`,
-      isError: true,
-    };
+    return errorResult(
+      query,
+      "brave",
+      startedAt,
+      response.status === 429
+        ? "Brave Search rate limit exceeded after retries. Try again shortly."
+        : `Brave Search API returned status ${response.status}`,
+    );
   }
 
-  return {
-    content:
-      "Error: Brave Search rate limit exceeded after retries. Try again shortly.",
-    isError: true,
-  };
+  return errorResult(
+    query,
+    "brave",
+    startedAt,
+    "Brave Search rate limit exceeded after retries. Try again shortly.",
+  );
 }
 
 async function executePerplexitySearch(
@@ -311,6 +423,7 @@ async function executePerplexitySearch(
   apiKey: string,
   signal?: AbortSignal,
 ): Promise<ToolExecutionResult> {
+  const startedAt = Date.now();
   for (let attempt = 0; attempt <= DEFAULT_MAX_RETRIES; attempt++) {
     const response = await fetch(PERPLEXITY_API_URL, {
       method: "POST",
@@ -327,6 +440,7 @@ async function executePerplexitySearch(
 
     if (response.ok) {
       const data = (await response.json()) as PerplexityResponse;
+      const durationMs = Date.now() - startedAt;
       return {
         content:
           wrapUntrustedContent(formatPerplexityResults(data, query), {
@@ -334,16 +448,21 @@ async function executePerplexitySearch(
             sourceDetail: "perplexity",
           }) + CITATION_INSTRUCTION,
         isError: false,
+        activityMetadata: {
+          webSearch: buildPerplexityMetadata(data, query, durationMs),
+        },
       };
     }
 
     await response.text();
 
     if (response.status === 401 || response.status === 403) {
-      return {
-        content: "Error: Invalid or expired Perplexity API key",
-        isError: true,
-      };
+      return errorResult(
+        query,
+        "perplexity",
+        startedAt,
+        "Invalid or expired Perplexity API key",
+      );
     }
 
     if (response.status === 429 && attempt < DEFAULT_MAX_RETRIES) {
@@ -361,24 +480,22 @@ async function executePerplexitySearch(
     }
 
     log.warn({ status: response.status }, "Perplexity API error");
-    if (response.status === 429) {
-      return {
-        content:
-          "Error: Perplexity rate limit exceeded after retries. Try again shortly.",
-        isError: true,
-      };
-    }
-    return {
-      content: `Error: Perplexity API returned status ${response.status}`,
-      isError: true,
-    };
+    return errorResult(
+      query,
+      "perplexity",
+      startedAt,
+      response.status === 429
+        ? "Perplexity rate limit exceeded after retries. Try again shortly."
+        : `Perplexity API returned status ${response.status}`,
+    );
   }
 
-  return {
-    content:
-      "Error: Perplexity rate limit exceeded after retries. Try again shortly.",
-    isError: true,
-  };
+  return errorResult(
+    query,
+    "perplexity",
+    startedAt,
+    "Perplexity rate limit exceeded after retries. Try again shortly.",
+  );
 }
 
 async function executeTavilySearch(
@@ -398,6 +515,8 @@ async function executeTavilySearch(
     body.time_range = timeRange;
   }
 
+  const startedAt = Date.now();
+
   for (let attempt = 0; attempt <= DEFAULT_MAX_RETRIES; attempt++) {
     const response = await fetch(TAVILY_API_URL, {
       method: "POST",
@@ -412,6 +531,7 @@ async function executeTavilySearch(
 
     if (response.ok) {
       const data = (await response.json()) as TavilySearchResponse;
+      const durationMs = Date.now() - startedAt;
       return {
         content:
           wrapUntrustedContent(formatTavilyResults(data, query), {
@@ -419,16 +539,21 @@ async function executeTavilySearch(
             sourceDetail: "tavily",
           }) + CITATION_INSTRUCTION,
         isError: false,
+        activityMetadata: {
+          webSearch: buildTavilyMetadata(data, query, durationMs),
+        },
       };
     }
 
     await response.text();
 
     if (response.status === 401 || response.status === 403) {
-      return {
-        content: "Error: Invalid or expired Tavily API key",
-        isError: true,
-      };
+      return errorResult(
+        query,
+        "tavily",
+        startedAt,
+        "Invalid or expired Tavily API key",
+      );
     }
 
     if (response.status === 429 && attempt < DEFAULT_MAX_RETRIES) {
@@ -446,24 +571,22 @@ async function executeTavilySearch(
     }
 
     log.warn({ status: response.status }, "Tavily Search API error");
-    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 errorResult(
+      query,
+      "tavily",
+      startedAt,
+      response.status === 429
+        ? "Tavily Search rate limit exceeded after retries. Try again shortly."
+        : `Tavily Search API returned status ${response.status}`,
+    );
   }
 
-  return {
-    content:
-      "Error: Tavily Search rate limit exceeded after retries. Try again shortly.",
-    isError: true,
-  };
+  return errorResult(
+    query,
+    "tavily",
+    startedAt,
+    "Tavily Search rate limit exceeded after retries. Try again shortly.",
+  );
 }
 
 // ----------------------------------------------------------------------------
@@ -573,6 +696,7 @@ class WebSearchTool implements Tool {
       };
     }
 
+    const startedAt = Date.now();
     let provider = getWebSearchProvider();
     let apiKey = await getApiKey(provider);
 
@@ -594,11 +718,12 @@ class WebSearchTool implements Tool {
       }
 
       if (!apiKey) {
-        return {
-          content:
-            "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,
-        };
+        return errorResult(
+          query,
+          provider,
+          startedAt,
+          "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.",
+        );
       }
     }
 
@@ -627,7 +752,7 @@ class WebSearchTool implements Tool {
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       log.error({ err }, "Web search failed");
-      return { content: `Error: Web search failed: ${msg}`, isError: true };
+      return errorResult(query, provider, startedAt, `Web search failed: ${msg}`);
     }
   }
 }

package/src/tools/registry.ts

@@ -10,7 +10,7 @@ import { hostFileWriteTool } from "./host-filesystem/write.js";
 import { hostShellTool } from "./host-terminal/host-shell.js";
 import { toProviderSafeToolName } from "./provider-tool-name.js";
 import { registerSystemTools } from "./system/register.js";
-import type { PluginTool, Tool } from "./types.js";
+import type { LoadedPluginTool, Tool } from "./types.js";
 import { allUiSurfaceTools } from "./ui-surface/definitions.js";
 import { registerUiSurfaceTools } from "./ui-surface/registry.js";
 
@@ -193,7 +193,7 @@ export function registerSkillTools(newTools: Tool[]): Tool[] {
  */
 export function registerPluginTools(
   pluginName: string,
-  newTools: PluginTool[],
+  newTools: LoadedPluginTool[],
 ): Tool[] {
   const stamped: Tool[] = newTools.map((pluginTool) => {
     const { input_schema, ...rest } = pluginTool;

package/src/tools/terminal/safe-env.ts

@@ -61,12 +61,13 @@ export const SAFE_ENV_VARS = [
 ] as const;
 
 export const KATA_SAFE_ENV_VARS = [
-  "LD_LIBRARY_PATH",
   "VELLUM_APT_DATA_ROOT",
   "VELLUM_APT_DATA_SUITE",
   "VELLUM_APT_DATA_MIRROR",
 ] as const;
 
+export const KATA_INJECTED_ENV_VARS = ["LD_LIBRARY_PATH"] as const;
+
 const KATA_APT_DATA_ROOT = "/data/system";
 
 function kataAptPaths(dataRoot: string): string[] {
@@ -132,7 +133,7 @@ export function buildSanitizedEnv(): Record<string, string> {
     env.VELLUM_APT_DATA_ROOT = kataAptDataRoot;
     env.PATH = appendUniquePathEntries(env.PATH, kataAptPaths(kataAptDataRoot));
     env.LD_LIBRARY_PATH = appendUniquePathEntries(
-      env.LD_LIBRARY_PATH,
+      undefined,
       kataAptLibraryPaths(kataAptDataRoot),
     );
   }

package/src/tools/tool-approval-handler.ts

@@ -334,9 +334,19 @@ export class ToolApprovalHandler {
       return { allowed: false, result: { content: msg, isError: true } };
     }
 
-    // Gate tools not active for the current turn
-    if (context.allowedToolNames && !context.allowedToolNames.has(name)) {
-      const msg = `Tool "${name}" is not currently active. Load the skill that provides this tool first.`;
+    // Look up the tool before the allowedToolNames gate so a name no skill
+    // provides surfaces as "Unknown tool" (with the real list) instead of
+    // the misleading "load the skill" hint.
+    const tool = getTool(name);
+    if (!tool) {
+      const allowedToolNames = context.allowedToolNames;
+      const available = getAllTools()
+        .filter((t) => t.executionMode !== "proxy" || context.proxyToolResolver)
+        .map((t) => t.name)
+        .filter((n) => !allowedToolNames || allowedToolNames.has(n))
+        .sort()
+        .join(", ");
+      const msg = `Unknown tool: ${name}. Available tools: ${available}`;
       const durationMs = Date.now() - startTime;
       emitLifecycleEvent({
         type: "error",
@@ -356,15 +366,12 @@ export class ToolApprovalHandler {
       return { allowed: false, result: { content: msg, isError: true } };
     }
 
-    // Resolve the tool from the registry
-    const tool = getTool(name);
-    if (!tool) {
-      const available = getAllTools()
-        .filter((t) => t.executionMode !== "proxy" || context.proxyToolResolver)
-        .map((t) => t.name)
-        .sort()
-        .join(", ");
-      const msg = `Unknown tool: ${name}. Available tools: ${available}`;
+    // Gate tools not active for the current turn
+    if (context.allowedToolNames && !context.allowedToolNames.has(name)) {
+      const loadHint = tool.ownerSkillId
+        ? `Load the "${tool.ownerSkillId}" skill that provides this tool first.`
+        : `Load the skill that provides this tool first.`;
+      const msg = `Tool "${name}" is not currently active. ${loadHint}`;
       const durationMs = Date.now() - startTime;
       emitLifecycleEvent({
         type: "error",

package/src/tools/types.ts

@@ -14,6 +14,7 @@ import type {
 
 import type { InterfaceId } from "../channels/types.js";
 import type { CesClient } from "../credential-execution/client.js";
+import type { ToolActivityMetadata } from "../daemon/message-types/web-activity.js";
 import type { SecretPromptResult } from "../permissions/secret-prompter.js";
 import type { ContentBlock } from "../providers/types.js";
 import type { TrustClass } from "../runtime/actor-trust-resolver.js";
@@ -163,6 +164,9 @@ export interface ToolExecutionResult extends PluginToolExecutionResult {
    * approval flow transparently.
    */
   cesApprovalRequired?: ApprovalRequired;
+  /** Structured activity metadata for client rendering (web search, web fetch, etc).
+   *  Populated by daemon-internal tools; plugins must not set this. */
+  activityMetadata?: ToolActivityMetadata;
 }
 
 export type ProxyToolResolver = (
@@ -376,16 +380,51 @@ export interface Tool {
 
 /**
  * Plugin-facing tool shape. The narrow surface plugin authors implement;
- * differs from {@link Tool} in three ways:
+ * differs from {@link Tool} in four ways:
  * - Plugins declare `input_schema` as a top-level field instead of
  *   implementing `getDefinition()`. The registration boundary synthesizes
  *   `getDefinition()` from `{name, description, input_schema}` before the
  *   tool enters the internal registry.
+ * - `name` is derived from the tool file's basename by the external plugin
+ *   loader.
  * - `category` is registry-owned and stamped to `"plugin"` when the tool is
  *   registered.
  * - All ownership stamps (`origin`, `ownerPluginId`, etc.) are set
  *   authoritatively by the bootstrap; plugin authors leave them blank.
+ *
+ * Every author-visible field is optional. The loader fills the four
+ * normally-required slots (`description`, `defaultRiskLevel`,
+ * `input_schema`, `execute`) with documented defaults when a plugin omits
+ * them — see `applyPluginToolDefaults` in `external-plugin-loader.ts`.
+ * A nameless, body-less `export default {}` is a valid (if useless) tool;
+ * misconfigured tools surface at call time rather than blocking plugin
+ * load.
+ */
+export type PluginTool = Omit<
+  Tool,
+  "category" | "getDefinition" | "name" | "description" | "defaultRiskLevel"
+> & {
+  description?: string;
+  defaultRiskLevel?: RiskLevel;
+  input_schema?: object;
+  execute?: (
+    input: Record<string, unknown>,
+    context: ToolContext,
+  ) => Promise<ToolExecutionResult>;
+};
+
+/**
+ * Plugin tool after the external loader has derived its registry name and
+ * filled defaults for any author-omitted fields. All four normally-required
+ * slots are guaranteed present.
  */
-export type PluginTool = Omit<Tool, "category" | "getDefinition"> & {
+export type LoadedPluginTool = PluginTool & {
+  name: string;
+  description: string;
+  defaultRiskLevel: RiskLevel;
   input_schema: object;
+  execute: (
+    input: Record<string, unknown>,
+    context: ToolContext,
+  ) => Promise<ToolExecutionResult>;
 };

package/src/tools/ui-surface/definitions.ts

@@ -36,7 +36,8 @@ export const uiShowTool: Tool = {
     '- list: { items: [{ id, title, subtitle?, icon?, selected? }], selectionMode: "single"|"multiple"|"none" }\n' +
     "- confirmation: { message, detail?, confirmLabel?, confirmedLabel?, cancelLabel?, destructive? }\n" +
     "- dynamic_page: { html, width?, height?, preview?: { title, subtitle?, description?, icon?, metrics?: [{ label, value }] } }\n" +
-    "- file_upload: { prompt, acceptedTypes?, maxFiles? }\n\n" +
+    "- file_upload: { prompt, acceptedTypes?, maxFiles? }\n" +
+    "- task_preferences: {} (no data needed — categories are rendered client-side)\n\n" +
     "Proactively show a task_progress card before multi-step or long-running work (web searches, file operations, research). Show it before your first tool call, then update steps as work progresses.",
   category: "ui-surface",
   defaultRiskLevel: RiskLevel.Low,
@@ -59,6 +60,7 @@ export const uiShowTool: Tool = {
               "confirmation",
               "dynamic_page",
               "file_upload",
+              "task_preferences",
             ],
             description: "The type of surface to display",
           },

package/src/types/onboarding-context.ts

@@ -4,6 +4,10 @@ export interface OnboardingContext {
   tone: string;
   userName?: string;
   assistantName?: string;
+  priorAssistants?: string[];
   googleConnected?: boolean;
   googleScopes?: string[];
+  cohort?: string;
+  websiteUrl?: string;
+  contentSourceUrl?: string;
 }

package/src/util/__tests__/favicon.test.ts

@@ -0,0 +1,84 @@
+import { describe, expect, test } from "bun:test";
+
+import { faviconUrlForDomain } from "../favicon.js";
+
+describe("faviconUrlForDomain", () => {
+  test("returns a properly encoded s2 URL for a valid host", () => {
+    expect(faviconUrlForDomain("example.com")).toBe(
+      "https://www.google.com/s2/favicons?domain=example.com&sz=64",
+    );
+  });
+
+  test("lowercases mixed-case hosts before encoding", () => {
+    expect(faviconUrlForDomain("Example.COM")).toBe(
+      "https://www.google.com/s2/favicons?domain=example.com&sz=64",
+    );
+  });
+
+  test("returns undefined for empty input", () => {
+    expect(faviconUrlForDomain("")).toBeUndefined();
+  });
+
+  test("returns undefined for whitespace-only input", () => {
+    expect(faviconUrlForDomain("   ")).toBeUndefined();
+  });
+
+  test("returns undefined for hosts containing a slash", () => {
+    expect(faviconUrlForDomain("example.com/path")).toBeUndefined();
+  });
+
+  test("returns undefined for hosts containing a space", () => {
+    expect(faviconUrlForDomain("example .com")).toBeUndefined();
+  });
+
+  test("URL-encodes unicode/IDN hosts", () => {
+    // Punycode-style raw unicode host should be percent-encoded by encodeURIComponent.
+    const result = faviconUrlForDomain("münchen.de");
+    expect(result).toBe(
+      `https://www.google.com/s2/favicons?domain=${encodeURIComponent("münchen.de")}&sz=64`,
+    );
+    // Sanity check: the encoded form contains percent-encoded bytes for "ü".
+    expect(result).toContain("m%C3%BCnchen.de");
+  });
+
+  test("returns undefined for localhost", () => {
+    expect(faviconUrlForDomain("localhost")).toBeUndefined();
+  });
+
+  test("returns undefined for private IPv4 hosts", () => {
+    expect(faviconUrlForDomain("127.0.0.1")).toBeUndefined();
+    expect(faviconUrlForDomain("10.0.0.5")).toBeUndefined();
+    expect(faviconUrlForDomain("192.168.1.1")).toBeUndefined();
+  });
+
+  test("returns undefined for any raw IPv4 literal — private or public", () => {
+    // We can't tell from the host alone whether an IP belongs to a routable
+    // public host or an internal one, so all IP literals are rejected to avoid
+    // leaking the address to Google when the client renders the icon.
+    expect(faviconUrlForDomain("172.16.0.1")).toBeUndefined();
+    expect(faviconUrlForDomain("8.8.8.8")).toBeUndefined();
+    expect(faviconUrlForDomain("1.1.1.1")).toBeUndefined();
+  });
+
+  test("returns undefined for raw IPv6 literals (bracketed or bare)", () => {
+    expect(faviconUrlForDomain("2001:db8::1")).toBeUndefined();
+    expect(faviconUrlForDomain("[2001:db8::1]")).toBeUndefined();
+  });
+
+  test("strips :port before the private-host check (host:port → undefined for private)", () => {
+    expect(faviconUrlForDomain("localhost:3000")).toBeUndefined();
+    expect(faviconUrlForDomain("127.0.0.1:8080")).toBeUndefined();
+    expect(faviconUrlForDomain("192.168.1.1:443")).toBeUndefined();
+  });
+
+  test("strips :port and encodes only the host (public host with port)", () => {
+    const result = faviconUrlForDomain("example.com:8080");
+    expect(result).toBe(
+      "https://www.google.com/s2/favicons?domain=example.com&sz=64",
+    );
+  });
+
+  test("handles bracketed IPv6 hosts with ports", () => {
+    expect(faviconUrlForDomain("[::1]:8080")).toBeUndefined();
+  });
+});