@vellumai/assistant 0.8.5 → 0.8.6

package/src/tools/tool-name-aliases.ts

@@ -1,19 +1,77 @@
-const TOOL_NAME_ALIASES = new Map<string, string>([
-  ["create_app", "app_create"],
+type ToolInputNormalizer = (
+  input: Record<string, unknown>,
+) => Record<string, unknown>;
+
+const TOOL_NAME_ALIASES = new Map<
+  string,
+  { canonicalName: string; normalizeInput?: ToolInputNormalizer }
+>([
+  ["create_app", { canonicalName: "app_create" }],
+  [
+    "computer_use_press_key",
+    {
+      canonicalName: "computer_use_key",
+      normalizeInput: normalizeLegacyComputerUsePressKeyInput,
+    },
+  ],
 ]);
 
-/**
- * Resolve high-confidence compatibility aliases before active-tool gating.
- * Keep this list narrow: aliases should only cover observed model drift where
- * the canonical target is active for the turn.
- */
-export function resolveToolNameAlias(
+export function resolveToolInvocationAlias(
   name: string,
+  input: Record<string, unknown>,
   allowedToolNames?: ReadonlySet<string>,
-): string {
-  if (allowedToolNames?.has(name)) return name;
-  const canonical = TOOL_NAME_ALIASES.get(name);
-  if (!canonical) return name;
-  if (allowedToolNames && !allowedToolNames.has(canonical)) return name;
-  return canonical;
+): { name: string; input: Record<string, unknown> } {
+  if (allowedToolNames?.has(name)) return { name, input };
+  const alias = TOOL_NAME_ALIASES.get(name);
+  if (!alias) return { name, input };
+  if (allowedToolNames && !allowedToolNames.has(alias.canonicalName)) {
+    return { name, input };
+  }
+  return {
+    name: alias.canonicalName,
+    input: alias.normalizeInput ? alias.normalizeInput(input) : input,
+  };
+}
+
+function normalizeLegacyComputerUsePressKeyInput(
+  input: Record<string, unknown>,
+): Record<string, unknown> {
+  const normalized = { ...input };
+  const key = typeof normalized.key === "string" ? normalized.key.trim() : "";
+  const modifiers = Array.isArray(normalized.modifiers)
+    ? normalized.modifiers.flatMap((modifier) => {
+        if (typeof modifier !== "string") return [];
+        const normalizedModifier = normalizeKeyModifier(modifier);
+        return normalizedModifier ? [normalizedModifier] : [];
+      })
+    : [];
+
+  delete normalized.modifiers;
+
+  if (key && modifiers.length > 0 && !key.includes("+")) {
+    normalized.key = [...new Set(modifiers), key.toLowerCase()].join("+");
+  } else if (key && !key.includes("+")) {
+    normalized.key = key.toLowerCase();
+  }
+
+  return normalized;
+}
+
+function normalizeKeyModifier(modifier: string): string | undefined {
+  switch (modifier.trim().toLowerCase()) {
+    case "cmd":
+    case "command":
+    case "meta":
+      return "cmd";
+    case "ctrl":
+    case "control":
+      return "ctrl";
+    case "option":
+    case "alt":
+      return "option";
+    case "shift":
+      return "shift";
+    default:
+      return undefined;
+  }
 }

package/src/tools/types.ts

@@ -338,22 +338,24 @@ export interface ToolDefinition {
 }
 
 /** Tool after the loader has derived its name and filled defaults. */
-export type LoadedTool = Required<ToolDefinition> & { name: string };
+export type LoadedTool = Required<ToolDefinition> & {
+  name: string;
+};
+
+/** The kind of extension that owns a tool. Core tools have no owner. */
+export type OwnerKind = "skill" | "mcp" | "plugin";
+
+/**
+ * Identifies which extension owns a tool (skill / plugin / MCP server).
+ * Tracked by the tool registry keyed by tool name, not stored on the `Tool`
+ * object itself — query via {@link ../tools/registry.getToolOwner}.
+ */
+export interface OwnerInfo {
+  kind: OwnerKind;
+  /** ID of the owning extension (skill id / plugin name / MCP server id). */
+  id: string;
+}
 
 export interface Tool extends LoadedTool {
   category: string;
-  /** When set to 'proxy', the tool is forwarded to a connected client rather than executed locally. */
-  executionMode?: "local" | "proxy";
-  /** Whether this tool is a core built-in, provided by a skill, contributed by a plugin, or from an MCP server. */
-  origin?: "core" | "skill" | "mcp" | "plugin";
-  /** If origin is 'skill', the ID of the owning skill. */
-  ownerSkillId?: string;
-  /** If origin is 'mcp', the ID of the owning MCP server. */
-  ownerMcpServerId?: string;
-  /** If origin is 'plugin', the name of the owning plugin. */
-  ownerPluginId?: string;
-  /** Content-hash of the owning skill's source at registration time. */
-  ownerSkillVersionHash?: string;
-  /** Whether the owning skill is bundled with the daemon (trusted first-party). */
-  ownerSkillBundled?: boolean;
 }

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

@@ -8,16 +8,31 @@
  */
 
 import { RiskLevel } from "../../permissions/types.js";
-import type { Tool, ToolExecutionResult } from "../types.js";
+import type { Tool, ToolContext, ToolExecutionResult } from "../types.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
 
-function proxyExecute(): Promise<ToolExecutionResult> {
-  throw new Error(
-    "Proxy tool: execution must be forwarded to the connected client",
-  );
+/**
+ * Forward execution to the connected macOS client via the request-bound
+ * `proxyToolResolver`. Returns a structured error when no resolver is
+ * configured (e.g. no client connected) so callers see a normal tool
+ * failure rather than an unhandled throw.
+ */
+function proxyExecute(toolName: string) {
+  return async (
+    input: Record<string, unknown>,
+    context: ToolContext,
+  ): Promise<ToolExecutionResult> => {
+    if (!context.proxyToolResolver) {
+      return {
+        content: `No proxy resolver configured for proxy tool "${toolName}". This tool requires an external resolver (e.g. a connected macOS client).`,
+        isError: true,
+      };
+    }
+    return context.proxyToolResolver(toolName, input);
+  };
 }
 
 // ---------------------------------------------------------------------------
@@ -40,73 +55,72 @@ export const uiShowTool: Tool = {
     "Proactively show a task_progress card before multi-step or long-running work (web searches, file operations, research). Show it before your first tool call, then update steps as work progresses.",
   category: "ui-surface",
   defaultRiskLevel: RiskLevel.Low,
-  executionMode: "proxy",
   executionTarget: "host",
 
   input_schema: {
+    type: "object",
+    properties: {
+      surface_type: {
+        type: "string",
+        enum: [
+          "card",
+          "form",
+          "list",
+          "table",
+          "confirmation",
+          "dynamic_page",
+          "file_upload",
+          "task_preferences",
+        ],
+        description: "The type of surface to display",
+      },
+      title: {
+        type: "string",
+        description: "Optional title for the surface window",
+      },
+      data: {
         type: "object",
-        properties: {
-          surface_type: {
-            type: "string",
-            enum: [
-              "card",
-              "form",
-              "list",
-              "table",
-              "confirmation",
-              "dynamic_page",
-              "file_upload",
-              "task_preferences",
-            ],
-            description: "The type of surface to display",
-          },
-          title: {
-            type: "string",
-            description: "Optional title for the surface window",
-          },
-          data: {
-            type: "object",
-            description:
-              "Surface data; structure depends on surface_type (see tool description)",
-          },
-          actions: {
-            type: "array",
-            items: {
-              type: "object",
-              properties: {
-                id: { type: "string", description: "Unique action identifier" },
-                label: { type: "string", description: "Button label text" },
-                style: {
-                  type: "string",
-                  enum: ["primary", "secondary", "destructive"],
-                  description: "Visual style of the button",
-                },
-              },
-              required: ["id", "label"],
+        description:
+          "Surface data; structure depends on surface_type (see tool description)",
+      },
+      actions: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            id: { type: "string", description: "Unique action identifier" },
+            label: { type: "string", description: "Button label text" },
+            style: {
+              type: "string",
+              enum: ["primary", "secondary", "destructive"],
+              description: "Visual style of the button",
             },
-            description: "Optional action buttons to display on the surface",
-          },
-          display: {
-            type: "string",
-            enum: ["inline", "panel"],
-            description:
-              'Where to render the surface. "inline" embeds it in the chat message. "panel" shows a floating window. Defaults to "inline". Prefer inline — only use panel when a separate window is explicitly requested.',
-          },
-          await_action: {
-            type: "boolean",
-            description:
-              "Whether to block until an action is selected. Defaults to true when actions are provided.",
-          },
-          persistent: {
-            type: "boolean",
-            description:
-              "When true, clicking an action does not dismiss the surface — the card stays visible and only the clicked action is marked as spent. Use for launcher or menu-style cards where multiple buttons may be clicked. Defaults to false.",
           },
+          required: ["id", "label"],
         },
-        required: ["surface_type", "data"],
+        description: "Optional action buttons to display on the surface",
       },
+      display: {
+        type: "string",
+        enum: ["inline", "panel"],
+        description:
+          'Where to render the surface. "inline" embeds it in the chat message. "panel" shows a floating window. Defaults to "inline". Prefer inline — only use panel when a separate window is explicitly requested.',
+      },
+      await_action: {
+        type: "boolean",
+        description:
+          "Whether to block until an action is selected. Defaults to true when actions are provided.",
+      },
+      persistent: {
+        type: "boolean",
+        description:
+          "When true, clicking an action does not dismiss the surface — the card stays visible and only the clicked action is marked as spent. Use for launcher or menu-style cards where multiple buttons may be clicked. Defaults to false.",
+      },
+    },
+    required: ["surface_type", "data"],
+  },
 
-  execute: proxyExecute,
+  execute: proxyExecute("ui_show"),
 };
 
 // ---------------------------------------------------------------------------
@@ -120,25 +134,24 @@ const uiUpdateTool: Tool = {
     "For card templates (for example `task_progress`), update nested fields under `data.templateData` rather than sending template fields at the top level.",
   category: "ui-surface",
   defaultRiskLevel: RiskLevel.Low,
-  executionMode: "proxy",
   executionTarget: "host",
 
   input_schema: {
+    type: "object",
+    properties: {
+      surface_id: {
+        type: "string",
+        description: "The ID of the surface to update",
+      },
+      data: {
         type: "object",
-        properties: {
-          surface_id: {
-            type: "string",
-            description: "The ID of the surface to update",
-          },
-          data: {
-            type: "object",
-            description: "Partial data to merge into the existing surface data",
-          },
-        },
-        required: ["surface_id", "data"],
+        description: "Partial data to merge into the existing surface data",
       },
+    },
+    required: ["surface_id", "data"],
+  },
 
-  execute: proxyExecute,
+  execute: proxyExecute("ui_update"),
 };
 
 // ---------------------------------------------------------------------------
@@ -150,21 +163,20 @@ const uiDismissTool: Tool = {
   description: "Dismiss a currently displayed surface.",
   category: "ui-surface",
   defaultRiskLevel: RiskLevel.Low,
-  executionMode: "proxy",
   executionTarget: "host",
 
   input_schema: {
-        type: "object",
-        properties: {
-          surface_id: {
-            type: "string",
-            description: "The ID of the surface to dismiss",
-          },
-        },
-        required: ["surface_id"],
+    type: "object",
+    properties: {
+      surface_id: {
+        type: "string",
+        description: "The ID of the surface to dismiss",
       },
+    },
+    required: ["surface_id"],
+  },
 
-  execute: proxyExecute,
+  execute: proxyExecute("ui_dismiss"),
 };
 
 export const allUiSurfaceTools: Tool[] = [

package/src/types/onboarding-context.ts

@@ -10,4 +10,10 @@ export interface OnboardingContext {
   cohort?: string;
   websiteUrl?: string;
   contentSourceUrl?: string;
+  /** Filename of the bootstrap template to use (e.g. "BOOTSTRAP-CONTENT-AUTOMATION.md"). When set, replaces generic BOOTSTRAP.md if still pristine. */
+  bootstrapTemplate?: string;
+  /** Override the first user message content. When set during a wake-up greeting, this replaces the canned greeting. */
+  initialMessage?: string;
+  /** Skills to eagerly load on first turn (e.g. ["geo-writing", "document-editor"]). Informational — the bootstrap template drives actual loading. */
+  skills?: string[];
 }

package/src/usage/attribution.ts

@@ -15,6 +15,14 @@ export type UsageAttributionProfileSource =
 export interface UsageAttributionInput {
   callSite: LLMCallSite | null;
   overrideProfile?: string | null;
+  /**
+   * Per-conversation seed for `mix`-profile expansion (the conversation id).
+   * When the applied profile is a mix, threading the same seed the dispatch
+   * path uses ensures `resolvedModel`/`resolvedMixArm` reflect the arm the
+   * request actually ran on. Omitted by one-shot callers (the snapshot's
+   * `resolvedMixArm` is then null even if a mix was involved).
+   */
+  selectionSeed?: string;
 }
 
 export interface UsageAttributionSnapshot {
@@ -26,6 +34,12 @@ export interface UsageAttributionSnapshot {
   profileSource: UsageAttributionProfileSource;
   resolvedProvider: string;
   resolvedModel: string;
+  /**
+   * When `appliedProfile` is a mix profile, the constituent arm chosen for
+   * this request; null otherwise. Lets A/B analysis attribute usage to the
+   * specific arm (mix name lives in `appliedProfile`).
+   */
+  resolvedMixArm: string | null;
 }
 
 /**
@@ -51,7 +65,11 @@ export function resolveUsageAttribution(
   const overrideProfile = normalizeProfileId(input.overrideProfile);
 
   if (callSite == null) {
-    const resolvedMainAgent = resolveCallSiteConfig("mainAgent", llm);
+    const resolvedMainAgent = resolveCallSiteConfig("mainAgent", llm, {
+      ...(input.selectionSeed != null
+        ? { selectionSeed: input.selectionSeed }
+        : {}),
+    });
     return {
       callSite: null,
       activeProfile: normalizeProfileId(llm.activeProfile),
@@ -61,11 +79,20 @@ export function resolveUsageAttribution(
       profileSource: "unknown",
       resolvedProvider: resolvedMainAgent.provider,
       resolvedModel: resolvedMainAgent.model,
+      resolvedMixArm: null,
     };
   }
 
+  // Capture which arm each expanded mix resolved to so we can attribute usage
+  // to the arm behind the applied (mix) profile below.
+  const mixSelections = new Map<string, string>();
   const resolved = resolveCallSiteConfig(callSite, llm, {
     ...(overrideProfile != null ? { overrideProfile } : {}),
+    ...(input.selectionSeed != null
+      ? { selectionSeed: input.selectionSeed }
+      : {}),
+    onMixSelected: ({ mixProfile, chosenProfile }) =>
+      mixSelections.set(mixProfile, chosenProfile),
   });
   const activeProfile = normalizeProfileId(llm.activeProfile);
   const callSiteProfile = normalizeProfileId(
@@ -88,6 +115,10 @@ export function resolveUsageAttribution(
     profileSource: profile.profileSource,
     resolvedProvider: resolved.provider,
     resolvedModel: resolved.model,
+    resolvedMixArm:
+      profile.appliedProfile != null
+        ? (mixSelections.get(profile.appliedProfile) ?? null)
+        : null,
   };
 }
 

package/src/util/browser.ts

@@ -10,8 +10,13 @@ const log = getLogger("browser");
  * Open a URL on the user's host machine.
  *
  * Writes an `open_url` event to the `signals/emit-event` file so that the
- * daemon's ConfigWatcher picks it up and publishes it to connected clients
- * (e.g. the Swift macOS app) via the assistant event hub.
+ * assistant's ConfigWatcher picks it up and publishes it to connected
+ * clients (e.g. the Swift macOS app) via the assistant event hub.
+ *
+ * CLI-initiated emit — no conversation context available, so the inner
+ * message has no `conversationId`. That's fine: `OpenUrlEventSchema`
+ * declares `conversationId` as optional, so this payload parses
+ * cleanly on the web side as well as in the Swift macOS app.
  */
 export async function openInHostBrowser(url: string): Promise<void> {
   try {

package/src/workspace/migrations/090-memory-router-cost-optimized-profile.ts

@@ -0,0 +1,109 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+// Flip callSites.memoryRouter from { profile: "balanced" } (the shape that
+// migration 087 wrote) to the shipped cost-optimized default so the router
+// rides the workspace's cheaper/faster managed profile.
+//
+// The migrated entry must mirror the shipped default in call-site-defaults.ts
+// EXACTLY — { profile: "cost-optimized", contextWindow: { maxInputTokens:
+// 1_000_000 } } — because the resolver prefers an explicit
+// llm.callSites.memoryRouter entry over CALL_SITE_DEFAULTS. Writing a bare
+// { profile: "cost-optimized" } would drop the 1M input window and regress
+// migrated users to the profile's normal ~200k window.
+//
+// The shipped default in call-site-defaults.ts also moves to cost-optimized
+// in the same change; this migration is what gets existing users — who carry
+// an explicit { profile: "balanced" } in their config.json — onto the new
+// default. Workspaces with no memoryRouter entry already pick up the shipped
+// default automatically (e.g. BYOK installs that skipped 077/087, or fresh
+// installs), so this migration only touches the 087-seeded balanced shape and
+// the bare { profile: "cost-optimized" } shape an earlier (pre-fix) run of
+// this migration may have written — the latter so those users also recover
+// the 1M window.
+//
+// Two skip conditions, mirroring 087:
+//
+//   1. BYOK / non-Anthropic workspaces. `cost-optimized` is a managed
+//      Anthropic profile, which off-platform installs disable. Forcing it
+//      there would make getConfiguredProvider("memoryRouter") return null
+//      and silently disable memory injection. Detect via llm.default.provider.
+//
+//   2. User-customized memoryRouter config. If the existing entry carries any
+//      key beyond a bare balanced/cost-optimized profile reference, the user —
+//      or a platform overlay — chose those values deliberately. Preserve them.
+const MEMORY_ROUTER_COST_OPTIMIZED = {
+  profile: "cost-optimized",
+  contextWindow: { maxInputTokens: 1_000_000 },
+} as const;
+
+export const memoryRouterCostOptimizedProfileMigration: WorkspaceMigration = {
+  id: "090-memory-router-cost-optimized-profile",
+  description:
+    "Set callSites.memoryRouter to the shipped cost-optimized default (with 1M context) for workspaces still carrying the 087-seeded balanced profile",
+  run(workspaceDir: string): void {
+    if (process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH) return;
+
+    const configPath = join(workspaceDir, "config.json");
+    if (!existsSync(configPath)) return;
+
+    let config: Record<string, unknown> = {};
+    try {
+      const raw = JSON.parse(readFileSync(configPath, "utf-8"));
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) return;
+      config = raw as Record<string, unknown>;
+    } catch {
+      return;
+    }
+
+    const llm = readObject(config.llm);
+    if (llm === null) return;
+
+    const explicitProvider = readString(readObject(llm.default)?.provider);
+    if (explicitProvider !== undefined && explicitProvider !== "anthropic") {
+      return;
+    }
+
+    const callSites = readObject(llm.callSites);
+    if (callSites === null) return;
+
+    const existing = readObject(callSites.memoryRouter);
+    if (existing === null || !needsCostOptimizedUpgrade(existing)) return;
+
+    callSites.memoryRouter = { ...MEMORY_ROUTER_COST_OPTIMIZED };
+    llm.callSites = callSites;
+    config.llm = llm;
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  },
+  down(_workspaceDir: string): void {
+    // Forward-only.
+  },
+};
+
+// True when the entry is a bare single-key profile reference we own:
+//   - { profile: "balanced" }       — what migration 087 wrote
+//   - { profile: "cost-optimized" } — what a pre-fix run of THIS migration
+//                                      wrote (no contextWindow), so those users
+//                                      still recover the 1M window
+// Any extra keys (model pins, tuning fields, an already-present contextWindow)
+// mean the user/platform customized it — preserve and skip. This keeps the
+// migration idempotent: once it writes the full cost-optimized + contextWindow
+// shape, the two-key entry no longer matches.
+function needsCostOptimizedUpgrade(entry: Record<string, unknown>): boolean {
+  const keys = Object.keys(entry);
+  if (keys.length !== 1) return false;
+  return entry.profile === "balanced" || entry.profile === "cost-optimized";
+}
+
+function readObject(value: unknown): Record<string, unknown> | null {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  return value as Record<string, unknown>;
+}
+
+function readString(value: unknown): string | undefined {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}

package/src/workspace/migrations/091-retighten-migration-onboarding-thread.ts

@@ -0,0 +1,41 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { MigrationRunContext, WorkspaceMigration } from "./types.js";
+
+// The exact onboarding bullet seeded by 069-seed-onboarding-threads for the
+// assistant-migration step. Inlined here (not imported) to keep this migration
+// self-contained and decoupled from 069.
+const OLD_BULLET =
+  "- Ask your user if they use ChatGPT, Claude or another AI tool and offer to help them import memories from there.";
+
+// The tightened replacement: help-first, an early light one-time offer, naming
+// the common prior assistants. Keeps the literal "ChatGPT, Claude" substring.
+const NEW_BULLET =
+  "- After helping with the user's first real task, offer early — at the first natural opening — to port their context, memories, prompts, skills, or workflows from a prior assistant (ChatGPT, Claude, OpenClaw, Hermes, or another tool). Keep it a light one-time offer, not a push; if they decline, drop it.";
+
+export const retightenMigrationOnboardingThreadMigration: WorkspaceMigration = {
+  id: "091-retighten-migration-onboarding-thread",
+  description:
+    "Retighten the assistant-migration onboarding bullet in memory/threads.md for brand new assistants",
+
+  run(workspaceDir: string, ctx?: MigrationRunContext): void {
+    // Only rewrite onboarding tasks for newly-created workspaces. An existing
+    // assistant whose user has edited threads.md must not have its content
+    // rewritten on upgrade. When invoked without a context (e.g. from older
+    // callers), default to the safe path and skip — the runner always supplies
+    // one in production.
+    if (!ctx?.isNewWorkspace) return;
+    const filePath = join(workspaceDir, "memory", "threads.md");
+    if (!existsSync(filePath)) return;
+    const content = readFileSync(filePath, "utf-8");
+    // Idempotent: if the old bullet is absent (already replaced, or the user
+    // edited it away), there is nothing to do.
+    if (!content.includes(OLD_BULLET)) return;
+    writeFileSync(filePath, content.replace(OLD_BULLET, NEW_BULLET), "utf-8");
+  },
+
+  down(_workspaceDir: string): void {
+    // Forward-only: never rewrite user-visible memory content on rollback.
+  },
+};

package/src/workspace/migrations/registry.ts

@@ -87,6 +87,8 @@ import { revertStaleGeminiMisRewritesMigration } from "./086-revert-stale-gemini
 import { memoryRouterBalancedProfileMigration } from "./087-memory-router-balanced-profile.js";
 import { deprecateBackgroundConversationOverrideMigration } from "./088-deprecate-background-conversation-override.js";
 import { moveMemoryTreeOutOfV3Migration } from "./089-move-memory-tree-out-of-v3.js";
+import { memoryRouterCostOptimizedProfileMigration } from "./090-memory-router-cost-optimized-profile.js";
+import { retightenMigrationOnboardingThreadMigration } from "./091-retighten-migration-onboarding-thread.js";
 import { migrateToWorkspaceVolumeMigration } from "./migrate-to-workspace-volume.js";
 import type { WorkspaceMigration } from "./types.js";
 
@@ -185,4 +187,6 @@ export const WORKSPACE_MIGRATIONS: WorkspaceMigration[] = [
   memoryRouterBalancedProfileMigration,
   deprecateBackgroundConversationOverrideMigration,
   moveMemoryTreeOutOfV3Migration,
+  memoryRouterCostOptimizedProfileMigration,
+  retightenMigrationOnboardingThreadMigration,
 ];