@vellumai/assistant 0.4.44 → 0.4.45

package/src/tools/swarm/delegate.ts

@@ -8,7 +8,6 @@ import { executeSwarm } from "../../swarm/orchestrator.js";
 import { generatePlan } from "../../swarm/router-planner.js";
 import { getLogger } from "../../util/logger.js";
 import { truncate } from "../../util/truncate.js";
-import { registerTool } from "../registry.js";
 import type { Tool, ToolContext, ToolExecutionResult } from "../types.js";
 
 const log = getLogger("swarm-delegate");
@@ -205,8 +204,6 @@ export const swarmDelegateTool: Tool = {
   },
 };
 
-registerTool(swarmDelegateTool);
-
 /** Clear all active sessions — only for testing. */
 export function _resetSwarmActive(): void {
   activeSessions.clear();

package/src/tools/system/avatar-generator.ts

@@ -109,39 +109,33 @@ export const setAvatarTool: Tool = {
       };
     } catch (error) {
       if (error instanceof ManagedAvatarError) {
+        log.error(
+          {
+            error: error.message,
+            statusCode: error.statusCode,
+            code: error.code,
+          },
+          "Avatar generation failed (managed)",
+        );
         if (error.statusCode === 429) {
-          log.warn(
-            { correlationId: error.correlationId },
-            "Avatar generation rate limited",
-          );
           return {
             content:
-              "Avatar generation is rate limited. Please wait and try again.",
+              "Avatar generation is currently rate limited. Please try again in a moment.",
             isError: true,
           };
         }
-        if (error.statusCode === 503) {
-          log.warn(
-            { correlationId: error.correlationId },
-            "Avatar generation service unavailable",
-          );
+        if (error.statusCode >= 500) {
           return {
-            content: "Avatar generation service is temporarily unavailable.",
+            content:
+              "Avatar generation is temporarily unavailable. Please try again later.",
             isError: true,
           };
         }
-        const detail =
-          error.message || "Avatar generation failed. Please try again.";
-        log.error(
-          { error: detail, correlationId: error.correlationId },
-          "Managed avatar generation failed",
-        );
         return {
-          content: `Avatar generation failed: ${detail}`,
+          content: `Avatar generation failed: ${error.message}`,
           isError: true,
         };
       }
-
       const message = mapGeminiError(error);
       log.error({ error: message }, "Avatar generation failed");
       return {

package/src/tools/system/request-permission.ts

@@ -110,4 +110,5 @@ class RequestSystemPermissionTool implements Tool {
   }
 }
 
-registerTool(new RequestSystemPermissionTool());
+export const requestSystemPermissionTool = new RequestSystemPermissionTool();
+registerTool(requestSystemPermissionTool);

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

@@ -27,6 +27,7 @@ const SAFE_ENV_VARS = [
   "SSH_AGENT_PID",
   "GPG_TTY",
   "GNUPGHOME",
+  "VELLUM_DEV",
 ] as const;
 
 export function buildSanitizedEnv(): Record<string, string> {

package/src/tools/tool-manifest.ts

@@ -6,24 +6,28 @@
  * so adding/removing tools only requires editing this manifest.
  */
 
-import { accountManageTool } from "./credentials/account-registry.js";
+import { assetMaterializeTool } from "./assets/materialize.js";
+import { assetSearchTool } from "./assets/search.js";
 import { credentialStoreTool } from "./credentials/vault.js";
-import {
-  memoryDeleteTool,
-  memoryRecallTool,
-  memorySaveTool,
-  memoryUpdateTool,
-} from "./memory/register.js";
+import { fileEditTool } from "./filesystem/edit.js";
+import { fileReadTool } from "./filesystem/read.js";
+import { fileWriteTool } from "./filesystem/write.js";
+import { memoryManageTool, memoryRecallTool } from "./memory/register.js";
+import { webFetchTool } from "./network/web-fetch.js";
+import { webSearchTool } from "./network/web-search.js";
 import type { LazyToolDescriptor } from "./registry.js";
-import { setAvatarTool } from "./system/avatar-generator.js";
-import { navigateSettingsTabTool } from "./system/navigate-settings.js";
-import { openSystemSettingsTool } from "./system/open-system-settings.js";
-import { voiceConfigUpdateTool } from "./system/voice-config.js";
+import { skillExecuteTool } from "./skills/execute.js";
+import { skillLoadTool } from "./skills/load.js";
+import { requestSystemPermissionTool } from "./system/request-permission.js";
+import { shellTool } from "./terminal/shell.js";
 import type { Tool } from "./types.js";
-import { screenWatchTool } from "./watch/screen-watch.js";
 
 // ── Eager side-effect modules ───────────────────────────────────────
-// These static imports trigger top-level `registerTool()` side effects.
+// These static imports trigger top-level `registerTool()` side effects on
+// first evaluation. The named imports above serve double duty: they give us
+// module-level references to each tool instance so that initializeTools()
+// can explicitly re-register them after a test registry reset (ESM caching
+// prevents side effects from re-running on subsequent imports).
 //
 // IMPORTANT: These MUST be static imports (not dynamic `await import()`).
 // When the daemon is compiled with `bun --compile`, dynamic imports with
@@ -31,21 +35,6 @@ import { screenWatchTool } from "./watch/screen-watch.js";
 // filesystem root rather than the module's own directory, causing
 // "Cannot find module './filesystem/read.js'" crashes in production builds.
 // Static imports are resolved at bundle time and are always safe.
-import "./assets/materialize.js";
-import "./assets/search.js";
-import "./filesystem/edit.js";
-import "./filesystem/read.js";
-import "./filesystem/view-image.js";
-import "./filesystem/write.js";
-import "./network/web-fetch.js";
-import "./network/web-search.js";
-import "./skills/delete-managed.js";
-import "./skills/load.js";
-import "./skills/scaffold-managed.js";
-import "./swarm/delegate.js";
-import "./system/request-permission.js";
-import "./system/version.js";
-import "./terminal/shell.js";
 
 // loadEagerModules is a no-op now that all eager registrations happen via
 // static imports above. Kept for API compatibility with registry.ts callers.
@@ -64,39 +53,44 @@ export const eagerModuleToolNames: string[] = [
   "file_edit",
   "web_search",
   "web_fetch",
+  "skill_execute",
   "skill_load",
-  "scaffold_managed_skill",
-  "delete_managed_skill",
   "request_system_permission",
   "asset_search",
   "asset_materialize",
-  "swarm_delegate",
-  "view_image",
-  "version",
 ];
 
 // ── Explicit tool instances ─────────────────────────────────────────
-// Tools exported as instances — registered by initializeTools() without
-// relying on import side effects.
+// Tools registered by initializeTools() via explicit instance references.
+// This includes both previously-eager tools (referenced here so they survive
+// a test registry reset) and tools that have always been explicit.
 
 export const explicitTools: Tool[] = [
-  memorySaveTool,
-  memoryUpdateTool,
-  memoryDeleteTool,
+  // Previously-eager tools — kept here so initializeTools() can re-register
+  // them after __resetRegistryForTesting() clears the registry (ESM caching
+  // prevents their side-effect registrations from re-running).
+  shellTool,
+  fileReadTool,
+  fileWriteTool,
+  fileEditTool,
+  webFetchTool,
+  webSearchTool,
+  skillExecuteTool,
+  skillLoadTool,
+  requestSystemPermissionTool,
+  assetSearchTool,
+  assetMaterializeTool,
+  // Always-explicit tools
+  memoryManageTool,
   memoryRecallTool,
   credentialStoreTool,
-  accountManageTool,
-  screenWatchTool,
-  voiceConfigUpdateTool,
-  setAvatarTool,
-  openSystemSettingsTool,
-  navigateSettingsTabTool,
 ];
 
 // ── Lazy tool descriptors ───────────────────────────────────────────
 // Tools that defer module loading until first invocation.
-// bash and swarm_delegate were previously lazy but are now eagerly registered
-// via side-effect imports above, preserving their full definitions (including
-// the `reason` field on bash) and fixing bun --compile module-not-found crashes.
+// bash was previously lazy but is now eagerly registered via side-effect
+// imports above, preserving its full definition (including the `reason` field)
+// and fixing bun --compile module-not-found crashes.
+// swarm_delegate has been moved to the orchestration bundled skill.
 
 export const lazyTools: LazyToolDescriptor[] = [];

package/src/tools/types.ts

@@ -136,9 +136,9 @@ export interface ToolContext {
     allowedTools?: string[];
     allowedDomains?: string[];
   }) => Promise<SecretPromptResult>;
-  /** Optional callback to send a message to the connected IPC client (e.g. open_url). */
+  /** Optional callback to send a message to the connected client (e.g. open_url). */
   sendToClient?: (msg: { type: string; [key: string]: unknown }) => void;
-  /** True when an interactive IPC client is connected (not just a no-op callback). */
+  /** True when an interactive client is connected (not just a no-op callback). */
   isInteractive?: boolean;
   /** Memory scope ID from the session's memory policy, so memory tools can target the correct scope. */
   memoryScopeId?: string;
@@ -169,6 +169,10 @@ export interface ToolContext {
   channelPermissionChannelId?: string;
   /** The tool_use block ID from the LLM response, used to correlate confirmation prompts with specific tool invocations. */
   toolUseId?: string;
+  /** Optional proxy for delegating host_bash execution to a connected client (managed/cloud-hosted mode). */
+  hostBashProxy?: import("../daemon/host-bash-proxy.js").HostBashProxy;
+  /** Optional proxy for delegating host_file_read/write/edit execution to a connected client (managed/cloud-hosted mode). */
+  hostFileProxy?: import("../daemon/host-file-proxy.js").HostFileProxy;
 }
 
 export interface DiffInfo {

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

@@ -218,63 +218,8 @@ export const uiDismissTool: Tool = {
   execute: proxyExecute,
 };
 
-// ---------------------------------------------------------------------------
-// request_file
-// ---------------------------------------------------------------------------
-
-export const requestFileTool: Tool = {
-  name: "request_file",
-  description:
-    "Request a file or image from the user. Shows a file upload dialog where the user can drag-and-drop or browse for files. " +
-    "Use this when you need the user to share a file (image, document, PDF, etc.) to continue the conversation. " +
-    "The result contains the uploaded file data including base64 content and MIME type.",
-  category: "ui-surface",
-  defaultRiskLevel: RiskLevel.Low,
-  executionMode: "proxy",
-
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
-        type: "object",
-        properties: {
-          prompt: {
-            type: "string",
-            description:
-              'What to ask the user for, e.g. "Please share the design file you\'d like me to review"',
-          },
-          accepted_types: {
-            type: "array",
-            items: { type: "string" },
-            description:
-              'MIME type filters, e.g. ["image/*", "application/pdf"]. If omitted, all supported file types are accepted.',
-          },
-          max_files: {
-            type: "number",
-            description: "Maximum number of files to accept. Defaults to 1.",
-          },
-          reason: {
-            type: "string",
-            description:
-              "Brief non-technical explanation of what you are requesting and why, shown to the user as a status update. Use simple language a non-technical person would understand.",
-          },
-        },
-        required: ["prompt"],
-      },
-    };
-  },
-
-  execute: proxyExecute,
-};
-
-// ---------------------------------------------------------------------------
-// All tools exported as array for convenience
-// ---------------------------------------------------------------------------
-
 export const allUiSurfaceTools: Tool[] = [
   uiShowTool,
   uiUpdateTool,
   uiDismissTool,
-  requestFileTool,
 ];

package/src/util/errors.ts

@@ -14,9 +14,6 @@ export enum ErrorCode {
   // Daemon errors
   DAEMON_ERROR = "DAEMON_ERROR",
 
-  // IPC/socket errors
-  IPC_ERROR = "IPC_ERROR",
-
   // Platform-specific errors (clipboard, unsupported OS features)
   PLATFORM_ERROR = "PLATFORM_ERROR",
 
@@ -170,13 +167,6 @@ export class DaemonError extends AssistantError {
   }
 }
 
-export class IpcError extends AssistantError {
-  constructor(message: string, options?: { cause?: unknown }) {
-    super(message, ErrorCode.IPC_ERROR, options);
-    this.name = "IpcError";
-  }
-}
-
 export class PlatformError extends AssistantError {
   constructor(message: string, options?: { cause?: unknown }) {
     super(message, ErrorCode.PLATFORM_ERROR, options);

package/src/workspace/git-service.ts

@@ -54,7 +54,6 @@ function cleanGitEnv(workspaceDir: string): Record<string, string> {
 const WORKSPACE_GITIGNORE_RULES = [
   "data/db/",
   "data/qdrant/",
-  "data/ipc-blobs/",
   "logs/",
   "*.log",
   "*.sock",
@@ -67,7 +66,6 @@ const WORKSPACE_GITIGNORE_RULES = [
   "*.db-journal",
   "*.db-wal",
   "*.db-shm",
-  "vellum.sock",
   "vellum.pid",
   "session-token",
 ];

package/src/__tests__/account-registry.test.ts

@@ -1,258 +0,0 @@
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
-
-const testDir = mkdtempSync(join(tmpdir(), "account-registry-test-"));
-
-mock.module("../util/platform.js", () => ({
-  getDataDir: () => testDir,
-  isMacOS: () => process.platform === "darwin",
-  isLinux: () => process.platform === "linux",
-  isWindows: () => process.platform === "win32",
-  getSocketPath: () => join(testDir, "test.sock"),
-  getPidPath: () => join(testDir, "test.pid"),
-  getDbPath: () => join(testDir, "test.db"),
-  getLogPath: () => join(testDir, "test.log"),
-  ensureDataDir: () => {},
-  getPlatformName: () => process.platform,
-}));
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-mock.module("../tools/registry.js", () => ({
-  registerTool: () => {},
-}));
-
-import {
-  createAccount,
-  getAccount,
-  listAccounts,
-  updateAccount,
-} from "../memory/account-store.js";
-import { getDb, initializeDb, resetDb } from "../memory/db.js";
-import type { ToolContext } from "../tools/types.js";
-
-// Initialize db once
-initializeDb();
-
-const _ctx: ToolContext = {
-  workingDir: "/tmp",
-  sessionId: "test-session",
-  conversationId: "test-conv",
-  trustClass: "guardian",
-};
-
-afterAll(() => {
-  resetDb();
-  mock.restore();
-  try {
-    rmSync(testDir, { recursive: true });
-  } catch {
-    /* best effort */
-  }
-});
-
-describe("account_manage tool", () => {
-  beforeEach(() => {
-    const db = getDb();
-    db.run(`DELETE FROM accounts`);
-  });
-
-  // -----------------------------------------------------------------------
-  // Create
-  // -----------------------------------------------------------------------
-  describe("create action", () => {
-    test("creates an account with auto-generated UUID", () => {
-      const record = createAccount({
-        service: "gmail",
-        username: "user@gmail.com",
-      });
-      expect(record.id).toBeTruthy();
-      // UUID v4 format: 8-4-4-4-12
-      expect(record.id).toMatch(
-        /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/,
-      );
-    });
-
-    test("sets timestamps correctly", () => {
-      const before = Date.now();
-      const record = createAccount({ service: "github" });
-      const after = Date.now();
-
-      expect(record.createdAt).toBeGreaterThanOrEqual(before);
-      expect(record.createdAt).toBeLessThanOrEqual(after);
-      expect(record.updatedAt).toBe(record.createdAt);
-    });
-
-    test("stores all provided fields", () => {
-      const record = createAccount({
-        service: "github",
-        username: "octocat",
-        email: "octocat@github.com",
-        displayName: "Octo Cat",
-        status: "pending_verification",
-        credentialRef: "github",
-        metadata: { twoFactor: true },
-      });
-
-      expect(record.service).toBe("github");
-      expect(record.username).toBe("octocat");
-      expect(record.email).toBe("octocat@github.com");
-      expect(record.displayName).toBe("Octo Cat");
-      expect(record.status).toBe("pending_verification");
-      expect(record.credentialRef).toBe("github");
-      expect(record.metadataJson).toBe(JSON.stringify({ twoFactor: true }));
-    });
-
-    test("defaults status to active", () => {
-      const record = createAccount({ service: "gmail" });
-      expect(record.status).toBe("active");
-    });
-
-    test("returns the created record as JSON", () => {
-      const record = createAccount({ service: "slack", email: "me@slack.com" });
-      expect(record.service).toBe("slack");
-      expect(record.email).toBe("me@slack.com");
-    });
-  });
-
-  // -----------------------------------------------------------------------
-  // List
-  // -----------------------------------------------------------------------
-  describe("list action", () => {
-    test("lists all accounts", () => {
-      createAccount({ service: "gmail", username: "user1" });
-      createAccount({ service: "github", username: "user2" });
-
-      const accounts = listAccounts();
-      expect(accounts).toHaveLength(2);
-    });
-
-    test("filters by service", () => {
-      createAccount({ service: "gmail", username: "user1" });
-      createAccount({ service: "github", username: "user2" });
-      createAccount({ service: "gmail", username: "user3" });
-
-      const gmailAccounts = listAccounts({ service: "gmail" });
-      expect(gmailAccounts).toHaveLength(2);
-      expect(gmailAccounts.every((a) => a.service === "gmail")).toBe(true);
-    });
-
-    test("filters by status", () => {
-      createAccount({ service: "gmail", status: "active" });
-      createAccount({ service: "github", status: "suspended" });
-      createAccount({ service: "slack", status: "active" });
-
-      const activeAccounts = listAccounts({ status: "active" });
-      expect(activeAccounts).toHaveLength(2);
-      expect(activeAccounts.every((a) => a.status === "active")).toBe(true);
-    });
-
-    test("filters by both service and status", () => {
-      createAccount({ service: "gmail", status: "active" });
-      createAccount({ service: "gmail", status: "suspended" });
-      createAccount({ service: "github", status: "active" });
-
-      const result = listAccounts({ service: "gmail", status: "active" });
-      expect(result).toHaveLength(1);
-      expect(result[0].service).toBe("gmail");
-      expect(result[0].status).toBe("active");
-    });
-
-    test("returns empty array when no accounts exist", () => {
-      const accounts = listAccounts();
-      expect(accounts).toEqual([]);
-    });
-  });
-
-  // -----------------------------------------------------------------------
-  // Get
-  // -----------------------------------------------------------------------
-  describe("get action", () => {
-    test("retrieves an account by id", () => {
-      const created = createAccount({ service: "gmail", username: "user1" });
-      const fetched = getAccount(created.id);
-      expect(fetched).toBeDefined();
-      expect(fetched!.id).toBe(created.id);
-      expect(fetched!.service).toBe("gmail");
-      expect(fetched!.username).toBe("user1");
-    });
-
-    test("returns undefined for invalid id", () => {
-      const result = getAccount("nonexistent-id");
-      expect(result).toBeUndefined();
-    });
-  });
-
-  // -----------------------------------------------------------------------
-  // Update
-  // -----------------------------------------------------------------------
-  describe("update action", () => {
-    test("updates provided fields", () => {
-      const created = createAccount({ service: "gmail", username: "old-user" });
-      const updated = updateAccount(created.id, { username: "new-user" });
-
-      expect(updated).toBeDefined();
-      expect(updated!.username).toBe("new-user");
-      expect(updated!.service).toBe("gmail"); // unchanged
-    });
-
-    test("bumps updatedAt on update", async () => {
-      const created = createAccount({ service: "gmail" });
-      // Small delay to ensure timestamp difference
-      await new Promise((r) => setTimeout(r, 10));
-      const updated = updateAccount(created.id, { username: "updated" });
-
-      expect(updated!.updatedAt).toBeGreaterThan(created.updatedAt);
-    });
-
-    test("returns undefined for non-existent id", () => {
-      const result = updateAccount("nonexistent-id", { username: "test" });
-      expect(result).toBeUndefined();
-    });
-
-    test("updates metadata as JSON", () => {
-      const created = createAccount({ service: "github" });
-      const updated = updateAccount(created.id, {
-        metadata: { role: "admin" },
-      });
-
-      expect(updated!.metadataJson).toBe(JSON.stringify({ role: "admin" }));
-    });
-
-    test("updates status", () => {
-      const created = createAccount({ service: "gmail", status: "active" });
-      const updated = updateAccount(created.id, { status: "suspended" });
-      expect(updated!.status).toBe("suspended");
-    });
-  });
-
-  // -----------------------------------------------------------------------
-  // Tool execute() via account-registry.ts
-  // -----------------------------------------------------------------------
-  describe("account_manage tool execute", () => {
-    // We test through the account-store functions since the tool is a thin wrapper.
-    // Also test the tool's error handling for missing required fields.
-
-    test("create without service returns error message", async () => {
-      // Import the tool module to test its execute method
-      const _mod = await import("../tools/credentials/account-registry.js");
-      // The tool was registered via side-effect; we test the store functions directly
-      // and verify the tool's error-handling logic matches.
-      // Since we mocked registerTool, let's just verify the store logic.
-      // The tool delegates to createAccount, which requires service.
-    });
-
-    test("multiple accounts for same service have unique IDs", () => {
-      const a1 = createAccount({ service: "gmail", username: "user1" });
-      const a2 = createAccount({ service: "gmail", username: "user2" });
-      expect(a1.id).not.toBe(a2.id);
-    });
-  });
-});

package/src/__tests__/email-classifier.test.ts

@@ -1,25 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import {
-  classifyEmails,
-  type EmailMetadata,
-} from "../messaging/email-classifier.js";
-
-describe("classifyEmails", () => {
-  test("returns empty classifications for empty input", async () => {
-    const result = await classifyEmails([]);
-    expect(result.classifications).toEqual([]);
-  });
-
-  test("accepts well-formed email metadata", () => {
-    const email: EmailMetadata = {
-      id: "msg-1",
-      from: "test@example.com",
-      subject: "Test Subject",
-      snippet: "This is a test email snippet",
-      labels: ["INBOX", "UNREAD"],
-    };
-    expect(email.id).toBe("msg-1");
-    expect(email.labels).toContain("INBOX");
-  });
-});