@vellumai/assistant 0.6.6 → 0.7.1

package/src/usage/pricing.ts

@@ -0,0 +1,166 @@
+import { getConfig } from "../config/loader.js";
+import type { ProviderResponse } from "../providers/types.js";
+import { getLogger } from "../util/logger.js";
+import {
+  resolvePricingForUsageWithOverrides,
+  usesAnthropicPricingRules,
+} from "../util/pricing.js";
+import type {
+  AnthropicCacheCreationTokenDetails,
+  PricingResult,
+  PricingUsage,
+} from "./types.js";
+
+const log = getLogger("usage-pricing");
+
+export function normalizeTokenCount(value: number | null | undefined): number {
+  if (typeof value !== "number" || !Number.isFinite(value)) return 0;
+  return Math.max(value, 0);
+}
+
+function asRecord(value: unknown): Record<string, unknown> | null {
+  if (typeof value !== "object" || value == null) return null;
+  return value as Record<string, unknown>;
+}
+
+function extractAnthropicCacheCreationFromResponse(
+  response: unknown,
+): AnthropicCacheCreationTokenDetails | null {
+  const rawResponse = asRecord(response);
+  const usage = asRecord(rawResponse?.usage);
+  const cacheCreation = asRecord(usage?.cache_creation);
+  if (!cacheCreation) return null;
+
+  return {
+    ephemeral_5m_input_tokens: normalizeTokenCount(
+      cacheCreation.ephemeral_5m_input_tokens as number | null | undefined,
+    ),
+    ephemeral_1h_input_tokens: normalizeTokenCount(
+      cacheCreation.ephemeral_1h_input_tokens as number | null | undefined,
+    ),
+  };
+}
+
+function extractAnthropicCacheCreation(
+  rawResponse: unknown,
+): AnthropicCacheCreationTokenDetails | null {
+  const responses = Array.isArray(rawResponse) ? rawResponse : [rawResponse];
+  let foundDetails = false;
+  let ephemeral5mInputTokens = 0;
+  let ephemeral1hInputTokens = 0;
+
+  for (const response of responses) {
+    const details = extractAnthropicCacheCreationFromResponse(response);
+    if (!details) continue;
+    foundDetails = true;
+    ephemeral5mInputTokens += normalizeTokenCount(
+      details.ephemeral_5m_input_tokens,
+    );
+    ephemeral1hInputTokens += normalizeTokenCount(
+      details.ephemeral_1h_input_tokens,
+    );
+  }
+
+  if (!foundDetails) return null;
+
+  return {
+    ephemeral_5m_input_tokens: ephemeral5mInputTokens,
+    ephemeral_1h_input_tokens: ephemeral1hInputTokens,
+  };
+}
+
+/**
+ * Extract the speed indicator from Anthropic fast mode API responses.
+ * The API returns `usage.speed: "fast" | "standard"` when using the
+ * fast-mode beta. For multi-response arrays, returns "fast" if any
+ * response used fast mode.
+ */
+function extractAnthropicSpeed(
+  rawResponse: unknown,
+): "fast" | "standard" | null {
+  const responses = Array.isArray(rawResponse) ? rawResponse : [rawResponse];
+  let foundStandard = false;
+  for (const response of responses) {
+    const rec = asRecord(response);
+    const usage = asRecord(rec?.usage);
+    if (usage?.speed === "fast") return "fast";
+    if (usage?.speed === "standard") foundStandard = true;
+  }
+  return foundStandard ? "standard" : null;
+}
+
+export function buildPricingUsage(input: {
+  providerName: string;
+  model: string;
+  inputTokens: number;
+  outputTokens: number;
+  cacheCreationInputTokens?: number | null;
+  cacheReadInputTokens?: number | null;
+  rawResponse?: unknown;
+}): PricingUsage & {
+  directInputTokens: number;
+  cacheCreationInputTokens: number;
+  cacheReadInputTokens: number;
+} {
+  const normalizedCacheCreationInputTokens = normalizeTokenCount(
+    input.cacheCreationInputTokens,
+  );
+  const normalizedCacheReadInputTokens = normalizeTokenCount(
+    input.cacheReadInputTokens,
+  );
+  const directInputTokens = Math.max(
+    normalizeTokenCount(input.inputTokens) -
+      normalizedCacheCreationInputTokens -
+      normalizedCacheReadInputTokens,
+    0,
+  );
+
+  const useAnthropicRules = usesAnthropicPricingRules(
+    input.providerName,
+    input.model,
+  );
+  return {
+    directInputTokens,
+    outputTokens: normalizeTokenCount(input.outputTokens),
+    cacheCreationInputTokens: normalizedCacheCreationInputTokens,
+    cacheReadInputTokens: normalizedCacheReadInputTokens,
+    anthropicCacheCreation: useAnthropicRules
+      ? extractAnthropicCacheCreation(input.rawResponse)
+      : null,
+    speed: useAnthropicRules ? extractAnthropicSpeed(input.rawResponse) : null,
+  };
+}
+
+export function buildPricingUsageFromResponse(
+  providerName: string,
+  response: ProviderResponse,
+): ReturnType<typeof buildPricingUsage> {
+  return buildPricingUsage({
+    providerName,
+    model: response.model,
+    inputTokens: response.usage.inputTokens,
+    outputTokens: response.usage.outputTokens,
+    cacheCreationInputTokens: response.usage.cacheCreationInputTokens,
+    cacheReadInputTokens: response.usage.cacheReadInputTokens,
+    rawResponse: response.rawResponse,
+  });
+}
+
+export function resolveStructuredPricing(
+  providerName: string,
+  model: string,
+  usage: PricingUsage,
+): PricingResult {
+  try {
+    const config = getConfig();
+    return resolvePricingForUsageWithOverrides(
+      providerName,
+      model,
+      usage,
+      config.llm.pricingOverrides,
+    );
+  } catch (err) {
+    log.warn({ err, model, providerName }, "Failed to resolve usage pricing");
+    return { estimatedCostUsd: null, pricingStatus: "unpriced" };
+  }
+}

package/src/usage/types.ts

@@ -1,4 +1,12 @@
+import type { LLMCallSite } from "../config/schemas/llm.js";
 import type { UsageActor } from "./actors.js";
+import type { UsageAttributionProfileSource } from "./attribution.js";
+
+export type {
+  UsageAttributionInput,
+  UsageAttributionProfileSource,
+  UsageAttributionSnapshot,
+} from "./attribution.js";
 
 /**
  * Anthropic prompt caching exposes write-tier detail so callers can price
@@ -38,6 +46,9 @@ export interface UsageEventInput {
   conversationId: string | null;
   runId: string | null;
   requestId: string | null;
+  callSite?: LLMCallSite | null;
+  inferenceProfile?: string | null;
+  inferenceProfileSource?: UsageAttributionProfileSource | null;
   /** Number of actual LLM API calls represented by this event (defaults to 1). */
   llmCallCount?: number;
 }
@@ -57,6 +68,9 @@ export interface PricingResult {
 export interface UsageEvent extends UsageEventInput {
   id: string;
   createdAt: number;
+  callSite: LLMCallSite | null;
+  inferenceProfile: string | null;
+  inferenceProfileSource: UsageAttributionProfileSource | null;
   estimatedCostUsd: number | null;
   pricingStatus: "priced" | "unpriced";
 }

package/src/util/debounce.ts

@@ -2,27 +2,6 @@
  * Single-key debouncer. Delays execution until no new calls arrive
  * within the specified delay period.
  */
-export class Debouncer {
-  private timer: ReturnType<typeof setTimeout> | null = null;
-
-  constructor(private readonly delayMs: number) {}
-
-  schedule(fn: () => void): void {
-    if (this.timer) clearTimeout(this.timer);
-    this.timer = setTimeout(() => {
-      this.timer = null;
-      fn();
-    }, this.delayMs);
-  }
-
-  cancel(): void {
-    if (this.timer) {
-      clearTimeout(this.timer);
-      this.timer = null;
-    }
-  }
-}
-
 /**
  * Multi-key debouncer. Each key gets its own independent timer.
  * Includes an optional entry limit with eviction of oldest non-protected entries.

package/src/util/errors.ts

@@ -169,17 +169,9 @@ export class DaemonError extends AssistantError {
   }
 }
 
-export class PlatformError extends AssistantError {
-  constructor(message: string, options?: { cause?: unknown }) {
-    super(message, ErrorCode.PLATFORM_ERROR, options);
-    this.name = "PlatformError";
-  }
-}
-
 export class IntegrityError extends AssistantError {
   constructor(message: string, options?: { cause?: unknown }) {
     super(message, ErrorCode.INTEGRITY_ERROR, options);
     this.name = "IntegrityError";
   }
 }
-

package/src/util/json.ts

@@ -9,6 +9,19 @@ export function parseJsonSafe<T = unknown>(text: string): T | null {
   }
 }
 
+/** Convert any object's Date-valued fields to ISO strings. */
+export function datesToISO<T extends Record<string, unknown>>(
+  obj: T,
+): { [K in keyof T]: T[K] extends Date ? string : T[K] } {
+  const result = { ...obj } as Record<string, unknown>;
+  for (const [key, value] of Object.entries(result)) {
+    if (value instanceof Date) {
+      result[key] = value.toISOString();
+    }
+  }
+  return result as { [K in keyof T]: T[K] extends Date ? string : T[K] };
+}
+
 /** Tolerant JSON parse that returns `{}` for invalid or non-object payloads. */
 export function safeParseRecord(raw: string): Record<string, unknown> {
   try {

package/src/util/log-redact.ts

@@ -161,4 +161,3 @@ export const logSerializers: Record<string, (value: unknown) => unknown> = {
 };
 
 // Exported for testing
-export { redactString as _redactString, redactValue as _redactValue };

package/src/util/logger.ts

@@ -142,9 +142,9 @@ function buildRotatingLogger(config: LogFileConfig): pino.Logger {
   // When stdout is not a TTY (e.g. desktop app redirects to a hatch log file),
   // write to the rotating file only — the hatch log already captured early
   // startup output and echoing pino output there is unnecessary duplication.
-  // Exception: in containers, always write to stdout so `docker logs` can
-  // capture daemon output for debugging.
-  if (!process.stdout.isTTY && !getIsContainerized()) {
+  // DEBUG_STDOUT_LOGS opts in to stdout output for any non-TTY environment
+  // (containers, background daemons, etc.).
+  if (!process.stdout.isTTY && !getDebugStdoutLogs()) {
     return pino(
       { name: "assistant", level: "info", serializers: logSerializers },
       pino.multistream([

package/src/util/platform.ts

@@ -1,9 +1,23 @@
-import { chmodSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { chmodSync, existsSync, mkdirSync } from "node:fs";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 
 import { getWorkspaceDirOverride } from "../config/env-registry.js";
 
+/**
+ * The daemon's root data directory (`~/.vellum`).
+ *
+ * Multi-instance path relocation is handled by the CLI when spawning the
+ * daemon (via `VELLUM_WORKSPACE_DIR` and `GATEWAY_SECURITY_DIR`); the
+ * assistant itself never reads an env var for this.
+ */
+const VELLUM_ROOT = join(homedir(), ".vellum");
+
+/** Returns the daemon's root data directory (`~/.vellum`). */
+export function vellumRoot(): string {
+  return VELLUM_ROOT;
+}
+
 export function isMacOS(): boolean {
   return process.platform === "darwin";
 }
@@ -44,34 +58,6 @@ export function normalizeAssistantId(assistantId: string): string {
   return assistantId;
 }
 
-/**
- * The daemon's per-instance root data directory. Resolution order:
- *
- *   1. `BASE_DATA_DIR` env var — set by the CLI when spawning the daemon
- *      for a specific assistant (see `cli/src/lib/local.ts`). Points at the
- *      per-assistant instanceDir; we append `.vellum` to get the daemon's
- *      root so root-level state (PID, credentials, runtime-port, workspace)
- *      is isolated per instance.
- *   2. Fallback: `join(homedir(), ".vellum")`. Used when the daemon runs
- *      outside the CLI-spawn lifecycle (containerized deployments, manual
- *      test invocations).
- *
- * Docker mode relocates the workspace via `VELLUM_WORKSPACE_DIR` rather
- * than `BASE_DATA_DIR`, so honoring `BASE_DATA_DIR` here does not affect
- * containerized deployments.
- *
- * Exported so other daemon-side consumers (e.g. the meet-join orphan reaper
- * in `skills/meet-join/daemon/docker-runner.ts`) can derive a per-instance
- * identifier from the same canonical root. Do not replace with ad-hoc
- * `process.env.BASE_DATA_DIR` reads — this helper is the single source of
- * truth for per-instance path resolution.
- */
-export function vellumRoot(): string {
-  const baseDataDir = process.env.BASE_DATA_DIR?.trim();
-  if (baseDataDir) return join(baseDataDir, ".vellum");
-  return join(homedir(), ".vellum");
-}
-
 /**
  * Returns the internal data directory (~/.vellum/workspace/data). Runtime
  * databases, logs, memory indices, and other internal state live here.
@@ -131,40 +117,10 @@ export function getAvatarImagePath(): string {
   return join(getAvatarDir(), AVATAR_IMAGE_FILENAME);
 }
 
-/**
- * Returns the TCP port the daemon should listen on for iOS clients.
- * Hardcoded default: 8765.
- */
-export function getTCPPort(): number {
-  return 8765;
-}
-
-/**
- * Returns whether the daemon TCP listener should be enabled.
- * Checks for the presence of the flag file ~/.vellum/tcp-enabled.
- * Default: false.
- *
- * The flag-file check makes it easy to enable TCP in dev without restarting
- * the shell: `touch ~/.vellum/tcp-enabled && kill -USR1 <daemon-pid>`.
- */
-export function isTCPEnabled(): boolean {
-  return existsSync(join(vellumRoot(), "tcp-enabled"));
-}
-
-/**
- * Returns the hostname/address for the TCP listener.
- * Always binds to localhost only. iOS pairing uses the gateway
- * relay.
- */
-export function getTCPHost(): string {
-  return "127.0.0.1";
-}
-
-// Kept in sync with `cli/src/lib/environments/seeds.ts` and
-// `clients/chrome-extension/native-host/src/lockfile.ts`. Drift between
-// these three sites is caught at test time by
+// Kept in sync with `cli/src/lib/environments/seeds.ts`. Drift between
+// these two sites is caught at test time by
 // `cli/src/__tests__/env-drift.test.ts`. Fast follow: hoist the shared
-// list into a `packages/environments` package so all three sites import
+// list into a `packages/environments` package so both sites import
 // from one place.
 const KNOWN_ENVIRONMENTS: ReadonlySet<string> = new Set([
   "production",
@@ -178,11 +134,7 @@ const KNOWN_ENVIRONMENTS: ReadonlySet<string> = new Set([
  * Returns the env-scoped XDG config subdirectory name for Vellum
  * (`vellum` in production, `vellum-<env>` otherwise). Mirrors the Swift
  * side's `VellumPaths.configDir` and the CLI's
- * `environments/paths.ts:getConfigDir` so the daemon resolves to the
- * same on-disk location as every other writer of these files.
- *
- * Unknown environment names fall back to production to preserve the
- * legacy path for any unrecognized value.
+ * `environments/paths.ts:getConfigDir`.
  */
 export function getXdgVellumConfigDirName(): string {
   const raw = process.env.VELLUM_ENVIRONMENT?.trim();
@@ -191,59 +143,8 @@ export function getXdgVellumConfigDirName(): string {
   return `vellum-${raw}`;
 }
 
-/**
- * Returns the XDG-compliant path for the platform API token. Resolves to
- * `$XDG_CONFIG_HOME/vellum/platform-token` in production and
- * `$XDG_CONFIG_HOME/vellum-<env>/platform-token` otherwise, matching the
- * Swift client and CLI.
- */
-export function getXdgPlatformTokenPath(): string {
-  const configHome =
-    process.env.XDG_CONFIG_HOME?.trim() || join(homedir(), ".config");
-  return join(configHome, getXdgVellumConfigDirName(), "platform-token");
-}
-
-/**
- * Returns the instance-scoped path to the platform API token file
- * (~/.vellum/platform-token). Used as a fallback for local assistant
- * instances that may have the token written here by the desktop app.
- */
-export function getPlatformTokenPath(): string {
-  return join(vellumRoot(), "platform-token");
-}
-
-/**
- * Read the platform API token from disk. Checks the instance-scoped
- * path first, then falls back to the XDG-compliant shared location.
- * Returns null if neither file exists or can be read.
- */
-export function readPlatformToken(): string | null {
-  try {
-    return readFileSync(getPlatformTokenPath(), "utf-8").trim();
-  } catch {
-    // Instance-scoped token not found; try XDG path
-  }
-  try {
-    return readFileSync(getXdgPlatformTokenPath(), "utf-8").trim();
-  } catch {
-    return null;
-  }
-}
-
 export function getPidPath(): string {
-  return join(vellumRoot(), "vellum.pid");
-}
-
-/**
- * Returns the path to the runtime HTTP port file (~/.vellum/runtime-port).
- * The daemon writes its active HTTP port here on startup so thin helpers
- * that need to reach the runtime (e.g. the chrome-extension native messaging
- * helper) can locate a non-default `RUNTIME_HTTP_PORT` without a manifest
- * change. Root-level path by design — the file is read by helpers that may
- * not know the workspace override path.
- */
-export function getRuntimePortFilePath(): string {
-  return join(vellumRoot(), "runtime-port");
+  return join(getWorkspaceDir(), "vellum.pid");
 }
 
 export function getDbPath(): string {
@@ -269,7 +170,7 @@ export function getHistoryPath(): string {
  * - Skipped in containerized mode (credentials via CES, trust via gateway)
  */
 export function getProtectedDir(): string {
-  return join(vellumRoot(), "protected");
+  return join(VELLUM_ROOT, "protected");
 }
 
 /** Returns ~/.vellum/workspace/signals — the directory for IPC signal files. */
@@ -303,7 +204,7 @@ export function getBinDir(): string {
 
 /** Returns the path to the dot-env file (~/.vellum/.env). Stays at root because it contains secrets. */
 export function getDotEnvPath(): string {
-  return join(vellumRoot(), ".env");
+  return join(VELLUM_ROOT, ".env");
 }
 
 /** Returns the path to the embed-worker PID file (~/.vellum/workspace/embed-worker.pid). */
@@ -321,7 +222,7 @@ export function getEmbedWorkerPidPath(): string {
 export function getWorkspaceDir(): string {
   const override = getWorkspaceDirOverride();
   if (override) return override;
-  return join(vellumRoot(), "workspace");
+  return join(VELLUM_ROOT, "workspace");
 }
 
 /**
@@ -406,8 +307,68 @@ export function getProfilerRunDir(runId: string): string {
   return join(getProfilerRunsDir(), runId);
 }
 
+/**
+ * Resolve the shipped source directory for a first-party skill (e.g.
+ * `meet-join`) whose runtime is launched outside the compiled daemon
+ * binary — notably the meet-host child process spawned via
+ * `bun run <skill>/register.ts`.
+ *
+ * Layers on top of `getRepoSkillsDir()` from `skills/catalog-install.ts`:
+ * that helper locates the first-party skills root (validated by
+ * `catalog.json`); this helper appends the skill id and validates the
+ * per-skill entry point (`register.ts`). Returns `undefined` when the
+ * root is unavailable (e.g. dev-mode build without `VELLUM_DEV=1`) or
+ * the skill directory has no `register.ts`.
+ *
+ * Implemented here instead of `skills/catalog-install.ts` to avoid
+ * pulling that module's platform-API dependencies (fetch, memory graph)
+ * into callers that only need a path resolution. Takes the first-party
+ * skills root as a dependency to keep this module free of a reverse
+ * import.
+ */
+export function getSkillRuntimePath(
+  skillId: string,
+  firstPartySkillsRoot: string | undefined,
+): string | undefined {
+  if (!firstPartySkillsRoot) return undefined;
+  const candidate = join(firstPartySkillsRoot, skillId);
+  if (existsSync(join(candidate, "register.ts"))) {
+    return candidate;
+  }
+  return undefined;
+}
+
+/**
+ * Resolve the on-disk path to a standalone `bun` binary that the meet-host
+ * supervisor (PR 27) uses to spawn external skills. Prefers the
+ * packaging-site-bundled copy before falling back to the shared
+ * download/PATH resolver in `bun-runtime.ts`.
+ *
+ * Resolution order:
+ *
+ *   1. macOS `.app` bundle: `Contents/Resources/bun` — shipped by
+ *      `clients/macos/build.sh` at a version that matches `.tool-versions`.
+ *   2. Next-to-binary: `<execDir>/bun` for Docker/generic compiled layouts
+ *      that stage a bun binary alongside the daemon (PR 29 wires this up).
+ *
+ * Returns `undefined` when no bundled copy is present; callers should
+ * fall back to `ensureBun()` from `./bun-runtime.ts`, which handles PATH
+ * lookup and JIT download for bare-metal dev.
+ */
+export function getBundledBunPath(): string | undefined {
+  const importDir = import.meta.dir;
+  if (!importDir.startsWith("/$bunfs/")) return undefined;
+
+  const execDir = dirname(process.execPath);
+  const resourcesPath = join(execDir, "..", "Resources", "bun");
+  if (existsSync(resourcesPath)) return resourcesPath;
+  const execDirPath = join(execDir, "bun");
+  if (existsSync(execDirPath)) return execDirPath;
+  return undefined;
+}
+
 export function ensureDataDir(): void {
-  const root = vellumRoot();
+  const root = VELLUM_ROOT;
   const workspace = getWorkspaceDir();
   const wsData = join(workspace, "data");
   const dirs = [