@vellumai/assistant 0.7.0 → 0.7.1

package/src/usage/attribution.ts

@@ -0,0 +1,185 @@
+import { resolveCallSiteConfig } from "../config/llm-resolver.js";
+import { getConfig } from "../config/loader.js";
+import type { LLMCallSite } from "../config/schemas/llm.js";
+import { safeStringSlice } from "../util/unicode.js";
+
+const MAX_METADATA_VALUE_LENGTH = 128;
+
+export type UsageAttributionProfileSource =
+  | "call_site"
+  | "conversation"
+  | "active"
+  | "default"
+  | "unknown";
+
+export interface UsageAttributionInput {
+  callSite: LLMCallSite | null;
+  overrideProfile?: string | null;
+}
+
+export interface UsageAttributionSnapshot {
+  callSite: LLMCallSite | null;
+  activeProfile: string | null;
+  overrideProfile: string | null;
+  callSiteProfile: string | null;
+  appliedProfile: string | null;
+  profileSource: UsageAttributionProfileSource;
+  resolvedProvider: string;
+  resolvedModel: string;
+}
+
+/**
+ * Sanitizes values before they are copied into external metadata surfaces.
+ * Empty strings and control-character-bearing strings are dropped, and long
+ * values are capped so later forwarding cannot create unbounded headers.
+ */
+export function sanitizeUsageMetadataValue(value: unknown): string | null {
+  if (typeof value !== "string") return null;
+
+  const trimmed = value.trim();
+  if (trimmed.length === 0) return null;
+  if (containsControlCharacter(trimmed)) return null;
+
+  return safeStringSlice(trimmed, 0, MAX_METADATA_VALUE_LENGTH);
+}
+
+export function resolveUsageAttribution(
+  input: UsageAttributionInput,
+): UsageAttributionSnapshot {
+  const llm = getConfig().llm;
+  const callSite = input.callSite;
+  const overrideProfile = normalizeProfileId(input.overrideProfile);
+
+  if (callSite == null) {
+    return {
+      callSite: null,
+      activeProfile: normalizeProfileId(llm.activeProfile),
+      overrideProfile,
+      callSiteProfile: null,
+      appliedProfile: null,
+      profileSource: "unknown",
+      resolvedProvider: llm.default.provider,
+      resolvedModel: llm.default.model,
+    };
+  }
+
+  const resolved = resolveCallSiteConfig(callSite, llm, {
+    ...(overrideProfile != null ? { overrideProfile } : {}),
+  });
+  const activeProfile = normalizeProfileId(llm.activeProfile);
+  const callSiteProfile = normalizeProfileId(
+    llm.callSites?.[callSite]?.profile,
+  );
+  const profile = resolveAppliedProfile({
+    callSite,
+    profiles: llm.profiles ?? {},
+    activeProfile,
+    overrideProfile,
+    callSiteProfile,
+  });
+
+  return {
+    callSite,
+    activeProfile,
+    overrideProfile,
+    callSiteProfile,
+    appliedProfile: profile.appliedProfile,
+    profileSource: profile.profileSource,
+    resolvedProvider: resolved.provider,
+    resolvedModel: resolved.model,
+  };
+}
+
+function resolveAppliedProfile(input: {
+  callSite: LLMCallSite;
+  profiles: Record<string, unknown>;
+  activeProfile: string | null;
+  overrideProfile: string | null;
+  callSiteProfile: string | null;
+}): Pick<UsageAttributionSnapshot, "appliedProfile" | "profileSource"> {
+  if (input.callSite === "mainAgent") {
+    if (
+      input.overrideProfile != null &&
+      input.profiles[input.overrideProfile] != null
+    ) {
+      return {
+        appliedProfile: input.overrideProfile,
+        profileSource: "conversation",
+      };
+    }
+
+    if (
+      input.activeProfile != null &&
+      input.profiles[input.activeProfile] != null
+    ) {
+      return {
+        appliedProfile: input.activeProfile,
+        profileSource: "active",
+      };
+    }
+
+    if (
+      input.callSiteProfile != null &&
+      input.profiles[input.callSiteProfile] != null
+    ) {
+      return {
+        appliedProfile: input.callSiteProfile,
+        profileSource: "call_site",
+      };
+    }
+
+    return {
+      appliedProfile: null,
+      profileSource: "default",
+    };
+  }
+
+  if (
+    input.callSiteProfile != null &&
+    input.profiles[input.callSiteProfile] != null
+  ) {
+    return {
+      appliedProfile: input.callSiteProfile,
+      profileSource: "call_site",
+    };
+  }
+
+  if (
+    input.overrideProfile != null &&
+    input.profiles[input.overrideProfile] != null
+  ) {
+    return {
+      appliedProfile: input.overrideProfile,
+      profileSource: "conversation",
+    };
+  }
+
+  if (
+    input.activeProfile != null &&
+    input.profiles[input.activeProfile] != null
+  ) {
+    return {
+      appliedProfile: input.activeProfile,
+      profileSource: "active",
+    };
+  }
+
+  return {
+    appliedProfile: null,
+    profileSource: "default",
+  };
+}
+
+function normalizeProfileId(value: string | null | undefined): string | null {
+  return value ?? null;
+}
+
+function containsControlCharacter(value: string): boolean {
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (code < 0x20 || (code >= 0x7f && code <= 0x9f)) {
+      return true;
+    }
+  }
+  return false;
+}

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/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/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/pricing.ts

@@ -37,9 +37,48 @@ const PROVIDER_PRICING: Record<string, Record<string, ModelPricing>> = {
     "claude-haiku-4": { inputPer1M: 1, outputPer1M: 5 },
   },
   openai: {
-    "gpt-5.5": { inputPer1M: 5, outputPer1M: 30 },
-    "gpt-5.4": { inputPer1M: 2.5, outputPer1M: 15 },
-    "gpt-5.4-mini": { inputPer1M: 0.5, outputPer1M: 3 },
+    "gpt-5.5": {
+      inputPer1M: 5,
+      outputPer1M: 30,
+      cacheReadPer1M: 0.5,
+      tiers: [
+        {
+          inputTokenThreshold: 272_000,
+          inputPer1M: 10,
+          outputPer1M: 45,
+          cacheReadPer1M: 1,
+        },
+      ],
+    },
+    "gpt-5.5-pro": {
+      inputPer1M: 30,
+      outputPer1M: 180,
+      tiers: [
+        {
+          inputTokenThreshold: 272_000,
+          inputPer1M: 60,
+          outputPer1M: 270,
+        },
+      ],
+    },
+    "gpt-5.4": {
+      inputPer1M: 2.5,
+      outputPer1M: 15,
+      cacheReadPer1M: 0.25,
+      tiers: [
+        {
+          inputTokenThreshold: 272_000,
+          inputPer1M: 5,
+          outputPer1M: 22.5,
+          cacheReadPer1M: 0.5,
+        },
+      ],
+    },
+    "gpt-5.4-mini": {
+      inputPer1M: 0.75,
+      outputPer1M: 4.5,
+      cacheReadPer1M: 0.075,
+    },
     "gpt-5.4-nano": { inputPer1M: 0.2, outputPer1M: 1.25 },
     "gpt-5.2": { inputPer1M: 1.75, outputPer1M: 14 },
     "gpt-4o": { inputPer1M: 2.5, outputPer1M: 10 },
@@ -103,6 +142,14 @@ const PROVIDER_PRICING: Record<string, Record<string, ModelPricing>> = {
       inputPer1M: 1.25,
       outputPer1M: 10,
       cacheReadPer1M: 0.3125,
+      tiers: [
+        {
+          inputTokenThreshold: 200_000,
+          inputPer1M: 2.5,
+          outputPer1M: 15,
+          cacheReadPer1M: 0.625,
+        },
+      ],
     },
     "gemini-2.0-flash": { inputPer1M: 0.1, outputPer1M: 0.4 },
   },

package/src/work-items/work-item-runner.ts

@@ -1,13 +1,13 @@
 /**
- * Module-level registry for running work items from tool context.
+ * Module-level runner for executing work items from tool context.
  *
- * The daemon server registers its `getOrCreateConversation` and `broadcast`
- * callbacks at startup. Tool implementations can then trigger async
- * work item execution without needing direct access to HandlerContext.
+ * Imports conversation-store and the assistant event hub directly — no
+ * daemon-server callback registration needed.
  */
 
-import type { Conversation } from "../daemon/conversation.js";
+import { getOrCreateConversation } from "../daemon/conversation-store.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
+import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import { runTask } from "../tasks/task-runner.js";
 import { getTask } from "../tasks/task-store.js";
 import {
@@ -24,28 +24,12 @@ import {
 
 const log = getLogger("work-item-runner");
 
-// ── Daemon callback registry ─────────────────────────────────────────
-
-interface DaemonCallbacks {
-  getOrCreateConversation: (conversationId: string) => Promise<Conversation>;
-  broadcast: (msg: ServerMessage) => void;
-}
-
-let _callbacks: DaemonCallbacks | null = null;
-
-export function registerDaemonCallbacks(callbacks: DaemonCallbacks): void {
-  _callbacks = callbacks;
-}
-
 // ── Public API ───────────────────────────────────────────────────────
 
-function broadcastWorkItemStatus(
-  broadcast: (msg: ServerMessage) => void,
-  id: string,
-): void {
+function broadcastWorkItemStatus(id: string): void {
   const item = getWorkItem(id);
   if (item) {
-    broadcast({
+    broadcastMessage({
       type: "work_item_status_changed",
       item: {
         id: item.id,
@@ -75,14 +59,6 @@ export interface RunWorkItemResult {
  * auto-approved since the user explicitly requested execution.
  */
 export function runWorkItemInBackground(workItemId: string): RunWorkItemResult {
-  if (!_callbacks) {
-    return {
-      success: false,
-      error: "Daemon callbacks not registered",
-      errorCode: "not_initialized",
-    };
-  }
-
   const workItem = getWorkItem(workItemId);
   if (!workItem) {
     return {
@@ -135,11 +111,8 @@ export function runWorkItemInBackground(workItemId: string): RunWorkItemResult {
   // Set status to running
   updateWorkItem(workItemId, { status: "running" });
 
-  const { getOrCreateConversation, broadcast } = _callbacks;
-
-  // Broadcast the running state
-  broadcastWorkItemStatus(broadcast, workItemId);
-  broadcast({ type: "tasks_changed" } as ServerMessage);
+  broadcastWorkItemStatus(workItemId);
+  broadcastMessage({ type: "tasks_changed" } as ServerMessage);
 
   // Execute asynchronously
   let conversation: Awaited<ReturnType<typeof getOrCreateConversation>> | null =
@@ -155,7 +128,7 @@ export function runWorkItemInBackground(workItemId: string): RunWorkItemResult {
             });
             conversation = await getOrCreateConversation(conversationId);
 
-            broadcast({
+            broadcastMessage({
               type: "task_run_conversation_created",
               conversationId,
               workItemId,
@@ -165,7 +138,7 @@ export function runWorkItemInBackground(workItemId: string): RunWorkItemResult {
             conversation.headlessLock = true;
           }
           await conversation.processMessage(message, [], (event) => {
-            broadcast(event);
+            broadcastMessage(event);
           });
         },
       );
@@ -188,8 +161,8 @@ export function runWorkItemInBackground(workItemId: string): RunWorkItemResult {
         });
       }
 
-      broadcastWorkItemStatus(broadcast, workItemId);
-      broadcast({ type: "tasks_changed" } as ServerMessage);
+      broadcastWorkItemStatus(workItemId);
+      broadcastMessage({ type: "tasks_changed" } as ServerMessage);
     } catch (err) {
       const errConversation = conversation as { headlessLock: boolean } | null;
       if (errConversation) {
@@ -200,8 +173,8 @@ export function runWorkItemInBackground(workItemId: string): RunWorkItemResult {
         status: "failed",
         lastRunStatus: "failed",
       });
-      broadcastWorkItemStatus(broadcast, workItemId);
-      broadcast({ type: "tasks_changed" } as ServerMessage);
+      broadcastWorkItemStatus(workItemId);
+      broadcastMessage({ type: "tasks_changed" } as ServerMessage);
     }
   })();
 

package/src/workspace/migrations/050-seed-main-agent-opus-callsite.ts

@@ -60,9 +60,10 @@ export const seedMainAgentOpusCallsiteMigration: WorkspaceMigration = {
 
     if (readObject(callSites.mainAgent) !== null) return;
 
-    // maxTokens: 32000 matches Opus's maxOutputTokens (see
-    // model-catalog.ts); without it the site would inherit the
-    // default's 64000 and overshoot the model capability.
+    // Historical seed: at the time this migration shipped, Opus's standard
+    // output cap was 32k and this avoided inheriting a too-large default.
+    // The resolver now lets active/conversation profiles override this static
+    // mainAgent default.
     callSites.mainAgent = { model: "claude-opus-4-7", maxTokens: 32000 };
     llm.callSites = callSites;
     config.llm = llm;

package/src/workspace/migrations/052-seed-default-inference-profiles.ts

@@ -28,9 +28,9 @@ import type { WorkspaceMigration } from "./types.js";
  * Existing values are never overwritten:
  *   - A pre-existing profile by any of the three names is left intact.
  *   - A pre-existing `activeProfile` is preserved on Anthropic workspaces.
- *   - `llm.callSites` entries are not touched — they continue to win at
- *     resolver layer 5 over both `activeProfile` and per-site `profile`
- *     references.
+ *   - `llm.callSites` entries are not touched. Non-main-agent call sites
+ *     continue to win over profiles; `mainAgent` profiles now win over static
+ *     call-site defaults because they are the user's chat-model selection.
  *
  * **Skip when `VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH` is set.** Like
  * migration 040, a platform-provided default-config overlay (applied

package/src/workspace/migrations/060-memory-v2-init.ts

@@ -3,17 +3,6 @@ import { join } from "node:path";
 
 import type { WorkspaceMigration } from "./types.js";
 
-/**
- * Initial contents of `memory/edges.json` — the bidirectional concept-page
- * edge index for the v2 memory subsystem. The version field lets future
- * migrations bump the schema if needed.
- */
-const EMPTY_EDGES_INDEX = `${JSON.stringify(
-  { version: 1, edges: [] },
-  null,
-  2,
-)}\n`;
-
 const PROSE_FILES = ["essentials.md", "threads.md", "recent.md", "buffer.md"];
 
 export const memoryV2InitMigration: WorkspaceMigration = {
@@ -26,13 +15,8 @@ export const memoryV2InitMigration: WorkspaceMigration = {
     mkdirSync(join(memoryDir, "archive"), { recursive: true });
     mkdirSync(join(memoryDir, ".v2-state"), { recursive: true });
 
-    // Seed edges.json and the prose files only if missing — preserves any
-    // user content from manual setup or a prior migration.
-    const edgesPath = join(memoryDir, "edges.json");
-    if (!existsSync(edgesPath)) {
-      writeFileSync(edgesPath, EMPTY_EDGES_INDEX, "utf-8");
-    }
-
+    // Seed the prose files only if missing — preserves any user content from
+    // manual setup or a prior migration.
     for (const filename of PROSE_FILES) {
       const filePath = join(memoryDir, filename);
       if (!existsSync(filePath)) {