@vellumai/assistant 0.8.4 → 0.8.6

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

@@ -8,17 +8,31 @@
  */
 
 import { RiskLevel } from "../../permissions/types.js";
-import type { ToolDefinition } from "../../providers/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);
+  };
 }
 
 // ---------------------------------------------------------------------------
@@ -41,78 +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",
-
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
+  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"),
 };
 
 // ---------------------------------------------------------------------------
@@ -126,30 +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",
-
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
+  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"),
 };
 
 // ---------------------------------------------------------------------------
@@ -161,26 +163,20 @@ const uiDismissTool: Tool = {
   description: "Dismiss a currently displayed surface.",
   category: "ui-surface",
   defaultRiskLevel: RiskLevel.Low,
-  executionMode: "proxy",
-
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
-        type: "object",
-        properties: {
-          surface_id: {
-            type: "string",
-            description: "The ID of the surface to dismiss",
-          },
-        },
-        required: ["surface_id"],
+  executionTarget: "host",
+
+  input_schema: {
+    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/usage/pricing.ts

@@ -20,9 +20,32 @@ function normalizeTokenCount(value: number | null | undefined): number {
 
 function asRecord(value: unknown): Record<string, unknown> | null {
   if (typeof value !== "object" || value == null) return null;
+  if (Array.isArray(value)) return null;
   return value as Record<string, unknown>;
 }
 
+/**
+ * Extract the provider's untouched `usage` block from a `rawResponse`
+ * payload for opaque end-to-end forwarding (the `raw_usage` column /
+ * telemetry field).
+ *
+ * Returns `null` when there is no usage object to surface. For streaming
+ * providers that pass `rawResponse` as an accumulated array of chunks,
+ * the final element's `usage` is preferred — Anthropic and OpenAI both
+ * stamp the complete tally on the terminal chunk, so taking the last
+ * element captures the post-completion state without re-aggregating.
+ */
+export function extractRawUsage(
+  rawResponse: unknown,
+): Record<string, unknown> | null {
+  if (rawResponse == null) return null;
+  const candidate = Array.isArray(rawResponse)
+    ? rawResponse[rawResponse.length - 1]
+    : rawResponse;
+  const record = asRecord(candidate);
+  return asRecord(record?.usage);
+}
+
 function extractAnthropicCacheCreationFromResponse(
   response: unknown,
 ): AnthropicCacheCreationTokenDetails | null {

package/src/usage/types.ts

@@ -42,6 +42,18 @@ export interface UsageEventInput {
   outputTokens: number;
   cacheCreationInputTokens: number | null;
   cacheReadInputTokens: number | null;
+  /**
+   * The provider's untouched `usage` block (the literal object returned in
+   * the API response), preserved as JSON so downstream consumers can
+   * extract any provider-specific detail without requiring a schema
+   * change. Anthropic nests its TTL breakdown under
+   * `cache_creation.ephemeral_{5m,1h}_input_tokens`; OpenAI nests cached
+   * read counts under `prompt_tokens_details.cached_tokens`; both shapes
+   * are stored as-is. `null` when the provider did not return a usage
+   * block and for rows persisted before the
+   * `260-llm-usage-add-raw-usage` migration.
+   */
+  rawUsage: Record<string, unknown> | null;
   actor: UsageActor;
   conversationId: string | null;
   runId: string | 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/util/logger.ts

@@ -17,7 +17,7 @@ import {
   getIsContainerized,
 } from "../config/env-registry.js";
 import { logSerializers } from "./log-redact.js";
-import { getLogPath } from "./platform.js";
+import { getLogsDir } from "./platform.js";
 import { createSentryLogStream } from "./sentry-log-stream.js";
 
 /** Common pino-pretty options that inline [module] into the message prefix. */
@@ -87,7 +87,7 @@ function resolveLogDir(config: LogFileConfig): string | undefined {
       if (getIsContainerized()) {
         // Config has a host-specific path that can't be created inside the
         // container (e.g. /Users/…). Fall back to the default log directory.
-        const fallback = join(getLogPath(), "..");
+        const fallback = getLogsDir();
         console.warn(
           `[logger] Configured logFile.dir "${config.dir}" cannot be created ` +
             `in container (${(err as Error).message}). Falling back to "${fallback}".`,
@@ -210,7 +210,8 @@ function getRootLogger(): pino.Logger {
     }
 
     try {
-      const logPath = getLogPath();
+      const logDir = getLogsDir();
+      const logPath = logFilePathForDate(logDir, new Date());
       // Use sync: true so the fd is opened immediately. This prevents
       // "sonic boom is not ready yet" errors when commander calls
       // process.exit(0) for --help/--version before the async fd is ready.
@@ -247,6 +248,10 @@ function getRootLogger(): pino.Logger {
           fileStream,
         );
       }
+
+      // Register state so ensureCurrentDate() rebuilds across UTC midnight.
+      activeLogFileConfig = { dir: logDir, retentionDays: 0 };
+      activeLogDate = formatDate(new Date());
     } catch {
       rootLogger = pino(
         {
@@ -274,16 +279,20 @@ export function truncateForLog(value: string, maxLen = 500): string {
 /**
  * Returns a lazy logger that only initializes pino when a log method is called.
  * This avoids "sonic boom is not ready yet" errors when the process exits
- * quickly (e.g. `assistant --help`).
+ * quickly (e.g. `assistant --help`). The child is rebuilt whenever the
+ * underlying root logger changes (e.g. day rollover, late initLogger()).
  */
 export function getLogger(name: string): pino.Logger {
+  let cachedRoot: pino.Logger | null = null;
   let child: pino.Logger | null = null;
   const handler: ProxyHandler<pino.Logger> = {
     get(_target, prop, receiver) {
-      if (!child) {
-        child = getRootLogger().child({ module: name });
+      const root = getRootLogger();
+      if (root !== cachedRoot) {
+        cachedRoot = root;
+        child = root.child({ module: name });
       }
-      const val = Reflect.get(child, prop, receiver);
+      const val = Reflect.get(child!, prop, receiver);
       if (typeof val === "function") {
         return val.bind(child);
       }

package/src/util/platform.ts

@@ -158,8 +158,13 @@ export function getDbPath(): string {
   return join(getDataDir(), "db", "assistant.db");
 }
 
-export function getLogPath(): string {
-  return join(getDataDir(), "logs", "vellum.log");
+/**
+ * Returns the directory where logs live: `<dataDir>/logs/`. Files rotate
+ * daily (`assistant-YYYY-MM-DD.log`), so callers ask for the directory and
+ * let the logger own the filename.
+ */
+export function getLogsDir(): string {
+  return join(getDataDir(), "logs");
 }
 
 export function getHistoryPath(): string {

package/src/util/sqlite3-runtime.ts

@@ -0,0 +1,65 @@
+/**
+ * Shared helper for locating a `sqlite3` CLI binary on the host.
+ *
+ * Used by `memory/db-async-query.ts` so slow statements (`VACUUM`,
+ * `PRAGMA optimize`, large bulk deletes) can be shelled out to a
+ * subprocess and run without blocking the daemon's main event loop.
+ *
+ * Resolution order (matches the spirit of `bun-runtime.ts#findBun()`):
+ *   1. Common system install locations
+ *   2. `Bun.which("sqlite3")` (PATH lookup)
+ *
+ * Unlike `bun-runtime.ts`, this module does **not** download `sqlite3`
+ * when missing. The async path is opt-out (callers fall back to the
+ * synchronous in-process `bun:sqlite` connection); if a user wants the
+ * non-blocking behavior they install one package.
+ *
+ * On platform (k8s assistant container) `sqlite3` is installed in the
+ * Dockerfile, so the primary path is always available there. On macOS
+ * `sqlite3` ships with the OS. On most Linux distros it's available via
+ * the system package manager.
+ */
+
+import { existsSync } from "node:fs";
+
+let cachedSqlite3Path: string | undefined | null;
+
+/**
+ * Synchronous lookup for a usable `sqlite3` CLI binary.
+ * Returns the path if found, `undefined` otherwise. Result is cached
+ * per-process so the filesystem checks only happen once.
+ */
+export function findSqlite3(): string | undefined {
+  if (cachedSqlite3Path !== undefined) {
+    return cachedSqlite3Path ?? undefined;
+  }
+
+  // 1. Common install locations. We check these before `Bun.which` so we
+  //    pick a deterministic, predictable binary even when PATH is
+  //    unusual (e.g. a daemon launched with a stripped env).
+  for (const p of [
+    "/usr/bin/sqlite3",
+    "/usr/local/bin/sqlite3",
+    "/opt/homebrew/bin/sqlite3",
+  ]) {
+    if (existsSync(p)) {
+      cachedSqlite3Path = p;
+      return p;
+    }
+  }
+
+  // 2. PATH lookup.
+  const which = Bun.which("sqlite3");
+  if (which) {
+    cachedSqlite3Path = which;
+    return which;
+  }
+
+  cachedSqlite3Path = null;
+  return undefined;
+}
+
+/** Reset the cached lookup. Test-only. */
+export function _resetSqlite3Cache(): void {
+  cachedSqlite3Path = undefined;
+}

package/src/workspace/migrations/086-revert-stale-gemini-mis-rewrites.ts

@@ -140,6 +140,7 @@ const GEMINI_CATALOG_MODELS = new Set<string>([
   "gemini-3.1-pro-preview-customtools",
   "gemini-3-flash-preview",
   "gemini-3.1-flash-lite-preview",
+  "gemini-3.1-flash-lite",
   "gemini-2.5-flash",
   "gemini-2.5-flash-lite",
   "gemini-2.5-pro",

package/src/workspace/migrations/089-move-memory-tree-out-of-v3.ts

@@ -0,0 +1,86 @@
+import * as fs from "node:fs";
+import { dirname, join } from "node:path";
+
+import { getLogger } from "../../util/logger.js";
+import type { WorkspaceMigration } from "./types.js";
+
+const log = getLogger("workspace-migration-089-move-memory-tree-out-of-v3");
+
+function isNotFoundError(err: unknown): boolean {
+  return (
+    typeof err === "object" &&
+    err !== null &&
+    "code" in err &&
+    err.code === "ENOENT"
+  );
+}
+
+/**
+ * Move `<workspace>/memory/<fromRel>` to `<workspace>/memory/<toRel>` when the
+ * source exists and the destination does not. Idempotent: a missing source is a
+ * no-op (already migrated, or never created), and an existing destination is
+ * left untouched (we never clobber). Both directions go through here so `run`
+ * and `down` share the same safety checks.
+ */
+function moveMemorySubdir(
+  workspaceDir: string,
+  fromRel: string,
+  toRel: string,
+): void {
+  const memoryDir = join(workspaceDir, "memory");
+  const src = join(memoryDir, fromRel);
+  const dest = join(memoryDir, toRel);
+  try {
+    if (!fs.existsSync(src)) return;
+    if (fs.existsSync(dest)) {
+      log.warn(
+        { src, dest },
+        "Both source and destination tree dirs exist; leaving in place for manual resolution",
+      );
+      return;
+    }
+    fs.mkdirSync(dirname(dest), { recursive: true });
+    fs.renameSync(src, dest);
+    log.info({ src, dest }, "Moved memory tree directory");
+  } catch (err) {
+    if (isNotFoundError(err)) return;
+    log.warn({ err, src, dest }, "Failed to move memory tree directory");
+    throw err;
+  }
+}
+
+/** Remove `<workspace>/memory/v3` if it is now an empty wrapper (the tree was
+ *  its only child). Best-effort — a non-empty or missing dir is left alone. */
+function removeEmptyV3Wrapper(workspaceDir: string): void {
+  const v3Dir = join(workspaceDir, "memory", "v3");
+  try {
+    if (fs.existsSync(v3Dir) && fs.readdirSync(v3Dir).length === 0) {
+      fs.rmdirSync(v3Dir);
+    }
+  } catch {
+    // Non-fatal: leaving an empty memory/v3 wrapper is harmless.
+  }
+}
+
+/**
+ * Relocate the v3 memory tree from `memory/v3/tree` to `memory/tree`.
+ *
+ * The tree is a DAG overlay over the flat `memory/concepts/` pages and is now a
+ * top-level sibling of `concepts/` (matching the storage design), no longer
+ * nested under a `v3/` wrapper. `getTreeDir` reads `memory/tree` after this
+ * change, so any pre-existing hand-authored tree must move with it.
+ */
+export const moveMemoryTreeOutOfV3Migration: WorkspaceMigration = {
+  id: "089-move-memory-tree-out-of-v3",
+  description: "Relocate the v3 memory tree from memory/v3/tree to memory/tree",
+  retryFailedCheckpoint: true,
+
+  run(workspaceDir: string): void {
+    moveMemorySubdir(workspaceDir, join("v3", "tree"), "tree");
+    removeEmptyV3Wrapper(workspaceDir);
+  },
+
+  down(workspaceDir: string): void {
+    moveMemorySubdir(workspaceDir, "tree", join("v3", "tree"));
+  },
+};