dominds 1.16.3 → 1.16.5

package/dist/dialog-display-state.d.ts

@@ -51,6 +51,7 @@ export declare function broadcastDisplayStateMarker(dialogId: DialogID, marker:
     reason?: DialogInterruptionReason;
 }): void;
 export declare function computeIdleDisplayState(dlg: Dialog): Promise<DialogDisplayState>;
+export declare function refreshRunControlProjectionFromPersistenceFacts(dialogId: DialogID, trigger: 'resume_dialog' | 'resume_all' | 'run_control_snapshot' | 'pending_subdialogs_changed' | 'q4h_changed'): Promise<DialogLatestFile | null>;
 export declare function reconcileDisplayStatesAfterRestart(): Promise<void>;
 export declare function requestInterruptDialog(dialogId: DialogID, reason: StopRequestedReason): Promise<{
     applied: boolean;

package/dist/dialog-display-state.js

@@ -39,6 +39,7 @@ exports.clearDialogInterruptedExecutionMarker = clearDialogInterruptedExecutionM
 exports.setDialogDisplayState = setDialogDisplayState;
 exports.broadcastDisplayStateMarker = broadcastDisplayStateMarker;
 exports.computeIdleDisplayState = computeIdleDisplayState;
+exports.refreshRunControlProjectionFromPersistenceFacts = refreshRunControlProjectionFromPersistenceFacts;
 exports.reconcileDisplayStatesAfterRestart = reconcileDisplayStatesAfterRestart;
 exports.requestInterruptDialog = requestInterruptDialog;
 exports.requestEmergencyStopAll = requestEmergencyStopAll;
@@ -84,6 +85,9 @@ function isDialogLatestResumable(latest) {
         latest.displayState.continueEnabled &&
         latest.executionMarker?.kind === 'interrupted');
 }
+function isSameDisplayState(left, right) {
+    return JSON.stringify(left) === JSON.stringify(right);
+}
 function classifyRunControlBucket(state) {
     if (!state)
         return 'none';
@@ -122,8 +126,13 @@ async function getRunControlCountsSnapshot() {
             if (latest?.generating === true) {
                 proceeding++;
             }
-            else if (isDialogLatestResumable(latest)) {
-                resumable++;
+            else if (latest?.executionMarker?.kind === 'interrupted' &&
+                isStoppedReasonResumable(latest.executionMarker.reason)) {
+                const q4h = await persistence_1.DialogPersistence.loadQuestions4HumanState(dialogId, 'running');
+                const pendingSubdialogs = await persistence_1.DialogPersistence.loadPendingSubdialogs(dialogId, 'running');
+                if (q4h.length === 0 && pendingSubdialogs.length === 0) {
+                    resumable++;
+                }
             }
         }
         catch (error) {
@@ -444,6 +453,66 @@ async function computeIdleDisplayStateFromPersistence(dialogId) {
     }
     return { kind: 'idle_waiting_user' };
 }
+async function refreshRunControlProjectionFromPersistenceFacts(dialogId, trigger) {
+    const latest = await persistence_1.DialogPersistence.loadDialogLatest(dialogId, 'running');
+    if (!latest) {
+        return null;
+    }
+    if (latest.generating === true) {
+        return latest;
+    }
+    if (hasActiveRun(dialogId)) {
+        return latest;
+    }
+    const desired = await (async () => {
+        if (dialogId.selfId !== dialogId.rootId &&
+            latest.executionMarker &&
+            latest.executionMarker.kind === 'dead') {
+            return { kind: 'dead', reason: latest.executionMarker.reason };
+        }
+        const q4h = await persistence_1.DialogPersistence.loadQuestions4HumanState(dialogId, 'running');
+        const pendingSubdialogs = await persistence_1.DialogPersistence.loadPendingSubdialogs(dialogId, 'running');
+        const hasQ4H = q4h.length > 0;
+        const hasSubdialogs = pendingSubdialogs.length > 0;
+        if (hasQ4H && hasSubdialogs) {
+            return { kind: 'blocked', reason: { kind: 'needs_human_input_and_subdialogs' } };
+        }
+        if (hasQ4H) {
+            return { kind: 'blocked', reason: { kind: 'needs_human_input' } };
+        }
+        if (hasSubdialogs) {
+            return { kind: 'blocked', reason: { kind: 'waiting_for_subdialogs' } };
+        }
+        if (latest.executionMarker?.kind === 'interrupted') {
+            return {
+                kind: 'stopped',
+                reason: latest.executionMarker.reason,
+                continueEnabled: isStoppedReasonResumable(latest.executionMarker.reason),
+            };
+        }
+        return { kind: 'idle_waiting_user' };
+    })();
+    const executionMarkerNeedsHealing = desired.kind === 'stopped'
+        ? latest.executionMarker?.kind !== 'interrupted' ||
+            JSON.stringify(latest.executionMarker.reason) !== JSON.stringify(desired.reason)
+        : desired.kind === 'dead'
+            ? latest.executionMarker?.kind !== 'dead' ||
+                JSON.stringify(latest.executionMarker.reason) !== JSON.stringify(desired.reason)
+            : latest.executionMarker?.kind === 'interrupted';
+    const displayStateNeedsHealing = !isSameDisplayState(latest.displayState, desired);
+    if (!displayStateNeedsHealing && !executionMarkerNeedsHealing) {
+        return latest;
+    }
+    log.warn('Healing stale run-control projection from persistence facts', undefined, {
+        dialogId: dialogId.valueOf(),
+        trigger,
+        previousDisplayState: latest.displayState ?? null,
+        previousExecutionMarker: latest.executionMarker ?? null,
+        healedDisplayState: desired,
+    });
+    await setDialogDisplayState(dialogId, desired);
+    return await persistence_1.DialogPersistence.loadDialogLatest(dialogId, 'running');
+}
 async function computeIdleDisplayStateForReconciliation(dialogId) {
     try {
         return await computeIdleDisplayStateFromPersistence(dialogId);

package/dist/dialog-fork.js

@@ -113,6 +113,7 @@ function isPersistedMessageRecord(record) {
         // not contribute to message-count / context reconstruction semantics.
         case 'web_search_call_record':
         case 'native_tool_call_record':
+        case 'tool_result_image_ingest_record':
         case 'quest_for_sup_record':
         case 'tellask_reply_resolution_record':
         case 'tellask_call_anchor_record':
@@ -199,6 +200,14 @@ function rewriteRecordForFork(record, newRootId) {
                 ...record,
                 contentItems: rewriteFuncResultContentItems(record.contentItems, newRootId),
             };
+        case 'tool_result_image_ingest_record':
+            return {
+                ...record,
+                artifact: {
+                    ...record.artifact,
+                    rootId: newRootId,
+                },
+            };
         case 'subdialog_created_record':
         case 'reminders_reconciled_record':
         case 'questions4human_reconciled_record':

package/dist/dialog.d.ts

@@ -18,6 +18,7 @@ import type { DialogPrompt, DialogRunControlSpec, DialogSubdialogReplyTarget, Dr
 import type { LanguageCode } from '@longrun-ai/kernel/types/language';
 import type { CalleeCourseNumber, CalleeGenerationSeqNumber, CallingCourseNumber, DialogMetadataFile, HumanQuestion, ProviderData, ReasoningPayload, TellaskCallRecordName, TellaskReplyDirective } from '@longrun-ai/kernel/types/storage';
 import { ChatMessage, FuncResultMsg, TellaskCarryoverMsg, TellaskResultMsg } from './llm/client';
+import type { ToolResultImageIngest } from './llm/gen';
 import type { JsonValue } from './tool';
 import { Reminder, ReminderOptions, ReminderOwner } from './tool';
 type NewCourseHookResult = {
@@ -406,6 +407,7 @@ export declare abstract class Dialog {
         action?: WebSearchCallAction;
     }): Promise<void>;
     nativeToolCall(payload: NativeToolCallPayload): Promise<void>;
+    toolResultImageIngest(payload: ToolResultImageIngest): Promise<void>;
     callingStart(payload: {
         callName: 'tellaskBack' | 'tellask' | 'tellaskSessionless' | 'askHuman' | 'freshBootsReasoning';
         callId: string;
@@ -624,6 +626,7 @@ export declare abstract class DialogStore {
         action?: WebSearchCallAction;
     }): Promise<void>;
     nativeToolCall(_dialog: Dialog, _payload: NativeToolCallPayload): Promise<void>;
+    toolResultImageIngest(_dialog: Dialog, _payload: ToolResultImageIngest): Promise<void>;
     /**
      * Load current course number from persisted metadata
      * This method should be implemented by subclasses to read from storage

package/dist/dialog.js

@@ -1144,6 +1144,9 @@ class Dialog {
     async nativeToolCall(payload) {
         await this.dlgStore.nativeToolCall(this, payload);
     }
+    async toolResultImageIngest(payload) {
+        await this.dlgStore.toolResultImageIngest(this, payload);
+    }
     // Tellask-special call lifecycle events
     async callingStart(payload) {
         // Store callId for inline call-result correlation
@@ -1578,6 +1581,7 @@ class DialogStore {
     async funcCallRequested(_dialog, _funcId, _funcName, _argumentsStr) { }
     async webSearchCall(_dialog, _payload) { }
     async nativeToolCall(_dialog, _payload) { }
+    async toolResultImageIngest(_dialog, _payload) { }
     /**
      * Load current course number from persisted metadata
      * This method should be implemented by subclasses to read from storage

package/dist/docs/mcp-support.md

@@ -335,9 +335,13 @@ Policy:
     reduce tool set, etc.).
 - **Network/retriable errors**: Dominds may auto-retry only for clearly retriable classes such as
   transient network failures/timeouts and provider transient errors (e.g. rate limits or 5xx), using
-  bounded backoff and a max retry count.
+  strategy-specific backoff. Explicit short transport failures may use a brief aggressive burst, explicit
+  rate-limit signals may use smart-rate backoff, and everything else should default to conservative
+  keepalive retry instead of stopping just because a fixed retry-count ceiling was reached. Only
+  high-confidence non-progress cases should stop automatic retry.
 
-This keeps the system responsive and avoids infinite “retry loops” caused by invalid tool schemas.
+This keeps the system responsive while still avoiding pointless automatic loops caused by invalid tool
+schemas or other high-confidence non-retriable failures.
 
 ## Environment Variables (`env`)
 

package/dist/llm/api-quirks.js

@@ -7,6 +7,7 @@ const DOMINDS_LLM_EMPTY_RESPONSE_ERROR_CODE = 'DOMINDS_LLM_EMPTY_RESPONSE';
 const XCODE_BEST_EMPTY_RESPONSE_SINGLE_RETRY_DELAY_MS = 3000;
 const XCODE_BEST_EMPTY_RESPONSE_GIVE_UP_THRESHOLD = 5;
 const XCODE_BEST_GATEWAY_HTML_502_RETRY_MESSAGE = 'xcode.best gateway returned an HTML 502 Bad Gateway page; retrying conservatively.';
+const XCODE_BEST_AUTH_UNAVAILABLE_RETRY_MESSAGE = 'xcode.best upstream returned 500 auth_unavailable: no auth available; treating it as an infrastructure failure and retrying conservatively.';
 const XCODE_BEST_UNEXPECTED_EOF_RETRY_MESSAGE = 'xcode.best upstream stream ended unexpectedly (unexpected EOF); retrying conservatively.';
 const LOCAL_FILE_IO_ERROR_CODES = new Set(['ENOENT', 'ENOTDIR', 'EISDIR', 'EACCES', 'EPERM']);
 const LOCAL_FILE_IO_SYSCALLS = new Set([
@@ -42,6 +43,21 @@ function isXcodeBestUnexpectedEofFailure(failure, error) {
         failure.message.toLowerCase().includes('unexpected eof')) &&
         !hasLikelyLocalFileErrorContext(error));
 }
+function isXcodeBestAuthUnavailableFailure(failure, error) {
+    const status = failure.status ?? readErrorStatus(error);
+    if (status !== 500) {
+        return false;
+    }
+    const code = (failure.code ?? readErrorCode(error))?.trim().toLowerCase();
+    if (code === 'auth_unavailable') {
+        return true;
+    }
+    const message = (readErrorMessage(error) ?? failure.message).toLowerCase();
+    if (message.includes('auth_unavailable')) {
+        return true;
+    }
+    return code === 'internal_server_error' && message.includes('no auth available');
+}
 function getErrorChain(error) {
     const queue = [error];
     const visited = new Set();
@@ -248,12 +264,12 @@ function buildXcodeBestEmptyResponseGiveUpText(providerConfig, provider) {
     const providerName = providerConfig.name.trim().length > 0 ? providerConfig.name : provider;
     const summaryTextI18n = {
         zh: `${providerName} 在同一对话上下文中连续返回 empty response。` +
-            `Dominds 已在 ${String(XCODE_BEST_EMPTY_RESPONSE_GIVE_UP_THRESHOLD)} 次 empty response 后停止继续重试，因为这通常表示 provider 侧该对话上下文已经卡住；` +
-            '如果直接点继续，大概率仍然无真实进展；更建议结合真实情况灵活尝试多种新的指令，例如改写问题、补充上下文、换一个切入方式。',
+            `Dominds 已在 ${String(XCODE_BEST_EMPTY_RESPONSE_GIVE_UP_THRESHOLD)} 次 empty response 后停止沿用同一上下文继续自动重试，因为这通常表示 provider 侧该对话上下文已经卡住；` +
+            '如果不引入新的信息或新的指令，直接点继续大概率仍然无真实进展；更建议补充上下文、改写问题、换一个切入方式，或在确实需要人类判断时调用 askHuman。',
         en: `${providerName} returned empty responses repeatedly for the same dialog context. ` +
-            `Dominds stopped retrying after ${String(XCODE_BEST_EMPTY_RESPONSE_GIVE_UP_THRESHOLD)} empty responses because this usually means the provider-side conversation ` +
-            'context is stuck; simply pressing Continue is still unlikely to make real progress, ' +
-            'so it is better to try different fresh instructions based on the real situation, such as reframing the ask, adding context, or changing the angle.',
+            `Dominds stopped repeating the same-context automatic retry path after ${String(XCODE_BEST_EMPTY_RESPONSE_GIVE_UP_THRESHOLD)} empty responses because this usually means the provider-side conversation ` +
+            'context is stuck; simply pressing Continue without new information or fresh instructions is still unlikely to make real progress, ' +
+            'so it is better to add context, reframe the ask, change the angle, or call askHuman when human judgment is genuinely needed.',
     };
     return {
         providerName,
@@ -269,6 +285,11 @@ function createXcodeBestFailureQuirkHandlerSession(providerConfig) {
         onFailure(args) {
             const { providerName, summaryTextI18n, recoveryAction } = buildXcodeBestEmptyResponseGiveUpText(providerConfig, args.provider);
             if (args.failure.code === DOMINDS_LLM_EMPTY_RESPONSE_ERROR_CODE) {
+                // xcode.best can enter a same-context deadlock where the upstream keeps returning empty
+                // responses forever until the dialog context changes materially. A short burst of
+                // temporary retries is still worthwhile for transient glitches, but once the streak reaches
+                // the threshold we must stop repeating the exact same automatic path and require fresh
+                // information / fresh instructions instead of hiding the deadlock behind slow retries.
                 consecutiveEmptyResponseCount += 1;
                 if (consecutiveEmptyResponseCount < XCODE_BEST_EMPTY_RESPONSE_GIVE_UP_THRESHOLD) {
                     return {
@@ -279,7 +300,7 @@ function createXcodeBestFailureQuirkHandlerSession(providerConfig) {
                 return {
                     kind: 'give_up',
                     message: `${providerName} returned empty responses repeatedly for the same dialog context; ` +
-                        'automatic retries were stopped; simply continuing is still unlikely to make real progress, so it is better to flexibly try different fresh instructions based on the real situation.',
+                        'Dominds stopped repeating the same-context automatic retry path; continuing without new information is still unlikely to make real progress, so it is better to introduce fresh instructions or new context based on the real situation.',
                     summaryTextI18n,
                     recoveryAction: consumedDiligencePushRecoverySinceLastSuccess
                         ? { kind: 'none' }
@@ -301,6 +322,13 @@ function createXcodeBestFailureQuirkHandlerSession(providerConfig) {
                     message: XCODE_BEST_GATEWAY_HTML_502_RETRY_MESSAGE,
                 };
             }
+            if (isXcodeBestAuthUnavailableFailure(args.failure, args.error)) {
+                return {
+                    kind: 'retry_strategy',
+                    retryStrategy: 'conservative',
+                    message: XCODE_BEST_AUTH_UNAVAILABLE_RETRY_MESSAGE,
+                };
+            }
             return { kind: 'default' };
         },
         onRequestSucceeded() {

package/dist/llm/client.d.ts

@@ -56,7 +56,7 @@ export type ProviderConfig = {
     baseUrl: string;
     apiKeyEnvVar: string;
     tool_result_max_chars?: number;
-    llm_retry_max_retries?: number;
+    llm_retry_aggressive_max_retries?: number;
     llm_retry_initial_delay_ms?: number;
     llm_retry_conservative_delay_ms?: number;
     llm_retry_backoff_multiplier?: number;

package/dist/llm/defaults.yaml

@@ -1,5 +1,7 @@
 # Optional provider-level retry controls for kernel dialog driving:
-# - llm_retry_max_retries: extra retries after the initial attempt (default 99; ~41.2h total retry window with current backoff defaults).
+# - llm_retry_aggressive_max_retries: front-loaded fast retries before Dominds automatically downgrades
+#   to conservative slow retry (default 3). Automatic retries no longer stop just because a retry
+#   count budget was exhausted.
 # - llm_retry_initial_delay_ms: delay before the 1st retry (default 1000).
 # - llm_retry_conservative_delay_ms: base delay for provider-classified conservative retries (default 30000; fixed for first 10 retries, then ramps by x1.5 with the normal max-delay cap).
 # - llm_retry_backoff_multiplier: exponential factor between retries (default 1.5).
@@ -7,8 +9,9 @@
 # - apiQuirks: optional provider/gateway quirk profile(s) for non-standard transport behavior
 #   and provider-specific failure handling that can override the driver's default retry disposition.
 #   Example: `apiQuirks: xcode.best` currently covers both keepalive/heartbeat stream quirks and
-#   repeated empty-response handling for the same dialog context, plus conservative retry
-#   classification for gateway-returned HTML 502 Bad Gateway pages.
+#   repeated empty-response deadlock detection for the same unchanged dialog context, plus conservative retry
+#   classification for gateway-returned HTML 502 Bad Gateway pages and
+#   `500 auth_unavailable: no auth available` infrastructure failures.
 # - tool_result_max_chars: optional transport-level cap for a single tool-result text payload
 #   before Dominds projects it into the provider request. Use this when a provider/gateway enforces
 #   a stricter per-item string limit than Dominds' built-in defaults.

package/dist/llm/gen/anthropic.d.ts

@@ -8,7 +8,7 @@ export type AnthropicStreamConsumeResult = {
     usage: LlmUsageStats;
     llmGenModel?: string;
 };
-export declare function buildAnthropicRequestMessagesWrapper(context: ChatMessage[], providerConfig?: ProviderConfig): Promise<MessageParam[]>;
+export declare function buildAnthropicRequestMessagesWrapper(context: ChatMessage[], requestContextOrProviderConfig?: LlmRequestContext | ProviderConfig, providerConfigMaybe?: ProviderConfig): Promise<MessageParam[]>;
 export declare function consumeAnthropicStream(stream: AsyncIterable<MessageStreamEvent>, receiver: LlmStreamReceiver, abortSignal?: AbortSignal, forcedJsonToolName?: string): Promise<AnthropicStreamConsumeResult>;
 /**
  * Reconstruct Anthropic context from persisted messages with genseq tracking.
@@ -29,6 +29,6 @@ export declare function reconstructAnthropicContextWrapperAsync(persistedMessage
 export declare class AnthropicGen implements LlmGenerator {
     get apiType(): string;
     classifyFailure(error: unknown): LlmFailureDisposition | undefined;
-    genToReceiver(providerConfig: ProviderConfig, agent: Team.Member, systemPrompt: string, funcTools: FuncTool[], _requestContext: LlmRequestContext, context: ChatMessage[], receiver: LlmStreamReceiver, _genseq: number, abortSignal?: AbortSignal): Promise<LlmStreamResult>;
-    genMoreMessages(providerConfig: ProviderConfig, agent: Team.Member, systemPrompt: string, funcTools: FuncTool[], _requestContext: LlmRequestContext, context: ChatMessage[], genseq: number, abortSignal?: AbortSignal): Promise<LlmBatchResult>;
+    genToReceiver(providerConfig: ProviderConfig, agent: Team.Member, systemPrompt: string, funcTools: FuncTool[], requestContext: LlmRequestContext, context: ChatMessage[], receiver: LlmStreamReceiver, _genseq: number, abortSignal?: AbortSignal): Promise<LlmStreamResult>;
+    genMoreMessages(providerConfig: ProviderConfig, agent: Team.Member, systemPrompt: string, funcTools: FuncTool[], requestContext: LlmRequestContext, context: ChatMessage[], genseq: number, abortSignal?: AbortSignal): Promise<LlmBatchResult>;
 }

package/dist/llm/gen/anthropic.js

@@ -18,6 +18,7 @@ const artifacts_1 = require("./artifacts");
 const failure_classifier_1 = require("./failure-classifier");
 const tool_call_context_1 = require("./tool-call-context");
 const tool_output_limit_1 = require("./tool-output-limit");
+const tool_result_image_ingest_1 = require("./tool-result-image-ingest");
 const log = (0, log_1.createLogger)('llm/anthropic');
 const ANTHROPIC_JSON_RESPONSE_TOOL_NAME = 'dominds_json_response';
 const ANTHROPIC_JSON_RESPONSE_TOOL_DESCRIPTION = 'Return the final answer as a JSON object. Do not include any non-JSON text.';
@@ -75,6 +76,13 @@ function isRecord(value) {
 function isNonArrayRecord(value) {
     return isRecord(value) && !Array.isArray(value);
 }
+function isLlmRequestContext(value) {
+    return (isNonArrayRecord(value) &&
+        typeof value.dialogSelfId === 'string' &&
+        typeof value.dialogRootId === 'string' &&
+        typeof value.providerKey === 'string' &&
+        typeof value.modelKey === 'string');
+}
 function tryExtractApiReturnedModel(value) {
     // NOTE: External API payload; a runtime check is unavoidable.
     if (!isRecord(value))
@@ -177,7 +185,7 @@ function parseForcedJsonToolInput(rawJson, fallbackInput, at) {
     }
     throw new Error(`Invalid ${at}: ${errorText}; raw=${JSON.stringify(preview)}`);
 }
-async function funcResultToAnthropicToolResultBlock(chatMsg, limitChars) {
+async function funcResultToAnthropicToolResultBlock(chatMsg, limitChars, requestContext, allowedImageKeys, onToolResultImageIngest) {
     const items = chatMsg.contentItems;
     if (!Array.isArray(items) || items.length === 0) {
         return {
@@ -194,22 +202,85 @@ async function funcResultToAnthropicToolResultBlock(chatMsg, limitChars) {
         }
         if (item.type === 'input_image') {
             if (!(0, artifacts_1.isVisionImageMimeType)(item.mimeType)) {
+                if (onToolResultImageIngest) {
+                    await onToolResultImageIngest((0, tool_result_image_ingest_1.buildToolResultImageIngest)({
+                        requestContext,
+                        toolCallId: chatMsg.id,
+                        toolName: chatMsg.name,
+                        artifact: item.artifact,
+                        disposition: 'filtered_mime_unsupported',
+                        mimeType: item.mimeType,
+                        providerPathLabel: 'Anthropic Messages path',
+                    }));
+                }
                 content.push({
                     type: 'text',
                     text: `[image omitted: unsupported mimeType=${item.mimeType}]`,
                 });
                 continue;
             }
-            const bytes = await (0, artifacts_1.readDialogArtifactBytes)({
-                rootId: item.artifact.rootId,
-                selfId: item.artifact.selfId,
-                status: item.artifact.status,
-                relPath: item.artifact.relPath,
-            });
-            if (!bytes) {
+            if (!allowedImageKeys.has((0, tool_result_image_ingest_1.buildToolResultImageBudgetKeyForMsg)(chatMsg, item.artifact))) {
+                if (onToolResultImageIngest) {
+                    await onToolResultImageIngest((0, tool_result_image_ingest_1.buildToolResultImageIngest)({
+                        requestContext,
+                        toolCallId: chatMsg.id,
+                        toolName: chatMsg.name,
+                        artifact: item.artifact,
+                        disposition: 'filtered_size_limit',
+                        detail: (0, tool_result_image_ingest_1.buildToolResultImageBudgetLimitDetail)({
+                            byteLength: item.byteLength,
+                            budgetBytes: tool_result_image_ingest_1.ANTHROPIC_TOOL_RESULT_IMAGE_BUDGET_BYTES,
+                        }),
+                        providerPathLabel: 'Anthropic Messages path',
+                    }));
+                }
+                content.push({
+                    type: 'text',
+                    text: `[image omitted: request image budget exceeded bytes=${String(item.byteLength)} budget=${String(tool_result_image_ingest_1.ANTHROPIC_TOOL_RESULT_IMAGE_BUDGET_BYTES)}]`,
+                });
+                continue;
+            }
+            const bytesResult = await (0, tool_result_image_ingest_1.readToolResultImageBytesSafe)(item.artifact);
+            if (bytesResult.kind === 'missing') {
+                if (onToolResultImageIngest) {
+                    await onToolResultImageIngest((0, tool_result_image_ingest_1.buildToolResultImageIngest)({
+                        requestContext,
+                        toolCallId: chatMsg.id,
+                        toolName: chatMsg.name,
+                        artifact: item.artifact,
+                        disposition: 'filtered_missing',
+                        providerPathLabel: 'Anthropic Messages path',
+                    }));
+                }
                 content.push({ type: 'text', text: `[image missing: ${item.artifact.relPath}]` });
                 continue;
             }
+            if (bytesResult.kind === 'read_failed') {
+                if (onToolResultImageIngest) {
+                    await onToolResultImageIngest((0, tool_result_image_ingest_1.buildToolResultImageIngest)({
+                        requestContext,
+                        toolCallId: chatMsg.id,
+                        toolName: chatMsg.name,
+                        artifact: item.artifact,
+                        disposition: 'filtered_read_failed',
+                        detail: bytesResult.detail,
+                        providerPathLabel: 'Anthropic Messages path',
+                    }));
+                }
+                content.push({ type: 'text', text: `[image unreadable: ${item.artifact.relPath}]` });
+                continue;
+            }
+            if (onToolResultImageIngest) {
+                await onToolResultImageIngest((0, tool_result_image_ingest_1.buildToolResultImageIngest)({
+                    requestContext,
+                    toolCallId: chatMsg.id,
+                    toolName: chatMsg.name,
+                    artifact: item.artifact,
+                    disposition: 'fed_native',
+                    providerPathLabel: 'Anthropic Messages path',
+                }));
+            }
+            const bytes = bytesResult.bytes;
             const base64 = bytes.toString('base64');
             content.push({
                 type: 'image',
@@ -237,14 +308,16 @@ async function funcResultToAnthropicToolResultBlock(chatMsg, limitChars) {
         content: limitAnthropicToolOutputBlocks(content, chatMsg, limitChars),
     };
 }
-async function chatMessageToContentBlocksAsync(chatMsg, limitChars) {
+async function chatMessageToContentBlocksAsync(chatMsg, limitChars, requestContext, allowedImageKeys, onToolResultImageIngest) {
     if (chatMsg.type !== 'func_result_msg') {
         return chatMessageToContentBlocks(chatMsg);
     }
-    return [await funcResultToAnthropicToolResultBlock(chatMsg, limitChars)];
+    return [
+        await funcResultToAnthropicToolResultBlock(chatMsg, limitChars, requestContext, allowedImageKeys, onToolResultImageIngest),
+    ];
 }
-async function chatMessageToAnthropicAsync(chatMsg, limitChars) {
-    const contentBlocks = await chatMessageToContentBlocksAsync(chatMsg, limitChars);
+async function chatMessageToAnthropicAsync(chatMsg, limitChars, requestContext, allowedImageKeys, onToolResultImageIngest) {
+    const contentBlocks = await chatMessageToContentBlocksAsync(chatMsg, limitChars, requestContext, allowedImageKeys, onToolResultImageIngest);
     if (contentBlocks.length === 0) {
         throw new Error(`No content blocks generated for message: ${JSON.stringify(chatMsg)}`);
     }
@@ -257,7 +330,7 @@ async function chatMessageToAnthropicAsync(chatMsg, limitChars) {
         content: contentBlocks.length === 1 ? contentBlocks : contentBlocks,
     };
 }
-async function buildAnthropicRequestMessages(context, providerConfig) {
+async function buildAnthropicRequestMessages(context, requestContext, providerConfig, onToolResultImageIngest) {
     // We keep the async path for func_result_msg because it may contain image artifacts.
     const normalized = (0, tool_call_context_1.normalizeToolCallPairs)(context);
     const violation = (0, tool_call_context_1.findFirstToolCallAdjacencyViolation)(normalized);
@@ -273,13 +346,25 @@ async function buildAnthropicRequestMessages(context, providerConfig) {
     }
     const messages = [];
     const toolResultMaxChars = (0, tool_output_limit_1.resolveProviderToolResultMaxChars)(providerConfig);
+    const allowedImageKeys = (0, tool_result_image_ingest_1.selectLatestToolResultImagesWithinBudget)(normalized, tool_result_image_ingest_1.ANTHROPIC_TOOL_RESULT_IMAGE_BUDGET_BYTES);
     for (const msg of normalized) {
-        messages.push(await chatMessageToAnthropicAsync(msg, toolResultMaxChars));
+        messages.push(await chatMessageToAnthropicAsync(msg, toolResultMaxChars, requestContext, allowedImageKeys, onToolResultImageIngest));
     }
     return assembleAnthropicTurns(messages);
 }
-async function buildAnthropicRequestMessagesWrapper(context, providerConfig) {
-    return await buildAnthropicRequestMessages(context, providerConfig);
+async function buildAnthropicRequestMessagesWrapper(context, requestContextOrProviderConfig, providerConfigMaybe) {
+    const requestContext = isLlmRequestContext(requestContextOrProviderConfig)
+        ? requestContextOrProviderConfig
+        : {
+            dialogSelfId: '',
+            dialogRootId: '',
+            providerKey: 'anthropic',
+            modelKey: 'unknown',
+        };
+    const providerConfig = isLlmRequestContext(requestContextOrProviderConfig)
+        ? providerConfigMaybe
+        : requestContextOrProviderConfig;
+    return await buildAnthropicRequestMessages(context, requestContext, providerConfig);
 }
 /**
  * Reconstruct Anthropic context from persisted messages.
@@ -800,7 +885,12 @@ function reconstructAnthropicContextWrapper(persistedMessages) {
     return reconstructed;
 }
 async function reconstructAnthropicContextWrapperAsync(persistedMessages) {
-    const reconstructed = await buildAnthropicRequestMessages(persistedMessages);
+    const reconstructed = await buildAnthropicRequestMessages(persistedMessages, {
+        dialogSelfId: '',
+        dialogRootId: '',
+        providerKey: 'anthropic',
+        modelKey: 'unknown',
+    });
     // Validate the reconstructed context
     try {
         validateReconstructedContext(reconstructed);
@@ -824,12 +914,12 @@ class AnthropicGen {
     classifyFailure(error) {
         return (0, failure_classifier_1.classifyAnthropicFailure)(error);
     }
-    async genToReceiver(providerConfig, agent, systemPrompt, funcTools, _requestContext, context, receiver, _genseq, abortSignal) {
+    async genToReceiver(providerConfig, agent, systemPrompt, funcTools, requestContext, context, receiver, _genseq, abortSignal) {
         const apiKey = process.env[providerConfig.apiKeyEnvVar];
         if (!apiKey)
             throw new Error(`Missing API key env var ${providerConfig.apiKeyEnvVar}`);
         const client = new sdk_1.Anthropic({ apiKey, baseURL: providerConfig.baseUrl });
-        const requestMessages = await buildAnthropicRequestMessages(context, providerConfig);
+        const requestMessages = await buildAnthropicRequestMessages(context, requestContext, providerConfig, receiver.toolResultImageIngest);
         const anthropicParams = agent.model_params?.anthropic || {};
         const forceJsonResponse = resolveAnthropicJsonResponseEnabled(agent);
         const maxTokens = agent.model_params?.max_tokens;
@@ -874,12 +964,15 @@ class AnthropicGen {
         const stream = client.messages.stream(streamParams);
         return consumeAnthropicStream(stream, receiver, abortSignal, forceJsonResponse ? ANTHROPIC_JSON_RESPONSE_TOOL_NAME : undefined);
     }
-    async genMoreMessages(providerConfig, agent, systemPrompt, funcTools, _requestContext, context, genseq, abortSignal) {
+    async genMoreMessages(providerConfig, agent, systemPrompt, funcTools, requestContext, context, genseq, abortSignal) {
         const apiKey = process.env[providerConfig.apiKeyEnvVar];
         if (!apiKey)
             throw new Error(`Missing API key env var ${providerConfig.apiKeyEnvVar}`);
         const client = new sdk_1.Anthropic({ apiKey, baseURL: providerConfig.baseUrl });
-        const requestMessages = await buildAnthropicRequestMessages(context, providerConfig);
+        const outputs = [];
+        const requestMessages = await buildAnthropicRequestMessages(context, requestContext, providerConfig, async (ingest) => {
+            outputs.push({ kind: 'tool_result_image_ingest', ingest });
+        });
         const anthropicParams = agent.model_params?.anthropic || {};
         const forceJsonResponse = resolveAnthropicJsonResponseEnabled(agent);
         const maxTokens = agent.model_params?.max_tokens;
@@ -940,6 +1033,7 @@ class AnthropicGen {
         };
         return {
             messages: anthropicToChatMessages(response, genseq, forceJsonResponse ? ANTHROPIC_JSON_RESPONSE_TOOL_NAME : undefined),
+            ...(outputs.length > 0 ? { outputs } : {}),
             usage,
             llmGenModel: returnedModel,
         };