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

package/src/tools/document/document-tool.ts

@@ -1,9 +1,9 @@
-import { randomUUID } from "node:crypto";
-
 import { z } from "zod";
 
 import {
   addDocumentConversation,
+  createDocument,
+  DEFAULT_DOCUMENT_TITLE,
   deleteDocument,
   findInDocument,
   findRecentEmptyDocumentByTitle,
@@ -11,7 +11,6 @@ import {
   getDocumentsForConversation,
   isDocumentAssociatedWithConversation,
   replaceInDocument,
-  saveDocument,
   searchDocumentsByTitle,
   updateDocumentContent,
 } from "../../documents/document-store.js";
@@ -23,10 +22,6 @@ import {
 } from "../shared/zod-tool-schema.js";
 import type { ToolContext, ToolExecutionResult } from "../types.js";
 
-function isPrivilegedDocumentActor(context: ToolContext): boolean {
-  return canActOnPrivilegedDocuments(context);
-}
-
 export function documentNotFound(surfaceId: string): ToolExecutionResult {
   return {
     content: JSON.stringify({
@@ -43,7 +38,7 @@ export function canAccessDocument(
   context: ToolContext,
 ): boolean {
   return (
-    isPrivilegedDocumentActor(context) ||
+    canActOnPrivilegedDocuments(context) ||
     isDocumentAssociatedWithConversation(surfaceId, context.conversationId)
   );
 }
@@ -287,7 +282,7 @@ export function executeDocumentCreate(
     return invalidToolInputResult("document_create", parsedInput.error);
   }
   throwIfCancelled(context);
-  const title = parsedInput.data.title || "Untitled Document";
+  const title = parsedInput.data.title || DEFAULT_DOCUMENT_TITLE;
   const initialContent = parsedInput.data.initial_content || "";
 
   const reused = maybeReuseEmptyDocument(title, initialContent, context);
@@ -295,21 +290,21 @@ export function executeDocumentCreate(
     return reused;
   }
 
-  const surfaceId = `doc-${randomUUID()}`;
-
   // Persist the document so any client (web or macOS) can fetch it via
   // GET /v1/documents/:id. The macOS client may later update the row
   // via document_save; ON CONFLICT DO UPDATE handles that.
-  const wordCount = initialContent
-    .split(/\s+/)
-    .filter((w) => w.length > 0).length;
-  saveDocument({
-    surfaceId,
+  const created = createDocument({
     conversationId: context.conversationId,
     title,
     content: initialContent,
-    wordCount,
   });
+  if (!created.success) {
+    return {
+      content: JSON.stringify({ success: false, error: created.error }),
+      isError: true,
+    };
+  }
+  const { surfaceId } = created;
 
   // Send document_editor_show message to open the built-in RTE
   if (context.sendToClient) {
@@ -522,7 +517,7 @@ export function executeDocumentList(
   const docs = query
     ? searchDocumentsByTitle(
         query,
-        isPrivilegedDocumentActor(context)
+        canActOnPrivilegedDocuments(context)
           ? {}
           : { conversationId: context.conversationId },
       )

package/src/tools/execution-target.ts

@@ -1,26 +1,24 @@
 import type { ExecutionTarget } from "./tool-types.js";
+import type { Tool, ToolContext } from "./types.js";
 
 export interface ManifestOverride {
   risk: "low" | "medium" | "high";
   execution_target: "host" | "sandbox";
 }
 
-/**
- * Decide a tool's execution target — sandbox (assistant container) or host
- * (guardian's device via host-bridge proxy). Pure: same input → same output.
- *
- * Resolution order:
- *   1. Declared `executionTarget` on the tool wins.
- *   2. Name prefix heuristic — `host_*` / `computer_use_*` ⇒ host.
- *   3. Default sandbox.
- *
- * Called once per tool at load/construction time. The returned value is
- * stamped onto every `Tool`, so runtime reads are just a field read.
- */
-export function resolveExecutionTarget(tool: {
-  name: string;
-  executionTarget?: ExecutionTarget;
-}): ExecutionTarget {
+/** With no invocation input, returns the tool's default boundary. */
+export function resolveExecutionTarget(
+  tool: {
+    name: string;
+    executionTarget?: ExecutionTarget;
+    getExecutionTarget?: Tool["getExecutionTarget"];
+  },
+  input?: Record<string, unknown>,
+  context?: ToolContext,
+): ExecutionTarget {
+  if (input && tool.getExecutionTarget) {
+    return tool.getExecutionTarget(input, context);
+  }
   if (tool.executionTarget) {
     return tool.executionTarget;
   }

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

@@ -17,6 +17,7 @@ import { supportsHostProxy } from "../../channels/types.js";
 import { getConfig } from "../../config/loader.js";
 import { HostBashProxy } from "../../daemon/host-bash-proxy.js";
 import { RiskLevel } from "../../permissions/types.js";
+import { applyActivePluginName } from "../../plugins/active-plugin-env.js";
 import { wakeAgentForOpportunity } from "../../runtime/agent-wake.js";
 import { broadcastMessage } from "../../runtime/assistant-event-hub.js";
 import { conversationRevealNonce } from "../../runtime/reveal-nonce.js";
@@ -92,8 +93,9 @@ function buildHostBashProxyEnv(conversationId: string): Record<string, string> {
   // Keep nested `assistant` CLI calls in host_bash aligned with the
   // originating conversation so browser IPC can resolve live proxy context.
   env.__CONVERSATION_ID = 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(conversationId);
+  applyActivePluginName(env, conversationId);
   return env;
 }
 
@@ -438,6 +440,7 @@ export const hostShellTool = {
     // the active conversation when running through host_bash.
     hostEnv.__CONVERSATION_ID = context.conversationId;
     hostEnv.__REVEAL_NONCE = conversationRevealNonce(context.conversationId);
+    applyActivePluginName(hostEnv, context.conversationId);
 
     if (background) {
       // Check the registry limit BEFORE spawning so we never leak an

package/src/tools/network/__tests__/web-fetch-tinyfish.test.ts

@@ -0,0 +1,250 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { setConfig } from "../../../__tests__/helpers/set-config.js";
+
+let mockTinyfishSecureKey: string | undefined;
+let mockResolveAddresses: string[] = [];
+
+function seedWebFetch(provider: string, apiBase?: string): void {
+  const entry: Record<string, string> = { provider };
+  if (apiBase !== undefined) {
+    entry.apiBase = apiBase;
+  }
+  setConfig("services", { "web-fetch": entry });
+}
+
+mock.module("../../../security/secure-keys.js", () => ({
+  getProviderKeyAsync: async (provider: string) =>
+    provider === "tinyfish" ? mockTinyfishSecureKey : undefined,
+}));
+
+const realLogger = await import("../../../util/logger.js");
+mock.module("../../../util/logger.js", () => ({
+  ...realLogger,
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
+}));
+
+mock.module("../../../permissions/types.js", () => ({
+  RiskLevel: { Low: "low", Medium: "medium", High: "high" },
+}));
+
+const realUrlSafety = await import("../url-safety.js");
+mock.module("../url-safety.js", () => ({
+  ...realUrlSafety,
+  resolveHostAddresses: async () => mockResolveAddresses,
+}));
+
+const { executeTinyfishFetch, webFetchTool } = await import("../web-fetch.js");
+
+function fetchResponse(body: unknown, status = 200): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "content-type": "application/json" },
+  });
+}
+
+describe("executeTinyfishFetch", () => {
+  let originalFetch: typeof globalThis.fetch;
+
+  beforeEach(() => {
+    originalFetch = globalThis.fetch;
+    seedWebFetch("tinyfish");
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+  });
+
+  test("posts the URL and returns markdown with metadata", async () => {
+    let capturedUrl = "";
+    let capturedBody: Record<string, unknown> = {};
+    let capturedApiKey = "";
+    globalThis.fetch = (async (url: string, init?: RequestInit) => {
+      capturedUrl = url;
+      capturedBody = JSON.parse(String(init?.body));
+      capturedApiKey = new Headers(init?.headers).get("x-api-key") ?? "";
+      return fetchResponse({
+        results: [
+          {
+            url: "https://example.com/",
+            final_url: "https://www.example.com/",
+            title: "Example",
+            description: "An example page",
+            text: "# Example\n\nHello from TinyFish.",
+            format: "markdown",
+            latency_ms: 120,
+          },
+        ],
+        errors: [],
+      });
+    }) as typeof fetch;
+
+    const result = await executeTinyfishFetch(
+      { url: "https://example.com", timeout_seconds: 45 },
+      { apiKey: "tf_test" },
+    );
+
+    expect(result.isError).toBe(false);
+    expect(capturedUrl).toBe("https://api.fetch.tinyfish.ai/");
+    expect(capturedBody).toEqual({
+      urls: ["https://example.com/"],
+      format: "markdown",
+      per_url_timeout_ms: 45_000,
+    });
+    expect(capturedApiKey).toBe("tf_test");
+    expect(result.content).toContain("Hello from TinyFish.");
+    expect(result.content).toContain("Title: Example");
+    expect(result.activityMetadata?.webFetch?.provider).toBe("tinyfish");
+    expect(result.activityMetadata?.webFetch?.finalUrl).toBe(
+      "https://www.example.com/",
+    );
+  });
+
+  test("uses a custom API base and applies character windows", async () => {
+    seedWebFetch("tinyfish", "https://fetch.example.com/api/");
+    let capturedUrl = "";
+    globalThis.fetch = (async (url: string) => {
+      capturedUrl = url;
+      return fetchResponse({
+        results: [
+          {
+            url: "https://example.com/",
+            final_url: "https://example.com/",
+            text: "0123456789",
+            format: "markdown",
+          },
+        ],
+        errors: [],
+      });
+    }) as typeof fetch;
+
+    const result = await executeTinyfishFetch(
+      { url: "https://example.com", start_index: 2, max_chars: 4 },
+      { apiKey: "tf_test" },
+    );
+
+    expect(capturedUrl).toBe("https://fetch.example.com/api/");
+    expect(result.content).toContain("Character Window: 2-6 of 10");
+    expect(result.content).toContain("2345");
+    expect(result.activityMetadata?.webFetch?.truncated).toBe(true);
+  });
+
+  test("surfaces per-URL errors from a successful HTTP response", async () => {
+    globalThis.fetch = (async () =>
+      fetchResponse({
+        results: [],
+        errors: [
+          {
+            url: "https://example.com/",
+            error: "bot_blocked",
+            status: 403,
+          },
+        ],
+      })) as unknown as typeof fetch;
+
+    const result = await executeTinyfishFetch(
+      { url: "https://example.com" },
+      { apiKey: "tf_test" },
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("bot_blocked");
+    expect(result.content).toContain("HTTP 403");
+    expect(result.activityMetadata?.webFetch?.provider).toBe("tinyfish");
+    expect(result.activityMetadata?.webFetch?.status).toBe(403);
+  });
+
+  test("rejects URL-embedded credentials before calling TinyFish", async () => {
+    let fetchCalls = 0;
+    globalThis.fetch = (async () => {
+      fetchCalls += 1;
+      return fetchResponse({ results: [], errors: [] });
+    }) as unknown as typeof fetch;
+
+    const result = await executeTinyfishFetch(
+      { url: "https://user:pass@example.com/private" },
+      { apiKey: "tf_test" },
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("embedded credentials");
+    expect(fetchCalls).toBe(0);
+  });
+});
+
+describe("webFetchTool TinyFish dispatch", () => {
+  let originalFetch: typeof globalThis.fetch;
+
+  const execute = (input: Record<string, unknown>, context: any = {}) =>
+    webFetchTool.execute(input, context);
+
+  beforeEach(() => {
+    originalFetch = globalThis.fetch;
+    seedWebFetch("tinyfish");
+    mockTinyfishSecureKey = "tf_test";
+    mockResolveAddresses = ["93.184.216.34"];
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+  });
+
+  test("routes public URLs to TinyFish when a key is stored", async () => {
+    let tinyfishHit = false;
+    globalThis.fetch = (async (url: string) => {
+      if (String(url).includes("api.fetch.tinyfish.ai")) {
+        tinyfishHit = true;
+      }
+      return fetchResponse({
+        results: [
+          {
+            url: "https://example.com/",
+            final_url: "https://example.com/",
+            text: "routed",
+            format: "markdown",
+          },
+        ],
+        errors: [],
+      });
+    }) as typeof fetch;
+
+    const result = await execute({ url: "https://example.com" });
+
+    expect(tinyfishHit).toBe(true);
+    expect(result.activityMetadata?.webFetch?.provider).toBe("tinyfish");
+  });
+
+  test("does not send private targets to TinyFish", async () => {
+    let tinyfishHit = false;
+    globalThis.fetch = (async (url: string) => {
+      if (String(url).includes("api.fetch.tinyfish.ai")) {
+        tinyfishHit = true;
+      }
+      return new Response("", { status: 200 });
+    }) as typeof fetch;
+
+    const result = await execute({ url: "http://localhost:8080/admin" });
+
+    expect(tinyfishHit).toBe(false);
+    expect(result.isError).toBe(true);
+    expect(result.activityMetadata?.webFetch?.provider).toBe("default");
+  });
+
+  test("falls back to the built-in fetcher when no TinyFish key is stored", async () => {
+    mockTinyfishSecureKey = undefined;
+    mockResolveAddresses = [];
+    let tinyfishHit = false;
+    globalThis.fetch = (async (url: string) => {
+      if (String(url).includes("api.fetch.tinyfish.ai")) {
+        tinyfishHit = true;
+      }
+      return new Response("", { status: 200 });
+    }) as typeof fetch;
+
+    const result = await execute({ url: "https://example.com" });
+
+    expect(tinyfishHit).toBe(false);
+    expect(result.activityMetadata?.webFetch?.provider).toBe("default");
+  });
+});

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

@@ -10,6 +10,8 @@ let mockTavilySecureKey: string | undefined;
 let mockFirecrawlSecureKey: string | undefined;
 let mockKeenableSecureKey: string | undefined;
 let mockFastcrwSecureKey: string | undefined;
+let mockSearxngSecureKey: string | undefined;
+let mockTinyfishSecureKey: string | undefined;
 let mockManagedSearchProxyResult: any;
 let mockManagedSearchAvailable = true;
 let mockManagedSearchProxyCalls: Array<{
@@ -57,6 +59,12 @@ mock.module("../../../security/secure-keys.js", () => ({
     if (provider === "fastcrw") {
       return mockFastcrwSecureKey;
     }
+    if (provider === "searxng") {
+      return mockSearxngSecureKey;
+    }
+    if (provider === "tinyfish") {
+      return mockTinyfishSecureKey;
+    }
     return undefined;
   },
 }));
@@ -101,6 +109,8 @@ describe("web_search tool", () => {
     mockFirecrawlSecureKey = undefined;
     mockKeenableSecureKey = undefined;
     mockFastcrwSecureKey = undefined;
+    mockSearxngSecureKey = undefined;
+    mockTinyfishSecureKey = undefined;
     mockManagedSearchProxyCalls = [];
     mockManagedSearchAvailable = true;
     mockManagedSearchProxyResult = {
@@ -1142,6 +1152,199 @@ describe("web_search tool", () => {
     expect(capturedHeaders?.get("authorization")).toBeNull();
   });
 
+  // ---- SearXNG provider (keyless, instance URL required) ------------------
+
+  test("SearXNG errors when API Base is missing and does not fetch", async () => {
+    seedWebSearch("your-own", "searxng");
+    let fetchCalls = 0;
+    globalThis.fetch = (async () => {
+      fetchCalls += 1;
+      return new Response("{}", { status: 200 });
+    }) as any;
+
+    const result = await execute({ query: "local search" });
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("SearXNG needs an instance URL");
+    expect(result.activityMetadata?.webSearch?.provider).toBe("searxng");
+    expect(fetchCalls).toBe(0);
+  });
+
+  test("executes SearXNG search against the instance URL without a key", async () => {
+    seedWebSearch("your-own", "searxng", "http://127.0.0.1:8888/");
+    let capturedUrl = "";
+    let capturedHeaders: any = null;
+    globalThis.fetch = (async (url: string, init?: RequestInit) => {
+      capturedUrl = url;
+      capturedHeaders = new Headers(init?.headers);
+      return new Response(
+        JSON.stringify({
+          results: [
+            {
+              title: "SearXNG Result",
+              url: "https://example.com/searx",
+              content: "From a local instance",
+            },
+          ],
+        }),
+        { status: 200, headers: { "content-type": "application/json" } },
+      );
+    }) as any;
+
+    const result = await execute({ query: "open source search" });
+    expect(result.isError).toBe(false);
+    expect(capturedUrl).toBe(
+      "http://127.0.0.1:8888/search?q=open+source+search&format=json",
+    );
+    expect(capturedHeaders?.get("authorization")).toBeNull();
+    expect(result.content).toContain("SearXNG Result");
+    expect(result.content).toContain("https://example.com/searx");
+    expect(result.activityMetadata?.webSearch?.provider).toBe("searxng");
+  });
+
+  test("SearXNG maps freshness and sends an optional bearer token", async () => {
+    seedWebSearch("your-own", "searxng", "http://searx.example.com");
+    mockSearxngSecureKey = "searx-token";
+    let capturedUrl = "";
+    let capturedHeaders: any = null;
+    globalThis.fetch = (async (url: string, init?: RequestInit) => {
+      capturedUrl = url;
+      capturedHeaders = new Headers(init?.headers);
+      return new Response(JSON.stringify({ results: [] }), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      });
+    }) as any;
+
+    await execute({ query: "fresh news", freshness: "pd" });
+    expect(capturedUrl).toContain("time_range=day");
+    expect(capturedHeaders?.get("authorization")).toBe("Bearer searx-token");
+
+    await execute({ query: "fresh news", freshness: "pw" });
+    expect(capturedUrl).not.toContain("time_range=");
+  });
+
+  test("SearXNG trims results to the requested count", async () => {
+    seedWebSearch("your-own", "searxng", "http://127.0.0.1:8888");
+    globalThis.fetch = (async () => {
+      return new Response(
+        JSON.stringify({
+          results: [
+            { title: "A", url: "https://a.example.com", content: "a" },
+            { title: "B", url: "https://b.example.com", content: "b" },
+            { title: "C", url: "https://c.example.com", content: "c" },
+          ],
+        }),
+        { status: 200, headers: { "content-type": "application/json" } },
+      );
+    }) as any;
+
+    const result = await execute({ query: "test", count: 2 });
+    expect(result.content).toContain("A");
+    expect(result.content).toContain("B");
+    expect(result.content).not.toContain("https://c.example.com");
+  });
+
+  test("SearXNG errors when the instance returns HTML instead of JSON", async () => {
+    seedWebSearch("your-own", "searxng", "http://127.0.0.1:8888");
+    globalThis.fetch = (async () => {
+      return new Response("<!DOCTYPE html><html><body>search</body></html>", {
+        status: 200,
+        headers: { "content-type": "text/html" },
+      });
+    }) as any;
+
+    const result = await execute({ query: "test" });
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("did not return JSON");
+  });
+
+  // ---- TinyFish provider --------------------------------------------------
+
+  test("executes TinyFish search with X-API-Key and freshness", async () => {
+    seedWebSearch("your-own", "tinyfish");
+    mockTinyfishSecureKey = "tf_test";
+    let capturedUrl = "";
+    let capturedApiKey = "";
+    globalThis.fetch = (async (url: string, init?: RequestInit) => {
+      capturedUrl = url;
+      capturedApiKey = new Headers(init?.headers).get("x-api-key") ?? "";
+      return new Response(
+        JSON.stringify({
+          query: "fresh tools",
+          results: [
+            {
+              position: 1,
+              site_name: "example.com",
+              title: "TinyFish Result",
+              snippet: "Fresh from TinyFish",
+              url: "https://example.com/tinyfish",
+              date: "2026-09-18",
+            },
+          ],
+          total_results: 1,
+          page: 0,
+        }),
+        { status: 200, headers: { "content-type": "application/json" } },
+      );
+    }) as any;
+
+    const result = await execute({ query: "fresh tools", freshness: "pw" });
+
+    expect(result.isError).toBe(false);
+    const url = new URL(capturedUrl);
+    expect(`${url.origin}${url.pathname}`).toBe(
+      "https://api.search.tinyfish.ai/",
+    );
+    expect(url.searchParams.get("query")).toBe("fresh tools");
+    expect(url.searchParams.get("recency_minutes")).toBe("10080");
+    expect(capturedApiKey).toBe("tf_test");
+    expect(result.content).toContain("TinyFish Result");
+    expect(result.content).toContain("Fresh from TinyFish");
+    expect(result.activityMetadata?.webSearch?.provider).toBe("tinyfish");
+  });
+
+  test("TinyFish uses a custom API base and trims to count", async () => {
+    seedWebSearch("your-own", "tinyfish", "https://search.example.com/api/");
+    mockTinyfishSecureKey = "tf_test";
+    let capturedUrl = "";
+    globalThis.fetch = (async (url: string) => {
+      capturedUrl = url;
+      return new Response(
+        JSON.stringify({
+          results: [
+            { title: "A", url: "https://a.example.com", snippet: "a" },
+            { title: "B", url: "https://b.example.com", snippet: "b" },
+            { title: "C", url: "https://c.example.com", snippet: "c" },
+          ],
+        }),
+        { status: 200, headers: { "content-type": "application/json" } },
+      );
+    }) as any;
+
+    const result = await execute({ query: "test", count: 2 });
+
+    expect(capturedUrl).toContain("https://search.example.com/api/");
+    expect(result.content).toContain("A");
+    expect(result.content).toContain("B");
+    expect(result.content).not.toContain("https://c.example.com");
+    expect(result.activityMetadata?.webSearch?.resultCount).toBe(2);
+  });
+
+  test.each([401, 402, 403])(
+    "TinyFish handles %d access error",
+    async (status) => {
+      seedWebSearch("your-own", "tinyfish");
+      mockTinyfishSecureKey = "tf_test";
+      globalThis.fetch = (async () =>
+        new Response(JSON.stringify({ error: "denied" }), { status })) as any;
+
+      const result = await execute({ query: "test" });
+
+      expect(result.isError).toBe(true);
+      expect(result.activityMetadata?.webSearch?.provider).toBe("tinyfish");
+    },
+  );
+
   // ---- Provider fallback --------------------------------------------------
 
   test("falls back from perplexity to brave when perplexity has no key", async () => {