dominds 1.17.7 → 1.18.2

package/dist/llm/gen/openai.js

@@ -211,6 +211,127 @@ function chatMessageToOpenAiInputItem(msg) {
         }
     }
 }
+async function userLikeMessageToOpenAiInputItemWithImages(msg, requestContext, providerConfig, allowedImageKeys, onUserImageIngest) {
+    const items = msg.contentItems;
+    if (!Array.isArray(items) || items.length === 0) {
+        return chatMessageToOpenAiInputItem(msg);
+    }
+    const content = [{ type: 'input_text', text: msg.content }];
+    const supportsImageInput = (0, tool_result_image_ingest_1.resolveModelImageInputSupport)(requestContext.modelKey === undefined
+        ? undefined
+        : providerConfig?.models[requestContext.modelKey], true);
+    for (const [itemIndex, item] of items.entries()) {
+        if (item.type === 'input_text') {
+            content.push({ type: 'input_text', text: item.text });
+            continue;
+        }
+        if (item.type === 'input_image') {
+            if (!supportsImageInput) {
+                if (onUserImageIngest) {
+                    await onUserImageIngest((0, tool_result_image_ingest_1.buildUserImageIngest)({
+                        requestContext,
+                        ...(msg.type === 'prompting_msg' ? { msgId: msg.msgId } : {}),
+                        artifact: item.artifact,
+                        disposition: 'filtered_model_unsupported',
+                        providerPathLabel: 'OpenAI Responses path',
+                    }));
+                }
+                content.push({
+                    type: 'input_text',
+                    text: `[image not sent: current model does not support image input]`,
+                });
+                continue;
+            }
+            if (!(0, artifacts_1.isVisionImageMimeType)(item.mimeType)) {
+                if (onUserImageIngest) {
+                    await onUserImageIngest((0, tool_result_image_ingest_1.buildUserImageIngest)({
+                        requestContext,
+                        ...(msg.type === 'prompting_msg' ? { msgId: msg.msgId } : {}),
+                        artifact: item.artifact,
+                        disposition: 'filtered_mime_unsupported',
+                        mimeType: item.mimeType,
+                        providerPathLabel: 'OpenAI Responses path',
+                    }));
+                }
+                content.push({
+                    type: 'input_text',
+                    text: `[image not sent: unsupported mimeType=${item.mimeType}]`,
+                });
+                continue;
+            }
+            if (!allowedImageKeys.has((0, tool_result_image_ingest_1.buildImageBudgetKeyForContentItem)({ msg, itemIndex, artifact: item.artifact }))) {
+                if (onUserImageIngest) {
+                    await onUserImageIngest((0, tool_result_image_ingest_1.buildUserImageIngest)({
+                        requestContext,
+                        ...(msg.type === 'prompting_msg' ? { msgId: msg.msgId } : {}),
+                        artifact: item.artifact,
+                        disposition: 'filtered_size_limit',
+                        detail: (0, tool_result_image_ingest_1.buildImageBudgetLimitDetail)({
+                            byteLength: item.byteLength,
+                            budgetBytes: tool_result_image_ingest_1.OPENAI_TOOL_RESULT_IMAGE_BUDGET_BYTES,
+                        }),
+                        providerPathLabel: 'OpenAI Responses path',
+                    }));
+                }
+                content.push({
+                    type: 'input_text',
+                    text: `[image not sent: 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 (onUserImageIngest) {
+                    await onUserImageIngest((0, tool_result_image_ingest_1.buildUserImageIngest)({
+                        requestContext,
+                        ...(msg.type === 'prompting_msg' ? { msgId: msg.msgId } : {}),
+                        artifact: item.artifact,
+                        disposition: 'filtered_missing',
+                        providerPathLabel: 'OpenAI Responses path',
+                    }));
+                }
+                content.push({ type: 'input_text', text: `[image missing: ${item.artifact.relPath}]` });
+                continue;
+            }
+            if (bytesResult.kind === 'read_failed') {
+                if (onUserImageIngest) {
+                    await onUserImageIngest((0, tool_result_image_ingest_1.buildUserImageIngest)({
+                        requestContext,
+                        ...(msg.type === 'prompting_msg' ? { msgId: msg.msgId } : {}),
+                        artifact: item.artifact,
+                        disposition: 'filtered_read_failed',
+                        detail: bytesResult.detail,
+                        providerPathLabel: 'OpenAI Responses path',
+                    }));
+                }
+                content.push({ type: 'input_text', text: `[image unreadable: ${item.artifact.relPath}]` });
+                continue;
+            }
+            if (onUserImageIngest) {
+                await onUserImageIngest((0, tool_result_image_ingest_1.buildUserImageIngest)({
+                    requestContext,
+                    ...(msg.type === 'prompting_msg' ? { msgId: msg.msgId } : {}),
+                    artifact: item.artifact,
+                    disposition: 'fed_native',
+                    providerPathLabel: 'OpenAI Responses path',
+                }));
+            }
+            content.push({
+                type: 'input_image',
+                detail: 'auto',
+                image_url: (0, artifacts_1.bytesToDataUrl)({ mimeType: item.mimeType, bytes: bytesResult.bytes }),
+            });
+            continue;
+        }
+        const _exhaustive = item;
+        throw new Error(`Unsupported user content item: ${String(_exhaustive)}`);
+    }
+    return {
+        type: 'message',
+        role: 'user',
+        content,
+    };
+}
 function buildReasoningPayloadFromText(text) {
     if (text.trim().length === 0)
         return undefined;
@@ -238,7 +359,7 @@ function thinkingMessageToOpenAiReasoningItem(msg) {
     }
     return out;
 }
-async function funcResultToOpenAiInputItemWithLimit(msg, limitChars, requestContext, allowedImageKeys, onToolResultImageIngest) {
+async function funcResultToOpenAiInputItemWithLimit(msg, limitChars, requestContext, allowedImageKeys, supportsImageInput, onToolResultImageIngest) {
     const items = msg.contentItems;
     if (!Array.isArray(items) || items.length === 0) {
         return {
@@ -248,12 +369,29 @@ async function funcResultToOpenAiInputItemWithLimit(msg, limitChars, requestCont
         };
     }
     const output = [];
-    for (const item of items) {
+    for (const [itemIndex, item] of items.entries()) {
         if (item.type === 'input_text') {
             output.push({ type: 'input_text', text: item.text });
             continue;
         }
         if (item.type === 'input_image') {
+            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_model_unsupported',
+                        providerPathLabel: 'OpenAI Responses path',
+                    }));
+                }
+                output.push({
+                    type: 'input_text',
+                    text: `[image not sent: current model does not support image input]`,
+                });
+                continue;
+            }
             if (!(0, artifacts_1.isVisionImageMimeType)(item.mimeType)) {
                 if (onToolResultImageIngest) {
                     await onToolResultImageIngest((0, tool_result_image_ingest_1.buildToolResultImageIngest)({
@@ -272,7 +410,7 @@ async function funcResultToOpenAiInputItemWithLimit(msg, limitChars, requestCont
                 });
                 continue;
             }
-            if (!allowedImageKeys.has((0, tool_result_image_ingest_1.buildToolResultImageBudgetKeyForMsg)(msg, item.artifact))) {
+            if (!allowedImageKeys.has((0, tool_result_image_ingest_1.buildImageBudgetKeyForContentItem)({ msg, itemIndex, artifact: item.artifact }))) {
                 if (onToolResultImageIngest) {
                     await onToolResultImageIngest((0, tool_result_image_ingest_1.buildToolResultImageIngest)({
                         requestContext,
@@ -280,7 +418,7 @@ async function funcResultToOpenAiInputItemWithLimit(msg, limitChars, requestCont
                         toolName: msg.name,
                         artifact: item.artifact,
                         disposition: 'filtered_size_limit',
-                        detail: (0, tool_result_image_ingest_1.buildToolResultImageBudgetLimitDetail)({
+                        detail: (0, tool_result_image_ingest_1.buildImageBudgetLimitDetail)({
                             byteLength: item.byteLength,
                             budgetBytes: tool_result_image_ingest_1.OPENAI_TOOL_RESULT_IMAGE_BUDGET_BYTES,
                         }),
@@ -394,7 +532,7 @@ function shouldIncludeOpenAiEncryptedReasoning(input, reasoning) {
         return true;
     return input.some((item) => isRecord(item) && item.type === 'reasoning');
 }
-async function buildOpenAiRequestInput(context, requestContext, providerConfig, onToolResultImageIngest) {
+async function buildOpenAiRequestInput(context, requestContext, providerConfig, onToolResultImageIngest, onUserImageIngest) {
     const normalized = (0, tool_call_context_1.normalizeToolCallPairs)(context);
     const violation = (0, tool_call_context_1.findFirstToolCallAdjacencyViolation)(normalized);
     if (violation) {
@@ -409,10 +547,21 @@ async function buildOpenAiRequestInput(context, requestContext, 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);
+    const allowedImageKeys = (0, tool_result_image_ingest_1.selectLatestImagesWithinBudget)(normalized, tool_result_image_ingest_1.OPENAI_TOOL_RESULT_IMAGE_BUDGET_BYTES);
+    const supportsImageInput = (0, tool_result_image_ingest_1.resolveModelImageInputSupport)(requestContext.modelKey === undefined
+        ? undefined
+        : providerConfig?.models[requestContext.modelKey], true);
     for (const msg of normalized) {
+        if ((msg.type === 'prompting_msg' ||
+            msg.type === 'tellask_result_msg' ||
+            msg.type === 'tellask_carryover_msg') &&
+            Array.isArray(msg.contentItems) &&
+            msg.contentItems.length > 0) {
+            input.push(await userLikeMessageToOpenAiInputItemWithImages(msg, requestContext, providerConfig, allowedImageKeys, onUserImageIngest));
+            continue;
+        }
         if (msg.type === 'func_result_msg') {
-            input.push(await funcResultToOpenAiInputItemWithLimit(msg, toolResultMaxChars, requestContext, allowedImageKeys, onToolResultImageIngest));
+            input.push(await funcResultToOpenAiInputItemWithLimit(msg, toolResultMaxChars, requestContext, allowedImageKeys, supportsImageInput, onToolResultImageIngest));
             continue;
         }
         input.push(chatMessageToOpenAiInputItem(msg));
@@ -1063,7 +1212,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, requestContext, providerConfig, receiver.toolResultImageIngest);
+        const requestInput = await buildOpenAiRequestInput(context, requestContext, providerConfig, receiver.toolResultImageIngest, receiver.userImageIngest);
         const openAiParams = agent.model_params?.openai || {};
         const maxTokens = agent.model_params?.max_tokens;
         const modelInfo = providerConfig.models[agent.model];
@@ -1100,12 +1249,13 @@ class OpenAiGen {
         let sayingStarted = false;
         let thinkingStarted = false;
         let currentThinkingContent = '';
-        let finishedThinkingFromDelta = false;
         let sawOutputText = false;
         let currentAudioTranscript = '';
         let activeStream = 'idle';
         let usage = { kind: 'unavailable' };
         let returnedModel;
+        const streamedReasoningItemIds = new Set();
+        let sawReasoningDeltaWithoutItemId = false;
         const nativeToolTracker = new OpenAiNativeToolTracker();
         function claimNativeToolStateByEventItemId(itemId, itemType, title) {
             try {
@@ -1334,6 +1484,12 @@ class OpenAiGen {
                                 await receiver.thinkingStart();
                                 activeStream = 'thinking';
                             }
+                            if (typeof event.item_id === 'string' && event.item_id.length > 0) {
+                                streamedReasoningItemIds.add(event.item_id);
+                            }
+                            else {
+                                sawReasoningDeltaWithoutItemId = true;
+                            }
                             currentThinkingContent += delta;
                             await receiver.thinkingChunk(delta);
                         }
@@ -1367,7 +1523,6 @@ class OpenAiGen {
                             await receiver.thinkingFinish(buildReasoningPayloadFromText(currentThinkingContent));
                             thinkingStarted = false;
                             currentThinkingContent = '';
-                            finishedThinkingFromDelta = true;
                             if (activeStream === 'thinking')
                                 activeStream = 'idle';
                         }
@@ -1476,8 +1631,17 @@ class OpenAiGen {
                             break;
                         }
                         if (isRecord(item) && item.type === 'reasoning') {
-                            if (finishedThinkingFromDelta) {
-                                finishedThinkingFromDelta = false;
+                            const itemId = typeof item.id === 'string' && item.id.length > 0 ? item.id : null;
+                            const sawReasoningDelta = itemId !== null
+                                ? streamedReasoningItemIds.has(itemId)
+                                : sawReasoningDeltaWithoutItemId;
+                            if (sawReasoningDelta) {
+                                if (itemId !== null) {
+                                    streamedReasoningItemIds.delete(itemId);
+                                }
+                                else {
+                                    sawReasoningDeltaWithoutItemId = false;
+                                }
                                 break;
                             }
                             const payload = extractReasoningPayload(item);
@@ -1821,6 +1985,8 @@ class OpenAiGen {
         const outputs = [];
         const requestInput = await buildOpenAiRequestInput(context, requestContext, providerConfig, async (ingest) => {
             outputs.push({ kind: 'tool_result_image_ingest', ingest });
+        }, async (ingest) => {
+            outputs.push({ kind: 'user_image_ingest', ingest });
         });
         const openAiParams = agent.model_params?.openai || {};
         const maxTokens = agent.model_params?.max_tokens;

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

@@ -1,6 +1,6 @@
 import type { ToolResultImageArtifact, ToolResultImageDisposition } from '@longrun-ai/kernel/types/storage';
-import type { ChatMessage, FuncResultMsg } from '../client';
-import type { LlmRequestContext, ToolResultImageIngest } from '../gen';
+import type { ChatMessage, ModelInfo } from '../client';
+import type { LlmRequestContext, ToolResultImageIngest, UserImageIngest } from '../gen';
 type ToolResultImageReadResult = {
     kind: 'ready';
     bytes: Buffer;
@@ -14,17 +14,17 @@ 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: {
+export declare function resolveModelImageInputSupport(modelInfo: ModelInfo | undefined, defaultValue: boolean): boolean;
+export declare function buildImageBudgetLimitDetail(args: {
     byteLength: number;
     budgetBytes: number;
 }): string;
-export declare function buildToolResultImageBudgetKey(args: {
-    genseq: number;
-    toolCallId: string;
+export declare function buildImageBudgetKeyForContentItem(args: {
+    msg: ChatMessage;
+    itemIndex: number;
     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 selectLatestImagesWithinBudget(context: ChatMessage[], budgetBytes: number): Set<string>;
 export declare function readToolResultImageBytesSafe(artifact: ToolResultImageArtifact): Promise<ToolResultImageReadResult>;
 export declare function buildToolResultImageIngest(args: {
     requestContext: LlmRequestContext;
@@ -36,4 +36,13 @@ export declare function buildToolResultImageIngest(args: {
     detail?: string;
     providerPathLabel?: string;
 }): ToolResultImageIngest;
+export declare function buildUserImageIngest(args: {
+    requestContext: LlmRequestContext;
+    msgId?: string;
+    artifact: ToolResultImageArtifact;
+    disposition: ToolResultImageDisposition;
+    mimeType?: string;
+    detail?: string;
+    providerPathLabel?: string;
+}): UserImageIngest;
 export {};

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

@@ -1,12 +1,13 @@
 "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.resolveModelImageInputSupport = resolveModelImageInputSupport;
+exports.buildImageBudgetLimitDetail = buildImageBudgetLimitDetail;
+exports.buildImageBudgetKeyForContentItem = buildImageBudgetKeyForContentItem;
+exports.selectLatestImagesWithinBudget = selectLatestImagesWithinBudget;
 exports.readToolResultImageBytesSafe = readToolResultImageBytesSafe;
 exports.buildToolResultImageIngest = buildToolResultImageIngest;
+exports.buildUserImageIngest = buildUserImageIngest;
 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.
@@ -23,32 +24,71 @@ 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) {
+function resolveModelImageInputSupport(modelInfo, defaultValue) {
+    const value = modelInfo?.['supports_image_input'];
+    if (value === undefined)
+        return defaultValue;
+    return value === true;
+}
+function resolveProviderModelLabel(requestContext) {
+    const providerKey = typeof requestContext.providerKey === 'string' && requestContext.providerKey.trim().length > 0
+        ? requestContext.providerKey.trim()
+        : 'unknown-provider';
+    const modelKey = typeof requestContext.modelKey === 'string' && requestContext.modelKey.trim().length > 0
+        ? requestContext.modelKey.trim()
+        : 'unknown-model';
+    return {
+        providerKey,
+        modelKey,
+        providerModel: `${providerKey}/${modelKey}`,
+    };
+}
+function buildImageBudgetLimitDetail(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 imageBudgetMessageKey(msg) {
+    switch (msg.type) {
+        case 'prompting_msg':
+            return `prompting:${String(msg.genseq)}:${msg.msgId}`;
+        case 'func_result_msg':
+            return `func_result:${String(msg.genseq)}:${msg.id}`;
+        case 'tellask_result_msg':
+            return `tellask_result:${msg.callName}:${msg.callId}`;
+        case 'tellask_carryover_msg':
+            return `tellask_carryover:${String(msg.genseq)}:${msg.callName}:${msg.callId}`;
+        case 'environment_msg':
+        case 'transient_guide_msg':
+        case 'saying_msg':
+        case 'thinking_msg':
+        case 'func_call_msg':
+            return null;
+        default: {
+            const _exhaustive = msg;
+            return _exhaustive;
+        }
+    }
 }
-function buildToolResultImageBudgetKeyForMsg(msg, artifact) {
-    return buildToolResultImageBudgetKey({
-        genseq: msg.genseq,
-        toolCallId: msg.id,
-        artifact,
-    });
+function buildImageBudgetKeyForContentItem(args) {
+    const msgKey = imageBudgetMessageKey(args.msg);
+    if (msgKey === null) {
+        throw new Error(`Message type ${args.msg.type} cannot carry image budget items`);
+    }
+    return `${msgKey}:${String(args.itemIndex)}:${args.artifact.rootId}:${args.artifact.selfId}:${args.artifact.relPath}`;
 }
-function selectLatestToolResultImagesWithinBudget(context, budgetBytes) {
+function selectLatestImagesWithinBudget(context, budgetBytes) {
     const candidates = [];
     for (const msg of context) {
-        if (msg.type !== 'func_result_msg')
+        const msgKey = imageBudgetMessageKey(msg);
+        if (msgKey === null)
             continue;
-        const items = msg.contentItems;
+        const items = 'contentItems' in msg ? msg.contentItems : undefined;
         if (!Array.isArray(items) || items.length === 0)
             continue;
-        for (const item of items) {
+        for (const [itemIndex, item] of items.entries()) {
             if (item.type !== 'input_image')
                 continue;
             candidates.push({
-                key: buildToolResultImageBudgetKeyForMsg(msg, item.artifact),
+                key: buildImageBudgetKeyForContentItem({ msg, itemIndex, artifact: item.artifact }),
                 byteLength: item.byteLength,
             });
         }
@@ -81,15 +121,7 @@ async function readToolResultImageBytesSafe(artifact) {
 }
 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 { providerKey, modelKey, providerModel } = resolveProviderModelLabel(args.requestContext);
     const pathLabel = typeof args.providerPathLabel === 'string' && args.providerPathLabel.trim().length > 0
         ? args.providerPathLabel.trim()
         : 'current provider path';
@@ -156,3 +188,71 @@ function buildToolResultImageIngest(args) {
         ...(args.detail !== undefined ? { detail: args.detail } : {}),
     };
 }
+function buildUserImageIngest(args) {
+    const language = (0, work_language_1.getWorkLanguage)();
+    const { providerKey, modelKey, providerModel } = resolveProviderModelLabel(args.requestContext);
+    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 user attachment image to ${providerModel}.`;
+            case 'fed_provider_transformed':
+                return `This round sent this user attachment image to ${providerModel} using the provider's native image-message projection.`;
+            case 'filtered_provider_unsupported':
+                return `This round did not send this user attachment image to ${providerModel}: the current ${pathLabel} does not support image input. The dialog will continue, but the model will not see this image.`;
+            case 'filtered_model_unsupported':
+                return `This round did not send this user attachment image to ${providerModel}: the current model does not support image input. The dialog will continue, but the model will not see this image.`;
+            case 'filtered_mime_unsupported':
+                return `This round did not send this user attachment image to ${providerModel}: the current ${pathLabel} does not accept this image format${mimeText ? ` (${mimeText})` : ''}. The dialog will continue, but the model will not see this image.`;
+            case 'filtered_size_limit':
+                return `This round did not send this user attachment image to ${providerModel}: the image exceeds the current ${pathLabel} limit. The dialog will continue, but the model will not see this image.`;
+            case 'filtered_read_failed':
+                return `This round did not send this user attachment image to ${providerModel}: failed to read the image artifact (${relPath}). The dialog will continue, but the model will not see this image.`;
+            case 'filtered_missing':
+                return `This round did not send this user attachment image to ${providerModel}: the image artifact is missing (${relPath}). The dialog will continue, but the model will not see this image.`;
+            default: {
+                const _exhaustive = args.disposition;
+                return _exhaustive;
+            }
+        }
+    })();
+    return {
+        ...(args.msgId !== undefined ? { msgId: args.msgId } : {}),
+        artifact: args.artifact,
+        provider: providerKey,
+        model: modelKey,
+        disposition: args.disposition,
+        message,
+        ...(args.detail !== undefined ? { detail: args.detail } : {}),
+    };
+}

package/dist/llm/gen.d.ts

@@ -29,6 +29,9 @@ export type LlmBatchOutput = {
 } | {
     kind: 'tool_result_image_ingest';
     ingest: ToolResultImageIngest;
+} | {
+    kind: 'user_image_ingest';
+    ingest: UserImageIngest;
 };
 export interface LlmBatchResult {
     messages: ChatMessage[];
@@ -63,6 +66,15 @@ export type ToolResultImageIngest = {
     message: string;
     detail?: string;
 };
+export type UserImageIngest = {
+    msgId?: string;
+    artifact: ToolResultImageArtifact;
+    provider: string;
+    model: string;
+    disposition: ToolResultImageDisposition;
+    message: string;
+    detail?: string;
+};
 export type CodexLlmWebSearchAction = {
     type: 'search';
     query?: string;
@@ -136,6 +148,7 @@ export interface LlmStreamReceiver {
     webSearchCall?: (call: LlmWebSearchCall) => Promise<void>;
     nativeToolCall?: (call: OpenAiResponsesNativeToolCall) => Promise<void>;
     toolResultImageIngest?: (ingest: ToolResultImageIngest) => Promise<void>;
+    userImageIngest?: (ingest: UserImageIngest) => Promise<void>;
     streamError?: (detail: string) => Promise<void>;
 }
 export interface LlmGenerator {