@vellumai/assistant 0.7.3 → 0.8.1

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

@@ -118,6 +118,12 @@ export interface EventHandlerState {
   orderingErrorDetected: boolean;
   deferredOrderingError: string | null;
   contextTooLargeDetected: boolean;
+  /**
+   * Set when the provider rejects with an image-dimension error. The agent
+   * loop strips or downscales oversized image blocks from ctx.messages and
+   * retries once before surfacing an error to the user.
+   */
+  imageTooLargeDetected: boolean;
   /**
    * The provider error object when context_too_large is detected, preserved
    * so `parseActualTokensFromError` can prefer the typed
@@ -127,6 +133,11 @@ export interface EventHandlerState {
    */
   contextTooLargeError: unknown;
   providerErrorUserMessage: string | null;
+  /**
+   * First persisted assistant row in this run; history keeps this id when it
+   * merges tool-turn rows into one display bubble.
+   */
+  firstAssistantMessageId: string | undefined;
   lastAssistantMessageId: string | undefined;
   readonly pendingToolResults: Map<string, PendingToolResult>;
   readonly persistedToolUseIds: Set<string>;
@@ -170,6 +181,16 @@ export interface EventHandlerState {
       approvalMode?: string;
       approvalReason?: string;
       riskThreshold?: string;
+      /** Display-only regex ladder for the rule editor (narrowest → broadest). */
+      riskScopeOptions?: Array<{ pattern: string; label: string }>;
+      /** Minimatch save patterns for the rule editor (narrowest → broadest). */
+      riskAllowlistOptions?: Array<{
+        label: string;
+        description: string;
+        pattern: string;
+      }>;
+      /** Directory scope ladder for the rule editor. */
+      riskDirectoryScopeOptions?: Array<{ scope: string; label: string }>;
     }
   >;
   /** tool_use_ids emitted in the current turn (populated in handleToolUse, cleared after annotation). */
@@ -210,8 +231,10 @@ export function createEventHandlerState(): EventHandlerState {
     orderingErrorDetected: false,
     deferredOrderingError: null,
     contextTooLargeDetected: false,
+    imageTooLargeDetected: false,
     contextTooLargeError: null,
     providerErrorUserMessage: null,
+    firstAssistantMessageId: undefined,
     lastAssistantMessageId: undefined,
     pendingToolResults: new Map(),
     persistedToolUseIds: new Set(),
@@ -235,6 +258,12 @@ export function createEventHandlerState(): EventHandlerState {
   };
 }
 
+export function getClientDisplayMessageId(
+  state: EventHandlerState,
+): string | undefined {
+  return state.firstAssistantMessageId ?? state.lastAssistantMessageId;
+}
+
 // ── Shared Helper ────────────────────────────────────────────────────
 
 // providerNameOverride should be supplied when the caller already knows the
@@ -554,6 +583,14 @@ export function handleToolResult(
       approvalMode: event.approvalMode,
       approvalReason: event.approvalReason,
       riskThreshold: event.riskThreshold,
+      // Capture the 3 risk-option arrays so the persisted tool_use block
+      // carries the same chip ladder as the live tool_result event. Without
+      // these, hydrated chips from chat history fall back to the synthesized
+      // `*` allowlist and an empty scope ladder (see the comment on
+      // `synthesizeFallbackOption` in web's RuleEditorModal).
+      riskScopeOptions: event.riskScopeOptions,
+      riskAllowlistOptions: event.riskAllowlistOptions,
+      riskDirectoryScopeOptions: event.riskDirectoryScopeOptions,
     });
   }
 
@@ -633,6 +670,7 @@ export function handleToolResult(
     matchedTrustRuleId: event.matchedTrustRuleId,
     isContainerized: event.isContainerized,
     riskScopeOptions: event.riskScopeOptions,
+    riskAllowlistOptions: event.riskAllowlistOptions,
     riskDirectoryScopeOptions: event.riskDirectoryScopeOptions,
     approvalMode: event.approvalMode,
     approvalReason: event.approvalReason,
@@ -694,6 +732,19 @@ function annotatePersistedAssistantMessage(
         if (risk.approvalMode) rec._approvalMode = risk.approvalMode;
         if (risk.approvalReason) rec._approvalReason = risk.approvalReason;
         if (risk.riskThreshold) rec._riskThreshold = risk.riskThreshold;
+        // Persist the 3 risk-option arrays so the rule editor's chip ladder
+        // survives chat-history reload. These mirror the same-named fields
+        // on the live `tool_result` event; clients should read them back via
+        // `shared.ts` and treat them identically to the live values.
+        if (risk.riskScopeOptions && risk.riskScopeOptions.length > 0)
+          rec._riskScopeOptions = risk.riskScopeOptions;
+        if (risk.riskAllowlistOptions && risk.riskAllowlistOptions.length > 0)
+          rec._riskAllowlistOptions = risk.riskAllowlistOptions;
+        if (
+          risk.riskDirectoryScopeOptions &&
+          risk.riskDirectoryScopeOptions.length > 0
+        )
+          rec._riskDirectoryScopeOptions = risk.riskDirectoryScopeOptions;
         modified = true;
       }
     }
@@ -749,6 +800,10 @@ function handleError(
     if (classified.code === "CONTEXT_TOO_LARGE") {
       state.contextTooLargeDetected = true;
       state.contextTooLargeError = event.error;
+    } else if (classified.code === "IMAGE_TOO_LARGE") {
+      // Trigger silent recovery: the agent loop will strip/downscale images
+      // in ctx.messages and retry once before surfacing an error.
+      state.imageTooLargeDetected = true;
     } else if (
       classified.code === "PROVIDER_ORDERING" ||
       classified.code === "PROVIDER_WEB_SEARCH"
@@ -972,6 +1027,7 @@ export async function handleMessageComplete(
     DEFAULT_TIMEOUTS.persistence,
   )) as PersistAddResult;
   const assistantMsg = assistantPersistResult.message;
+  state.firstAssistantMessageId ??= assistantMsg.id;
   state.lastAssistantMessageId = assistantMsg.id;
 
   // Backfill message_id on all LLM request logs from this turn.

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

@@ -11,6 +11,7 @@ import { join } from "node:path";
 
 import { v4 as uuid } from "uuid";
 
+import { optimizeImageForTransport } from "../agent/image-optimize.js";
 import type {
   AgentEvent,
   AgentLoop,
@@ -28,6 +29,7 @@ import {
   contextWindowConfigFromEffective,
   resolveEffectiveContextWindow,
 } from "../config/llm-context-resolution.js";
+import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import { getConfig } from "../config/loader.js";
 import type { LLMCallSite } from "../config/schemas/llm.js";
 import type { ContextWindowConfig } from "../config/types.js";
@@ -41,9 +43,7 @@ import {
 } from "../context/token-estimator.js";
 import type { ContextWindowManager } from "../context/window-manager.js";
 import type { ToolProfiler } from "../events/tool-profiling-listener.js";
-import { emitFeedEvent } from "../home/emit-feed-event.js";
 import { writeRelationshipState } from "../home/relationship-state-writer.js";
-import { rewriteFeedTitle } from "../home/rewrite-feed-title.js";
 import {
   clearSentryConversationContext,
   setSentryConversationContext,
@@ -71,11 +71,12 @@ import {
 } from "../memory/conversation-title-service.js";
 import type { ConversationGraphMemory } from "../memory/graph/conversation-graph-memory.js";
 import { recordMemoryRecallLog } from "../memory/memory-recall-log-store.js";
+import { enqueueMemoryRetrospectiveOnCompaction } from "../memory/memory-retrospective-enqueue.js";
 import { PKB_WORKSPACE_SCOPE } from "../memory/pkb/types.js";
 import type { QdrantSparseVector } from "../memory/qdrant-client.js";
 import {
   readMemoryV2StaticContent,
-  shouldLoadMemoryV2Static,
+  shouldExposePersonalMemory,
 } from "../memory/v2/static-context.js";
 import type { PermissionPrompter } from "../permissions/prompter.js";
 import { defaultCompactionTerminal } from "../plugins/defaults/compaction.js";
@@ -147,6 +148,7 @@ import {
   createEventHandlerState,
   dispatchAgentEvent,
   type EventHandlerDeps,
+  getClientDisplayMessageId,
 } from "./conversation-agent-loop-handlers.js";
 import {
   approveHostAttachmentRead,
@@ -679,7 +681,9 @@ export async function runAgentLoopImpl(
     overrideProfile: turnOverrideProfile ?? undefined,
   });
   const turnContextWindowConfig = contextWindowConfigFromEffective(
-    config.llm.default.contextWindow,
+    resolveCallSiteConfig(turnCallSite, config.llm, {
+      overrideProfile: turnOverrideProfile ?? undefined,
+    }).contextWindow,
     effectiveContextWindow,
   );
   (
@@ -986,7 +990,7 @@ export async function runAgentLoopImpl(
         compactableStartIndex: 1,
       };
     };
-    const applySuccessfulCompaction = (
+    const applySuccessfulCompaction = async (
       result: Awaited<ReturnType<typeof ctx.contextWindowManager.maybeCompact>>,
       compactedBasis?: Message[],
     ) => {
@@ -1000,7 +1004,7 @@ export async function runAgentLoopImpl(
         provenanceContext,
         result.compactedMessages,
       );
-      applyCompactionResult(ctx, result, onEvent, reqId, {
+      await applyCompactionResult(ctx, result, onEvent, reqId, {
         slackContextCompactionWatermarkTs: slackWatermarkTs,
       });
       currentSlackContextSummary = result.summaryText;
@@ -1087,7 +1091,10 @@ export async function runAgentLoopImpl(
       await trackCompactionOutcome(ctx, compacted.summaryFailed, onEvent);
     }
     if (compacted?.compacted) {
-      applySuccessfulCompaction(compacted, messagesForStartOfTurnCompaction);
+      await applySuccessfulCompaction(
+        compacted,
+        messagesForStartOfTurnCompaction,
+      );
       shouldInjectWorkspace = true;
       if (compacted.compactedPersistedMessages > 0) {
         compactedThisTurn = true;
@@ -1408,33 +1415,44 @@ export async function runAgentLoopImpl(
 
     // The `remember` tool handles scratchpad-style memory writes directly to the graph.
 
+    // Personal-memory trust gate: PKB, NOW.md, and v2 static blocks all
+    // hold private user content. Block exposure to non-guardian actors
+    // arriving over a remote channel; internal/local flows pass through.
+    // See `shouldExposePersonalMemory` for the threat model.
+    const personalMemoryAllowed = shouldExposePersonalMemory({
+      sourceChannel: ctx.trustContext?.sourceChannel,
+      isTrustedActor,
+    });
+
     // 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.
     // PKB/NOW content is sourced from the `memoryRetrieval` pipeline above
     // so plugins can override either source without touching the agent loop.
-    const currentNowContent = memoryResult.nowContent;
+    const currentNowContent = personalMemoryAllowed
+      ? memoryResult.nowContent
+      : null;
     const shouldInjectNowAndPkb = isFirstMessage || compactedThisTurn;
     const nowScratchpad = shouldInjectNowAndPkb ? currentNowContent : null;
 
-    const currentPkbContent = memoryResult.pkbContent;
+    const currentPkbContent = personalMemoryAllowed
+      ? memoryResult.pkbContent
+      : null;
     const pkbContext = shouldInjectNowAndPkb ? currentPkbContent : null;
     const pkbActive = currentPkbContent !== null;
 
-    // V2 static memory block (essentials/threads/recent/buffer). Same
-    // 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,
-    })
+    // V2 static memory block (essentials/threads/recent/buffer).
+    // `currentMemoryV2Static` is the trust-gated content reused by every
+    // re-injection path — it stays non-null on non-full-mode turns so
+    // that mid-turn reducer compaction (which strips the prior `<memory>`
+    // block) can restore the freshest content. `memoryV2Static` is the
+    // first-turn / post-compaction cadence-gated value for initial
+    // injection only. `readMemoryV2StaticContent` self-gates on the v2
+    // flag + config and returns null when v2 is off.
+    const currentMemoryV2Static = personalMemoryAllowed
       ? readMemoryV2StaticContent()
       : null;
-    const memoryV2Static = currentMemoryV2Static;
+    const memoryV2Static = shouldInjectNowAndPkb ? currentMemoryV2Static : null;
 
     // PKB relevance-hint inputs. Resolved once per turn and reused across
     // re-injections so post-compaction rebuilds pick up fresh hints against
@@ -1572,7 +1590,8 @@ export async function runAgentLoopImpl(
       injection.blocks.pkbSystemReminder ||
       injection.blocks.workspaceBlock ||
       injection.blocks.nowScratchpadBlock ||
-      injection.blocks.pkbContextBlock
+      injection.blocks.pkbContextBlock ||
+      injection.blocks.memoryV2StaticBlock
     ) {
       try {
         const metadataUpdates: Record<string, unknown> = {};
@@ -1594,6 +1613,10 @@ export async function runAgentLoopImpl(
         if (injection.blocks.pkbContextBlock) {
           metadataUpdates.pkbContextBlock = injection.blocks.pkbContextBlock;
         }
+        if (injection.blocks.memoryV2StaticBlock) {
+          metadataUpdates.memoryV2StaticBlock =
+            injection.blocks.memoryV2StaticBlock;
+        }
         await runPipeline<PersistArgs, PersistResult>(
           "persistence",
           getMiddlewaresFor("persistence"),
@@ -1790,7 +1813,7 @@ export async function runAgentLoopImpl(
             await trackCompactionOutcome(ctx, result.summaryFailed, onEvent);
           }
           if (result.compacted) {
-            applySuccessfulCompaction(result, compactedBasis);
+            await applySuccessfulCompaction(result, compactedBasis);
             shouldInjectWorkspace = true;
           }
         },
@@ -2119,7 +2142,7 @@ export async function runAgentLoopImpl(
         );
       }
       if (midLoopCompact.compacted) {
-        applySuccessfulCompaction(midLoopCompact, rawHistory);
+        await applySuccessfulCompaction(midLoopCompact, rawHistory);
         reducerCompacted = true;
         shouldInjectWorkspace = true;
       }
@@ -2237,6 +2260,83 @@ export async function runAgentLoopImpl(
       }
     }
 
+    // ── Image-dimension overflow recovery ──────────────────────────
+    // When the provider rejects because an image block exceeds its pixel
+    // cap, strip every image block from ctx.messages and retry once.
+    // optimizeImageForTransport already ran at upload time; if sips was
+    // unavailable (non-macOS) it returns the same bytes unchanged.  In
+    // that case we swap the block for a text note so the model can tell
+    // the user what happened instead of hard-failing with a red banner.
+    if (state.imageTooLargeDetected) {
+      state.imageTooLargeDetected = false;
+      rlog.warn(
+        { phase: "image-recovery" },
+        "Image too large — stripping oversized image blocks and retrying",
+      );
+      ctx.messages = ctx.messages.map((msg) => {
+        if (!Array.isArray(msg.content)) return msg;
+        if (!msg.content.some((b) => b.type === "image")) return msg;
+        return {
+          ...msg,
+          content: msg.content.flatMap((b): ContentBlock[] => {
+            if (b.type !== "image") return [b];
+            const resized = optimizeImageForTransport(
+              b.source.data,
+              b.source.media_type,
+            );
+            if (resized.data !== b.source.data) {
+              // sips managed to downscale — use the smaller version
+              return [
+                {
+                  ...b,
+                  source: {
+                    type: "base64" as const,
+                    media_type: resized.mediaType,
+                    data: resized.data,
+                  },
+                },
+              ];
+            }
+            // Can't resize — replace with a text annotation so the model
+            // can explain the situation rather than silently dropping context
+            return [
+              {
+                type: "text" as const,
+                text: "(An image was attached but could not be sent — its dimensions exceed the provider limit and automatic resize was not available. Please resize the image and try again.)",
+              },
+            ];
+          }),
+        };
+      });
+      runMessages = ctx.messages;
+      updatedHistory = await ctx.agentLoop.run(
+        runMessages,
+        eventHandler,
+        abortController.signal,
+        reqId,
+        onCheckpoint,
+        turnCallSite,
+        loopTurnCtx,
+        turnOverrideProfile,
+        effectiveContextWindow.maxInputTokens,
+      );
+      if (state.imageTooLargeDetected) {
+        rlog.error(
+          { phase: "image-recovery" },
+          "Image-recovery retry also failed — surfacing error to user",
+        );
+        const classified = classifyConversationError(
+          new Error("Image dimensions too large"),
+          { phase: "agent_loop" },
+        );
+        deps.onEvent(
+          buildConversationErrorMessage(deps.ctx.conversationId, classified),
+        );
+        state.providerErrorUserMessage = classified.userMessage;
+        state.imageTooLargeDetected = false;
+      }
+    }
+
     // ── Bounded context overflow convergence loop ──────────────────
     // When the provider rejects with context-too-large, iterate through
     // reducer tiers (forced compaction, tool-result truncation, media
@@ -2371,7 +2471,7 @@ export async function runAgentLoopImpl(
         }
 
         if (step.compactionResult?.compacted) {
-          applySuccessfulCompaction(
+          await applySuccessfulCompaction(
             step.compactionResult,
             convergenceCompactionBasis,
           );
@@ -2537,7 +2637,7 @@ export async function runAgentLoopImpl(
             );
           }
           if (emergencyCompact?.compacted) {
-            applySuccessfulCompaction(emergencyCompact, ctx.messages);
+            await applySuccessfulCompaction(emergencyCompact, ctx.messages);
             reducerCompacted = true;
             shouldInjectWorkspace = true;
           }
@@ -2831,6 +2931,7 @@ export async function runAgentLoopImpl(
       ctx.lastAssistantAttachments = assistantAttachments;
       ctx.lastAttachmentWarnings = attachmentResult.directiveWarnings;
       syncLastAssistantMessageToDisk();
+      const clientDisplayMessageId = getClientDisplayMessageId(state);
 
       // Re-check: the user may have cancelled during attachment resolution
       if (abortController.signal.aborted) {
@@ -2871,6 +2972,9 @@ export async function runAgentLoopImpl(
           ...(state.lastAssistantMessageId
             ? { messageId: state.lastAssistantMessageId }
             : {}),
+          ...(clientDisplayMessageId
+            ? { displayMessageId: clientDisplayMessageId }
+            : {}),
         });
       } else {
         ctx.emitActivityState("idle", "message_complete", "global", reqId);
@@ -2894,86 +2998,11 @@ export async function runAgentLoopImpl(
           ...(state.lastAssistantMessageId
             ? { messageId: state.lastAssistantMessageId }
             : {}),
+          ...(clientDisplayMessageId
+            ? { displayMessageId: clientDisplayMessageId }
+            : {}),
         });
 
-        // Emit a home-feed event for background/scheduled conversation completions.
-        // Scoped to message_complete only (not cancelled/handoff), wrapped in
-        // try-catch so malformed message content can never propagate errors.
-        try {
-          const conv = getConversation(ctx.conversationId);
-          if (
-            conv &&
-            (conv.conversationType === "background" ||
-              conv.conversationType === "scheduled")
-          ) {
-            const lastMsg = state.lastAssistantMessageId
-              ? getMessageById(state.lastAssistantMessageId, ctx.conversationId)
-              : undefined;
-            let summary: string;
-            if (lastMsg) {
-              const parsed: unknown = JSON.parse(lastMsg.content);
-              if (typeof parsed === "string") {
-                summary = parsed.slice(0, 200);
-              } else if (Array.isArray(parsed)) {
-                const textBlock = parsed.find(
-                  (b: { type?: string }) => b.type === "text",
-                );
-                summary =
-                  typeof textBlock?.text === "string"
-                    ? textBlock.text.slice(0, 200)
-                    : (conv.title ?? "Background task completed.");
-              } else {
-                summary = conv.title ?? "Background task completed.";
-              }
-            } else {
-              summary = conv.title ?? "Background task completed.";
-            }
-            const feedTitle =
-              conv.title && !isReplaceableTitle(conv.title)
-                ? conv.title
-                : "Background task";
-            const dedupKey = `bg-conv:${ctx.conversationId}`;
-            void emitFeedEvent({
-              source: "assistant",
-              title: feedTitle,
-              summary,
-              dedupKey,
-              conversationId: ctx.conversationId,
-            }).catch((err) => {
-              log.warn(
-                { err, conversationId: ctx.conversationId },
-                "Failed to emit background conversation feed event",
-              );
-            });
-
-            if (isReplaceableTitle(conv.title ?? null)) {
-              void rewriteFeedTitle(feedTitle)
-                .then((prose) => {
-                  if (prose && prose !== feedTitle) {
-                    return emitFeedEvent({
-                      source: "assistant",
-                      title: prose,
-                      summary,
-                      dedupKey,
-                      conversationId: ctx.conversationId,
-                    });
-                  }
-                })
-                .catch((err) => {
-                  log.warn(
-                    { err, conversationId: ctx.conversationId },
-                    "Failed to update feed event with prose title rewrite",
-                  );
-                });
-            }
-          }
-        } catch (feedErr) {
-          log.warn(
-            { err: feedErr, conversationId: ctx.conversationId },
-            "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).
         {
@@ -3223,7 +3252,7 @@ export interface CompactionApplyContext {
  * truth for the UI indicator after compaction. Emitting both caused a
  * redundant SwiftUI invalidation on every compaction.
  */
-export function applyCompactionResult(
+export async function applyCompactionResult(
   ctx: CompactionApplyContext,
   result: {
     messages: Message[];
@@ -3249,12 +3278,12 @@ export function applyCompactionResult(
   options: {
     slackContextCompactionWatermarkTs?: string | null;
   } = {},
-): void {
+): Promise<void> {
   ctx.messages = result.messages;
   ctx.contextCompactedMessageCount += result.compactedPersistedMessages;
   const compactedAt = Date.now();
   ctx.contextCompactedAt = compactedAt;
-  ctx.graphMemory.onCompacted(result.compactedPersistedMessages);
+  await ctx.graphMemory.onCompacted(result.compactedPersistedMessages);
   updateConversationContextWindow(
     ctx.conversationId,
     result.summaryText,
@@ -3271,6 +3300,10 @@ export function applyCompactionResult(
     ctx.conversationId,
     ctx.trustContext?.trustClass,
   );
+  enqueueMemoryRetrospectiveOnCompaction(
+    ctx.conversationId,
+    ctx.trustContext?.trustClass,
+  );
   const summarySignals = computeSummaryQualitySignals(result.summaryText);
   onEvent({
     type: "context_compacted",

package/src/daemon/conversation-error.ts

@@ -120,6 +120,13 @@ const STREAMING_ERROR_PATTERNS = [
 ];
 
 // User-initiated cancellation patterns — these should NOT produce conversation_error
+// Image-input validation patterns — Anthropic 400s with this message when an image
+// block exceeds the per-side pixel cap. Distinct classification matters because
+// retrying with the same oversized image is futile; the user needs to resize.
+const IMAGE_DIMENSIONS_TOO_LARGE_PATTERNS = [
+  /image dimensions? exceeds? max allowed size/i,
+];
+
 const CANCEL_PATTERNS = [/abort/i, /cancel/i];
 
 /**
@@ -370,6 +377,15 @@ function classifyCore(
           errorCategory: "provider_not_configured",
         };
       }
+      if (isImageDimensionsTooLarge(message)) {
+        return {
+          code: "IMAGE_TOO_LARGE",
+          userMessage:
+            "An attached image is too large for the AI provider — image dimensions must be under 8000 pixels per side. Resize the image and try again.",
+          retryable: false,
+          errorCategory: "image_dimensions_too_large",
+        };
+      }
       return {
         code: "PROVIDER_API",
         userMessage: "The AI provider rejected the request.",
@@ -388,6 +404,11 @@ export function isContextTooLarge(message: string): boolean {
   return CONTEXT_TOO_LARGE_PATTERNS.some((p) => p.test(message));
 }
 
+/** Check whether an error message indicates an image-input dimension failure. */
+function isImageDimensionsTooLarge(message: string): boolean {
+  return IMAGE_DIMENSIONS_TOO_LARGE_PATTERNS.some((p) => p.test(message));
+}
+
 /** Check whether an error message indicates a web-search-specific ordering failure. */
 function isWebSearchOrderingError(message: string): boolean {
   return WEB_SEARCH_ORDERING_PATTERNS.some((p) => p.test(message));