@vellumai/assistant 0.6.4 → 0.6.6

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

@@ -8,16 +8,16 @@
  *   run with `hasNoClient: true` because chrome-extension is not in
  *   `INTERACTIVE_INTERFACES`).
  * - macos requires a connected SSE client for host tools that flow through
- *   the proxy (e.g. host_bash, host_file_*), so `hasNoClient: true` denies
- *   those on macos.
- * - host_browser is NOT in the macos capability set because the proxy path
- *   requires a Chrome extension that isn't guaranteed to be attached; macos
- *   browser tools fall back to local Playwright Chromium.
+ *   the proxy (e.g. host_bash, host_file_*, host_browser), so
+ *   `hasNoClient: true` denies those on macos.
+ * - host_browser IS in the macos capability set — the proxy routes
+ *   host_browser_request frames to the desktop client via SSE (or via the
+ *   Chrome extension registry when an extension connection is present).
  *
  * The per-capability check (`supportsHostProxy(transport, capability)`) runs
  * first and is authoritative for structural support, so host_bash and
  * host_file_* are filtered out for chrome-extension regardless of the
- * hasNoClient flag, and host_browser is filtered out for macos.
+ * hasNoClient flag.
  */
 
 import { describe, expect, test } from "bun:test";
@@ -74,23 +74,22 @@ describe("isToolActiveForContext — host tool capability gating", () => {
     ).toBe(false);
   });
 
-  test("host_browser is NOT active for macOS (uses local Playwright)", () => {
-    // host_browser is not in the macos capability set because the proxy path
-    // requires a Chrome extension that isn't guaranteed to be attached; macos
-    // browser tools fall back to local Playwright Chromium instead. The
-    // per-capability check is authoritative, so host_browser is filtered out
-    // for macos regardless of client connection state.
+  test("host_browser is active for macOS with a connected client", () => {
+    // macOS supports host_browser — the proxy routes host_browser_request
+    // frames to the desktop client via SSE (or via the Chrome extension
+    // registry when an extension connection is present).
     expect(
       isToolActiveForContext(
         "host_browser",
         makeCtx({ hasNoClient: false, transportInterface: "macos" }),
       ),
-    ).toBe(false);
+    ).toBe(true);
   });
 
   test("host_browser is NOT active for macOS when hasNoClient is true", () => {
-    // Same capability gate as above: host_browser is unsupported on macos
-    // regardless of connection state.
+    // macOS supports host_browser structurally, but without a connected
+    // client the host_browser_request frames have no consumer, so the tool
+    // is denied.
     expect(
       isToolActiveForContext(
         "host_browser",

package/src/daemon/approval-generators.ts

@@ -1,5 +1,7 @@
 import { loadConfig } from "../config/loader.js";
+import { CallSiteRoutingProvider } from "../providers/call-site-routing.js";
 import { getProvider, listProviders } from "../providers/registry.js";
+import type { Provider } from "../providers/types.js";
 import {
   APPROVAL_COPY_MAX_TOKENS,
   APPROVAL_COPY_SYSTEM_PROMPT,
@@ -89,12 +91,15 @@ const VALID_DISPOSITIONS: ReadonlySet<string> = new Set([
 export function createApprovalCopyGenerator(): ApprovalCopyGenerator {
   return async (context, options = {}) => {
     const config = loadConfig();
-    let provider;
+    let baseProvider: Provider;
     try {
-      provider = getProvider(config.services.inference.provider);
+      baseProvider = getProvider(config.llm.default.provider);
     } catch {
       return null;
     }
+    // Wrap so per-call `callSite` can route to an alternative provider
+    // transport when `llm.callSites.<id>.provider` overrides the default.
+    const provider = wrapWithCallSiteRouting(baseProvider);
 
     const fallbackText =
       options.fallbackText?.trim() || getFallbackMessage(context);
@@ -114,6 +119,7 @@ export function createApprovalCopyGenerator(): ApprovalCopyGenerator {
       {
         config: {
           max_tokens: options.maxTokens ?? APPROVAL_COPY_MAX_TOKENS,
+          callSite: "approvalCopy",
         },
         signal: AbortSignal.timeout(
           options.timeoutMs ?? APPROVAL_COPY_TIMEOUT_MS,
@@ -142,10 +148,12 @@ export function createApprovalCopyGenerator(): ApprovalCopyGenerator {
 export function createApprovalConversationGenerator(): ApprovalConversationGenerator {
   return async (context) => {
     const config = loadConfig();
-    if (!listProviders().includes(config.services.inference.provider)) {
+    if (!listProviders().includes(config.llm.default.provider)) {
       throw new Error("No provider available for approval conversation");
     }
-    const provider = getProvider(config.services.inference.provider);
+    const provider = wrapWithCallSiteRouting(
+      getProvider(config.llm.default.provider),
+    );
 
     const pendingDescription = context.pendingApprovals
       .map((p) => `- Request ${p.requestId}: tool "${p.toolName}"`)
@@ -166,6 +174,7 @@ export function createApprovalConversationGenerator(): ApprovalConversationGener
       {
         config: {
           max_tokens: APPROVAL_CONVERSATION_MAX_TOKENS,
+          callSite: "approvalConversation",
         },
         signal: AbortSignal.timeout(APPROVAL_CONVERSATION_TIMEOUT_MS),
       },
@@ -215,3 +224,19 @@ export function createApprovalConversationGenerator(): ApprovalConversationGener
     return result;
   };
 }
+
+/**
+ * Wrap a base Provider so per-call `callSite` metadata can route the actual
+ * transport to a different provider when `llm.callSites.<id>.provider`
+ * differs from the default. Without this wrapper, only request metadata
+ * reflects the callSite — the HTTP transport stays bound to the default.
+ */
+function wrapWithCallSiteRouting(base: Provider): Provider {
+  return new CallSiteRoutingProvider(base, (name) => {
+    try {
+      return getProvider(name);
+    } catch {
+      return undefined;
+    }
+  });
+}

package/src/daemon/assistant-attachments.ts

@@ -8,6 +8,7 @@
 import { readFileSync, statSync } from "node:fs";
 import { basename } from "node:path";
 
+import { isPlaceholderSentinelText } from "../providers/anthropic/client.js";
 import {
   hostPolicy,
   sandboxPolicy,
@@ -692,19 +693,29 @@ export function cleanAssistantContent(content: readonly unknown[]): {
   const directives: DirectiveRequest[] = [];
   const warnings: string[] = [];
 
-  const cleanedContent = content.map((block) => {
-    const b = block as Record<string, unknown>;
-    if (b.type !== "text") return block;
-    const text = b.text as string;
-    // Only run the directive parser when the text actually contains a
-    // potential tag. This avoids unintentional whitespace normalisation
-    // (parseDirectives trims and collapses blank lines) on plain messages.
-    if (!text.includes("<vellum-attachment")) return block;
-    const result = parseDirectives(text);
-    directives.push(...result.directiveRequests);
-    warnings.push(...result.parseWarnings);
-    return { ...b, text: result.cleanText };
-  });
+  const cleanedContent = content
+    .filter((block) => {
+      // Drop placeholder sentinel text blocks. These are injected by the
+      // Anthropic provider to preserve role alternation in outbound requests
+      // and must never be persisted or rendered to users.
+      const b = block as Record<string, unknown>;
+      if (b.type !== "text") return true;
+      const text = b.text;
+      return typeof text !== "string" || !isPlaceholderSentinelText(text);
+    })
+    .map((block) => {
+      const b = block as Record<string, unknown>;
+      if (b.type !== "text") return block;
+      const text = b.text as string;
+      // Only run the directive parser when the text actually contains a
+      // potential tag. This avoids unintentional whitespace normalisation
+      // (parseDirectives trims and collapses blank lines) on plain messages.
+      if (!text.includes("<vellum-attachment")) return block;
+      const result = parseDirectives(text);
+      directives.push(...result.directiveRequests);
+      warnings.push(...result.parseWarnings);
+      return { ...b, text: result.cleanText };
+    });
 
   return { cleanedContent, directives, warnings };
 }

package/src/daemon/classifier.ts

@@ -28,7 +28,7 @@ export async function classifyInteraction(
     return "text_qa";
   }
 
-  const provider = await getConfiguredProvider();
+  const provider = await getConfiguredProvider("interactionClassifier");
   if (!provider) {
     log.warn(
       "No configured provider available, falling back to heuristic classification",
@@ -65,7 +65,7 @@ export async function classifyInteraction(
         "You are a classifier. Determine whether the user's request requires computer use (controlling the GUI — clicking, scrolling, typing into app windows, navigating between apps) or can be handled with local tools (answering questions, running terminal commands, creating/editing/reading files, web searches, writing code). GUI tasks → computer_use. Everything else → text_qa.",
         {
           config: {
-            modelIntent: "latency-optimized",
+            callSite: "interactionClassifier",
             max_tokens: 128,
             tool_choice: {
               type: "tool" as const,

package/src/daemon/config-watcher.ts

@@ -24,7 +24,6 @@ import { handleCancelSignal } from "../signals/cancel.js";
 import { handleConversationUndoSignal } from "../signals/conversation-undo.js";
 import { handleEmitEventSignal } from "../signals/emit-event.js";
 import { handleMcpReloadSignal } from "../signals/mcp-reload.js";
-import { handleShotgunSignal } from "../signals/shotgun.js";
 import { handleUserMessageSignal } from "../signals/user-message.js";
 import { DebouncerMap } from "../util/debounce.js";
 import { getLogger } from "../util/logger.js";
@@ -172,7 +171,6 @@ export class ConfigWatcher {
         onConversationEvict();
         onIdentityChanged?.();
       },
-      "UPDATES.md": () => onConversationEvict(),
     };
 
     const watchDir = (
@@ -397,7 +395,6 @@ export class ConfigWatcher {
       (filename: string) => void | Promise<void>
     > = {
       "bash.": handleBashSignal,
-      "shotgun.": handleShotgunSignal,
       "user-message.": handleUserMessageSignal,
     };
 

package/src/daemon/context-overflow-policy.ts

@@ -4,10 +4,7 @@ import type { ContextOverflowRecoveryConfig } from "../config/schemas/inference.
  * Actions the overflow recovery loop can take when the context window is
  * exceeded and standard compaction has already been applied.
  */
-export type OverflowAction =
-  | "auto_compress_latest_turn"
-  | "request_user_approval"
-  | "fail_gracefully";
+export type OverflowAction = "auto_compress_latest_turn" | "fail_gracefully";
 
 export interface OverflowPolicyInput {
   overflowRecovery: ContextOverflowRecoveryConfig;
@@ -19,8 +16,8 @@ export interface OverflowPolicyInput {
  * to a concrete overflow action.
  *
  * The recovery pipeline calls this after standard compaction is exhausted.
- * Interactive conversations default to asking the user before compressing the
- * latest turn; non-interactive conversations auto-compress.
+ * All conversations auto-compress the latest turn when standard compaction is
+ * exhausted, unless the policy is `drop` (opt-out) or recovery is disabled.
  */
 export function resolveOverflowAction(
   input: OverflowPolicyInput,
@@ -40,11 +37,5 @@ export function resolveOverflowAction(
     return "fail_gracefully";
   }
 
-  // For non-interactive conversations, compress without asking.
-  if (!isInteractive) {
-    return "auto_compress_latest_turn";
-  }
-
-  // Interactive conversations ask for approval before compressing.
-  return "request_user_approval";
+  return "auto_compress_latest_turn";
 }

package/src/daemon/context-overflow-reducer.ts

@@ -279,7 +279,10 @@ function applyMediaStubbing(
       providerName: config.providerName,
     });
     const adjustedNonMediaTokens = nonMediaTokens + estimatedStubTokens;
-    const mediaTokenBudget = Math.max(0, config.targetTokens - adjustedNonMediaTokens);
+    const mediaTokenBudget = Math.max(
+      0,
+      config.targetTokens - adjustedNonMediaTokens,
+    );
 
     const stripped = stripMediaPayloadsForRetry(messages, {
       mediaTokenBudget,

package/src/daemon/conversation-agent-loop-handlers.ts

@@ -13,20 +13,35 @@ import type {
   TurnChannelContext,
   TurnInterfaceContext,
 } from "../channels/types.js";
+import { recordEstimate } from "../context/estimator-calibration.js";
+import { getCalibrationProviderKey } from "../context/token-estimator.js";
 import {
-  addMessage,
   getConversation,
   getMessageById,
   provenanceFromTrustContext,
   updateMessageContent,
 } from "../memory/conversation-crud.js";
-import { syncMessageToDisk } from "../memory/conversation-disk-view.js";
 import {
   backfillMessageIdOnLogs,
   recordRequestLog,
 } from "../memory/llm-request-log-store.js";
 import { backfillMemoryRecallLogMessageId } from "../memory/memory-recall-log-store.js";
+import { getThreadTs } from "../memory/slack-thread-store.js";
+import {
+  type SlackMessageMetadata,
+  writeSlackMetadata,
+} from "../messaging/providers/slack/message-metadata.js";
+import { defaultPersistenceTerminal } from "../plugins/defaults/persistence.js";
+import { DEFAULT_TIMEOUTS, runPipeline } from "../plugins/pipeline.js";
+import { getMiddlewaresFor } from "../plugins/registry.js";
+import type {
+  PersistAddResult,
+  PersistArgs,
+  PersistResult,
+  TurnContext,
+} from "../plugins/types.js";
 import type { ContentBlock, ImageContent } from "../providers/types.js";
+import { isContextOverflowError } from "../providers/types.js";
 import { ProviderError } from "../util/errors.js";
 import { getLogger } from "../util/logger.js";
 import type { DirectiveRequest } from "./assistant-attachments.js";
@@ -45,6 +60,34 @@ import type { ServerMessage } from "./message-protocol.js";
 
 const log = getLogger("agent-loop-handlers");
 
+/**
+ * Build a {@link TurnContext} from the handler's deps for pipeline logging
+ * and plugin attribution.
+ *
+ * Reads `turnIndex` from `deps.ctx.turnCount` — the orchestrator-owned
+ * per-turn counter that is stable for the entire duration of a single
+ * `runAgentLoopImpl` invocation. The handlers fire after the orchestrator
+ * has completed its in-turn pipeline work but before `ctx.turnCount++` runs
+ * in the outer `finally` block, so this value always reflects the turn the
+ * handler's event belongs to. Trust pulls from the per-turn snapshot first,
+ * then the conversation-level context, then the canonical `unknown`
+ * fallback so the required field stays populated for edge cases (fresh
+ * conversations before the trust resolver runs, heartbeat turns that never
+ * bind an actor).
+ */
+function buildHandlerTurnContext(deps: EventHandlerDeps): TurnContext {
+  return {
+    requestId: deps.reqId,
+    conversationId: deps.ctx.conversationId,
+    turnIndex: deps.ctx.turnCount,
+    trust: deps.ctx.currentTurnTrustContext ??
+      deps.ctx.trustContext ?? {
+        sourceChannel: "vellum",
+        trustClass: "unknown",
+      },
+  };
+}
+
 // ── Types ────────────────────────────────────────────────────────────
 
 export interface PendingToolResult {
@@ -73,8 +116,14 @@ export interface EventHandlerState {
   orderingErrorDetected: boolean;
   deferredOrderingError: string | null;
   contextTooLargeDetected: boolean;
-  /** The raw error message from the provider when context_too_large is detected. */
-  contextTooLargeErrorMessage: string | null;
+  /**
+   * The provider error object when context_too_large is detected, preserved
+   * so `parseActualTokensFromError` can prefer the typed
+   * `ContextOverflowError` fields over the string-regex fallback. The
+   * message is always reachable via `.message` on this object — no separate
+   * field is needed.
+   */
+  contextTooLargeError: unknown;
   providerErrorUserMessage: string | null;
   lastAssistantMessageId: string | undefined;
   readonly pendingToolResults: Map<string, PendingToolResult>;
@@ -144,7 +193,7 @@ export function createEventHandlerState(): EventHandlerState {
     orderingErrorDetected: false,
     deferredOrderingError: null,
     contextTooLargeDetected: false,
-    contextTooLargeErrorMessage: null,
+    contextTooLargeError: null,
     providerErrorUserMessage: null,
     lastAssistantMessageId: undefined,
     pendingToolResults: new Map(),
@@ -204,12 +253,6 @@ const TOOL_FRIENDLY_NAMES: Record<string, string> = {
   file_read: "file read",
   file_write: "file write",
   file_edit: "file edit",
-  browser_navigate: "browser",
-  browser_click: "browser",
-  browser_type: "browser",
-  browser_screenshot: "browser",
-  browser_scroll: "browser",
-  browser_wait: "browser",
   app_create: "app",
   app_refresh: "app refresh",
   skill_load: "skill",
@@ -530,6 +573,10 @@ export function handleToolResult(
     imageData: imageDataList?.[0],
     imageDataList,
     toolUseId: event.toolUseId,
+    riskLevel: event.riskLevel,
+    riskReason: event.riskReason,
+    isContainerized: event.isContainerized,
+    riskScopeOptions: event.riskScopeOptions,
   });
 }
 
@@ -616,16 +663,20 @@ export function handleError(
   if (isProviderOrderingError(event.error.message)) {
     state.orderingErrorDetected = true;
     state.deferredOrderingError = event.error.message;
+  } else if (isContextOverflowError(event.error)) {
+    // Typed path — the provider client already classified this as overflow.
+    state.contextTooLargeDetected = true;
+    state.contextTooLargeError = event.error;
   } else if (isContextTooLarge(event.error.message)) {
     state.contextTooLargeDetected = true;
-    state.contextTooLargeErrorMessage = event.error.message;
+    state.contextTooLargeError = event.error;
   } else {
     const classified = classifyConversationError(event.error, {
       phase: "agent_loop",
     });
     if (classified.code === "CONTEXT_TOO_LARGE") {
       state.contextTooLargeDetected = true;
-      state.contextTooLargeErrorMessage = event.error.message;
+      state.contextTooLargeError = event.error;
     } else if (
       classified.code === "PROVIDER_ORDERING" ||
       classified.code === "PROVIDER_WEB_SEARCH"
@@ -703,21 +754,30 @@ export async function handleMessageComplete(
       assistantMessageInterface:
         deps.turnInterfaceContext.assistantMessageInterface,
     };
-    const toolResultMsg = await addMessage(
-      deps.ctx.conversationId,
-      "user",
-      JSON.stringify(toolResultBlocks),
-      toolResultMetadata,
-    );
-    // Sync tool-result user message to disk view
+    // Route the add + disk-view sync through the `persistence` pipeline so
+    // plugins can observe or override both operations together. The default
+    // plugin's terminal performs the add and, when `syncToDisk` is true,
+    // immediately calls `syncMessageToDisk` against the just-persisted row.
+    // `getConversation` returns `ConversationRow | null`, so `!= null`
+    // gates on a real row (skipping the sync when the conversation was
+    // not found rather than asking the disk-view to resolve a missing id).
     const convForToolResult = getConversation(deps.ctx.conversationId);
-    if (convForToolResult) {
-      syncMessageToDisk(
-        deps.ctx.conversationId,
-        toolResultMsg.id,
-        convForToolResult.createdAt,
-      );
-    }
+    await runPipeline<PersistArgs, PersistResult>(
+      "persistence",
+      getMiddlewaresFor("persistence"),
+      defaultPersistenceTerminal,
+      {
+        op: "add",
+        conversationId: deps.ctx.conversationId,
+        role: "user",
+        content: JSON.stringify(toolResultBlocks),
+        metadata: toolResultMetadata,
+        syncToDisk: convForToolResult != null,
+        createdAtMs: convForToolResult?.createdAt,
+      },
+      buildHandlerTurnContext(deps),
+      DEFAULT_TIMEOUTS.persistence,
+    );
     for (const id of state.pendingToolResults.keys()) {
       state.persistedToolUseIds.add(id);
     }
@@ -767,7 +827,7 @@ export async function handleMessageComplete(
     } as unknown as ContentBlock);
   }
 
-  const assistantChannelMetadata = {
+  const assistantChannelMetadata: Record<string, unknown> = {
     ...provenanceFromTrustContext(deps.ctx.trustContext),
     userMessageChannel: deps.turnChannelContext.userMessageChannel,
     assistantMessageChannel: deps.turnChannelContext.assistantMessageChannel,
@@ -776,12 +836,53 @@ export async function handleMessageComplete(
       deps.turnInterfaceContext.assistantMessageInterface,
     sentAt: state.turnStartedAt,
   };
-  const assistantMsg = await addMessage(
-    deps.ctx.conversationId,
-    "assistant",
-    JSON.stringify(contentWithSurfaces),
-    assistantChannelMetadata,
-  );
+
+  // When the assistant is replying through Slack, stamp a `slackMeta`
+  // sub-object so the transcript-rendering / thread-aware-context lookup
+  // can identify this row's thread without joining tables.
+  // Persistence happens BEFORE the Slack adapter sends the message, so
+  // Slack's authoritative `ts` (-> `channelTs`) is not yet known and is
+  // intentionally omitted here. The post-send reconciliation step in
+  // `deliverReplyViaCallback` writes `channelTs` back into this row once
+  // the gateway returns the Slack-assigned ts, restoring a fully-formed
+  // metadata envelope before any subsequent turn reads the row.
+  if (deps.turnChannelContext.assistantMessageChannel === "slack") {
+    const channelId = deps.ctx.trustContext?.requesterChatId;
+    if (channelId) {
+      const threadTs = getThreadTs(deps.ctx.conversationId);
+      const partialSlackMeta: Partial<SlackMessageMetadata> = {
+        source: "slack",
+        eventKind: "message",
+        channelId,
+        ...(threadTs ? { threadTs } : {}),
+      };
+      assistantChannelMetadata.slackMeta = writeSlackMetadata(
+        // `channelTs` is filled in by the post-send reconciliation step in
+        // `deliverReplyViaCallback`; cast through the Partial to satisfy
+        // the writer's type at this pre-send boundary.
+        partialSlackMeta as SlackMessageMetadata,
+      );
+    }
+  }
+  // Route the assistant-message persistence through the `persistence`
+  // pipeline. No `syncToDisk` here — the orchestrator separately invokes
+  // `syncMessageToDisk` on `state.lastAssistantMessageId` after the loop
+  // completes (see `conversation-agent-loop.ts::syncLastAssistantMessageToDisk`).
+  const assistantPersistResult = (await runPipeline<PersistArgs, PersistResult>(
+    "persistence",
+    getMiddlewaresFor("persistence"),
+    defaultPersistenceTerminal,
+    {
+      op: "add",
+      conversationId: deps.ctx.conversationId,
+      role: "assistant",
+      content: JSON.stringify(contentWithSurfaces),
+      metadata: assistantChannelMetadata,
+    },
+    buildHandlerTurnContext(deps),
+    DEFAULT_TIMEOUTS.persistence,
+  )) as PersistAddResult;
+  const assistantMsg = assistantPersistResult.message;
   state.lastAssistantMessageId = assistantMsg.id;
 
   // Backfill message_id on all LLM request logs from this turn.
@@ -841,6 +942,33 @@ export function handleUsage(
   state.exchangeCacheReadInputTokens += event.cacheReadInputTokens ?? 0;
   state.exchangeOutputTokens += event.outputTokens;
   state.model = event.model;
+
+  // Feed the self-calibration loop: compare the pre-send estimate to the
+  // provider's ground-truth inputTokens. `recordEstimate` silently ignores
+  // samples below its magnitude threshold or outside its outlier bounds,
+  // so it's safe to call unconditionally.
+  //
+  // The calibration key must match what `estimatePromptTokens` callers look
+  // up — use the canonical provider key (`tokenEstimationProvider ?? name`),
+  // falling back to the response's `actualProvider` only when neither hint
+  // is set on the provider object (shouldn't happen, but cheap). Using
+  // `event.actualProvider` as the primary key would scatter data across
+  // mismatched keys for wrapper providers like OpenRouter.
+  const calibrationProviderKey =
+    getCalibrationProviderKey(deps.ctx.provider) ||
+    (event.actualProvider ?? "");
+  if (
+    calibrationProviderKey.length > 0 &&
+    event.estimatedInputTokens !== undefined &&
+    event.estimatedInputTokens > 0
+  ) {
+    recordEstimate(
+      calibrationProviderKey,
+      event.model,
+      event.estimatedInputTokens,
+      event.inputTokens,
+    );
+  }
   if (event.rawResponse !== undefined) {
     state.exchangeRawResponses.push(event.rawResponse);
   }