@vellumai/assistant 0.12.3-staging.1 → 0.12.3-staging.2

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

@@ -1,8 +1,8 @@
-import { getConfig } from "../../config/loader.js";
 import type {
   WebSearchMetadata,
   WebSearchResultItem,
-} from "../../daemon/message-types/web-activity.js";
+} from "../../api/events/tool-result.js";
+import { getConfig } from "../../config/loader.js";
 import { RiskLevel } from "../../permissions/types.js";
 import { getProviderKeyAsync } from "../../security/secure-keys.js";
 import { wrapUntrustedContent } from "../../security/untrusted-content.js";
@@ -44,6 +44,7 @@ const PERPLEXITY_API_URL = "https://api.perplexity.ai/chat/completions";
 const TAVILY_API_URL = "https://api.tavily.com/search";
 const FIRECRAWL_API_URL = "https://api.firecrawl.dev/v2/search";
 const FASTCRW_SEARCH_PATH = "/v1/search";
+const TINYFISH_DEFAULT_SEARCH_API_BASE = "https://api.search.tinyfish.ai";
 // Keenable is keyless by default: the public path needs no key (rate-limited);
 // a key switches to the authenticated path and lifts the cap.
 const KEENABLE_API_BASE_URL = "https://api.keenable.ai";
@@ -56,7 +57,9 @@ type WebSearchProvider =
   | "tavily"
   | "firecrawl"
   | "keenable"
-  | "fastcrw";
+  | "fastcrw"
+  | "searxng"
+  | "tinyfish";
 
 /**
  * Arguments passed to every {@link WebSearchAdapter}. The full superset is
@@ -167,6 +170,38 @@ interface KeenableSearchResponse {
   results?: KeenableSearchResult[];
 }
 
+interface SearxngSearchResult {
+  title?: string;
+  url?: string;
+  content?: string;
+}
+
+interface SearxngSearchResponse {
+  query?: string;
+  results?: SearxngSearchResult[];
+}
+
+interface TinyfishSearchResult {
+  position?: number;
+  site_name?: string;
+  title?: string;
+  snippet?: string;
+  url?: string;
+  date?: string;
+}
+
+interface TinyfishSearchResponse {
+  query?: string;
+  results?: TinyfishSearchResult[];
+  total_results?: number;
+  page?: number;
+}
+
+const SEARXNG_MISSING_INSTANCE_MESSAGE =
+  "SearXNG needs an instance URL. Set API Base in Settings under Web Search.";
+const SEARXNG_JSON_DISABLED_MESSAGE =
+  "This SearXNG instance did not return JSON. Enable the JSON format on the instance, or point API Base at an instance that allows it.";
+
 function getWebSearchProvider(): WebSearchProvider {
   const config = getConfig();
   const configured = config.services["web-search"].provider ?? "perplexity";
@@ -573,6 +608,159 @@ function buildKeenableMetadata(
   };
 }
 
+function formatSearxngResults(
+  data: SearxngSearchResponse,
+  query: string,
+): string {
+  const results = data.results ?? [];
+  if (results.length === 0) {
+    return `No results found for "${query}".`;
+  }
+
+  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}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+function buildSearxngMetadata(
+  data: SearxngSearchResponse,
+  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: faviconUrlForDomain(domain),
+      snippet: r.content?.trim() || undefined,
+    };
+  });
+  return {
+    query,
+    provider: "searxng",
+    resultCount: items.length,
+    durationMs,
+    results: items,
+  };
+}
+
+function formatTinyfishResults(
+  data: TinyfishSearchResponse,
+  query: string,
+): string {
+  const results = data.results ?? [];
+  if (results.length === 0) {
+    return `No results found for "${query}".`;
+  }
+
+  const lines: string[] = [`Web search results for "${query}":\n`];
+  for (let i = 0; i < results.length; i++) {
+    const result = results[i];
+    const title =
+      result.title?.trim() || result.url?.trim() || "Untitled result";
+    lines.push(`${i + 1}. ${title}`);
+    if (result.url) {
+      lines.push(`   URL: ${result.url}`);
+    }
+    if (result.snippet) {
+      lines.push(`   ${result.snippet}`);
+    }
+    if (result.date) {
+      lines.push(`   Published: ${result.date}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+function buildTinyfishMetadata(
+  data: TinyfishSearchResponse,
+  query: string,
+  durationMs: number,
+): WebSearchMetadata {
+  const results = data.results ?? [];
+  const items: WebSearchResultItem[] = results.map((result, index) => {
+    const url = result.url ?? "";
+    const domain = extractDomain(url);
+    return {
+      rank: index + 1,
+      title: result.title?.trim() || url.trim() || "Untitled result",
+      url,
+      domain,
+      faviconUrl: faviconUrlForDomain(domain),
+      snippet: result.snippet?.trim() || undefined,
+    };
+  });
+  return {
+    query,
+    provider: "tinyfish",
+    resultCount: items.length,
+    durationMs,
+    results: items,
+  };
+}
+
+function tinyfishRecencyMinutesForFreshness(
+  freshness: string | undefined,
+): number | undefined {
+  switch (freshness) {
+    case "pd":
+      return 24 * 60;
+    case "pw":
+      return 7 * 24 * 60;
+    case "pm":
+      return 30 * 24 * 60;
+    case "py":
+      return 365 * 24 * 60;
+    default:
+      return undefined;
+  }
+}
+
+/**
+ * Map the tool's `freshness` window onto SearXNG's `time_range`
+ * (`day` / `month` / `year`). SearXNG has no week filter, so `pw` is omitted.
+ */
+function searxngTimeRangeForFreshness(
+  freshness: string | undefined,
+): "day" | "month" | "year" | undefined {
+  switch (freshness) {
+    case "pd":
+      return "day";
+    case "pm":
+      return "month";
+    case "py":
+      return "year";
+    default:
+      return undefined;
+  }
+}
+
+function isNonJsonSearchBody(contentType: string, bodyText: string): boolean {
+  const type = contentType.toLowerCase();
+  if (type.includes("text/html") || type.includes("application/xhtml")) {
+    return true;
+  }
+  const trimmed = bodyText.trimStart();
+  return trimmed.startsWith("<");
+}
+
 /**
  * Map the tool's `freshness` window onto a Keenable `published_after` date
  * (YYYY-MM-DD). Keenable filters by absolute publication date rather than a
@@ -1358,6 +1546,261 @@ async function executeKeenableSearch(
   );
 }
 
+async function executeSearxngSearch(
+  query: string,
+  count: number,
+  freshness: string | undefined,
+  apiKey: string,
+  signal?: AbortSignal,
+): Promise<ToolExecutionResult> {
+  const startedAt = Date.now();
+  const apiBase = getConfig().services["web-search"]?.apiBase?.trim() ?? "";
+  if (apiBase.length === 0) {
+    return errorResult(
+      query,
+      "searxng",
+      startedAt,
+      SEARXNG_MISSING_INSTANCE_MESSAGE,
+    );
+  }
+
+  const params = new URLSearchParams({
+    q: query,
+    format: "json",
+  });
+  const timeRange = searxngTimeRangeForFreshness(freshness);
+  if (timeRange) {
+    params.set("time_range", timeRange);
+  }
+  const url = `${resolveProviderApiUrl(apiBase, "/search", apiBase)}?${params.toString()}`;
+
+  const headers: Record<string, string> = {
+    Accept: "application/json",
+  };
+  const trimmedKey = apiKey.trim();
+  if (trimmedKey.length > 0) {
+    headers.Authorization = `Bearer ${trimmedKey}`;
+  }
+
+  for (let attempt = 0; attempt <= DEFAULT_MAX_RETRIES; attempt++) {
+    let response: Response;
+    try {
+      response = await fetch(url, {
+        headers,
+        signal,
+      });
+    } catch (err) {
+      return networkFailureResult(query, "searxng", startedAt, err, signal);
+    }
+
+    const bodyText = await response.text();
+    const contentType = response.headers.get("content-type") ?? "";
+    if (isNonJsonSearchBody(contentType, bodyText)) {
+      return errorResult(
+        query,
+        "searxng",
+        startedAt,
+        SEARXNG_JSON_DISABLED_MESSAGE,
+      );
+    }
+
+    if (response.ok) {
+      let data: SearxngSearchResponse;
+      try {
+        data = JSON.parse(bodyText) as SearxngSearchResponse;
+      } catch {
+        return errorResult(
+          query,
+          "searxng",
+          startedAt,
+          SEARXNG_JSON_DISABLED_MESSAGE,
+        );
+      }
+      if (data.results && data.results.length > count) {
+        data.results = data.results.slice(0, count);
+      }
+      const durationMs = Date.now() - startedAt;
+      return {
+        content:
+          wrapUntrustedContent(formatSearxngResults(data, query), {
+            source: "search",
+            sourceDetail: "searxng",
+          }) + CITATION_INSTRUCTION,
+        isError: false,
+        activityMetadata: {
+          webSearch: buildSearxngMetadata(data, query, durationMs),
+        },
+      };
+    }
+
+    if (response.status === 401 || response.status === 403) {
+      return errorResult(
+        query,
+        "searxng",
+        startedAt,
+        "SearXNG rejected the request. Check the instance URL, optional token, and that JSON search is enabled.",
+      );
+    }
+
+    if (response.status === 429 && attempt < DEFAULT_MAX_RETRIES) {
+      const delayMs = getHttpRetryDelay(
+        response,
+        attempt,
+        DEFAULT_BASE_DELAY_MS,
+      );
+      log.warn(
+        { attempt: attempt + 1, delayMs },
+        "SearXNG Search rate limited, retrying",
+      );
+      await sleep(delayMs);
+      continue;
+    }
+
+    log.warn({ status: response.status }, "SearXNG Search API error");
+    return backendFailureResult(
+      query,
+      "searxng",
+      startedAt,
+      { statusCode: response.status, error: rawBodyDetail(bodyText) },
+      response.status === 429
+        ? "SearXNG Search rate limit exceeded after retries. Try again shortly."
+        : `SearXNG Search API returned status ${response.status}`,
+    );
+  }
+
+  return backendFailureResult(
+    query,
+    "searxng",
+    startedAt,
+    { statusCode: 429 },
+    "SearXNG Search rate limit exceeded after retries. Try again shortly.",
+  );
+}
+
+async function executeTinyfishSearch(
+  query: string,
+  count: number,
+  freshness: string | undefined,
+  apiKey: string,
+  signal?: AbortSignal,
+): Promise<ToolExecutionResult> {
+  const startedAt = Date.now();
+  const apiBase = getConfig().services["web-search"]?.apiBase;
+  const endpoint = resolveProviderApiUrl(
+    apiBase,
+    "/",
+    TINYFISH_DEFAULT_SEARCH_API_BASE,
+  );
+  const url = new URL(endpoint);
+  url.searchParams.set("query", query);
+  const recencyMinutes = tinyfishRecencyMinutesForFreshness(freshness);
+  if (recencyMinutes !== undefined) {
+    url.searchParams.set("recency_minutes", String(recencyMinutes));
+  }
+
+  const headers = {
+    Accept: "application/json",
+    "X-API-Key": apiKey.trim(),
+  };
+
+  for (let attempt = 0; attempt <= DEFAULT_MAX_RETRIES; attempt++) {
+    let response: Response;
+    try {
+      response = await fetch(url.toString(), { headers, signal });
+    } catch (err) {
+      return networkFailureResult(query, "tinyfish", startedAt, err, signal);
+    }
+
+    const bodyText = await response.text();
+    if (response.ok) {
+      let data: TinyfishSearchResponse;
+      try {
+        data = JSON.parse(bodyText) as TinyfishSearchResponse;
+      } catch {
+        return errorResult(
+          query,
+          "tinyfish",
+          startedAt,
+          "TinyFish Search returned an invalid JSON payload.",
+        );
+      }
+      if (data.results && data.results.length > count) {
+        data.results = data.results.slice(0, count);
+      }
+      const durationMs = Date.now() - startedAt;
+      return {
+        content:
+          wrapUntrustedContent(formatTinyfishResults(data, query), {
+            source: "search",
+            sourceDetail: "tinyfish",
+          }) + CITATION_INSTRUCTION,
+        isError: false,
+        activityMetadata: {
+          webSearch: buildTinyfishMetadata(data, query, durationMs),
+        },
+      };
+    }
+
+    if (response.status === 401) {
+      return errorResult(
+        query,
+        "tinyfish",
+        startedAt,
+        "Invalid or expired TinyFish API key",
+      );
+    }
+    if (response.status === 402) {
+      return errorResult(
+        query,
+        "tinyfish",
+        startedAt,
+        "TinyFish Search API access is not enabled for this account.",
+      );
+    }
+    if (response.status === 403) {
+      return errorResult(
+        query,
+        "tinyfish",
+        startedAt,
+        "TinyFish Search request was forbidden by the upstream service.",
+      );
+    }
+
+    if (response.status === 429 && attempt < DEFAULT_MAX_RETRIES) {
+      const delayMs = getHttpRetryDelay(
+        response,
+        attempt,
+        DEFAULT_BASE_DELAY_MS,
+      );
+      log.warn(
+        { attempt: attempt + 1, delayMs },
+        "TinyFish Search rate limited, retrying",
+      );
+      await sleep(delayMs);
+      continue;
+    }
+
+    log.warn({ status: response.status }, "TinyFish Search API error");
+    return backendFailureResult(
+      query,
+      "tinyfish",
+      startedAt,
+      { statusCode: response.status, error: rawBodyDetail(bodyText) },
+      response.status === 429
+        ? "TinyFish Search rate limit exceeded after retries. Try again shortly."
+        : `TinyFish Search API returned status ${response.status}`,
+    );
+  }
+
+  return backendFailureResult(
+    query,
+    "tinyfish",
+    startedAt,
+    { statusCode: 429 },
+    "TinyFish Search rate limit exceeded after retries. Try again shortly.",
+  );
+}
+
 // ----------------------------------------------------------------------------
 // Adapter registry
 //
@@ -1424,6 +1867,23 @@ const fastcrwSearchAdapter: WebSearchAdapter = {
     executeFastcrwSearch(query, count, freshness, apiKey, signal),
 };
 
+const searxngSearchAdapter: WebSearchAdapter = {
+  id: "searxng",
+  providerKeyName: "searxng",
+  fallbackOrder: 7,
+  keyless: true,
+  execute: ({ query, count, freshness, apiKey, signal }) =>
+    executeSearxngSearch(query, count, freshness, apiKey, signal),
+};
+
+const tinyfishSearchAdapter: WebSearchAdapter = {
+  id: "tinyfish",
+  providerKeyName: "tinyfish",
+  fallbackOrder: 8,
+  execute: ({ query, count, freshness, apiKey, signal }) =>
+    executeTinyfishSearch(query, count, freshness, apiKey, signal),
+};
+
 /**
  * All built-in web-search adapters keyed by provider id. The
  * `Record<WebSearchProvider, ...>` shape forces TypeScript to flag any
@@ -1436,6 +1896,8 @@ const WEB_SEARCH_ADAPTERS: Record<WebSearchProvider, WebSearchAdapter> = {
   firecrawl: firecrawlSearchAdapter,
   keenable: keenableSearchAdapter,
   fastcrw: fastcrwSearchAdapter,
+  searxng: searxngSearchAdapter,
+  tinyfish: tinyfishSearchAdapter,
 };
 
 /**
@@ -1467,7 +1929,7 @@ export const webSearchTool = {
       count: {
         type: "number",
         description:
-          "Number of results to return (1-20, default 10). Used with Brave, Tavily, Firecrawl, Keenable, and fastCRW providers.",
+          "Number of results to return (1-20, default 10). Used with Brave, Tavily, Firecrawl, Keenable, fastCRW, SearXNG, and TinyFish providers.",
       },
       offset: {
         type: "number",
@@ -1477,7 +1939,7 @@ export const webSearchTool = {
       freshness: {
         type: "string",
         description:
-          'Filter by recency: "pd" (past day), "pw" (past week), "pm" (past month), "py" (past year). Used with Brave, Tavily, Firecrawl, Keenable, and fastCRW providers.',
+          'Filter by recency: "pd" (past day), "pw" (past week), "pm" (past month), "py" (past year). Used with Brave, Tavily, Firecrawl, Keenable, fastCRW, SearXNG, and TinyFish providers. SearXNG maps day/month/year and omits week.',
       },
     },
     required: ["query"],
@@ -1593,7 +2055,7 @@ export const webSearchTool = {
           query,
           provider,
           startedAt,
-          "No web search API key configured. Set it via `keys set perplexity <key>`, `keys set brave <key>`, `keys set tavily <key>`, `keys set firecrawl <key>`, or `keys set fastcrw <key>`, or configure it from the Settings page under API Keys. Or switch the web-search provider to Keenable, which works without a key.",
+          "No web search API key configured. Set it via `keys set perplexity <key>`, `keys set brave <key>`, `keys set tavily <key>`, `keys set firecrawl <key>`, or `keys set fastcrw <key>`, or `keys set tinyfish <key>`, or configure it from the Settings page under API Keys. Or switch the web-search provider to Keenable, which works without a key, or SearXNG with your instance URL.",
         );
       }
     }

package/src/tools/permission-checker.ts

@@ -119,8 +119,8 @@ export class PermissionChecker {
     >,
     classification?: RiskClassificationWithMeta,
   ): Promise<PermissionDecision> {
-    // Sandbox/host routing for the prompt comes from the tool's manifest.
-    const executionTarget = resolveExecutionTarget(tool);
+    // Policy and prompts use the invocation's execution target.
+    const executionTarget = resolveExecutionTarget(tool, input, context);
     classification ??= await classifyRisk(
       name,
       input,
@@ -149,7 +149,7 @@ export class PermissionChecker {
     // this, the executor's catch block would fall back to the default
     // low risk, degrading audit/alert accuracy for high-risk attempts.
     try {
-      const policyContext = buildPolicyContext(tool, context);
+      const policyContext = buildPolicyContext(tool, context, input);
       const result = await check(
         name,
         input,

package/src/tools/policy-context.ts

@@ -3,6 +3,7 @@ import { isSkillImprovementActive } from "../config/memory-v3-gate.js";
 import type { ExecutionContext } from "../permissions/approval-policy.js";
 import type { ChannelPermissionCoordinates } from "../permissions/channel-permission-query.js";
 import type { PolicyContext } from "../permissions/types.js";
+import { resolveExecutionTarget } from "./execution-target.js";
 import { getToolOwner } from "./registry.js";
 import type { Tool, ToolContext } from "./types.js";
 
@@ -48,6 +49,7 @@ function deriveExecutionContext(context?: ToolContext): ExecutionContext {
 export function buildPolicyContext(
   tool: Tool,
   context?: ToolContext,
+  input?: Record<string, unknown>,
 ): PolicyContext {
   const executionContext = deriveExecutionContext(context);
 
@@ -73,7 +75,7 @@ export function buildPolicyContext(
   const ownerKind = getToolOwner(tool.name)?.kind;
   if (ownerKind === "skill" || ownerKind === "plugin") {
     return {
-      executionTarget: tool.executionTarget,
+      executionTarget: resolveExecutionTarget(tool, input, context),
       executionContext,
       conversationId,
       ...originSignals,

package/src/tools/skills/load.ts

@@ -90,12 +90,13 @@ function formatToolSchemas(
   manifest: SkillToolManifest,
   context: Pick<
     ToolContext,
-    "clientOs" | "transportInterface" | "sourceActorPrincipalId"
+    "clientOs" | "transportInterface" | "sourceActorPrincipalId" | "trustClass"
   >,
   childSkillName?: string,
 ): string | undefined {
   const tools = manifest.tools.filter((tool) =>
     supportsClientOsForSkillTool(tool.supported_client_os, tool.name, {
+      trustClass: context.trustClass,
       clientOs: context.clientOs,
       transportInterface: context.transportInterface,
       sourceActorPrincipalId: context.sourceActorPrincipalId,

package/src/tools/skills/sandbox-runner.ts

@@ -3,6 +3,7 @@ import { randomUUID } from "node:crypto";
 import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 
+import { PLUGIN_NAME_ENV } from "../../plugin-api/plugin-name-env.js";
 import { conversationRevealNonce } from "../../runtime/reveal-nonce.js";
 import { computeSkillVersionHash } from "../../skills/version-hash.js";
 import {
@@ -74,6 +75,7 @@ export async function runSkillToolScriptSandbox(
     timeoutMs?: number;
     expectedSkillVersionHash?: string;
     skillDirHashResolver?: (skillDir: string) => string;
+    pluginOwner?: string;
   },
 ): Promise<ToolExecutionResult> {
   const scriptPath = resolve(join(skillDir, executorPath));
@@ -117,7 +119,9 @@ export async function runSkillToolScriptSandbox(
       "utf-8",
     );
 
-    return await spawnRunner(runDir, input, context, timeoutMs, executorPath);
+    return await spawnRunner(runDir, input, context, timeoutMs, executorPath, {
+      pluginOwner: options?.pluginOwner,
+    });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     return {
@@ -139,6 +143,7 @@ function spawnRunner(
   context: ToolContext,
   timeoutMs: number,
   executorPath: string,
+  pluginContext?: { pluginOwner?: string },
 ): Promise<ToolExecutionResult> {
   return new Promise<ToolExecutionResult>((resolve) => {
     const stdoutChunks: Buffer[] = [];
@@ -156,9 +161,13 @@ function spawnRunner(
       conversationId: context.conversationId,
     });
     env.__CONVERSATION_ID = context.conversationId;
-    // Secret binding for reveal-derived chat authority — see reveal-nonce.ts.
+    // Secret binding for reveal-derived chat authority. See reveal-nonce.ts.
     env.__REVEAL_NONCE = conversationRevealNonce(context.conversationId);
 
+    if (pluginContext?.pluginOwner) {
+      env[PLUGIN_NAME_ENV] = pluginContext.pluginOwner;
+    }
+
     const child = spawn(wrapped.command, wrapped.args, {
       cwd: runDir,
       env,

package/src/tools/skills/skill-script-runner.ts

@@ -24,6 +24,12 @@ export interface RunSkillToolScriptOptions {
    *  with `execution_target: host` (in-process); non-bundled skills are forced to
    *  execute in the sandbox. */
   bundled?: boolean;
+  /**
+   * Catalog owner id when this skill is plugin-resident. The sandbox runner
+   * sets VELLUM_PLUGIN_NAME so the child can resolve credentials under
+   * that plugin's service.
+   */
+  pluginOwner?: string;
 }
 
 /**
@@ -42,6 +48,7 @@ export async function runSkillToolScript(
       timeoutMs: options.timeoutMs,
       expectedSkillVersionHash: options.expectedSkillVersionHash,
       skillDirHashResolver: options.skillDirHashResolver,
+      pluginOwner: options.pluginOwner,
     });
   }