dominds 1.16.2 → 1.16.4

package/dist/llm/gen/openai-compatible.js

@@ -27,6 +27,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/openai-compatible');
 function limitOpenAiCompatibleToolOutputText(text, msg, limitChars) {
     const limited = (0, tool_output_limit_1.truncateProviderToolOutputText)(text, limitChars);
@@ -43,6 +44,13 @@ function limitOpenAiCompatibleToolOutputText(text, msg, limitChars) {
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
+function isLlmRequestContext(value) {
+    return (isRecord(value) &&
+        typeof value.dialogSelfId === 'string' &&
+        typeof value.dialogRootId === 'string' &&
+        typeof value.providerKey === 'string' &&
+        typeof value.modelKey === 'string');
+}
 function tryExtractChatUsage(usage) {
     // NOTE: External API payload; a runtime check is unavoidable.
     if (!isRecord(usage))
@@ -177,7 +185,7 @@ function chatMessageToChatCompletionMessage(msg) {
         }
     }
 }
-async function funcResultToChatCompletionMessages(msg, limitChars) {
+async function funcResultToChatCompletionMessages(msg, limitChars, requestContext, providerConfig, allowedImageKeys, onToolResultImageIngest) {
     const items = msg.contentItems;
     if (!Array.isArray(items) || items.length === 0) {
         return [
@@ -201,31 +209,121 @@ async function funcResultToChatCompletionMessages(msg, limitChars) {
         type: 'text',
         text: `Tool output images (${msg.name}, call_id=${msg.id}):`,
     });
+    const supportsImageInput = (() => {
+        if (!providerConfig)
+            return false;
+        const modelKey = typeof requestContext.modelKey === 'string' ? requestContext.modelKey.trim() : '';
+        const modelInfo = modelKey.length > 0 ? providerConfig.models[modelKey] : undefined;
+        return isRecord(modelInfo) && modelInfo['supports_image_input'] === true;
+    })();
     for (const item of items) {
         if (item.type === 'input_text')
             continue;
         if (item.type === 'input_image') {
             sawAnyImage = true;
+            if (!supportsImageInput) {
+                if (onToolResultImageIngest) {
+                    await onToolResultImageIngest((0, tool_result_image_ingest_1.buildToolResultImageIngest)({
+                        requestContext,
+                        toolCallId: msg.id,
+                        toolName: msg.name,
+                        artifact: item.artifact,
+                        disposition: 'filtered_provider_unsupported',
+                        providerPathLabel: 'OpenAI-compatible path',
+                    }));
+                }
+                parts.push({
+                    type: 'text',
+                    text: `[image not sent: current openai-compatible image input is disabled for model=${typeof requestContext.modelKey === 'string' && requestContext.modelKey.trim().length > 0 ? requestContext.modelKey.trim() : 'unknown'}]`,
+                });
+                continue;
+            }
             if (!(0, artifacts_1.isVisionImageMimeType)(item.mimeType)) {
+                if (onToolResultImageIngest) {
+                    await onToolResultImageIngest((0, tool_result_image_ingest_1.buildToolResultImageIngest)({
+                        requestContext,
+                        toolCallId: msg.id,
+                        toolName: msg.name,
+                        artifact: item.artifact,
+                        disposition: 'filtered_mime_unsupported',
+                        mimeType: item.mimeType,
+                        providerPathLabel: 'OpenAI-compatible path',
+                    }));
+                }
                 parts.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)(msg, item.artifact))) {
+                if (onToolResultImageIngest) {
+                    await onToolResultImageIngest((0, tool_result_image_ingest_1.buildToolResultImageIngest)({
+                        requestContext,
+                        toolCallId: msg.id,
+                        toolName: msg.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.OPENAI_COMPATIBLE_TOOL_RESULT_IMAGE_BUDGET_BYTES,
+                        }),
+                        providerPathLabel: 'OpenAI-compatible path',
+                    }));
+                }
+                parts.push({
+                    type: 'text',
+                    text: `[image omitted: request image budget exceeded bytes=${String(item.byteLength)} budget=${String(tool_result_image_ingest_1.OPENAI_COMPATIBLE_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: msg.id,
+                        toolName: msg.name,
+                        artifact: item.artifact,
+                        disposition: 'filtered_missing',
+                        providerPathLabel: 'OpenAI-compatible path',
+                    }));
+                }
                 parts.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: msg.id,
+                        toolName: msg.name,
+                        artifact: item.artifact,
+                        disposition: 'filtered_read_failed',
+                        detail: bytesResult.detail,
+                        providerPathLabel: 'OpenAI-compatible path',
+                    }));
+                }
+                parts.push({
+                    type: 'text',
+                    text: `[image unreadable: ${item.artifact.relPath}]`,
+                });
+                continue;
+            }
+            if (onToolResultImageIngest) {
+                await onToolResultImageIngest((0, tool_result_image_ingest_1.buildToolResultImageIngest)({
+                    requestContext,
+                    toolCallId: msg.id,
+                    toolName: msg.name,
+                    artifact: item.artifact,
+                    disposition: 'fed_provider_transformed',
+                    providerPathLabel: 'OpenAI-compatible path',
+                }));
+            }
+            const bytes = bytesResult.bytes;
             parts.push({
                 type: 'image_url',
                 image_url: {
@@ -358,7 +456,7 @@ function mergeAdjacentMessages(input) {
     }
     return merged;
 }
-async function buildChatCompletionMessages(systemPrompt, context, options) {
+async function buildChatCompletionMessages(systemPrompt, context, requestContext, options) {
     const normalized = (0, tool_call_context_1.normalizeToolCallPairs)(context);
     const violation = (0, tool_call_context_1.findFirstToolCallAdjacencyViolation)(normalized);
     if (violation) {
@@ -374,6 +472,7 @@ async function buildChatCompletionMessages(systemPrompt, context, options) {
     const input = [];
     const reasoningContentMode = options?.reasoningContentMode === true;
     const toolResultMaxChars = (0, tool_output_limit_1.resolveProviderToolResultMaxChars)(options?.providerConfig);
+    const allowedImageKeys = (0, tool_result_image_ingest_1.selectLatestToolResultImagesWithinBudget)(normalized, tool_result_image_ingest_1.OPENAI_COMPATIBLE_TOOL_RESULT_IMAGE_BUDGET_BYTES);
     let pendingReasoningContent;
     const takePendingReasoningContent = () => {
         const current = pendingReasoningContent;
@@ -412,7 +511,7 @@ async function buildChatCompletionMessages(systemPrompt, context, options) {
         }
         if (msg.type === 'func_result_msg') {
             flushPendingReasoningAsAssistantMessage();
-            input.push(...(await funcResultToChatCompletionMessages(msg, toolResultMaxChars)));
+            input.push(...(await funcResultToChatCompletionMessages(msg, toolResultMaxChars, requestContext, options?.providerConfig, allowedImageKeys, options?.onToolResultImageIngest)));
             continue;
         }
         const mapped = chatMessageToChatCompletionMessage(msg);
@@ -421,8 +520,19 @@ async function buildChatCompletionMessages(systemPrompt, context, options) {
     flushPendingReasoningAsAssistantMessage();
     return mergeAdjacentMessages(input);
 }
-async function buildOpenAiCompatibleRequestMessagesWrapper(systemPrompt, context, options) {
-    return await buildChatCompletionMessages(systemPrompt, context, options);
+async function buildOpenAiCompatibleRequestMessagesWrapper(systemPrompt, context, requestContextOrOptions, optionsMaybe) {
+    const requestContext = isLlmRequestContext(requestContextOrOptions)
+        ? requestContextOrOptions
+        : {
+            dialogSelfId: '',
+            dialogRootId: '',
+            providerKey: 'openai-compatible',
+            modelKey: 'unknown',
+        };
+    const options = isLlmRequestContext(requestContextOrOptions)
+        ? optionsMaybe
+        : requestContextOrOptions;
+    return await buildChatCompletionMessages(systemPrompt, context, requestContext, options);
 }
 function applyArgsDelta(state, chunk) {
     if (chunk.length === 0)
@@ -507,7 +617,7 @@ class OpenAiCompatibleGen {
     classifyFailure(error) {
         return (0, failure_classifier_1.classifyOpenAiLikeFailure)(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}`);
@@ -516,9 +626,10 @@ class OpenAiCompatibleGen {
         }
         const client = new openai_1.default({ apiKey, baseURL: providerConfig.baseUrl });
         const reasoningContentMode = resolveOpenAiCompatibleReasoningContentMode(providerConfig, agent);
-        const messages = await buildChatCompletionMessages(systemPrompt, context, {
+        const messages = await buildChatCompletionMessages(systemPrompt, context, requestContext, {
             reasoningContentMode,
             providerConfig,
+            onToolResultImageIngest: receiver.toolResultImageIngest,
         });
         const openAiParams = agent.model_params?.openai || {};
         const maxTokens = agent.model_params?.max_tokens;
@@ -707,7 +818,7 @@ class OpenAiCompatibleGen {
         }
         return { usage, ...(returnedModel ? { llmGenModel: returnedModel } : {}) };
     }
-    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}`);
@@ -716,9 +827,13 @@ class OpenAiCompatibleGen {
         }
         const client = new openai_1.default({ apiKey, baseURL: providerConfig.baseUrl });
         const reasoningContentMode = resolveOpenAiCompatibleReasoningContentMode(providerConfig, agent);
-        const messages = await buildChatCompletionMessages(systemPrompt, context, {
+        const outputs = [];
+        const messages = await buildChatCompletionMessages(systemPrompt, context, requestContext, {
             reasoningContentMode,
             providerConfig,
+            onToolResultImageIngest: async (ingest) => {
+                outputs.push({ kind: 'tool_result_image_ingest', ingest });
+            },
         });
         const openAiParams = agent.model_params?.openai || {};
         const maxTokens = agent.model_params?.max_tokens;
@@ -754,6 +869,7 @@ class OpenAiCompatibleGen {
                 : undefined;
             return {
                 messages: messagesOut,
+                ...(outputs.length > 0 ? { outputs } : {}),
                 usage,
                 ...(model ? { llmGenModel: model } : {}),
             };

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

@@ -14,6 +14,6 @@ export declare function buildOpenAiRequestInputWrapper(context: ChatMessage[], p
 export declare class OpenAiGen 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/openai.js

@@ -23,6 +23,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/openai');
 const OPENAI_API_QUIRK_VENDOR_HEARTBEAT_EVENT_TYPES = {
     'xcode.best': ['keepalive'],
@@ -237,7 +238,7 @@ function thinkingMessageToOpenAiReasoningItem(msg) {
     }
     return out;
 }
-async function funcResultToOpenAiInputItemWithLimit(msg, limitChars) {
+async function funcResultToOpenAiInputItemWithLimit(msg, limitChars, requestContext, allowedImageKeys, onToolResultImageIngest) {
     const items = msg.contentItems;
     if (!Array.isArray(items) || items.length === 0) {
         return {
@@ -254,25 +255,91 @@ async function funcResultToOpenAiInputItemWithLimit(msg, 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: msg.id,
+                        toolName: msg.name,
+                        artifact: item.artifact,
+                        disposition: 'filtered_mime_unsupported',
+                        mimeType: item.mimeType,
+                        providerPathLabel: 'OpenAI Responses path',
+                    }));
+                }
                 output.push({
                     type: 'input_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)(msg, item.artifact))) {
+                if (onToolResultImageIngest) {
+                    await onToolResultImageIngest((0, tool_result_image_ingest_1.buildToolResultImageIngest)({
+                        requestContext,
+                        toolCallId: msg.id,
+                        toolName: msg.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.OPENAI_TOOL_RESULT_IMAGE_BUDGET_BYTES,
+                        }),
+                        providerPathLabel: 'OpenAI Responses path',
+                    }));
+                }
+                output.push({
+                    type: 'input_text',
+                    text: `[image omitted: request image budget exceeded bytes=${String(item.byteLength)} budget=${String(tool_result_image_ingest_1.OPENAI_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: msg.id,
+                        toolName: msg.name,
+                        artifact: item.artifact,
+                        disposition: 'filtered_missing',
+                        providerPathLabel: 'OpenAI Responses path',
+                    }));
+                }
                 output.push({
                     type: 'input_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: msg.id,
+                        toolName: msg.name,
+                        artifact: item.artifact,
+                        disposition: 'filtered_read_failed',
+                        detail: bytesResult.detail,
+                        providerPathLabel: 'OpenAI Responses path',
+                    }));
+                }
+                output.push({
+                    type: 'input_text',
+                    text: `[image unreadable: ${item.artifact.relPath}]`,
+                });
+                continue;
+            }
+            const bytes = bytesResult.bytes;
+            if (onToolResultImageIngest) {
+                await onToolResultImageIngest((0, tool_result_image_ingest_1.buildToolResultImageIngest)({
+                    requestContext,
+                    toolCallId: msg.id,
+                    toolName: msg.name,
+                    artifact: item.artifact,
+                    disposition: 'fed_native',
+                    providerPathLabel: 'OpenAI Responses path',
+                }));
+            }
             output.push({
                 type: 'input_image',
                 detail: 'auto',
@@ -327,7 +394,7 @@ function shouldIncludeOpenAiEncryptedReasoning(input, reasoning) {
         return true;
     return input.some((item) => isRecord(item) && item.type === 'reasoning');
 }
-async function buildOpenAiRequestInput(context, providerConfig) {
+async function buildOpenAiRequestInput(context, requestContext, providerConfig, onToolResultImageIngest) {
     const normalized = (0, tool_call_context_1.normalizeToolCallPairs)(context);
     const violation = (0, tool_call_context_1.findFirstToolCallAdjacencyViolation)(normalized);
     if (violation) {
@@ -342,7 +409,12 @@ async function buildOpenAiRequestInput(context, providerConfig) {
     }
     const input = [];
     const toolResultMaxChars = (0, tool_output_limit_1.resolveProviderToolResultMaxChars)(providerConfig);
+    const allowedImageKeys = (0, tool_result_image_ingest_1.selectLatestToolResultImagesWithinBudget)(normalized, tool_result_image_ingest_1.OPENAI_TOOL_RESULT_IMAGE_BUDGET_BYTES);
     for (const msg of normalized) {
+        if (msg.type === 'func_result_msg') {
+            input.push(await funcResultToOpenAiInputItemWithLimit(msg, toolResultMaxChars, requestContext, allowedImageKeys, onToolResultImageIngest));
+            continue;
+        }
         input.push(chatMessageToOpenAiInputItem(msg));
     }
     return mergeAdjacentOpenAiMessages(input);
@@ -806,7 +878,12 @@ function buildOpenAiNativeToolSeed(item, itemId) {
     }
 }
 async function buildOpenAiRequestInputWrapper(context, providerConfig) {
-    return await buildOpenAiRequestInput(context, providerConfig);
+    return await buildOpenAiRequestInput(context, {
+        dialogSelfId: '',
+        dialogRootId: '',
+        providerKey: 'openai',
+        modelKey: 'unknown',
+    }, providerConfig);
 }
 function extractOutputMessageText(item) {
     if (!isRecord(item) || item.type !== 'message')
@@ -978,7 +1055,7 @@ class OpenAiGen {
     classifyFailure(error) {
         return (0, failure_classifier_1.classifyOpenAiLikeFailure)(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}`);
@@ -986,7 +1063,7 @@ class OpenAiGen {
             throw new Error(`Internal error: Model is undefined for agent '${agent.id}'`);
         }
         const client = new openai_1.default({ apiKey, baseURL: providerConfig.baseUrl });
-        const requestInput = await buildOpenAiRequestInput(context, providerConfig);
+        const requestInput = await buildOpenAiRequestInput(context, requestContext, providerConfig, receiver.toolResultImageIngest);
         const openAiParams = agent.model_params?.openai || {};
         const maxTokens = agent.model_params?.max_tokens;
         const modelInfo = providerConfig.models[agent.model];
@@ -1733,7 +1810,7 @@ class OpenAiGen {
         }
         return { usage, llmGenModel: returnedModel };
     }
-    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}`);
@@ -1741,7 +1818,10 @@ class OpenAiGen {
             throw new Error(`Internal error: Model is undefined for agent '${agent.id}'`);
         }
         const client = new openai_1.default({ apiKey, baseURL: providerConfig.baseUrl });
-        const requestInput = await buildOpenAiRequestInput(context, providerConfig);
+        const outputs = [];
+        const requestInput = await buildOpenAiRequestInput(context, requestContext, providerConfig, async (ingest) => {
+            outputs.push({ kind: 'tool_result_image_ingest', ingest });
+        });
         const openAiParams = agent.model_params?.openai || {};
         const maxTokens = agent.model_params?.max_tokens;
         const modelInfo = providerConfig.models[agent.model];
@@ -1782,7 +1862,7 @@ class OpenAiGen {
         }
         const returnedModel = typeof response.model === 'string' ? response.model : undefined;
         const usage = parseOpenAiUsage(response.usage);
-        const outputs = openAiResponseToBatchOutputs(response, genseq);
+        outputs.push(...openAiResponseToBatchOutputs(response, genseq));
         return {
             messages: outputs
                 .filter((entry) => entry.kind === 'message')

package/dist/llm/gen/tool-result-image-ingest.d.ts

@@ -0,0 +1,39 @@
+import type { ToolResultImageArtifact, ToolResultImageDisposition } from '@longrun-ai/kernel/types/storage';
+import type { ChatMessage, FuncResultMsg } from '../client';
+import type { LlmRequestContext, ToolResultImageIngest } from '../gen';
+type ToolResultImageReadResult = {
+    kind: 'ready';
+    bytes: Buffer;
+} | {
+    kind: 'missing';
+} | {
+    kind: 'read_failed';
+    detail: string;
+};
+export declare const OPENAI_TOOL_RESULT_IMAGE_BUDGET_BYTES: number;
+export declare const OPENAI_COMPATIBLE_TOOL_RESULT_IMAGE_BUDGET_BYTES: number;
+export declare const CODEX_TOOL_RESULT_IMAGE_BUDGET_BYTES: number;
+export declare const ANTHROPIC_TOOL_RESULT_IMAGE_BUDGET_BYTES: number;
+export declare function buildToolResultImageBudgetLimitDetail(args: {
+    byteLength: number;
+    budgetBytes: number;
+}): string;
+export declare function buildToolResultImageBudgetKey(args: {
+    genseq: number;
+    toolCallId: string;
+    artifact: ToolResultImageArtifact;
+}): string;
+export declare function buildToolResultImageBudgetKeyForMsg(msg: FuncResultMsg, artifact: ToolResultImageArtifact): string;
+export declare function selectLatestToolResultImagesWithinBudget(context: ChatMessage[], budgetBytes: number): Set<string>;
+export declare function readToolResultImageBytesSafe(artifact: ToolResultImageArtifact): Promise<ToolResultImageReadResult>;
+export declare function buildToolResultImageIngest(args: {
+    requestContext: LlmRequestContext;
+    toolCallId: string;
+    toolName: string;
+    artifact: ToolResultImageArtifact;
+    disposition: ToolResultImageDisposition;
+    mimeType?: string;
+    detail?: string;
+    providerPathLabel?: string;
+}): ToolResultImageIngest;
+export {};

package/dist/llm/gen/tool-result-image-ingest.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ANTHROPIC_TOOL_RESULT_IMAGE_BUDGET_BYTES = exports.CODEX_TOOL_RESULT_IMAGE_BUDGET_BYTES = exports.OPENAI_COMPATIBLE_TOOL_RESULT_IMAGE_BUDGET_BYTES = exports.OPENAI_TOOL_RESULT_IMAGE_BUDGET_BYTES = void 0;
+exports.buildToolResultImageBudgetLimitDetail = buildToolResultImageBudgetLimitDetail;
+exports.buildToolResultImageBudgetKey = buildToolResultImageBudgetKey;
+exports.buildToolResultImageBudgetKeyForMsg = buildToolResultImageBudgetKeyForMsg;
+exports.selectLatestToolResultImagesWithinBudget = selectLatestToolResultImagesWithinBudget;
+exports.readToolResultImageBytesSafe = readToolResultImageBytesSafe;
+exports.buildToolResultImageIngest = buildToolResultImageIngest;
+const work_language_1 = require("../../runtime/work-language");
+const artifacts_1 = require("./artifacts");
+// These are provider-path guardrails derived from publicly documented request payload limits.
+// They are intentionally documented here as coarse transport caps for Dominds' inline image replay,
+// not as claims about the provider's exact per-image validator.
+//
+// OpenAI official vision guide currently documents up to 50 MB total payload size per request.
+// Codex here reuses the OpenAI Responses image path, so we follow the same cap by inference.
+// Anthropic vision docs currently document 32 MB request size limits for standard endpoints.
+//
+// OpenAI-compatible has no cross-provider standard. We keep an OpenAI-like fallback cap here for
+// future opt-in paths, but must not present it as an official guarantee for arbitrary gateways.
+exports.OPENAI_TOOL_RESULT_IMAGE_BUDGET_BYTES = 50 * 1024 * 1024;
+exports.OPENAI_COMPATIBLE_TOOL_RESULT_IMAGE_BUDGET_BYTES = 50 * 1024 * 1024;
+exports.CODEX_TOOL_RESULT_IMAGE_BUDGET_BYTES = 50 * 1024 * 1024;
+exports.ANTHROPIC_TOOL_RESULT_IMAGE_BUDGET_BYTES = 32 * 1024 * 1024;
+function buildToolResultImageBudgetLimitDetail(args) {
+    return `image_bytes=${String(args.byteLength)}, request_image_budget_bytes=${String(args.budgetBytes)}`;
+}
+function buildToolResultImageBudgetKey(args) {
+    return `${String(args.genseq)}::${args.toolCallId}::${args.artifact.rootId}::${args.artifact.selfId}::${args.artifact.relPath}`;
+}
+function buildToolResultImageBudgetKeyForMsg(msg, artifact) {
+    return buildToolResultImageBudgetKey({
+        genseq: msg.genseq,
+        toolCallId: msg.id,
+        artifact,
+    });
+}
+function selectLatestToolResultImagesWithinBudget(context, budgetBytes) {
+    const candidates = [];
+    for (const msg of context) {
+        if (msg.type !== 'func_result_msg')
+            continue;
+        const items = msg.contentItems;
+        if (!Array.isArray(items) || items.length === 0)
+            continue;
+        for (const item of items) {
+            if (item.type !== 'input_image')
+                continue;
+            candidates.push({
+                key: buildToolResultImageBudgetKeyForMsg(msg, item.artifact),
+                byteLength: item.byteLength,
+            });
+        }
+    }
+    const allowed = new Set();
+    let usedBytes = 0;
+    for (let index = candidates.length - 1; index >= 0; index -= 1) {
+        const candidate = candidates[index];
+        if (usedBytes + candidate.byteLength > budgetBytes) {
+            continue;
+        }
+        allowed.add(candidate.key);
+        usedBytes += candidate.byteLength;
+    }
+    return allowed;
+}
+async function readToolResultImageBytesSafe(artifact) {
+    try {
+        const bytes = await (0, artifacts_1.readDialogArtifactBytes)(artifact);
+        if (!bytes)
+            return { kind: 'missing' };
+        return { kind: 'ready', bytes };
+    }
+    catch (error) {
+        return {
+            kind: 'read_failed',
+            detail: error instanceof Error ? `${error.name}: ${error.message}` : String(error),
+        };
+    }
+}
+function buildToolResultImageIngest(args) {
+    const language = (0, work_language_1.getWorkLanguage)();
+    const providerKey = typeof args.requestContext.providerKey === 'string' &&
+        args.requestContext.providerKey.trim().length > 0
+        ? args.requestContext.providerKey.trim()
+        : 'unknown-provider';
+    const modelKey = typeof args.requestContext.modelKey === 'string' &&
+        args.requestContext.modelKey.trim().length > 0
+        ? args.requestContext.modelKey.trim()
+        : 'unknown-model';
+    const providerModel = `${providerKey}/${modelKey}`;
+    const pathLabel = typeof args.providerPathLabel === 'string' && args.providerPathLabel.trim().length > 0
+        ? args.providerPathLabel.trim()
+        : 'current provider path';
+    const relPath = args.artifact.relPath;
+    const mimeText = typeof args.mimeType === 'string' && args.mimeType.trim().length > 0
+        ? args.mimeType
+        : undefined;
+    const message = (() => {
+        if (language === 'zh') {
+            switch (args.disposition) {
+                case 'fed_native':
+                    return `本轮已将这张图片发送给 ${providerModel}。`;
+                case 'fed_provider_transformed':
+                    return `本轮已将这张图片发送给 ${providerModel}（按当前 provider 的原生图片消息方式投喂）。`;
+                case 'filtered_provider_unsupported':
+                    return `本轮未将这张图片发送给 ${providerModel}：当前 ${pathLabel} 不支持图片输入。对话仍会继续，但后续分析不会使用这张图片。`;
+                case 'filtered_model_unsupported':
+                    return `本轮未将这张图片发送给 ${providerModel}：当前模型不支持图片输入。对话仍会继续，但后续分析不会使用这张图片。`;
+                case 'filtered_mime_unsupported':
+                    return `本轮未将这张图片发送给 ${providerModel}：当前 ${pathLabel} 不接受该图片格式${mimeText ? `（${mimeText}）` : ''}。对话仍会继续，但后续分析不会使用这张图片。`;
+                case 'filtered_size_limit':
+                    return `本轮未将这张图片发送给 ${providerModel}：图片超出当前 ${pathLabel} 的限制。对话仍会继续，但后续分析不会使用这张图片。`;
+                case 'filtered_read_failed':
+                    return `本轮未将这张图片发送给 ${providerModel}：读取图片 artifact 失败（${relPath}）。对话仍会继续，但后续分析不会使用这张图片。`;
+                case 'filtered_missing':
+                    return `本轮未将这张图片发送给 ${providerModel}：图片 artifact 缺失（${relPath}）。对话仍会继续，但后续分析不会使用这张图片。`;
+                default: {
+                    const _exhaustive = args.disposition;
+                    return _exhaustive;
+                }
+            }
+        }
+        switch (args.disposition) {
+            case 'fed_native':
+                return `This round sent this image to ${providerModel}.`;
+            case 'fed_provider_transformed':
+                return `This round sent this image to ${providerModel} using the provider's native image-message projection.`;
+            case 'filtered_provider_unsupported':
+                return `This round did not send this image to ${providerModel}: the current ${pathLabel} does not support image input. The dialog will continue, but later analysis will not use this image.`;
+            case 'filtered_model_unsupported':
+                return `This round did not send this image to ${providerModel}: the current model does not support image input. The dialog will continue, but later analysis will not use this image.`;
+            case 'filtered_mime_unsupported':
+                return `This round did not send this image to ${providerModel}: the current ${pathLabel} does not accept this image format${mimeText ? ` (${mimeText})` : ''}. The dialog will continue, but later analysis will not use this image.`;
+            case 'filtered_size_limit':
+                return `This round did not send this image to ${providerModel}: the image exceeds the current ${pathLabel} limit. The dialog will continue, but later analysis will not use this image.`;
+            case 'filtered_read_failed':
+                return `This round did not send this image to ${providerModel}: failed to read the image artifact (${relPath}). The dialog will continue, but later analysis will not use this image.`;
+            case 'filtered_missing':
+                return `This round did not send this image to ${providerModel}: the image artifact is missing (${relPath}). The dialog will continue, but later analysis will not use this image.`;
+            default: {
+                const _exhaustive = args.disposition;
+                return _exhaustive;
+            }
+        }
+    })();
+    return {
+        toolCallId: args.toolCallId,
+        toolName: args.toolName,
+        artifact: args.artifact,
+        provider: providerKey,
+        model: modelKey,
+        disposition: args.disposition,
+        message,
+        ...(args.detail !== undefined ? { detail: args.detail } : {}),
+    };
+}