@vellumai/assistant 0.8.5 → 0.8.6

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

@@ -1,8 +1,10 @@
 import { randomUUID } from "node:crypto";
 
 import {
+  addDocumentConversation,
   deleteDocument,
   findInDocument,
+  findRecentEmptyDocumentByTitle,
   getDocumentById,
   getDocumentsForConversation,
   isDocumentAssociatedWithConversation,
@@ -40,13 +42,36 @@ export function canAccessDocument(
   );
 }
 
+function invalidInput(message: string): ToolExecutionResult {
+  return {
+    content: JSON.stringify({
+      success: false,
+      error: `Invalid input: ${message}`,
+    }),
+    isError: true,
+  };
+}
+
+function validateSurfaceId(
+  input: Record<string, unknown>,
+): ToolExecutionResult | string {
+  if (typeof input.surface_id !== "string" || input.surface_id.trim() === "") {
+    return invalidInput(
+      "surface_id is required and must be a non-empty string",
+    );
+  }
+  return input.surface_id;
+}
+
 // ── Exported execute functions ──────────────────────────────────────
 
 export function executeDocumentOpen(
   input: Record<string, unknown>,
   context: ToolContext,
 ): ToolExecutionResult {
-  const surfaceId = input.surface_id as string;
+  const surfaceIdOrError = validateSurfaceId(input);
+  if (typeof surfaceIdOrError !== "string") return surfaceIdOrError;
+  const surfaceId = surfaceIdOrError;
   if (!canAccessDocument(surfaceId, context)) {
     return documentNotFound(surfaceId);
   }
@@ -101,12 +126,87 @@ export function executeDocumentOpen(
   };
 }
 
+const EMPTY_DOCUMENT_DEDUPE_WINDOW_MS = 5 * 60 * 1000;
+
+/**
+ * If the model just created an empty same-title document in this conversation
+ * and is now creating a second one with real content, reuse the first row
+ * instead of producing a duplicate. Returns `null` when no dedupe applies.
+ *
+ * Only triggers when `initialContent` is non-empty — an empty incoming create
+ * likely means the model intends a fresh blank doc.
+ */
+function maybeReuseEmptyDocument(
+  title: string,
+  initialContent: string,
+  context: ToolContext,
+): ToolExecutionResult | null {
+  if (initialContent.length === 0) return null;
+  const existing = findRecentEmptyDocumentByTitle(
+    context.conversationId,
+    title,
+    EMPTY_DOCUMENT_DEDUPE_WINDOW_MS,
+  );
+  if (!existing) return null;
+
+  const surfaceId = existing.surfaceId;
+  const update = updateDocumentContent(surfaceId, initialContent, "replace");
+  if (!update.success) return null;
+
+  // Defensive idempotent insert (saveDocument from the create-new path already
+  // ran addDocumentConversation; INSERT OR IGNORE makes this a safe no-op).
+  addDocumentConversation(surfaceId, context.conversationId);
+
+  if (context.sendToClient) {
+    // Use document_editor_update — not document_editor_show — because the
+    // empty draft is typically still OPEN on the macOS client. A *_show on an
+    // open doc triggers DocumentManager.closeDocument() → async save() of the
+    // OLD (empty) content, clobbering the initialContent we just persisted.
+    context.sendToClient({
+      type: "document_editor_update",
+      conversationId: context.conversationId,
+      surfaceId,
+      markdown: initialContent,
+      mode: "replace",
+    });
+
+    context.sendToClient({
+      type: "ui_surface_show",
+      conversationId: context.conversationId,
+      surfaceId: `preview-${surfaceId}`,
+      surfaceType: "document_preview",
+      display: "inline",
+      title,
+      data: {
+        title,
+        surfaceId,
+        subtitle: "Document",
+      },
+    });
+  }
+
+  return {
+    content: JSON.stringify({
+      surface_id: surfaceId,
+      title,
+      opened: context.sendToClient != null,
+      reused: true,
+      message: "Document editor reopened (deduped empty draft)",
+    }),
+    isError: false,
+  };
+}
+
 export function executeDocumentCreate(
   input: Record<string, unknown>,
   context: ToolContext,
 ): ToolExecutionResult {
   const title = (input.title as string | undefined) || "Untitled Document";
   const initialContent = (input.initial_content as string | undefined) || "";
+
+  const reused = maybeReuseEmptyDocument(title, initialContent, context);
+  if (reused) return reused;
+
   const surfaceId = `doc-${randomUUID()}`;
 
   // Persist the document so any client (web or macOS) can fetch it via
@@ -174,9 +274,24 @@ export function executeDocumentUpdate(
   input: Record<string, unknown>,
   context: ToolContext,
 ): ToolExecutionResult {
-  const surfaceId = input.surface_id as string;
-  const content = input.content as string;
-  const mode = (input.mode as string | undefined) || "append";
+  const surfaceIdOrError = validateSurfaceId(input);
+  if (typeof surfaceIdOrError !== "string") return surfaceIdOrError;
+  const surfaceId = surfaceIdOrError;
+  if (typeof input.content !== "string") {
+    return invalidInput("content is required and must be a string");
+  }
+  // Loose `!= null` to match validateInputAgainstSchema, which treats null as
+  // "absent" for enum checks — without this, { mode: null } passes the
+  // factory validator but rejects here. The `?? "append"` below handles null.
+  if (
+    input.mode != null &&
+    input.mode !== "replace" &&
+    input.mode !== "append"
+  ) {
+    return invalidInput('mode must be "replace" or "append"');
+  }
+  const content = input.content;
+  const mode = (input.mode as "replace" | "append" | undefined) ?? "append";
 
   if (!canAccessDocument(surfaceId, context)) {
     return documentNotFound(surfaceId);
@@ -229,7 +344,9 @@ export function executeDocumentRead(
   input: Record<string, unknown>,
   context: ToolContext,
 ): ToolExecutionResult {
-  const surfaceId = input.surface_id as string;
+  const surfaceIdOrError = validateSurfaceId(input);
+  if (typeof surfaceIdOrError !== "string") return surfaceIdOrError;
+  const surfaceId = surfaceIdOrError;
   if (!canAccessDocument(surfaceId, context)) {
     return documentNotFound(surfaceId);
   }
@@ -286,7 +403,9 @@ export function executeDocumentDelete(
   input: Record<string, unknown>,
   context: ToolContext,
 ): ToolExecutionResult {
-  const surfaceId = input.surface_id as string;
+  const surfaceIdOrError = validateSurfaceId(input);
+  if (typeof surfaceIdOrError !== "string") return surfaceIdOrError;
+  const surfaceId = surfaceIdOrError;
   if (!canAccessDocument(surfaceId, context)) {
     return documentNotFound(surfaceId);
   }
@@ -309,7 +428,9 @@ export function executeDocumentFind(
   input: Record<string, unknown>,
   context: ToolContext,
 ): ToolExecutionResult {
-  const surfaceId = input.surface_id as string;
+  const surfaceIdOrError = validateSurfaceId(input);
+  if (typeof surfaceIdOrError !== "string") return surfaceIdOrError;
+  const surfaceId = surfaceIdOrError;
   const query = input.query as string;
   const regex = (input.regex as boolean | undefined) ?? false;
   const caseSensitive = (input.case_sensitive as boolean | undefined) ?? false;
@@ -360,7 +481,9 @@ export function executeDocumentReplaceText(
   input: Record<string, unknown>,
   context: ToolContext,
 ): ToolExecutionResult {
-  const surfaceId = input.surface_id as string;
+  const surfaceIdOrError = validateSurfaceId(input);
+  if (typeof surfaceIdOrError !== "string") return surfaceIdOrError;
+  const surfaceId = surfaceIdOrError;
   const find = input.find as string;
   const replace = (input.replace as string) ?? "";
   const regex = (input.regex as boolean | undefined) ?? false;

package/src/tools/execution-target.ts

@@ -11,9 +11,8 @@ export interface ManifestOverride {
  *
  * Resolution order:
  *   1. Declared `executionTarget` on the tool wins.
- *   2. `executionMode === "proxy"` ⇒ host (proxied tools run on the client).
- *   3. Name prefix heuristic — `host_*` / `computer_use_*` ⇒ host.
- *   4. Default sandbox.
+ *   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 `LoadedTool`, so runtime reads are just a field read.
@@ -21,10 +20,8 @@ export interface ManifestOverride {
 export function resolveExecutionTarget(tool: {
   name: string;
   executionTarget?: ExecutionTarget;
-  executionMode?: "local" | "proxy";
 }): ExecutionTarget {
   if (tool.executionTarget) return tool.executionTarget;
-  if (tool.executionMode === "proxy") return "host";
   if (tool.name.startsWith("host_") || tool.name.startsWith("computer_use_")) {
     return "host";
   }

package/src/tools/executor.ts

@@ -28,7 +28,7 @@ import { applyEdit } from "./shared/filesystem/edit-engine.js";
 import { sandboxPolicy } from "./shared/filesystem/path-policy.js";
 import { MAX_FILE_SIZE_BYTES } from "./shared/filesystem/size-guard.js";
 import { ToolApprovalHandler } from "./tool-approval-handler.js";
-import { resolveToolNameAlias } from "./tool-name-aliases.js";
+import { resolveToolInvocationAlias } from "./tool-name-aliases.js";
 import type {
   ToolContext,
   ToolExecutionResult,
@@ -78,10 +78,11 @@ export class ToolExecutor {
     };
 
     const middlewares = getMiddlewaresFor("toolExecute");
-    const executionName = resolveToolNameAlias(name, context.allowedToolNames);
+    const { name: executionName, input: executionInput } =
+      resolveToolInvocationAlias(name, input, context.allowedToolNames);
     const pipelineArgs: ToolExecuteArgs = {
       name: executionName,
-      input,
+      input: executionInput,
       context,
     };
 
@@ -241,48 +242,18 @@ export class ToolExecutor {
         permApprovalReason = "grant_scoped_consumed";
       }
 
-      // Execute the tool - proxy tools delegate to an external resolver.
-      // Use the shared per-tool timeout helper so the pipeline runner and
-      // the inner execute-with-timeout wrapper agree on the same budget.
-      let execResult: ToolExecutionResult;
+      // Execute the tool. Tools that forward to an external resolver
+      // (computer-use, ui-surface, apps, meet) handle that dispatch in
+      // their own `execute()` body — the executor no longer special-cases
+      // proxy mode here.
       const toolTimeoutMs = computePerToolTimeoutMs(name, input);
-
       const execContext = context;
 
-      if (tool.executionMode === "proxy") {
-        if (!context.proxyToolResolver) {
-          const msg = `No proxy resolver configured for proxy tool "${name}". This tool requires an external resolver (e.g. a connected macOS client for computer-use tools).`;
-          const durationMs = Date.now() - startTime;
-          emitLifecycleEvent(context, {
-            type: "error",
-            toolName: name,
-            executionTarget,
-            input,
-            workingDir: context.workingDir,
-            conversationId: context.conversationId,
-            requestId: context.requestId,
-            riskLevel,
-            matchedTrustRuleId: permMatchedTrustRuleId,
-            decision: "error",
-            durationMs,
-            errorMessage: msg,
-            isExpected: true,
-            errorCategory: "tool_failure",
-          });
-          return { content: msg, isError: true };
-        }
-        execResult = await executeWithTimeout(
-          context.proxyToolResolver(name, input),
-          toolTimeoutMs,
-          name,
-        );
-      } else {
-        execResult = await executeWithTimeout(
-          tool.execute(input, execContext),
-          toolTimeoutMs,
-          name,
-        );
-      }
+      let execResult: ToolExecutionResult = await executeWithTimeout(
+        tool.execute(input, execContext),
+        toolTimeoutMs,
+        name,
+      );
 
       // CES approval bridge: if the tool returned an approval_required
       // indicator, present the proposal to the guardian via the existing
@@ -336,19 +307,11 @@ export class ToolExecutor {
             "CES approval granted - retrying tool invocation with grantId",
           );
 
-          if (tool.executionMode === "proxy") {
-            execResult = await executeWithTimeout(
-              context.proxyToolResolver!(name, retryInput),
-              toolTimeoutMs,
-              name,
-            );
-          } else {
-            execResult = await executeWithTimeout(
-              tool.execute(retryInput, execContext),
-              toolTimeoutMs,
-              name,
-            );
-          }
+          execResult = await executeWithTimeout(
+            tool.execute(retryInput, execContext),
+            toolTimeoutMs,
+            name,
+          );
         } else if (
           bridgeResult.outcome === "denied" ||
           bridgeResult.outcome === "timeout"

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/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/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/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/mcp/mcp-tool-factory.ts

@@ -48,8 +48,6 @@ export function createMcpTool(
     description: metadata.description,
     category: "mcp",
     defaultRiskLevel: riskLevel,
-    origin: "mcp",
-    ownerMcpServerId: serverId,
     executionTarget: "host",
 
     input_schema: metadata.inputSchema as object,