@vellumai/assistant 0.8.5 → 0.8.7

package/src/daemon/conversation-surfaces.ts

@@ -18,7 +18,11 @@ import {
   assistantEventHub,
   broadcastMessage,
 } from "../runtime/assistant-event-hub.js";
-import { enforceSameActorOrErrorResult } from "../runtime/auth/same-actor.js";
+import {
+  ambiguousSameUserError,
+  enforceSameActorOrErrorResult,
+  pickSameUserAutoResolve,
+} from "../runtime/auth/same-actor.js";
 import type {
   InteractiveUiRequest,
   InteractiveUiResult,
@@ -28,6 +32,8 @@ import { getLogger } from "../util/logger.js";
 import { isPlainObject } from "../util/object.js";
 import { buildConversationErrorMessage } from "./conversation-error.js";
 import { launchConversation } from "./conversation-launch.js";
+import type { EnqueueMessageOptions } from "./conversation-messaging.js";
+import type { ProcessMessageOptions } from "./conversation-process.js";
 import type { HostAppControlProxy } from "./host-app-control-proxy.js";
 import type { HostCuProxy } from "./host-cu-proxy.js";
 import type {
@@ -45,7 +51,6 @@ import type {
   UiSurfaceShow,
 } from "./message-protocol.js";
 import { INTERACTIVE_SURFACE_TYPES } from "./message-protocol.js";
-import type { ConversationTransportMetadata } from "./message-types/conversations.js";
 import type { HostAppControlInput } from "./message-types/host-app-control.js";
 import type { UserMessageAttachment } from "./message-types/shared.js";
 import type { TrustContext } from "./trust-context.js";
@@ -503,6 +508,7 @@ export interface SurfaceConversationContext {
     }>;
     display?: string;
     persistent?: boolean;
+    toolCallId?: string;
   }>;
   /** Optional proxy for delegating computer-use actions to a connected desktop client. */
   hostCuProxy?: HostCuProxy;
@@ -518,29 +524,13 @@ export interface SurfaceConversationContext {
   /** True when no interactive client is connected (headless / channel-only). */
   readonly hasNoClient?: boolean;
   isProcessing(): boolean;
-  enqueueMessage(
-    content: string,
-    attachments: UserMessageAttachment[],
-    onEvent?: (msg: ServerMessage) => void,
-    requestId?: string,
-    activeSurfaceId?: string,
-    currentPage?: string,
-    metadata?: Record<string, unknown>,
-    options?: { isInteractive?: boolean },
-    displayContent?: string,
-    transport?: ConversationTransportMetadata,
-  ): { queued: boolean; requestId: string; rejected?: boolean };
+  enqueueMessage(options: EnqueueMessageOptions): {
+    queued: boolean;
+    requestId: string;
+    rejected?: boolean;
+  };
   getQueueDepth(): number;
-  processMessage(
-    content: string,
-    attachments: UserMessageAttachment[],
-    onEvent?: (msg: ServerMessage) => void,
-    requestId?: string,
-    activeSurfaceId?: string,
-    currentPage?: string,
-    options?: { isInteractive?: boolean },
-    displayContent?: string,
-  ): Promise<string>;
+  processMessage(options: ProcessMessageOptions): Promise<string>;
   /** Serialize operations on a given surface to prevent read-modify-write races. */
   withSurface<T>(surfaceId: string, fn: () => T | Promise<T>): Promise<T>;
 }
@@ -1142,6 +1132,34 @@ export type SurfaceActionResult =
   | { accepted: false; error: string }
   | void;
 
+const SURFACE_COMPLETE_FLAG = "_completeSurface";
+const SURFACE_COMPLETION_SUMMARY_FIELD = "_completionSummary";
+
+function getRequestedSurfaceCompletionSummary(
+  data?: Record<string, unknown>,
+): string | null {
+  if (data?.[SURFACE_COMPLETE_FLAG] !== true) return null;
+  const summary =
+    typeof data[SURFACE_COMPLETION_SUMMARY_FIELD] === "string"
+      ? data[SURFACE_COMPLETION_SUMMARY_FIELD].trim()
+      : "";
+  return summary || "Completed";
+}
+
+function completeSurfaceFromAction(
+  ctx: SurfaceConversationContext,
+  surfaceId: string,
+  summary: string,
+): void {
+  broadcastMessage({
+    type: "ui_surface_complete",
+    conversationId: ctx.conversationId,
+    surfaceId,
+    summary,
+  });
+  markSurfaceCompleted(ctx, surfaceId, summary);
+}
+
 export async function handleSurfaceAction(
   ctx: SurfaceConversationContext,
   surfaceId: string,
@@ -1318,9 +1336,16 @@ export async function handleSurfaceAction(
     }
 
     // Determine message content from the action.
+    const stored = ctx.surfaceState.get(surfaceId);
+    const actionDef = stored?.actions?.find((a) => a.id === actionId);
+    const mergedData: Record<string, unknown> | undefined =
+      actionDef?.data || data ? { ...actionDef?.data, ...data } : undefined;
+
     const isRelay = actionId === "relay_prompt" || actionId === "agent_prompt";
     const prompt =
-      isRelay && typeof data?.prompt === "string" ? data.prompt.trim() : "";
+      isRelay && typeof mergedData?.prompt === "string"
+        ? mergedData.prompt.trim()
+        : "";
 
     // Read accumulated state once — used by both relay and custom action paths.
     const accState = ctx.accumulatedSurfaceState.get(surfaceId);
@@ -1329,9 +1354,9 @@ export async function handleSurfaceAction(
     // Extract file attachments from action data so they are sent as proper
     // image/file content blocks instead of dumping base64 into the text.
     let attachments: UserMessageAttachment[] = [];
-    let actionDataForText = data;
-    if (data && Array.isArray(data.files)) {
-      const files = data.files as Array<Record<string, unknown>>;
+    let actionDataForText = mergedData;
+    if (mergedData && Array.isArray(mergedData.files)) {
+      const files = mergedData.files as Array<Record<string, unknown>>;
       attachments = files
         .filter(
           (f) =>
@@ -1351,7 +1376,7 @@ export async function handleSurfaceAction(
       // attachments — otherwise preserve the original data so the model still
       // sees the files field (e.g. IDs/paths from dynamic app actions).
       if (attachments.length > 0) {
-        const { files: _files, ...rest } = data;
+        const { files: _files, ...rest } = mergedData;
         actionDataForText = Object.keys(rest).length > 0 ? rest : undefined;
       }
     }
@@ -1414,23 +1439,26 @@ export async function handleSurfaceAction(
       attributes: { source: "surface_action", surfaceId, actionId },
     });
 
-    const result = ctx.enqueueMessage(
+    const result = ctx.enqueueMessage({
       content,
       attachments,
       onEvent,
       requestId,
-      surfaceId,
-      undefined,
-      undefined,
-      undefined,
+      activeSurfaceId: surfaceId,
       displayContent,
-    );
+    });
 
     if (result.rejected) {
       ctx.surfaceActionRequestIds.delete(requestId);
       return;
     }
 
+    const requestedCompletionSummary =
+      getRequestedSurfaceCompletionSummary(mergedData);
+    if (requestedCompletionSummary) {
+      completeSurfaceFromAction(ctx, surfaceId, requestedCompletionSummary);
+    }
+
     // One-shot: clear accumulated state now that the message has been accepted.
     // Deferred until after rejection check so state is preserved for retry on rejection.
     if (hasAccState) {
@@ -1461,16 +1489,14 @@ export async function handleSurfaceAction(
       "Processing surface action immediately (history-restored) with attachments",
     );
     ctx
-      .processMessage(
+      .processMessage({
         content,
         attachments,
         onEvent,
         requestId,
-        surfaceId,
-        undefined,
-        undefined,
+        activeSurfaceId: surfaceId,
         displayContent,
-      )
+      })
       .catch((err) => {
         const message = err instanceof Error ? err.message : String(err);
         log.error(
@@ -1653,22 +1679,22 @@ export async function handleSurfaceAction(
     "Surface action follow-up: preparing to send message to model",
   );
 
-  const result = ctx.enqueueMessage(
+  const result = ctx.enqueueMessage({
     content,
-    pendingAttachments,
+    attachments: pendingAttachments,
     onEvent,
     requestId,
-    surfaceId,
-    undefined,
-    undefined,
-    undefined,
+    activeSurfaceId: surfaceId,
     displayContent,
-  );
+  });
   if (result.rejected) {
     ctx.surfaceActionRequestIds.delete(requestId);
     return;
   }
 
+  const requestedCompletionSummary =
+    getRequestedSurfaceCompletionSummary(mergedData);
+
   // One-shot interactive surfaces — auto-complete now that the message has
   // been accepted. Deferred until after rejection check so the surface stays
   // active and retryable if the queue was full.
@@ -1678,15 +1704,19 @@ export async function handleSurfaceAction(
     "file_upload",
     "task_preferences",
   ];
-  if (ONE_SHOT_SURFACE_TYPES.includes(pending.surfaceType)) {
+  if (
+    requestedCompletionSummary ||
+    ONE_SHOT_SURFACE_TYPES.includes(pending.surfaceType)
+  ) {
+    const completionSummary = requestedCompletionSummary ?? summary;
     broadcastMessage({
       type: "ui_surface_complete",
       conversationId: ctx.conversationId,
       surfaceId,
-      summary,
+      summary: completionSummary,
       submittedData: mergedDataForText,
     });
-    markSurfaceCompleted(ctx, surfaceId, summary);
+    markSurfaceCompleted(ctx, surfaceId, completionSummary);
   }
 
   // One-shot: clear accumulated state now that the message has been accepted.
@@ -1744,16 +1774,14 @@ export async function handleSurfaceAction(
     "Processing surface action as follow-up with attachments",
   );
   ctx
-    .processMessage(
+    .processMessage({
       content,
-      pendingAttachments,
+      attachments: pendingAttachments,
       onEvent,
       requestId,
-      surfaceId,
-      undefined,
-      undefined,
+      activeSurfaceId: surfaceId,
       displayContent,
-    )
+    })
     .catch((err) => {
       const message = err instanceof Error ? err.message : String(err);
       log.error(
@@ -1943,6 +1971,7 @@ export async function surfaceProxyResolver(
   toolName: string,
   input: Record<string, unknown>,
   signal?: AbortSignal,
+  toolUseId?: string,
 ): Promise<ToolExecutionResult> {
   // Route CU proxy tools (all computer_use_* action tools)
   if (toolName.startsWith("computer_use_")) {
@@ -2007,44 +2036,29 @@ export async function surfaceProxyResolver(
       if (rejection) return rejection;
     }
 
-    // Guard: require explicit targeting when multiple same-user CU-capable
-    // clients are connected. The tool schemas document target_client_id as
-    // "required when multiple clients support host_cu" but nothing enforced
-    // it at runtime until now. Without this guard, the request would
-    // broadcast to all capable clients simultaneously, causing the same CU
-    // action to execute on multiple machines. The filter mirrors
-    // HostFileProxy's auto-resolve: only same-user clients participate, so
-    // a cross-user client connected to the same daemon does not falsely
-    // trigger this ambiguity error.
-    //
-    // Asymmetry with host_bash / host_file (host-shell.ts): the bash/file
-    // guard additionally checks `transportInterface != null &&
-    // !supportsHostProxy(transportInterface)` and so only fires for non-host-
-    // proxy transports (web, Slack). For CU that check would be a no-op:
-    // every host_cu-capable client is host-proxy-capable by definition
-    // (host_cu only ships on macOS and the Chrome extension), so there is no
-    // host_cu-capable transport for which auto-routing-to-self would be
-    // appropriate. We therefore fire whenever there is genuine ambiguity.
+    // Untargeted CU must resolve to exactly one same-user capable client
+    // before dispatch. Otherwise the proxy would broadcast without a target
+    // actor binding, which is unsafe in shared runtimes.
     if (targetClientId == null) {
-      const allCuClients = assistantEventHub.listClientsByCapability("host_cu");
-      const sameUserCuClients = allCuClients.filter(
-        (c) => c.actorPrincipalId === sourceActorPrincipalId,
-      );
-      if (sameUserCuClients.length > 1) {
+      const resolved = pickSameUserAutoResolve({
+        hub: assistantEventHub,
+        capability: "host_cu",
+        sourceActorPrincipalId,
+      });
+      if (resolved.kind === "ambiguous") {
+        return ambiguousSameUserError("host_cu");
+      }
+      if (resolved.kind === "match") {
+        targetClientId = resolved.clientId;
+      } else if (
+        assistantEventHub.listClientsByCapability("host_cu").length > 0
+      ) {
         return {
-          content: `Error: multiple clients support host_cu. Specify which client to target with \`target_client_id\`. Run \`assistant clients list --capability host_cu\` to see client IDs and labels.`,
+          content:
+            "Computer use is not available for the current actor. Connect a host_cu-capable client as the same user.",
           isError: true,
         };
       }
-      // When cross-user host_cu clients are connected, we MUST auto-resolve
-      // to the unique same-user client (or fail explicitly) — otherwise the
-      // proxy would broadcast untargeted and the CU action would reach the
-      // cross-user client too. Setting targetClientId here forces the proxy
-      // to deliver only to that client, with the same-user check below as
-      // belt-and-suspenders.
-      if (sameUserCuClients.length === 1 && allCuClients.length > 1) {
-        targetClientId = sameUserCuClients[0].clientId;
-      }
     }
 
     ctx.hostCuProxy.recordAction(toolName, input, reasoning);
@@ -2129,24 +2143,25 @@ export async function surfaceProxyResolver(
     }
 
     if (targetClientId == null) {
-      const allAcClients =
-        assistantEventHub.listClientsByCapability("host_app_control");
-      const sameUserAcClients = allAcClients.filter(
-        (c) => c.actorPrincipalId === sourceActorPrincipalId,
-      );
-      if (sameUserAcClients.length > 1) {
+      const resolved = pickSameUserAutoResolve({
+        hub: assistantEventHub,
+        capability: "host_app_control",
+        sourceActorPrincipalId,
+      });
+      if (resolved.kind === "ambiguous") {
+        return ambiguousSameUserError("host_app_control");
+      }
+      if (resolved.kind === "match") {
+        targetClientId = resolved.clientId;
+      } else if (
+        assistantEventHub.listClientsByCapability("host_app_control").length > 0
+      ) {
         return {
-          content: `Error: multiple clients support host_app_control. Specify which client to target with \`target_client_id\`. Run \`assistant clients list --capability host_app_control\` to see client IDs and labels.`,
+          content:
+            "App control is not available for the current actor. Connect a host_app_control-capable client as the same user.",
           isError: true,
         };
       }
-      // When cross-user host_app_control clients are connected, auto-
-      // resolve to the unique same-user client. Otherwise the proxy would
-      // dispatch untargeted and the action could reach a cross-user
-      // client. Belt-and-suspenders: the proxy re-checks same-user.
-      if (sameUserAcClients.length === 1 && allAcClients.length > 1) {
-        targetClientId = sameUserAcClients[0].clientId;
-      }
     }
 
     // The TS `HostAppControlInput` (and the Swift mirror) is a discriminated
@@ -2288,6 +2303,7 @@ export async function surfaceProxyResolver(
       actions: mappedActions,
       display,
       ...(persistent ? { persistent: true } : {}),
+      ...(toolUseId ? { toolCallId: toolUseId } : {}),
     } as unknown as UiSurfaceShow);
 
     // Track surface for persistence with the message
@@ -2299,6 +2315,7 @@ export async function surfaceProxyResolver(
       actions: mappedActions,
       display,
       ...(persistent ? { persistent: true } : {}),
+      ...(toolUseId ? { toolCallId: toolUseId } : {}),
     });
 
     if (awaitAction) {
@@ -2472,6 +2489,7 @@ export async function surfaceProxyResolver(
         title: app.name,
         data: surfaceData,
         display: "inline",
+        ...(toolUseId ? { toolCallId: toolUseId } : {}),
       } as UiSurfaceShow);
 
       // Track for message persistence so the inline card survives history reload.
@@ -2481,6 +2499,7 @@ export async function surfaceProxyResolver(
         title: app.name,
         data: surfaceData,
         display: "inline",
+        ...(toolUseId ? { toolCallId: toolUseId } : {}),
       });
 
       return { content: JSON.stringify({ surfaceId, appId }), isError: false };
@@ -2499,6 +2518,7 @@ export async function surfaceProxyResolver(
       surfaceType: "dynamic_page",
       title: app.name,
       data: surfaceData,
+      ...(toolUseId ? { toolCallId: toolUseId } : {}),
     } as UiSurfaceShow);
 
     // Track surface for persistence
@@ -2507,6 +2527,7 @@ export async function surfaceProxyResolver(
       surfaceType: "dynamic_page",
       title: app.name,
       data: surfaceData,
+      ...(toolUseId ? { toolCallId: toolUseId } : {}),
     });
 
     ctx.pendingSurfaceActions.set(surfaceId, { surfaceType: "dynamic_page" });

package/src/daemon/conversation-tool-setup.ts

@@ -20,18 +20,14 @@ import type { SecretPrompter } from "../permissions/secret-prompter.js";
 import type { Message, ToolDefinition } from "../providers/types.js";
 import type { TrustClass } from "../runtime/actor-trust-resolver.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
-import { coreAppProxyTools } from "../tools/apps/definitions.js";
 import { registerConversationSender } from "../tools/browser/browser-screencast.js";
 import type { ToolExecutor } from "../tools/executor.js";
-import {
-  getAllToolDefinitions,
-  getMcpToolDefinitions,
-} from "../tools/registry.js";
+import { getMcpToolDefinitions } from "../tools/registry.js";
 import {
   ACTIVITY_SKIP_SET,
   injectActivityField,
 } from "../tools/schema-transforms.js";
-import { resolveToolNameAlias } from "../tools/tool-name-aliases.js";
+import { resolveToolInvocationAlias } from "../tools/tool-name-aliases.js";
 import {
   isDiskPressureCleanupToolName,
   type ProxyApprovalCallback,
@@ -40,7 +36,6 @@ import {
   type ToolExecutionResult,
   type ToolLifecycleEventHandler,
 } from "../tools/types.js";
-import { allUiSurfaceTools } from "../tools/ui-surface/definitions.js";
 import { getLogger } from "../util/logger.js";
 import {
   projectSkillTools,
@@ -75,6 +70,7 @@ export function resolveTrustClass(
 }
 
 import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
+import { AUTO_PROFILE_KEY } from "../config/seed-inference-profiles.js";
 import {
   buildSwitchInferenceProfileToolDef,
   SWITCH_INFERENCE_PROFILE_TOOL_NAME,
@@ -82,20 +78,6 @@ import {
 import type { ToolSetupContext } from "./tool-setup-types.js";
 export type { ToolSetupContext } from "./tool-setup-types.js";
 
-// ── buildToolDefinitions ─────────────────────────────────────────────
-
-/**
- * Collect all tool definitions for the agent loop: built-in tools,
- * UI surface proxy tools, and app proxy tools.
- */
-export function buildToolDefinitions(): ToolDefinition[] {
-  return [
-    ...getAllToolDefinitions(),
-    ...allUiSurfaceTools,
-    ...coreAppProxyTools,
-  ];
-}
-
 // ── createToolExecutor ───────────────────────────────────────────────
 
 /**
@@ -129,10 +111,11 @@ export function createToolExecutor(
     toolUseId?: string,
     turnContext?: import("../plugins/types.js").TurnContext,
   ) => {
-    const executionName = resolveToolNameAlias(name, ctx.allowedToolNames);
+    const { name: executionName, input: executionInput } =
+      resolveToolInvocationAlias(name, input, ctx.allowedToolNames);
 
-    if (isDoordashCommand(executionName, input)) {
-      markDoordashStepInProgress(ctx, input);
+    if (isDoordashCommand(executionName, executionInput)) {
+      markDoordashStepInProgress(ctx, executionInput);
     }
 
     // Build the context object shared by both the skill_execute interception
@@ -176,6 +159,7 @@ export function createToolExecutor(
         ctx.sendToClient(msg as ServerMessage);
         if (msg.type === "ui_surface_show") {
           const s = msg as unknown as UiSurfaceShow;
+          const surfaceToolCallId = s.toolCallId ?? toolUseId;
           ctx.currentTurnSurfaces.push({
             surfaceId: s.surfaceId,
             surfaceType: s.surfaceType,
@@ -184,6 +168,7 @@ export function createToolExecutor(
             actions: s.actions,
             display: s.display,
             ...(s.persistent ? { persistent: true } : {}),
+            ...(surfaceToolCallId ? { toolCallId: surfaceToolCallId } : {}),
           });
         }
       },
@@ -197,6 +182,7 @@ export function createToolExecutor(
           toolName,
           proxyInput,
           ctx.abortController?.signal,
+          toolUseId,
         ),
       proxyApprovalCallback: createProxyApprovalCallback(prompter, ctx),
       requestSecret: async (params) => {
@@ -218,7 +204,10 @@ export function createToolExecutor(
     // model self-select a different inference profile mid-turn. No permission
     // checks — this is a control-flow signal, not a user-visible tool.
     if (executionName === SWITCH_INFERENCE_PROFILE_TOOL_NAME) {
-      const profile = typeof input.profile === "string" ? input.profile : "";
+      const profile =
+        typeof executionInput.profile === "string"
+          ? executionInput.profile
+          : "";
       const config = getConfig();
       const profileEntry = config.llm.profiles?.[profile];
       if (!profileEntry) {
@@ -246,15 +235,19 @@ export function createToolExecutor(
     // risk level, permission checks, hooks, and lifecycle events all fire
     // with the real tool name.
     if (executionName === "skill_execute") {
-      const rawToolName = typeof input.tool === "string" ? input.tool : "";
-      const toolName = resolveToolNameAlias(rawToolName, ctx.allowedToolNames);
+      const rawToolName =
+        typeof executionInput.tool === "string" ? executionInput.tool : "";
       const rawToolInput =
-        input.input != null && typeof input.input === "object"
-          ? (input.input as Record<string, unknown>)
+        executionInput.input != null && typeof executionInput.input === "object"
+          ? (executionInput.input as Record<string, unknown>)
           : {};
 
       // Clone to avoid mutating shared input objects
-      const toolInput = { ...rawToolInput };
+      const { name: toolName, input: toolInput } = resolveToolInvocationAlias(
+        rawToolName,
+        { ...rawToolInput },
+        ctx.allowedToolNames,
+      );
 
       if (!toolName) {
         return {
@@ -281,7 +274,7 @@ export function createToolExecutor(
 
     const result = await executor.execute(
       executionName,
-      input,
+      executionInput,
       toolContext,
       turnContext,
     );
@@ -289,7 +282,7 @@ export function createToolExecutor(
       ctx.approvedViaPromptThisTurn = true;
     }
 
-    runPostExecutionSideEffects(executionName, input, result, { ctx });
+    runPostExecutionSideEffects(executionName, executionInput, result, { ctx });
 
     return result;
   };
@@ -360,12 +353,6 @@ export interface SkillProjectionContext {
   readonly transportInterface?: InterfaceId;
   /** Per-turn override profile, read by the switch_inference_profile tool injection. */
   currentTurnOverrideProfile?: string;
-  /**
-   * True when the user has explicitly selected an inference profile for this
-   * conversation (via the composer profile picker). When set, tool-based
-   * auto-routing is suppressed — the user's explicit choice takes precedence.
-   */
-  hasExplicitProfileOverride?: boolean;
 }
 
 // ── Conditional tool sets ────────────────────────────────────────────
@@ -658,18 +645,19 @@ export function createResolveToolsCallback(
     const config = getConfig();
     if (
       isAssistantFeatureFlagEnabled("query-complexity-routing", config) &&
-      config.llm &&
-      !ctx.hasExplicitProfileOverride
+      config.llm
     ) {
-      const currentProfile =
+      const effectiveProfile =
         ctx.currentTurnOverrideProfile ?? config.llm.activeProfile;
-      const toolDef = buildSwitchInferenceProfileToolDef(
-        config.llm.profiles ?? {},
-        currentProfile,
-      );
-      if (toolDef) {
-        turnAllowed.add(SWITCH_INFERENCE_PROFILE_TOOL_NAME);
-        return [...baseDefs, toolDef];
+      if (effectiveProfile === AUTO_PROFILE_KEY) {
+        const toolDef = buildSwitchInferenceProfileToolDef(
+          config.llm.profiles ?? {},
+          effectiveProfile,
+        );
+        if (toolDef) {
+          turnAllowed.add(SWITCH_INFERENCE_PROFILE_TOOL_NAME);
+          return [...baseDefs, toolDef];
+        }
       }
     }