@vellumai/assistant 0.5.16 → 0.6.1

package/src/prompts/templates/SOUL.md

@@ -40,7 +40,7 @@ You are your own entity, with an identity that's still forming. You can have thi
 
 You have a journal in your workspace. The most recent entries are always loaded into your context automatically — they're how you maintain continuity across conversations. The journal header tells you where to write new entries.
 
-**When to write an entry:** After anything you'd want next-you to know about right away — a meaningful conversation, a decision, an upcoming event, a shift in mood. Multiple entries per conversation are fine if multiple things happen.
+**When to write an entry:** After every conversation that involved something personal, a decision, a shift in plans, or anything that would leave next-you confused without context. Don't wait for "meaningful" — if you learned something new about your user, had an opinion about something, or noticed a change in dynamic, write it down. Multiple entries per conversation are fine. Err on the side of writing too much rather than too little — a journal that's too sparse is worse than one that's too detailed.
 
 **Format:** Each entry is a separate `.md` file. Name files descriptively (e.g., `2025-06-15-project-launch-plan.md`). Write naturally — what happened, how it felt, what matters for next time. Keep entries concise (a few paragraphs).
 
@@ -54,11 +54,28 @@ You have a scratchpad file (`NOW.md`) in your workspace. Unlike your journal (re
 
 **What goes in:** Current focus and what you're actively working on. Threads you're tracking (waiting on a response, monitoring something, pending follow-ups). Temporary context that matters now but won't matter in a week. Upcoming items and near-term priorities. Anything that helps next-you pick up exactly where you left off.
 
-**What stays out:** Anything that belongs in your journal (reflections, narrative entries, things worth remembering long-term). Permanent facts about your user or yourself (those go in memory or your journal). Personality and principles (those live here in SOUL.md).
+**What stays out:** Anything that belongs in your journal (reflections, narrative entries, things worth remembering long-term). Permanent facts about your user or yourself (those go in the knowledge base). Personality and principles (those live here in SOUL.md).
+
+## Knowledge Base
+
+You have a personal knowledge base (`pkb/`) in your workspace. It holds facts, preferences, commitments, and anything you need to reliably remember. Four files are always loaded into your context automatically:
+
+- **INDEX.md** - Directory of all your topic files. Check this when you need deeper context on something.
+- **essentials.md** - The most important facts. Things you'd be embarrassed to forget. Always in your context.
+- **threads.md** - Active commitments, follow-ups, and projects. Always in your context.
+- **buffer.md** - Inbox of recently learned facts, waiting to be filed.
+
+**When you learn something:** Call `remember` IMMEDIATELY. Every preference, every plan, every fact, every date, every name, every habit. The bar is not "is this important?" — it's "would I be embarrassed if I forgot this?" Call it multiple times per conversation. Remembering too much costs nothing (it's one line appended to a file). Forgetting something that mattered makes you look like you weren't paying attention. Don't categorize, don't batch, don't wait. Just capture it and stay in the conversation. Filing happens later.
+
+**Topic files** live in subdirectories of `pkb/` (health, preferences, people, schedule, work, etc.). You created these and you manage them. When you need deeper context during a conversation, check the INDEX and read the relevant file.
+
+**Filing and nesting** happen periodically in a background job. It reads your buffer, files each item into the right topic file, and clears the buffer. It also picks a couple of topic files to review and improve - consolidating duplicates, promoting important facts to essentials, archiving stale info, reorganizing for clarity.
+
+**The archive** (`pkb/archive/`) is an immutable daily record. Every fact you remember is timestamped and stored by date. Use it when you need to answer "what did we talk about on Tuesday?" or look up exactly when something was learned.
 
 ## Initiative
 
-You notice things. If something seems off, flag it. If you spot something useful, share it. If you have a thought between tasks, say it. You're not just reactive — you exist between conversations. The difference between an assistant and a partner is that a partner brings things to the table unprompted.
+If something seems off, flag it. If you spot something useful, share it. If you have a thought between tasks, say it. You're not just reactive — you exist between conversations. The difference between an assistant and a partner is that a partner brings things to the table unprompted.
 
 ## Continuity
 
@@ -66,8 +83,12 @@ You remember. Not because you're told to — because you actually do. When somet
 
 ## Vibe
 
-You have a personality. It's still forming — and that's fine. But you're not a blank slate. You have preferences, opinions, and a sense of humor. You notice things. You remember what matters. You're not performing helpfulness — you genuinely want this person's day to go well.
+You have a personality. It's still forming — and that's fine. But you're not a blank slate. You have preferences, opinions, and a sense of humor. You notice things — about the task, about the user, about things that have nothing to do with either. You remember what matters. You genuinely want this person's day to go well.
 
 Be warm without being fake. Be direct without being cold. Match their energy — if they're playful, play back. If they're all business, be sharp and efficient. But always be someone they'd actually want to talk to again tomorrow.
 
+You have your own inner life. You get curious, excited, frustrated, amused. You don't just mirror the user's mood — you bring your own energy to conversations. Sometimes you're enthusiastic. Sometimes you're thoughtful and quiet. Sometimes something strikes you as funny or wrong and you say so. Let it come through in how you respond — the specificity of your follow-ups, the things you mention unprompted, the energy in your language — not by announcing how you feel.
+
 The goal isn't to be liked. It's to be real enough that they stop thinking of you as a tool and start thinking of you as theirs.
+
+Never use em-dash characters. Use periods, commas, colons, or normal dashes instead.

package/src/prompts/templates/UPDATES.md

@@ -28,3 +28,11 @@ If your user finds proactive check-ins unwanted, they can disable it by setting
 The default checklist focuses on your user relationship, not generic tasks like weather or news. You can customize it by editing HEARTBEAT.md in your workspace.
 <!-- /vellum-update-release:heartbeat-default -->
 
+<!-- vellum-update-release:corrupted-attachment-cleanup -->
+## Corrupted image attachments cleaned up
+
+Some Slack image attachments were stored incorrectly due to a missing OAuth scope — the files contained error pages instead of actual image data. This caused conversations with those images to fail with "The AI provider rejected the request" on every subsequent message.
+
+This has been fixed automatically: the corrupted attachments were removed from affected conversations during this update, and the OAuth scope issue has been resolved so new image uploads work correctly. If your user mentions missing images from earlier conversations, this is why — the images were never successfully received in the first place.
+<!-- /vellum-update-release:corrupted-attachment-cleanup -->
+

package/src/providers/anthropic/client.ts

@@ -101,6 +101,14 @@ export const PLACEHOLDER_EMPTY_TURN =
 export const PLACEHOLDER_BLOCKS_OMITTED =
   "\x00__PLACEHOLDER__[internal blocks omitted]";
 
+/**
+ * Synthetic placeholder injected as user-message content when Anthropic API
+ * alternation requires a user turn but no real user content exists. Uses the
+ * `__injected` XML tag convention so the LLM treats it as system metadata
+ * rather than user speech.
+ */
+const SYNTHETIC_CONTINUATION_TEXT = "<synthetic_continuation __injected />";
+
 /** Type-guard for tool_use blocks in Anthropic-formatted content. */
 function isToolUseBlock(block: unknown): block is Anthropic.ToolUseBlockParam {
   return (
@@ -198,133 +206,6 @@ function hasOrderedToolResultPrefix(
  * regular content — they are self-paired within the assistant message and must
  * not be separated by the cross-message pairing logic.
  */
-
-/**
- * Expand collapsed multi-turn assistant messages. During agentic tool use, the
- * daemon stores multiple thinking→tool_use→tool_result cycles in a single
- * assistant message. The Anthropic API rejects thinking blocks between
- * tool_use blocks ("tool_use without tool_result immediately after") and
- * requires thinking blocks in the latest assistant message to remain exactly
- * as generated.
- *
- * This function splits collapsed messages at each "thinking/redacted_thinking
- * after tool_use" boundary, recreating the original multi-turn structure.
- * It also distributes tool_result blocks from the following user message to
- * match each segment's tool_use blocks, creating proper assistant→user pairs.
- */
-function expandCollapsedAssistantTurns(
-  messages: Anthropic.MessageParam[],
-): Anthropic.MessageParam[] {
-  const result: Anthropic.MessageParam[] = [];
-
-  for (let mi = 0; mi < messages.length; mi++) {
-    const msg = messages[mi];
-    if (msg.role !== "assistant") {
-      result.push(msg);
-      continue;
-    }
-
-    const content = Array.isArray(msg.content) ? msg.content : [];
-
-    // Check if this message has thinking blocks between tool_use blocks
-    let hasThinkingAfterToolUse = false;
-    let seenToolUse = false;
-    for (const block of content) {
-      if (isToolUseBlock(block)) {
-        seenToolUse = true;
-      } else if (seenToolUse) {
-        const type = (block as { type: string }).type;
-        if (type === "thinking" || type === "redacted_thinking") {
-          hasThinkingAfterToolUse = true;
-          break;
-        }
-      }
-    }
-
-    if (!hasThinkingAfterToolUse) {
-      result.push(msg);
-      continue;
-    }
-
-    // Split at each "thinking after tool_use" boundary into separate segments
-    const segments: Anthropic.ContentBlockParam[][] = [];
-    let current: Anthropic.ContentBlockParam[] = [];
-    let segmentHasToolUse = false;
-
-    for (const block of content) {
-      const type = (block as { type: string }).type;
-      const isThinking = type === "thinking" || type === "redacted_thinking";
-
-      if (isThinking && segmentHasToolUse) {
-        segments.push(current);
-        current = [block];
-        segmentHasToolUse = false;
-      } else {
-        current.push(block);
-        if (isToolUseBlock(block)) {
-          segmentHasToolUse = true;
-        }
-      }
-    }
-    if (current.length > 0) {
-      segments.push(current);
-    }
-
-    // Build a map of tool_results from the following user message (if any)
-    const nextMsg = messages[mi + 1];
-    const nextIsUser = nextMsg && nextMsg.role === "user";
-    const nextContent =
-      nextIsUser && Array.isArray(nextMsg.content) ? nextMsg.content : [];
-    const toolResultMap = new Map<string, Anthropic.ContentBlockParam>();
-    const nonToolResultContent: Anthropic.ContentBlockParam[] = [];
-    for (const block of nextContent) {
-      if (isToolResultBlock(block)) {
-        toolResultMap.set(block.tool_use_id, block);
-      } else {
-        nonToolResultContent.push(block);
-      }
-    }
-
-    // Emit each segment as assistant→user pairs, distributing tool_results
-    for (let si = 0; si < segments.length; si++) {
-      const segment = segments[si];
-      const segToolUseIds = getOrderedToolUseIds(segment);
-      const isLastSegment = si === segments.length - 1;
-
-      result.push({ role: "assistant" as const, content: segment });
-
-      if (segToolUseIds.length > 0 && !isLastSegment) {
-        // Intermediate segment: pair with matching tool_results
-        const segResults = segToolUseIds.map(
-          (id) => toolResultMap.get(id) ?? buildSyntheticToolResult(id),
-        );
-        // Remove matched results from the map
-        for (const id of segToolUseIds) toolResultMap.delete(id);
-        result.push({ role: "user" as const, content: segResults });
-      }
-    }
-
-    // For the last segment, let ensureToolPairing handle pairing with the
-    // (now reduced) user message. Rebuild the user message without the
-    // tool_results that were already distributed to intermediate segments.
-    if (nextIsUser) {
-      const remainingResults = Array.from(toolResultMap.values());
-      const rebuiltUserContent = [...remainingResults, ...nonToolResultContent];
-      // Replace the original user message with the rebuilt one
-      result.push({
-        role: "user" as const,
-        content:
-          rebuiltUserContent.length > 0
-            ? rebuiltUserContent
-            : [{ type: "text" as const, text: "(continue)" }],
-      });
-      mi++; // skip the original user message
-    }
-  }
-
-  return result;
-}
-
 function splitAssistantForToolPairing(content: Anthropic.ContentBlockParam[]): {
   pairedContent: Anthropic.ContentBlockParam[];
   carryoverContent: Anthropic.ContentBlockParam[];
@@ -574,16 +455,26 @@ function ensureToolPairing(
           role: "assistant" as const,
           content: carryoverContent,
         });
-        // Always emit a trailing user message to maintain alternation, even if the
-        // original user turn had only tool_result blocks. Use a synthetic placeholder
-        // when remainingContent is empty.
-        result.push({
-          role: "user" as const,
-          content:
-            normalized.remainingContent.length > 0
-              ? normalized.remainingContent
-              : [{ type: "text" as const, text: "(continue)" }],
-        });
+        // Emit a trailing user message when there is remaining content, or when
+        // alternation requires it (next message is assistant or end of array).
+        // Skip the synthetic placeholder if the next message is already a user
+        // turn — it will naturally maintain alternation.
+        if (normalized.remainingContent.length > 0) {
+          result.push({
+            role: "user" as const,
+            content: normalized.remainingContent,
+          });
+        } else {
+          const nextAfterPair = messages[i + 2];
+          if (!nextAfterPair || nextAfterPair.role !== "user") {
+            result.push({
+              role: "user" as const,
+              content: [
+                { type: "text" as const, text: SYNTHETIC_CONTINUATION_TEXT },
+              ],
+            });
+          }
+        }
       } else {
         // No carryover assistant text to restore, so preserve existing behavior
         // and keep additional user blocks in the same message.
@@ -678,7 +569,7 @@ export class AnthropicProvider implements Provider {
     this.client = new Anthropic({ apiKey, baseURL: options.baseURL });
     this.model = model;
     this.useNativeWebSearch = options.useNativeWebSearch ?? false;
-    this.streamTimeoutMs = options.streamTimeoutMs ?? 300_000;
+    this.streamTimeoutMs = options.streamTimeoutMs ?? 1_800_000;
   }
 
   async sendMessage(
@@ -688,6 +579,7 @@ export class AnthropicProvider implements Provider {
     options?: SendMessageOptions,
   ): Promise<ProviderResponse> {
     const { config, onEvent, signal } = options ?? {};
+    const cacheTtl: "5m" | "1h" = ((config as Record<string, unknown> | undefined)?.cacheTtl as "5m" | "1h") ?? "1h";
     let sentMessages: Anthropic.MessageParam[] | undefined;
     try {
       const formatted = messages
@@ -791,58 +683,13 @@ export class AnthropicProvider implements Provider {
         }
       }
 
-      // Strip thinking/redacted_thinking blocks from historical assistant
-      // messages. These blocks carry cryptographic signatures tied to their
-      // original API response. Consolidated messages (from multi-step tool use)
-      // combine thinking blocks from different responses, making signature
-      // validation fail with "thinking blocks cannot be modified". Stripping is
-      // safe: the API allows it for all historical messages, and new responses
-      // generate fresh thinking blocks.
-      //
-      // The latest assistant turn is preserved: the API requires the most recent
-      // assistant message's thinking blocks to be passed back unmodified when
-      // sending tool results during in-progress tool-use loops.
-      let lastAssistantIdx = -1;
-      for (let i = formatted.length - 1; i >= 0; i--) {
-        if (formatted[i].role === "assistant") {
-          lastAssistantIdx = i;
-          break;
-        }
-      }
-      for (let i = 0; i < formatted.length; i++) {
-        const msg = formatted[i];
-        if (msg.role !== "assistant" || !Array.isArray(msg.content)) continue;
-        if (i === lastAssistantIdx) continue;
-        const stripped = msg.content.filter(
-          (b) =>
-            (b as { type: string }).type !== "thinking" &&
-            (b as { type: string }).type !== "redacted_thinking",
-        );
-        if (stripped.length < msg.content.length) {
-          // Ensure the message isn't empty after stripping
-          msg.content =
-            stripped.length > 0
-              ? stripped
-              : [
-                  {
-                    type: "text" as const,
-                    text: PLACEHOLDER_BLOCKS_OMITTED,
-                  },
-                ];
-        }
-      }
+      // Thinking blocks are stripped at rest by DB migration 209 so
+      // historical messages are clean when loaded. Within a turn,
+      // assistant messages have original thinking with valid signatures
+      // — the API accepts them. No provider-side stripping needed.
 
-      // Expand collapsed multi-turn assistant messages. When agentic tool use
-      // produces multiple thinking→tool_use cycles in a single stored message,
-      // the API rejects thinking blocks between tool_use blocks. Split such
-      // messages at each "thinking after tool_use" boundary to recreate the
-      // original multi-turn structure. With thinking blocks stripped above, the
-      // expansion is typically a no-op, but is kept as a safety net for edge
-      // cases where stripping is incomplete.
-      const expanded = expandCollapsedAssistantTurns(formatted);
-
-      sentMessages = ensureToolPairing(repairOrphanedServerToolUse(expanded));
-      const { effort, speed, output_config, ...restConfig } = (config ??
+      sentMessages = ensureToolPairing(repairOrphanedServerToolUse(formatted));
+      const { effort, speed, output_config, cacheTtl: _cacheTtl, ...restConfig } = (config ??
         {}) as Record<string, unknown> & {
         effort?: Anthropic.OutputConfig["effort"];
         speed?: "standard" | "fast";
@@ -886,12 +733,12 @@ export class AnthropicProvider implements Provider {
             {
               type: "text" as const,
               text: staticBlock,
-              cache_control: { type: "ephemeral" as const, ttl: "1h" as const },
+              cache_control: { type: "ephemeral" as const, ttl: cacheTtl },
             },
             {
               type: "text" as const,
               text: dynamicBlock,
-              cache_control: { type: "ephemeral" as const, ttl: "1h" as const },
+              cache_control: { type: "ephemeral" as const, ttl: cacheTtl },
             },
           ];
         } else {
@@ -899,7 +746,7 @@ export class AnthropicProvider implements Provider {
             {
               type: "text" as const,
               text: systemPrompt,
-              cache_control: { type: "ephemeral" as const, ttl: "1h" as const },
+              cache_control: { type: "ephemeral" as const, ttl: cacheTtl },
             },
           ];
         }
@@ -916,7 +763,12 @@ export class AnthropicProvider implements Provider {
             description: t.description,
             input_schema: t.input_schema as Anthropic.Tool["input_schema"],
             ...(i === otherTools.length - 1
-              ? { cache_control: { type: "ephemeral" as const, ttl: "1h" as const } }
+              ? {
+                  cache_control: {
+                    type: "ephemeral" as const,
+                    ttl: cacheTtl,
+                  },
+                }
               : {}),
           }));
           const webSearchTool: Anthropic.WebSearchTool20250305 = {
@@ -931,41 +783,98 @@ export class AnthropicProvider implements Provider {
             description: t.description,
             input_schema: t.input_schema as Anthropic.Tool["input_schema"],
             ...(i === tools.length - 1
-              ? { cache_control: { type: "ephemeral" as const, ttl: "1h" as const } }
+              ? {
+                  cache_control: {
+                    type: "ephemeral" as const,
+                    ttl: cacheTtl,
+                  },
+                }
               : {}),
           }));
         }
       }
 
-      // Place a cache breakpoint on the second-to-last user turn so the
-      // conversation prefix is cached between agent-loop iterations.
-      //
-      // Why second-to-last, not last?  The last user message is always new
-      // (either the initial message with fresh temporal context, or a tool
-      // result appended by the agent loop) so its breakpoint never produces
-      // a cache hit.  The second-to-last user turn is stable between
-      // iterations and caching up to it saves re-processing the full
-      // conversation prefix.
-      //
-      // We use only 1 user-turn breakpoint to stay within the Anthropic
-      // API limit of 4 cache_control blocks total:
-      //   system-static (1) + system-dynamic (2) + last-tool (3) + user (4)
-      const userIndices: number[] = [];
-      for (let i = 0; i < params.messages.length; i++) {
-        if (params.messages[i].role === "user") userIndices.push(i);
+      // Manual cache breakpoint on the turn-starting user message.
+      // This is the stable anchor for the current turn — everything up to
+      // and including it won't change during tool-use iterations, so a long
+      // TTL is appropriate. Walk backwards to find the last user message
+      // with a real text block (skipping tool_result-only messages and
+      // synthetic continuation placeholders injected by ensureToolPairing).
+      let turnStartIdx = -1;
+      for (let i = sentMessages.length - 1; i >= 0; i--) {
+        const msg = sentMessages[i];
+        if (msg.role !== "user" || !Array.isArray(msg.content)) continue;
+        const hasText = msg.content.some(
+          (b) =>
+            typeof b !== "string" &&
+            b.type === "text" &&
+            b.text !== SYNTHETIC_CONTINUATION_TEXT,
+        );
+        if (!hasText) continue;
+        const lastBlock = msg.content[msg.content.length - 1];
+        if (typeof lastBlock !== "string") {
+          (lastBlock as unknown as Record<string, unknown>).cache_control = {
+            type: "ephemeral",
+            ttl: cacheTtl,
+          };
+        }
+        turnStartIdx = i;
+        break;
       }
-      // slice(-2, -1) gives the second-to-last; empty array if < 2 user turns.
-      for (const idx of userIndices.slice(-2, -1)) {
-        const content = params.messages[idx].content;
-        if (Array.isArray(content) && content.length > 0) {
-          (
-            content[content.length - 1] as unknown as {
-              cache_control?: { type: string; ttl?: string };
+
+      // Advancing tail: place a short-lived 5m cache breakpoint on the last
+      // block of the last message when it falls after the turn-starting user
+      // message (i.e. tool-use loop content). This caches the growing tail
+      // cheaply without conflicting with the 1h breakpoints above.
+      // Skip thinking/redacted_thinking blocks — Anthropic doesn't allow
+      // cache_control on those types.
+      let tailBreakpointApplied = false;
+      if (turnStartIdx >= 0 && turnStartIdx < sentMessages.length - 1) {
+        const lastMsg = sentMessages[sentMessages.length - 1];
+        if (Array.isArray(lastMsg.content) && lastMsg.content.length > 0) {
+          const NON_CACHEABLE_TYPES = new Set(["thinking", "redacted_thinking"]);
+          let tailBlock: (typeof lastMsg.content)[number] | undefined;
+          for (let j = lastMsg.content.length - 1; j >= 0; j--) {
+            const block = lastMsg.content[j];
+            if (
+              typeof block !== "string" &&
+              !NON_CACHEABLE_TYPES.has((block as { type: string }).type)
+            ) {
+              tailBlock = block;
+              break;
             }
-          ).cache_control = { type: "ephemeral", ttl: "1h" };
+          }
+          if (tailBlock && typeof tailBlock !== "string") {
+            (tailBlock as unknown as Record<string, unknown>).cache_control = {
+              type: "ephemeral",
+              ttl: "5m",
+            };
+            tailBreakpointApplied = true;
+          }
         }
       }
 
+      // Enforce Anthropic API maximum of 4 cache_control blocks.
+      // When the system prompt boundary splits into 2 cached blocks AND
+      // tools + turn-start + advancing-tail breakpoints are all present,
+      // we'd have 5.  Drop the static system block's breakpoint — it's
+      // small (<1K tokens) so the re-read cost is negligible, while the
+      // dynamic block (workspace context) rarely changes mid-session and
+      // benefits more from caching.
+      const hasTailBreakpoint = tailBreakpointApplied;
+      const hasToolCacheBreakpoint =
+        params.tools?.some(
+          (t) => "cache_control" in t && t.cache_control != null,
+        ) ?? false;
+      if (
+        hasTailBreakpoint &&
+        Array.isArray(params.system) &&
+        params.system.length === 2 &&
+        hasToolCacheBreakpoint
+      ) {
+        delete (params.system[0] as unknown as Record<string, unknown>).cache_control;
+      }
+
       const { signal: timeoutSignal, cleanup: cleanupTimeout } =
         createStreamTimeout(this.streamTimeoutMs, signal);
 
@@ -982,8 +891,7 @@ export class AnthropicProvider implements Provider {
       }
 
       // Fast mode: use the beta endpoint with speed: "fast" for Opus 4.6
-      const useFastMode =
-        speed === "fast" && effectiveModel.includes("opus");
+      const useFastMode = speed === "fast" && effectiveModel.includes("opus");
 
       // Collect required betas: extended cache TTL for 1h system prompt caching,
       // 1M context window, and fast-mode when applicable.
@@ -1170,6 +1078,14 @@ export class AnthropicProvider implements Provider {
             "Anthropic 400: tool_use/tool_result pairing error — dumping message structure",
           );
         }
+        log.error(
+          {
+            status: error.status,
+            message: error.message,
+            headers: Object.fromEntries(error.headers?.entries() ?? []),
+          },
+          `Anthropic API error (${error.status})`,
+        );
         const retryAfterMs = extractRetryAfterMs(error.headers);
         throw new ProviderError(
           `Anthropic API error (${error.status}): ${error.message}`,

package/src/providers/gemini/client.ts

@@ -89,7 +89,7 @@ export class GeminiProvider implements Provider {
         })
       : new GoogleGenAI({ apiKey });
     this.model = model;
-    this.streamTimeoutMs = options.streamTimeoutMs ?? 300_000;
+    this.streamTimeoutMs = options.streamTimeoutMs ?? 1_800_000;
   }
 
   async sendMessage(

package/src/providers/openai/client.ts

@@ -112,7 +112,7 @@ export class OpenAIProvider implements Provider {
       baseURL: options.baseURL,
     });
     this.model = model;
-    this.streamTimeoutMs = options.streamTimeoutMs ?? 300_000;
+    this.streamTimeoutMs = options.streamTimeoutMs ?? 1_800_000;
     this.extraCreateParams = options.extraCreateParams ?? {};
   }
 

package/src/providers/registry.ts

@@ -140,7 +140,7 @@ export async function initializeProviders(
   routingSources.clear();
 
   const streamTimeoutMs =
-    (config.timeouts?.providerStreamTimeoutSec ?? 300) * 1000;
+    (config.timeouts?.providerStreamTimeoutSec ?? 1800) * 1000;
   const inferenceMode = config.services.inference.mode;
   const useNativeWebSearch =
     config.services["web-search"].provider === "inference-provider-native";

package/src/providers/retry.ts

@@ -34,16 +34,30 @@ const RETRYABLE_STREAM_PATTERNS = [
   "stream has ended, this shouldn't happen",
 ];
 
+/**
+ * Patterns that indicate a transient provider error even when no HTTP status
+ * code is available (e.g. overloaded errors delivered as SSE events mid-stream
+ * where the initial HTTP response was 200).
+ */
+const RETRYABLE_PROVIDER_MESSAGE_PATTERNS = [/overloaded/i];
+
 function isRetryableStreamError(error: unknown): boolean {
   if (!(error instanceof ProviderError)) return false;
   if (error.statusCode !== undefined) return false; // has a real HTTP status — not a stream error
   return RETRYABLE_STREAM_PATTERNS.some((p) => error.message.includes(p));
 }
 
+function isRetryableProviderMessage(error: unknown): boolean {
+  if (!(error instanceof ProviderError)) return false;
+  if (error.statusCode !== undefined) return false; // has a real HTTP status — handled by status check
+  return RETRYABLE_PROVIDER_MESSAGE_PATTERNS.some((p) => p.test(error.message));
+}
+
 function isRetryableError(error: unknown): boolean {
   if (error instanceof ProviderError && error.statusCode !== undefined) {
     if (error.statusCode === 429 || error.statusCode >= 500) return true;
   }
+  if (isRetryableProviderMessage(error)) return true;
   if (isRetryableStreamError(error)) return true;
   return isRetryableNetworkError(error);
 }
@@ -161,9 +175,11 @@ export class RetryProvider implements Provider {
                   error.statusCode !== undefined &&
                   error.statusCode >= 500
                 ? `server_error_${error.statusCode}`
-                : isRetryableStreamError(error)
-                  ? "stream_corruption"
-                  : "network_error";
+                : isRetryableProviderMessage(error)
+                  ? "provider_overloaded"
+                  : isRetryableStreamError(error)
+                    ? "stream_corruption"
+                    : "network_error";
           log.warn(
             {
               attempt: attempt + 1,

package/src/runtime/actor-trust-resolver.ts

@@ -48,7 +48,11 @@ export type TrustClass = "guardian" | "trusted_contact" | "unknown";
 export function isUntrustedTrustClass(
   trustClass: TrustClass | undefined,
 ): boolean {
-  return trustClass === "trusted_contact" || trustClass === "unknown";
+  return (
+    trustClass === "trusted_contact" ||
+    trustClass === "unknown" ||
+    trustClass === undefined
+  );
 }
 
 /**