@vellumai/assistant 0.8.4 → 0.8.6

package/src/tools/filesystem/write.ts

@@ -3,7 +3,6 @@ import { join, resolve, sep } from "node:path";
 import { enqueuePkbIndexJob } from "../../memory/jobs/embed-pkb-file.js";
 import { PKB_WORKSPACE_SCOPE } from "../../memory/pkb/types.js";
 import { RiskLevel } from "../../permissions/types.js";
-import type { ToolDefinition } from "../../providers/types.js";
 import { getLogger } from "../../util/logger.js";
 import { getWorkspaceDir } from "../../util/platform.js";
 import { registerTool } from "../registry.js";
@@ -35,13 +34,10 @@ class FileWriteTool implements Tool {
   description =
     "Write content to a file on your own machine, creating it if it does not exist. Use host_file_write for files on your guardian's device instead.";
   category = "filesystem";
+  executionTarget = "sandbox" as const;
   defaultRiskLevel = RiskLevel.Low;
 
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
+  input_schema = {
         type: "object",
         properties: {
           path: {
@@ -60,9 +56,7 @@ class FileWriteTool implements Tool {
           },
         },
         required: ["path", "content", "activity"],
-      },
-    };
-  }
+      };
 
   async execute(
     input: Record<string, unknown>,

package/src/tools/host-filesystem/edit.test.ts

@@ -26,6 +26,7 @@ mock.module("../../runtime/assistant-event-hub.js", () => ({
   assistantEventHub: {
     listClientsByCapability: () => [],
   },
+  broadcastMessage: async () => {},
 }));
 
 const { hostFileEditTool } = await import("./edit.js");

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

@@ -1,7 +1,6 @@
 import { supportsHostProxy } from "../../channels/types.js";
 import { HostFileProxy } from "../../daemon/host-file-proxy.js";
 import { RiskLevel } from "../../permissions/types.js";
-import type { ToolDefinition } from "../../providers/types.js";
 import { assistantEventHub } from "../../runtime/assistant-event-hub.js";
 import { FileSystemOps } from "../shared/filesystem/file-ops-service.js";
 import { formatEditDiff } from "../shared/filesystem/format-diff.js";
@@ -13,13 +12,10 @@ class HostFileEditTool implements Tool {
   description =
     "Replace exact text in a file on your guardian's device with new text. For files on your own machine, use file_edit instead.";
   category = "host-filesystem";
+  executionTarget = "host" as const;
   defaultRiskLevel = RiskLevel.Medium;
 
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
+  input_schema = {
         type: "object",
         properties: {
           path: {
@@ -46,9 +42,7 @@ class HostFileEditTool implements Tool {
           },
         },
         required: ["path", "old_string", "new_string"],
-      },
-    };
-  }
+      };
 
   async execute(
     input: Record<string, unknown>,

package/src/tools/host-filesystem/read.test.ts

@@ -26,6 +26,7 @@ mock.module("../../runtime/assistant-event-hub.js", () => ({
   assistantEventHub: {
     listClientsByCapability: () => [],
   },
+  broadcastMessage: async () => {},
 }));
 
 const { hostFileReadTool } = await import("./read.js");

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

@@ -3,7 +3,6 @@ import { extname } from "node:path";
 import { supportsHostProxy } from "../../channels/types.js";
 import { HostFileProxy } from "../../daemon/host-file-proxy.js";
 import { RiskLevel } from "../../permissions/types.js";
-import type { ToolDefinition } from "../../providers/types.js";
 import { assistantEventHub } from "../../runtime/assistant-event-hub.js";
 import { FileSystemOps } from "../shared/filesystem/file-ops-service.js";
 import {
@@ -18,13 +17,10 @@ class HostFileReadTool implements Tool {
   description =
     "Read the contents of a file on your guardian's device, including images (JPEG, PNG, GIF, WebP). For files on your own machine, use file_read instead.";
   category = "host-filesystem";
+  executionTarget = "host" as const;
   defaultRiskLevel = RiskLevel.Medium;
 
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
+  input_schema = {
         type: "object",
         properties: {
           path: {
@@ -46,9 +42,7 @@ class HostFileReadTool implements Tool {
           },
         },
         required: ["path"],
-      },
-    };
-  }
+      };
 
   async execute(
     input: Record<string, unknown>,

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

@@ -1,4 +1,10 @@
-import { existsSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import {
+  existsSync,
+  mkdtempSync,
+  realpathSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, describe, expect, mock, test } from "bun:test";
@@ -18,12 +24,28 @@ mock.module("../../daemon/host-transfer-proxy.js", () => ({
     get instance() {
       return {
         isAvailable: () => mockProxyAvailable,
-        requestToSandbox: (args: { sourcePath: string; destPath: string; overwrite?: boolean; conversationId: string }) => {
-          toSandboxCalls.push({ sourcePath: args.sourcePath, destPath: args.destPath });
+        requestToSandbox: (args: {
+          sourcePath: string;
+          destPath: string;
+          overwrite?: boolean;
+          conversationId: string;
+        }) => {
+          toSandboxCalls.push({
+            sourcePath: args.sourcePath,
+            destPath: args.destPath,
+          });
           return Promise.resolve({ content: "ok", isError: false });
         },
-        requestToHost: (args: { sourcePath: string; destPath: string; overwrite: boolean; conversationId: string }) => {
-          toHostCalls.push({ sourcePath: args.sourcePath, destPath: args.destPath });
+        requestToHost: (args: {
+          sourcePath: string;
+          destPath: string;
+          overwrite: boolean;
+          conversationId: string;
+        }) => {
+          toHostCalls.push({
+            sourcePath: args.sourcePath,
+            destPath: args.destPath,
+          });
           return Promise.resolve({ content: "ok", isError: false });
         },
       };
@@ -38,6 +60,7 @@ mock.module("../../runtime/assistant-event-hub.js", () => ({
   assistantEventHub: {
     listClientsByCapability: () => [],
   },
+  broadcastMessage: async () => {},
 }));
 
 const { hostFileTransferTool } = await import("./transfer.js");
@@ -244,7 +267,9 @@ describe("host_file_transfer managed mode", () => {
     );
 
     expect(toSandboxCalls.length).toBe(1);
-    expect(toSandboxCalls[0].destPath).toBe(join(workingDir, "relative", "file.txt"));
+    expect(toSandboxCalls[0].destPath).toBe(
+      join(workingDir, "relative", "file.txt"),
+    );
   });
 
   test("to_host relative source is pre-resolved before proxy call", async () => {

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

@@ -5,7 +5,6 @@ import { dirname, isAbsolute } from "node:path";
 import { supportsHostProxy } from "../../channels/types.js";
 import { HostTransferProxy } from "../../daemon/host-transfer-proxy.js";
 import { RiskLevel } from "../../permissions/types.js";
-import type { ToolDefinition } from "../../providers/types.js";
 import { assistantEventHub } from "../../runtime/assistant-event-hub.js";
 import { sandboxPolicy } from "../shared/filesystem/path-policy.js";
 import type { Tool, ToolContext, ToolExecutionResult } from "../types.js";
@@ -15,13 +14,10 @@ class HostFileTransferTool implements Tool {
   description =
     "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";
+  executionTarget = "host" as const;
   defaultRiskLevel = RiskLevel.Medium;
 
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
+  input_schema = {
         type: "object",
         properties: {
           source_path: {
@@ -57,9 +53,7 @@ class HostFileTransferTool implements Tool {
           },
         },
         required: ["source_path", "dest_path", "direction"],
-      },
-    };
-  }
+      };
 
   async execute(
     input: Record<string, unknown>,

package/src/tools/host-filesystem/write.test.ts

@@ -26,6 +26,7 @@ mock.module("../../runtime/assistant-event-hub.js", () => ({
   assistantEventHub: {
     listClientsByCapability: () => [],
   },
+  broadcastMessage: async () => {},
 }));
 
 const { hostFileWriteTool } = await import("./write.js");

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

@@ -1,7 +1,6 @@
 import { supportsHostProxy } from "../../channels/types.js";
 import { HostFileProxy } from "../../daemon/host-file-proxy.js";
 import { RiskLevel } from "../../permissions/types.js";
-import type { ToolDefinition } from "../../providers/types.js";
 import { assistantEventHub } from "../../runtime/assistant-event-hub.js";
 import { FileSystemOps } from "../shared/filesystem/file-ops-service.js";
 import { formatWriteSummary } from "../shared/filesystem/format-diff.js";
@@ -13,13 +12,10 @@ class HostFileWriteTool implements Tool {
   description =
     "Write content to a file on your guardian's device, creating it if it does not exist. For files on your own machine, use file_write instead.";
   category = "host-filesystem";
+  executionTarget = "host" as const;
   defaultRiskLevel = RiskLevel.Medium;
 
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
+  input_schema = {
         type: "object",
         properties: {
           path: {
@@ -37,9 +33,7 @@ class HostFileWriteTool implements Tool {
           },
         },
         required: ["path", "content"],
-      },
-    };
-  }
+      };
 
   async execute(
     input: Record<string, unknown>,

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

@@ -23,7 +23,6 @@ import { getConfig } from "../../config/loader.js";
 import { isCesShellLockdownEnabled } from "../../credential-execution/feature-gates.js";
 import { HostBashProxy } from "../../daemon/host-bash-proxy.js";
 import { RiskLevel } from "../../permissions/types.js";
-import type { ToolDefinition } from "../../providers/types.js";
 import { isUntrustedTrustClass } from "../../runtime/actor-trust-resolver.js";
 import { wakeAgentForOpportunity } from "../../runtime/agent-wake.js";
 import { assistantEventHub } from "../../runtime/assistant-event-hub.js";
@@ -97,16 +96,13 @@ class HostShellTool implements Tool {
   description =
     "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";
+  executionTarget = "host" as const;
   // host_bash is a weaker-tier escape hatch under CES lockdown. It remains
   // Medium risk by default but persistent approvals are disabled for
   // untrusted sessions (see execute()).
   defaultRiskLevel = RiskLevel.Medium;
 
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
+  input_schema = {
         type: "object",
         properties: {
           command: {
@@ -140,9 +136,7 @@ class HostShellTool implements Tool {
           },
         },
         required: ["command", "activity"],
-      },
-    };
-  }
+      };
 
   async execute(
     input: Record<string, unknown>,

package/src/tools/mcp/mcp-tool-factory.ts

@@ -1,7 +1,6 @@
 import type { McpServerConfig } from "../../config/schemas/mcp.js";
 import type { McpServerManager } from "../../mcp/manager.js";
 import { RiskLevel } from "../../permissions/types.js";
-import type { ToolDefinition } from "../../providers/types.js";
 import { toProviderSafeToolName } from "../provider-tool-name.js";
 import { schemaDefinesProperty } from "../schema-transforms.js";
 import type { Tool, ToolContext, ToolExecutionResult } from "../types.js";
@@ -49,17 +48,9 @@ export function createMcpTool(
     description: metadata.description,
     category: "mcp",
     defaultRiskLevel: riskLevel,
-    origin: "mcp",
-    ownerMcpServerId: serverId,
     executionTarget: "host",
 
-    getDefinition(): ToolDefinition {
-      return {
-        name: namespacedName,
-        description: metadata.description,
-        input_schema: metadata.inputSchema as ToolDefinition["input_schema"],
-      };
-    },
+    input_schema: metadata.inputSchema as object,
 
     async execute(
       input: Record<string, unknown>,

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

@@ -100,7 +100,7 @@ function makeContext(overrides: Partial<ToolContext> = {}): ToolContext {
 
 describe("recallTool definition", () => {
   test("exposes the agentic local search schema", () => {
-    const definition = recallTool.getDefinition();
+    const definition = recallTool;
 
     expect(definition.name).toBe("recall");
     expect(definition.description).toContain("Search local information");

package/src/tools/memory/register.ts

@@ -10,7 +10,6 @@ import {
   graphRememberDefinition,
 } from "../../memory/graph/tools.js";
 import { RiskLevel } from "../../permissions/types.js";
-import type { ToolDefinition } from "../../providers/types.js";
 import { isUntrustedTrustClass } from "../../runtime/actor-trust-resolver.js";
 import type { Tool, ToolContext, ToolExecutionResult } from "../types.js";
 
@@ -20,11 +19,9 @@ class RememberTool implements Tool {
   name = "remember";
   description = graphRememberDefinition.description;
   category = "memory";
+  executionTarget = "sandbox" as const;
   defaultRiskLevel = RiskLevel.Low;
-
-  getDefinition(): ToolDefinition {
-    return graphRememberDefinition;
-  }
+  input_schema = graphRememberDefinition.input_schema;
 
   async execute(
     input: Record<string, unknown>,
@@ -51,11 +48,9 @@ class RecallTool implements Tool {
   name = "recall";
   description = graphRecallDefinition.description;
   category = "memory";
+  executionTarget = "sandbox" as const;
   defaultRiskLevel = RiskLevel.Low;
-
-  getDefinition(): ToolDefinition {
-    return graphRecallDefinition;
-  }
+  input_schema = graphRecallDefinition.input_schema;
 
   async execute(
     input: Record<string, unknown>,

package/src/tools/network/__tests__/managed-search-proxy.test.ts

@@ -0,0 +1,282 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+interface MockPlatformClient {
+  platformAssistantId: string;
+  fetch: ReturnType<typeof mock>;
+}
+
+let mockClient: MockPlatformClient | null = null;
+
+mock.module("../../../platform/client.js", () => ({
+  VellumPlatformClient: {
+    create: async () => mockClient,
+  },
+}));
+
+import { callManagedSearchProxy } from "../managed-search-proxy.js";
+
+describe("callManagedSearchProxy", () => {
+  beforeEach(() => {
+    mockClient = {
+      platformAssistantId: "asst-123",
+      fetch: mock(async () => {
+        return new Response(
+          JSON.stringify({
+            status: 200,
+            headers: { "content-type": "application/json" },
+            body: { web: { results: [] } },
+          }),
+          { status: 200, headers: { "content-type": "application/json" } },
+        );
+      }),
+    };
+  });
+
+  afterEach(() => {
+    mockClient = null;
+  });
+
+  test("posts to the managed search proxy endpoint for the assistant and provider", async () => {
+    await callManagedSearchProxy("brave", {
+      method: "GET",
+      path: "/res/v1/web/search",
+    });
+
+    expect(mockClient!.fetch).toHaveBeenCalledTimes(1);
+    expect(mockClient!.fetch.mock.calls[0][0]).toBe(
+      "/v1/assistants/asst-123/managed-search-proxy/brave/",
+    );
+  });
+
+  test("encodes URL path segments", async () => {
+    mockClient!.platformAssistantId = "asst/123";
+
+    await callManagedSearchProxy("brave", {
+      method: "GET",
+      path: "/res/v1/web/search",
+    });
+
+    expect(mockClient!.fetch.mock.calls[0][0]).toBe(
+      "/v1/assistants/asst%2F123/managed-search-proxy/brave/",
+    );
+  });
+
+  test("sends the platform contract request envelope", async () => {
+    await callManagedSearchProxy("brave", {
+      method: "GET",
+      path: "/res/v1/web/search",
+      query: {
+        q: "kimi k2 fireworks web search",
+        count: "10",
+        offset: "0",
+        freshness: "pw",
+      },
+      headers: {
+        Accept: "application/json",
+      },
+      body: null,
+    });
+
+    const init = mockClient!.fetch.mock.calls[0][1] as RequestInit;
+    expect(init.method).toBe("POST");
+    expect(new Headers(init.headers).get("Content-Type")).toBe(
+      "application/json",
+    );
+    expect(JSON.parse(init.body as string)).toEqual({
+      request: {
+        method: "GET",
+        path: "/res/v1/web/search",
+        query: {
+          q: "kimi k2 fireworks web search",
+          count: "10",
+          offset: "0",
+          freshness: "pw",
+        },
+        headers: {
+          Accept: "application/json",
+        },
+        body: null,
+      },
+    });
+  });
+
+  test("fills absent query, headers, and body with contract defaults", async () => {
+    await callManagedSearchProxy("brave", {
+      method: "GET",
+      path: "/res/v1/web/search",
+    });
+
+    const init = mockClient!.fetch.mock.calls[0][1] as RequestInit;
+    expect(JSON.parse(init.body as string)).toEqual({
+      request: {
+        method: "GET",
+        path: "/res/v1/web/search",
+        query: {},
+        headers: {},
+        body: null,
+      },
+    });
+  });
+
+  test("passes the abort signal through to platform fetch", async () => {
+    const controller = new AbortController();
+
+    await callManagedSearchProxy(
+      "brave",
+      {
+        method: "GET",
+        path: "/res/v1/web/search",
+      },
+      controller.signal,
+    );
+
+    const init = mockClient!.fetch.mock.calls[0][1] as RequestInit;
+    expect(init.signal).toBe(controller.signal);
+  });
+
+  test("parses the response envelope and preserves provider JSON body", async () => {
+    const providerBody = {
+      web: {
+        results: [{ title: "Result", url: "https://example.com" }],
+      },
+    };
+    mockClient!.fetch = mock(async () => {
+      return new Response(
+        JSON.stringify({
+          status: 200,
+          headers: {
+            "content-type": "application/json",
+            "x-request-id": "req-123",
+          },
+          body: providerBody,
+        }),
+        { status: 200, headers: { "content-type": "application/json" } },
+      );
+    });
+
+    const result = await callManagedSearchProxy("brave", {
+      method: "GET",
+      path: "/res/v1/web/search",
+    });
+
+    expect(result).toEqual({
+      ok: true,
+      status: 200,
+      headers: {
+        "content-type": "application/json",
+        "x-request-id": "req-123",
+      },
+      body: providerBody,
+    });
+  });
+
+  test("returns a typed platform error for non-2xx platform responses", async () => {
+    mockClient!.fetch = mock(async () => {
+      return new Response(
+        JSON.stringify({ detail: "unsupported managed search provider" }),
+        {
+          status: 400,
+          headers: {
+            "content-type": "application/json",
+            "x-platform-request-id": "platform-req-123",
+          },
+        },
+      );
+    });
+
+    const result = await callManagedSearchProxy("brave", {
+      method: "GET",
+      path: "/res/v1/web/search",
+    });
+
+    expect(result).toEqual({
+      ok: false,
+      kind: "platform-error",
+      status: 400,
+      headers: {
+        "content-type": "application/json",
+        "x-platform-request-id": "platform-req-123",
+      },
+      body: { detail: "unsupported managed search provider" },
+      message:
+        "Managed search proxy returned status 400: unsupported managed search provider",
+    });
+  });
+
+  test("preserves insufficient-balance platform errors", async () => {
+    mockClient!.fetch = mock(async () => {
+      return new Response(JSON.stringify({ detail: "Insufficient balance" }), {
+        status: 402,
+        headers: { "content-type": "application/json" },
+      });
+    });
+
+    const result = await callManagedSearchProxy("brave", {
+      method: "GET",
+      path: "/res/v1/web/search",
+    });
+
+    expect(result).toEqual({
+      ok: false,
+      kind: "platform-error",
+      status: 402,
+      headers: {
+        "content-type": "application/json",
+      },
+      body: { detail: "Insufficient balance" },
+      message: "Managed search proxy returned status 402: Insufficient balance",
+    });
+  });
+
+  test("returns unavailable when platform context is missing", async () => {
+    mockClient = null;
+
+    const result = await callManagedSearchProxy("brave", {
+      method: "GET",
+      path: "/res/v1/web/search",
+    });
+
+    expect(result).toEqual({
+      ok: false,
+      kind: "unavailable",
+      message: "Managed search proxy is unavailable in this environment.",
+    });
+  });
+
+  test("returns unavailable when platform assistant ID is missing", async () => {
+    mockClient!.platformAssistantId = "";
+
+    const result = await callManagedSearchProxy("brave", {
+      method: "GET",
+      path: "/res/v1/web/search",
+    });
+
+    expect(result).toEqual({
+      ok: false,
+      kind: "unavailable",
+      message:
+        "Managed search proxy is unavailable: platform assistant ID is missing.",
+    });
+  });
+
+  test("returns an invalid-response result for malformed platform envelopes", async () => {
+    mockClient!.fetch = mock(async () => {
+      return new Response(JSON.stringify({ ok: true }), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      });
+    });
+
+    const result = await callManagedSearchProxy("brave", {
+      method: "GET",
+      path: "/res/v1/web/search",
+    });
+
+    expect(result).toEqual({
+      ok: false,
+      kind: "invalid-response",
+      body: { ok: true },
+      message: "Managed search proxy returned an invalid response envelope.",
+    });
+  });
+});