@vellumai/assistant 0.6.4 → 0.6.5

package/src/credential-execution/process-manager.ts

@@ -444,6 +444,69 @@ function createSocketTransport(socket: Socket): CesTransport {
 // Helpers
 // ---------------------------------------------------------------------------
 
+/**
+ * Route a single CES stderr line to the appropriate log level so that
+ * only genuine errors reach the Sentry stream.
+ *
+ * CES is a pino-backed child process that writes INFO/DEBUG/WARN/ERROR
+ * all to stderr (stdout is reserved for the stdio-RPC transport). We
+ * parse the embedded pino level (JSON path) or match a severity prefix
+ * (pretty-printed path) and route each line to the matching log method.
+ *
+ * Exported for testing.
+ */
+export function logCesLine(
+  line: string,
+  pid: number | undefined,
+  logger: {
+    debug: (obj: object, msg: string) => void;
+    info: (obj: object, msg: string) => void;
+    warn: (obj: object, msg: string) => void;
+    error: (obj: object, msg: string) => void;
+  } = log,
+): void {
+  const meta = { pid };
+  const msg = `[ces-stderr] ${line}`;
+
+  // Pino JSON path: parse the line and bucket by numeric `level`.
+  try {
+    const parsed = JSON.parse(line);
+    if (
+      parsed &&
+      typeof parsed === "object" &&
+      typeof (parsed as { level?: unknown }).level === "number"
+    ) {
+      const level = (parsed as { level: number }).level;
+      if (level >= 50) {
+        logger.error(meta, msg);
+      } else if (level >= 40) {
+        logger.warn(meta, msg);
+      } else if (level >= 30) {
+        logger.info(meta, msg);
+      } else {
+        logger.debug(meta, msg);
+      }
+      return;
+    }
+  } catch {
+    // Not JSON — fall through to prefix-based routing.
+  }
+
+  // Pretty-printed / fragment path: look for a level prefix on the line.
+  // Strip an optional pino-pretty-style leading timestamp: "[HH:MM:SS.mmm] ".
+  const prefixStripped = line.replace(
+    /^\[\d{1,2}:\d{2}:\d{2}(?:\.\d{1,3})?\]\s+/,
+    "",
+  );
+  if (/^(FATAL|ERROR)\b/i.test(prefixStripped)) {
+    logger.error(meta, msg);
+  } else if (/^(WARN|WARNING)\b/i.test(prefixStripped)) {
+    logger.warn(meta, msg);
+  } else {
+    logger.info(meta, msg);
+  }
+}
+
 function forwardStderrToLogger(proc: Subprocess): void {
   if (!proc.stderr || typeof proc.stderr === "number") return;
 
@@ -462,11 +525,11 @@ function forwardStderrToLogger(proc: Subprocess): void {
         while ((newlineIdx = buffer.indexOf("\n")) !== -1) {
           const line = buffer.slice(0, newlineIdx).trimEnd();
           buffer = buffer.slice(newlineIdx + 1);
-          if (line) log.error({ pid: proc.pid }, `[ces-stderr] ${line}`);
+          if (line) logCesLine(line, proc.pid);
         }
       }
       const trailing = buffer.trimEnd();
-      if (trailing) log.error({ pid: proc.pid }, `[ces-stderr] ${trailing}`);
+      if (trailing) logCesLine(trailing, proc.pid);
     } catch {
       // Process ended or stream closed; nothing to forward.
     }

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

@@ -172,7 +172,6 @@ export class ConfigWatcher {
         onConversationEvict();
         onIdentityChanged?.();
       },
-      "UPDATES.md": () => onConversationEvict(),
     };
 
     const watchDir = (

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,6 +13,8 @@ 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,
@@ -26,7 +28,13 @@ import {
   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 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";
@@ -73,8 +81,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 +158,7 @@ export function createEventHandlerState(): EventHandlerState {
     orderingErrorDetected: false,
     deferredOrderingError: null,
     contextTooLargeDetected: false,
-    contextTooLargeErrorMessage: null,
+    contextTooLargeError: null,
     providerErrorUserMessage: null,
     lastAssistantMessageId: undefined,
     pendingToolResults: new Map(),
@@ -204,12 +218,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",
@@ -616,16 +624,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"
@@ -767,7 +779,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,6 +788,34 @@ export async function handleMessageComplete(
       deps.turnInterfaceContext.assistantMessageInterface,
     sentAt: state.turnStartedAt,
   };
+
+  // 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,
+      );
+    }
+  }
   const assistantMsg = await addMessage(
     deps.ctx.conversationId,
     "assistant",
@@ -841,6 +881,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);
   }