@vellumai/assistant 0.7.1 → 0.7.3

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

@@ -43,6 +43,7 @@ import type {
 } from "../plugins/types.js";
 import type { ContentBlock, ImageContent } from "../providers/types.js";
 import { isContextOverflowError } from "../providers/types.js";
+import { redactSecrets } from "../security/secret-scanner.js";
 import { ProviderError } from "../util/errors.js";
 import { getLogger } from "../util/logger.js";
 import type { DirectiveRequest } from "./assistant-attachments.js";
@@ -136,6 +137,8 @@ export interface EventHandlerState {
   readonly directiveWarnings: string[];
   readonly toolUseIdToName: Map<string, string>;
   currentTurnToolNames: string[];
+  /** Sticky for the whole run: this turn created/refreshed an app. */
+  appBuildToolUsedThisRun: boolean;
   /** Tracks whether the first text delta has been emitted this turn for activity state transitions. */
   firstTextDeltaEmitted: boolean;
   /** Tracks whether a thinking delta has been emitted this turn for activity state transitions. */
@@ -218,6 +221,7 @@ export function createEventHandlerState(): EventHandlerState {
     directiveWarnings: [],
     toolUseIdToName: new Map(),
     currentTurnToolNames: [],
+    appBuildToolUsedThisRun: false,
     firstTextDeltaEmitted: false,
     firstThinkingDeltaEmitted: false,
     lastCompletedToolName: undefined,
@@ -364,6 +368,9 @@ export function handleToolUse(
 ): void {
   state.toolUseIdToName.set(event.id, event.name);
   state.currentTurnToolNames.push(event.name);
+  if (event.name === "app_create" || event.name === "app_refresh") {
+    state.appBuildToolUsedThisRun = true;
+  }
   state.toolCallTimestamps.set(event.id, { startedAt: Date.now() });
   state.currentToolUseId = event.id;
   state.currentTurnToolUseIds.push(event.id);
@@ -804,10 +811,16 @@ export async function handleMessageComplete(
       ([toolUseId, result]) => ({
         type: "tool_result",
         tool_use_id: toolUseId,
-        content: result.content,
+        content: redactSecrets(result.content),
         is_error: result.isError,
         ...(result.contentBlocks
-          ? { contentBlocks: result.contentBlocks }
+          ? {
+              contentBlocks: result.contentBlocks.map((block) =>
+                block.type === "text"
+                  ? { ...block, text: redactSecrets(block.text) }
+                  : block,
+              ),
+            }
           : {}),
       }),
     );
@@ -929,6 +942,17 @@ export async function handleMessageComplete(
       );
     }
   }
+  // Redact known-pattern secrets from assistant text blocks before they are
+  // written to durable storage. Non-text blocks (images, UI surfaces) pass
+  // through unchanged. The live model history retains the original values.
+  const contentForPersistence = contentWithSurfaces.map((block) => {
+    if (block.type === "text") {
+      const tb = block as Extract<ContentBlock, { type: "text" }>;
+      return { ...tb, text: redactSecrets(tb.text) };
+    }
+    return block;
+  });
+
   // Route the assistant-message persistence through the `persistence`
   // pipeline. No `syncToDisk` here — the orchestrator separately invokes
   // `syncMessageToDisk` on `state.lastAssistantMessageId` after the loop
@@ -941,7 +965,7 @@ export async function handleMessageComplete(
       op: "add",
       conversationId: deps.ctx.conversationId,
       role: "assistant",
-      content: JSON.stringify(contentWithSurfaces),
+      content: JSON.stringify(contentForPersistence),
       metadata: assistantChannelMetadata,
     },
     buildHandlerTurnContext(deps),

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

@@ -24,7 +24,6 @@ import type {
   TurnChannelContext,
   TurnInterfaceContext,
 } from "../channels/types.js";
-import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
 import {
   contextWindowConfigFromEffective,
   resolveEffectiveContextWindow,
@@ -74,7 +73,10 @@ import type { ConversationGraphMemory } from "../memory/graph/conversation-graph
 import { recordMemoryRecallLog } from "../memory/memory-recall-log-store.js";
 import { PKB_WORKSPACE_SCOPE } from "../memory/pkb/types.js";
 import type { QdrantSparseVector } from "../memory/qdrant-client.js";
-import { readMemoryV2StaticContent } from "../memory/v2/static-context.js";
+import {
+  readMemoryV2StaticContent,
+  shouldLoadMemoryV2Static,
+} from "../memory/v2/static-context.js";
 import type { PermissionPrompter } from "../permissions/prompter.js";
 import { defaultCompactionTerminal } from "../plugins/defaults/compaction.js";
 import { defaultHistoryRepairTerminal } from "../plugins/defaults/history-repair.js";
@@ -107,6 +109,11 @@ import type {
   TurnContext as PluginTurnContext,
 } from "../plugins/types.js";
 import { PluginExecutionError, PluginTimeoutError } from "../plugins/types.js";
+import {
+  hasProactiveArtifactCompleted,
+  runProactiveArtifactJob,
+  tryClaimProactiveArtifactTrigger,
+} from "../proactive-artifact/index.js";
 import type {
   ContentBlock,
   Message,
@@ -114,7 +121,9 @@ import type {
 } from "../providers/types.js";
 import type { Provider } from "../providers/types.js";
 import { resolveActorTrust } from "../runtime/actor-trust-resolver.js";
+import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
+import { redactSecrets } from "../security/secret-scanner.js";
 import { getSubagentManager } from "../subagent/index.js";
 import type { UsageActor } from "../usage/actors.js";
 import { getLogger } from "../util/logger.js";
@@ -127,6 +136,7 @@ import {
   type AssistantAttachmentDraft,
   cleanAssistantContent,
 } from "./assistant-attachments.js";
+import { cleanupBootstrapAfterTurnThreshold } from "./bootstrap-turn-cleanup.js";
 import { resolveOverflowAction } from "./context-overflow-policy.js";
 import {
   createInitialReducerState,
@@ -174,7 +184,12 @@ import type { SkillProjectionCache } from "./conversation-skill-tools.js";
 import { markSurfaceCompleted } from "./conversation-surfaces.js";
 import { resolveTrustClass } from "./conversation-tool-setup.js";
 import { recordUsage } from "./conversation-usage.js";
-import { formatTurnTimestamp } from "./date-context.js";
+import {
+  formatTurnTimestamp,
+  resolveTurnTimezoneContext,
+} from "./date-context.js";
+import { getDiskPressureStatus } from "./disk-pressure-guard.js";
+import { classifyDiskPressureTurnPolicy } from "./disk-pressure-policy.js";
 import { deepRepairHistory } from "./history-repair.js";
 import type {
   DynamicPageSurfaceData,
@@ -191,6 +206,8 @@ import type { TrustContext } from "./trust-context.js";
 import { stripHistoricalWebSearchResults } from "./web-search-history.js";
 
 const log = getLogger("conversation-agent-loop");
+const DISK_PRESSURE_ERROR_CODE = "DISK_SPACE_CRITICAL" as const;
+const DISK_PRESSURE_ERROR_CATEGORY = "disk_pressure";
 
 /** Title-cased friendly labels for tool names, used in confirmation chips. */
 const TOOL_FRIENDLY_LABEL: Record<string, string> = {
@@ -210,6 +227,10 @@ type GitServiceInitializer = {
   ensureInitialized(): Promise<void>;
 };
 
+function formatDiskPressureBlockedMessage(): string {
+  return "Storage is critically low, so background processes are paused and remote messages are ignored until the guardian frees enough space. Remote senders should try again later.";
+}
+
 // ── Compaction circuit-breaker pipeline helpers ─────────────────────
 //
 // The circuit-breaker behavior (3 consecutive summary-LLM failures trips a
@@ -437,7 +458,6 @@ export interface AgentLoopConversationContext {
   /** Timestamp (ms since epoch) until which the circuit breaker is open. */
   compactionCircuitOpenUntil: number | null;
 
-  readonly memoryPolicy: { scopeId: string; includeDefaultFallback: boolean };
   readonly graphMemory: ConversationGraphMemory;
 
   currentActiveSurfaceId?: string;
@@ -494,9 +514,11 @@ export interface AgentLoopConversationContext {
   voiceCallControlPrompt?: string;
   transportHints?: string[];
   slackRuntimeContextNotice?: string;
+  clientTimezone?: string;
 
   readonly coreToolNames: Set<string>;
   allowedToolNames?: Set<string>;
+  diskPressureCleanupModeActive?: boolean;
   toolsDisabledDepth: number;
   preactivatedSkillIds?: string[];
   readonly skillProjectionState: Map<string, string>;
@@ -706,19 +728,39 @@ export async function runAgentLoopImpl(
     };
   })();
 
+  const isInteractiveResolved =
+    options?.isInteractive ?? (!ctx.hasNoClient && !ctx.headlessLock);
+  const diskPressureDecision = classifyDiskPressureTurnPolicy(
+    getDiskPressureStatus(),
+    {
+      conversationType: turnStartConversation?.conversationType ?? null,
+      conversationSource: turnStartConversation?.source ?? null,
+      callSite: turnCallSite,
+      isInteractive: isInteractiveResolved,
+      sourceChannel:
+        ctx.trustContext?.sourceChannel ??
+        capturedTurnChannelContext.userMessageChannel,
+      sourceInterface:
+        ctx.channelCapabilities?.clientOS ??
+        capturedTurnInterfaceContext.userMessageInterface,
+      trustContext: ctx.trustContext
+        ? {
+            sourceChannel: ctx.trustContext.sourceChannel,
+            trustClass: ctx.trustContext.trustClass,
+          }
+        : null,
+    },
+  );
+  const diskPressureContext =
+    diskPressureDecision.action === "allow-cleanup-mode"
+      ? { cleanupModeActive: true }
+      : null;
+  ctx.diskPressureCleanupModeActive =
+    diskPressureDecision.action === "allow-cleanup-mode";
+
   ctx.lastAssistantAttachments = [];
   ctx.lastAttachmentWarnings = [];
 
-  // Ensure workspace git repo is initialized before any tools run.
-  try {
-    const getWorkspaceGitServiceFn =
-      ctx.getWorkspaceGitService ?? getWorkspaceGitService;
-    const gitService = getWorkspaceGitServiceFn(ctx.workingDir);
-    await gitService.ensureInitialized();
-  } catch (err) {
-    rlog.warn({ err }, "Failed to initialize workspace git repo (non-fatal)");
-  }
-
   ctx.profiler.startRequest();
   let turnStarted = false;
 
@@ -735,6 +777,52 @@ export async function runAgentLoopImpl(
   });
 
   try {
+    if (diskPressureDecision.action === "block") {
+      const message = formatDiskPressureBlockedMessage();
+      rlog.warn(
+        { reason: diskPressureDecision.reason },
+        "Blocked turn during disk pressure cleanup mode",
+      );
+      ctx.emitActivityState("idle", "error_terminal", "global", reqId);
+      ctx.traceEmitter.emit("request_error", message, {
+        requestId: reqId,
+        status: "error",
+        attributes: {
+          errorCategory: DISK_PRESSURE_ERROR_CATEGORY,
+          errorCode: DISK_PRESSURE_ERROR_CODE,
+          diskPressureReason: diskPressureDecision.reason,
+        },
+      });
+      onEvent({
+        type: "error",
+        conversationId: ctx.conversationId,
+        requestId: reqId,
+        code: DISK_PRESSURE_ERROR_CODE,
+        message,
+        category: DISK_PRESSURE_ERROR_CATEGORY,
+        errorCategory: DISK_PRESSURE_ERROR_CATEGORY,
+      });
+      onEvent({
+        type: "conversation_error",
+        conversationId: ctx.conversationId,
+        code: DISK_PRESSURE_ERROR_CODE,
+        userMessage: message,
+        retryable: true,
+        errorCategory: DISK_PRESSURE_ERROR_CATEGORY,
+      });
+      return;
+    }
+
+    // Ensure workspace git repo is initialized before any tools run.
+    try {
+      const getWorkspaceGitServiceFn =
+        ctx.getWorkspaceGitService ?? getWorkspaceGitService;
+      const gitService = getWorkspaceGitServiceFn(ctx.workingDir);
+      await gitService.ensureInitialized();
+    } catch (err) {
+      rlog.warn({ err }, "Failed to initialize workspace git repo (non-fatal)");
+    }
+
     // Auto-complete stale interactive surfaces from previous turns.
     // Only dismiss when the user sends a new message (not a surface action
     // response), so internal turns (subagent notifications, lifecycle
@@ -1237,14 +1325,16 @@ export async function runAgentLoopImpl(
 
     // Compute fresh turn timestamp for date grounding.
     // Absolute "now" is always anchored to assistant host clock, while local
-    // date semantics prefer configured user timezone, then recalled memory.
+    // date semantics prefer configured user timezone, then device timezones.
     const hostTimeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
-    const configuredUserTimeZone = getConfig().ui.userTimezone ?? null;
-    const recalledUserTimeZone = null;
-    const timestamp = formatTurnTimestamp({
+    const timezoneContext = resolveTurnTimezoneContext({
+      configuredUserTimeZone: config.ui.userTimezone ?? null,
+      clientTimezone: ctx.clientTimezone ?? null,
+      detectedTimezone: config.ui.detectedTimezone ?? null,
       hostTimeZone,
-      configuredUserTimeZone,
-      userTimeZone: recalledUserTimeZone,
+    });
+    const timestamp = formatTurnTimestamp({
+      timeZone: timezoneContext.effectiveTimezone,
     });
 
     // Resolve the inbound actor context for the unified <turn_context> block.
@@ -1298,23 +1388,26 @@ export async function runAgentLoopImpl(
       }
     }
 
+    const baseTurnContext = {
+      timestamp,
+      interfaceName,
+      channelName,
+      configuredUserTimezone: timezoneContext.configuredUserTimezone,
+      clientTimezone: timezoneContext.clientTimezone,
+      detectedTimezone: timezoneContext.detectedTimezone,
+      timeSinceLastMessage,
+    };
     const unifiedTurnContextStr = buildUnifiedTurnContextBlock(
       isGuardian
-        ? { timestamp, interfaceName, channelName, timeSinceLastMessage }
+        ? baseTurnContext
         : {
-            timestamp,
-            interfaceName,
-            channelName,
+            ...baseTurnContext,
             actorContext: resolvedInboundActorContext,
-            timeSinceLastMessage,
           },
     );
 
     // The `remember` tool handles scratchpad-style memory writes directly to the graph.
 
-    const isInteractiveResolved =
-      options?.isInteractive ?? (!ctx.hasNoClient && !ctx.headlessLock);
-
     // Inject NOW.md and PKB content only on the first turn (or after
     // compaction re-strips them).  Old injections persist in history and
     // are never stripped on normal turns — this preserves the cached prefix.
@@ -1329,10 +1422,16 @@ export async function runAgentLoopImpl(
     const pkbActive = currentPkbContent !== null;
 
     // V2 static memory block (essentials/threads/recent/buffer). Same
-    // first-turn / post-compaction cadence as PKB — `readMemoryV2StaticContent`
-    // self-gates on the v2 flag + config, returning null when v2 is off.
-    // Skip the file reads entirely on non-injection turns.
-    const currentMemoryV2Static = shouldInjectNowAndPkb
+    // first-turn / post-compaction cadence as PKB. `shouldLoadMemoryV2Static`
+    // also blocks remote-channel non-guardian actors from inducing the
+    // model to recite private memory; `readMemoryV2StaticContent` self-gates
+    // on the v2 flag + config and returns null when v2 is off, so the file
+    // reads are skipped on non-injection turns.
+    const currentMemoryV2Static = shouldLoadMemoryV2Static({
+      shouldInjectNowAndPkb,
+      sourceChannel: ctx.trustContext?.sourceChannel,
+      isTrustedActor,
+    })
       ? readMemoryV2StaticContent()
       : null;
     const memoryV2Static = currentMemoryV2Static;
@@ -1348,8 +1447,8 @@ export async function runAgentLoopImpl(
     // `getInContextPkbPaths` re-reads `conversation.messages` on each call,
     // so post-compaction re-injects see the updated history.
     const pkbConversation = pkbActive ? ctx : undefined;
-    // PKB points live under a single workspace sentinel scope, not the
-    // conversation's memoryPolicy.scopeId. See `PKB_WORKSPACE_SCOPE` for why.
+    // PKB points live under a single workspace sentinel scope.
+    // See `PKB_WORKSPACE_SCOPE` for why.
     const pkbScopeId = pkbActive ? PKB_WORKSPACE_SCOPE : undefined;
 
     // Subagent status injection — gives the parent LLM visibility into active/completed children.
@@ -1416,6 +1515,7 @@ export async function runAgentLoopImpl(
 
     // Shared injection options — reused whenever we need to re-inject after reduction.
     const injectionOpts = {
+      diskPressureContext,
       activeSurface,
       workspaceTopLevelContext: shouldInjectWorkspace
         ? ctx.workspaceTopLevelContext
@@ -2533,10 +2633,16 @@ export async function runAgentLoopImpl(
       ).map(([toolUseId, result]) => ({
         type: "tool_result",
         tool_use_id: toolUseId,
-        content: result.content,
+        content: redactSecrets(result.content),
         is_error: result.isError,
         ...(result.contentBlocks
-          ? { contentBlocks: result.contentBlocks }
+          ? {
+              contentBlocks: result.contentBlocks.map((block) =>
+                block.type === "text"
+                  ? { ...block, text: redactSecrets(block.text) }
+                  : block,
+              ),
+            }
           : {}),
       }));
       const toolResultMetadata = {
@@ -2619,34 +2725,29 @@ export async function runAgentLoopImpl(
 
     // Post-turn tool result truncation: save large results to disk and
     // replace in-context content with a prefix/suffix stub + file pointer.
-    if (isAssistantFeatureFlagEnabled("tool-result-truncation", config)) {
-      try {
-        const conv = getConversation(ctx.conversationId);
-        if (conv) {
-          const convDir = getResolvedConversationDirPath(
-            ctx.conversationId,
-            conv.createdAt,
+    try {
+      const conv = getConversation(ctx.conversationId);
+      if (conv) {
+        const convDir = getResolvedConversationDirPath(
+          ctx.conversationId,
+          conv.createdAt,
+        );
+        const { messages: derefMessages, dereferencedCount } =
+          derefToolResultReReads(restoredHistory);
+        const { messages: truncatedMessages, truncatedCount } =
+          postTurnTruncateToolResults(derefMessages, {
+            conversationDir: convDir,
+          });
+        if (truncatedCount > 0 || dereferencedCount > 0) {
+          rlog.info(
+            { truncatedCount, dereferencedCount },
+            "Post-turn tool result truncation applied",
           );
-          const { messages: derefMessages, dereferencedCount } =
-            derefToolResultReReads(restoredHistory);
-          const { messages: truncatedMessages, truncatedCount } =
-            postTurnTruncateToolResults(derefMessages, {
-              conversationDir: convDir,
-            });
-          if (truncatedCount > 0 || dereferencedCount > 0) {
-            rlog.info(
-              { truncatedCount, dereferencedCount },
-              "Post-turn tool result truncation applied",
-            );
-          }
-          restoredHistory = truncatedMessages;
         }
-      } catch (err) {
-        rlog.warn(
-          { err },
-          "Post-turn tool result truncation failed (non-fatal)",
-        );
+        restoredHistory = truncatedMessages;
       }
+    } catch (err) {
+      rlog.warn({ err }, "Post-turn tool result truncation failed (non-fatal)");
     }
 
     // Persist injections in history: runtime-injected context stays on
@@ -2872,6 +2973,42 @@ export async function runAgentLoopImpl(
             "Failed to build home-feed event for background conversation",
           );
         }
+
+        // Proactive artifact: fire once when the processed turn was the 4th user message.
+        // Only trigger for real user-authored turns (not subagent/system messages).
+        {
+          const paConv = getConversation(ctx.conversationId);
+          if (
+            paConv &&
+            paConv.conversationType === "standard" &&
+            options?.isUserMessage
+          ) {
+            void (async () => {
+              try {
+                if (hasProactiveArtifactCompleted()) return;
+                const userMsg = getMessageById(
+                  userMessageId,
+                  ctx.conversationId,
+                );
+                if (!userMsg) return;
+                if (!tryClaimProactiveArtifactTrigger(userMsg.createdAt))
+                  return;
+                await runProactiveArtifactJob({
+                  conversationId: ctx.conversationId,
+                  userMessageCutoff: userMsg.createdAt,
+                  assistantMessageId: state.lastAssistantMessageId,
+                  suppressAppBuild: state.appBuildToolUsedThisRun,
+                  broadcastMessage,
+                });
+              } catch (err) {
+                log.warn(
+                  { err, conversationId: ctx.conversationId },
+                  "Proactive artifact trigger failed",
+                );
+              }
+            })();
+          }
+        }
       }
     }
 
@@ -2935,11 +3072,14 @@ export async function runAgentLoopImpl(
         conversationId: ctx.conversationId,
         code: classified.code,
         message: classified.userMessage,
+        errorCategory: classified.errorCategory,
       });
       onEvent(buildConversationErrorMessage(ctx.conversationId, classified));
     }
   } finally {
     if (turnStarted) {
+      cleanupBootstrapAfterTurnThreshold(ctx.conversationId);
+
       ctx.turnCount++;
       const config = getConfig();
       const maxWait = config.workspaceGit?.turnCommitMaxWaitMs ?? 4000;
@@ -2984,6 +3124,7 @@ export async function runAgentLoopImpl(
     ctx.currentRequestId = undefined;
     ctx.currentActiveSurfaceId = undefined;
     ctx.allowedToolNames = undefined;
+    ctx.diskPressureCleanupModeActive = false;
     ctx.preactivatedSkillIds = undefined;
     ctx.currentTurnOverrideProfile = undefined;
     ctx.slackRuntimeContextNotice = undefined;

package/src/daemon/conversation-error.ts

@@ -36,6 +36,23 @@ const NETWORK_PATTERNS = [
 // Rate limit patterns (HTTP 429 or explicit rate limit messages)
 const RATE_LIMIT_PATTERNS = [/429/, /rate.?limit/i, /too many requests/i];
 
+// Managed usage-limit responses are generated by Vellum, even though they can
+// travel through provider SDKs and get wrapped as ProviderError.
+const MANAGED_USAGE_LIMIT_PATTERNS = [
+  /"code"\s*:\s*"daily_quota_exceeded"/i,
+  /"code"\s*:\s*"rate_limit_exceeded"/i,
+  /system credential proxy rate limit/i,
+  /you've reached your usage limit for today/i,
+  /current plan allows/i,
+];
+
+const PROVIDER_BILLING_PATTERNS = [
+  /credit balance is too low/i,
+  /insufficient.*credits?/i,
+  /requires more credits/i,
+  /can only afford/i,
+];
+
 // Overloaded patterns — provider is capacity-constrained (distinct from rate limiting)
 const OVERLOADED_PATTERNS = [/overloaded/i];
 
@@ -259,15 +276,21 @@ function classifyCore(
       };
     }
     if (error.statusCode === 402) {
-      return {
-        code: "PROVIDER_BILLING",
-        userMessage:
-          "You've run out of credits. Add funds to continue using the assistant.",
-        retryable: false,
-        errorCategory: "credits_exhausted",
-      };
+      if (isManagedBalanceError(error)) {
+        return managedBalanceClassification();
+      }
+      return providerBillingClassification();
     }
     if (error.statusCode === 429) {
+      if (isManagedUsageLimitError(error, message)) {
+        return {
+          code: "MANAGED_USAGE_LIMIT",
+          userMessage:
+            "Vellum managed inference is rate limited. This is a Vellum-side usage limit, not an AI provider outage.",
+          retryable: true,
+          errorCategory: "managed_usage_limit",
+        };
+      }
       return {
         code: "PROVIDER_RATE_LIMIT",
         userMessage:
@@ -331,13 +354,8 @@ function classifyCore(
           errorCategory: "tool_ordering",
         };
       }
-      if (/credit balance is too low|insufficient.*credits?/i.test(message)) {
-        return {
-          code: "PROVIDER_BILLING",
-          userMessage: "Your API key has insufficient credits.",
-          retryable: false,
-          errorCategory: "provider_billing",
-        };
+      if (isProviderBillingError(message)) {
+        return providerBillingClassification();
       }
       if (
         /invalid.*api.?key|invalid.*x-api-key|authentication.?error|invalid.authentication/i.test(
@@ -362,7 +380,7 @@ function classifyCore(
   }
 
   // Regex fallback for non-ProviderError or ProviderError without statusCode
-  return classifyByMessage(message);
+  return classifyByMessage(error, message);
 }
 
 /** Check whether an error message indicates a context-too-large failure. */
@@ -394,7 +412,52 @@ function isStreamingError(message: string): boolean {
   return STREAMING_ERROR_PATTERNS.some((p) => p.test(message));
 }
 
+function isManagedUsageLimitError(error: unknown, message: string): boolean {
+  if (
+    error instanceof ProviderError &&
+    getProviderRoutingSource(error.provider) === "managed-proxy"
+  ) {
+    return true;
+  }
+  return MANAGED_USAGE_LIMIT_PATTERNS.some((p) => p.test(message));
+}
+
+function isManagedBalanceError(error: ProviderError): boolean {
+  return getProviderRoutingSource(error.provider) === "managed-proxy";
+}
+
+function isProviderBillingError(message: string): boolean {
+  return PROVIDER_BILLING_PATTERNS.some((p) => p.test(message));
+}
+
+function managedBalanceClassification(): Omit<
+  ClassifiedConversationError,
+  "debugDetails"
+> {
+  return {
+    code: "PROVIDER_BILLING",
+    userMessage:
+      "You've run out of credits. Add funds to continue using the assistant.",
+    retryable: false,
+    errorCategory: "credits_exhausted",
+  };
+}
+
+function providerBillingClassification(): Omit<
+  ClassifiedConversationError,
+  "debugDetails"
+> {
+  return {
+    code: "PROVIDER_BILLING",
+    userMessage:
+      "Your API provider account or key needs credits. Add funds with the provider or update the key in Settings.",
+    retryable: false,
+    errorCategory: "provider_billing",
+  };
+}
+
 function classifyByMessage(
+  error: unknown,
   message: string,
 ): Omit<ClassifiedConversationError, "debugDetails"> {
   // Check context-too-large before other patterns
@@ -411,6 +474,15 @@ function classifyByMessage(
   // Check rate limit first (before network, since 429 could match both)
   for (const pattern of RATE_LIMIT_PATTERNS) {
     if (pattern.test(message)) {
+      if (isManagedUsageLimitError(error, message)) {
+        return {
+          code: "MANAGED_USAGE_LIMIT",
+          userMessage:
+            "Vellum managed inference is rate limited. This is a Vellum-side usage limit, not an AI provider outage.",
+          retryable: true,
+          errorCategory: "managed_usage_limit",
+        };
+      }
       return {
         code: "PROVIDER_RATE_LIMIT",
         userMessage: