@spacex110/core 0.1.15 → 0.1.17

package/src/strategies.ts

@@ -1,4 +1,15 @@
-import type { Provider, Model, ModelCapability } from './types';
+import type {
+    Provider,
+    Model,
+    ModelCapability,
+    NormalizedMessage,
+    ResponseMessage,
+    MultimodalChatOptions,
+    MultimodalChatStreamOptions,
+    MultimodalChatResult,
+    MultimodalStreamDelta,
+} from './types';
+import { normalizeMessages } from './multimodal-normalize';
 
 export interface ProviderStrategy {
     format: string;
@@ -13,6 +24,21 @@ export interface ProviderStrategy {
     parseStreamChunk?: (data: any) => string;
     // Headers
     buildHeaders: (apiKey: string, baseUrl?: string) => Record<string, string>;
+    // ============ Multimodal (可选) ============
+    /** 是否支持图片/音频等多模态输入。不支持时调用方传入多模态消息应直接报错。 */
+    supportsMultimodalInput?: boolean;
+    /** 是否支持多模态输出（如文生图）。不支持时调用方传入 outputModalities 含 image 应直接报错。 */
+    supportsMultimodalOutput?: boolean;
+    /** 构造多模态聊天请求体 */
+    buildMultimodalChatPayload?: (
+        model: string,
+        messages: NormalizedMessage[],
+        options: MultimodalChatOptions
+    ) => Record<string, unknown>;
+    /** 解析多模态聊天响应为统一的 ResponseMessage */
+    parseMultimodalChatResponse?: (data: any) => ResponseMessage;
+    /** 解析 SSE 流式 chunk 为增量状态 */
+    parseMultimodalStreamChunk?: (data: any) => MultimodalStreamDelta;
 }
 
 /**
@@ -23,6 +49,21 @@ function prefersCompletionTokens(model: string): boolean {
     return /^o\d/.test(model) || /reasoner|thinking|o1|o3|o4/i.test(model);
 }
 
+/**
+ * 从 data URI 字符串中猜测 MIME 类型。
+ * 用于图片/音频响应在缺少 mimeType 字段时的回退解析。
+ *
+ * @example
+ * guessMimeFromDataUri('data:image/png;base64,xxx')  // => 'image/png'
+ * guessMimeFromDataUri('data:audio/mp3;base64,xxx')   // => 'audio/mp3'
+ * guessMimeFromDataUri('https://example.com/a.jpg')    // => null
+ */
+export function guessMimeFromDataUri(uri: string): string | null {
+    if (!uri) return null;
+    const m = /^data:([^;,]+)/.exec(uri);
+    return m ? m[1] : null;
+}
+
 /**
  * 从 API 响应中提取模型能力
  * 支持多种格式：
@@ -150,6 +191,155 @@ const openaiStrategy: ProviderStrategy = {
         // OpenAI SSE: { choices: [{ delta: { content } }] }，[DONE] 由调用方过滤
         return data.choices?.[0]?.delta?.content || '';
     },
+    // ============ Multimodal ============
+    supportsMultimodalInput: true,
+    supportsMultimodalOutput: true, // 实际能否输出由 model + modalities 决定
+    buildMultimodalChatPayload: (model, messages, options) => {
+        const converted = messages.map((m) => ({
+            role: m.role,
+            content: m.parts.map((p) => {
+                if (p.type === 'text') return { type: 'text', text: p.data };
+                if (p.type === 'image') {
+                    const detail = (p.meta?.detail as string) || 'auto';
+                    return {
+                        type: 'image_url',
+                        image_url: { url: p.data, detail },
+                    };
+                }
+                if (p.type === 'audio') {
+                    const fmt = p.mimeType?.includes('mp3') ? 'mp3' : 'wav';
+                    return {
+                        type: 'input_audio',
+                        input_audio: { data: p.data, format: fmt },
+                    };
+                }
+                return { type: 'text', text: '' };
+            }),
+        }));
+        const payload: Record<string, unknown> = { model, messages: converted };
+        if (options.maxTokens) {
+            payload[prefersCompletionTokens(model) ? 'max_completion_tokens' : 'max_tokens'] = options.maxTokens;
+        }
+        if (options.temperature !== undefined) {
+            payload.temperature = options.temperature;
+        }
+        // OpenRouter 专属：modalities 字段（启用文生图）
+        if (
+            options.outputModalities?.length &&
+            /openrouter\.ai/i.test(options.baseUrl)
+        ) {
+            payload.modalities = options.outputModalities;
+        }
+        return payload;
+    },
+    parseMultimodalChatResponse: (data) => {
+        const msg = data.choices?.[0]?.message;
+        if (!msg) {
+            return { role: 'assistant', content: '', raw: data };
+        }
+        let text = '';
+        if (typeof msg.content === 'string') {
+            text = msg.content;
+        } else if (Array.isArray(msg.content)) {
+            text = msg.content
+                .filter((p: { type: string }) => p.type === 'text')
+                .map((p: { text?: string }) => p.text || '')
+                .join('');
+        }
+        const images: import('./types').ContentResponsePart[] = [];
+        if (Array.isArray(msg.images)) {
+            for (const img of msg.images) {
+                const url: string | undefined = img.image_url?.url;
+                if (url) {
+                    images.push({
+                        type: 'image',
+                        url,
+                        mimeType: img.mimeType || guessMimeFromDataUri(url) || 'image/png',
+                    });
+                } else if (img.b64_json) {
+                    images.push({
+                        type: 'image',
+                        b64_json: img.b64_json,
+                        mimeType: img.mimeType || 'image/png',
+                    });
+                }
+            }
+        }
+        const u = data.usage;
+        const content: string | import('./types').ContentResponsePart[] =
+            images.length
+                ? [{ type: 'text', text }, ...images]
+                : (text || '');
+        return {
+            role: 'assistant',
+            content,
+            usage: u
+                ? {
+                      inputTokens: u.prompt_tokens,
+                      outputTokens: u.completion_tokens,
+                      totalTokens: u.total_tokens,
+                  }
+                : undefined,
+            raw: data,
+            finishReason: data.choices?.[0]?.finish_reason,
+        };
+    },
+    parseMultimodalStreamChunk: (data) => {
+        const delta = data.choices?.[0]?.delta;
+        if (!delta) return {};
+        const out: import('./types').MultimodalStreamDelta = {};
+        if (typeof delta.content === 'string') {
+            out.text = delta.content;
+        } else if (Array.isArray(delta.content)) {
+            out.text = delta.content
+                .filter((p: { type: string }) => p.type === 'text')
+                .map((p: { text?: string }) => p.text || '')
+                .join('');
+            const imgs = delta.content.filter(
+                (p: { type: string }) => p.type === 'image_url'
+            );
+            if (imgs.length) {
+                out.images = imgs.map(
+                    (p: { image_url?: { url?: string } }) => ({
+                        type: 'image' as const,
+                        url: p.image_url?.url,
+                        mimeType:
+                            guessMimeFromDataUri(p.image_url?.url || '') ||
+                            'image/png',
+                    })
+                );
+            }
+        }
+        if (Array.isArray(delta.images)) {
+            const extra = delta.images.map(
+                (img: {
+                    image_url?: { url?: string };
+                    b64_json?: string;
+                    mimeType?: string;
+                }) => ({
+                    type: 'image' as const,
+                    url: img.image_url?.url,
+                    b64_json: img.b64_json,
+                    mimeType:
+                        img.mimeType ||
+                        guessMimeFromDataUri(img.image_url?.url || '') ||
+                        'image/png',
+                })
+            );
+            out.images = out.images ? out.images.concat(extra) : extra;
+        }
+        if (data.choices?.[0]?.finish_reason) {
+            out.finishReason = data.choices[0].finish_reason;
+        }
+        if (data.usage) {
+            out.usage = {
+                inputTokens: data.usage.prompt_tokens,
+                outputTokens: data.usage.completion_tokens,
+                totalTokens: data.usage.total_tokens,
+            };
+        }
+        return out;
+    },
 };
 
 const anthropicStrategy: ProviderStrategy = {
@@ -195,6 +385,119 @@ const anthropicStrategy: ProviderStrategy = {
         }
         return [];
     },
+    // ============ Multimodal ============
+    supportsMultimodalInput: true,
+    supportsMultimodalOutput: false, // Anthropic 当前不支持图片输出
+    buildMultimodalChatPayload: (model, messages, options) => {
+        // 抽出 system 消息（Anthropic 顶层 system）
+        let systemText: string | undefined;
+        const contents = messages
+            .filter((m) => {
+                if (m.role === 'system') {
+                    const t = m.parts
+                        .filter((p) => p.type === 'text')
+                        .map((p) => p.data)
+                        .join('\n');
+                    systemText = (systemText ? systemText + '\n' : '') + t;
+                    return false;
+                }
+                return true;
+            })
+            .map((m) => ({
+                role: m.role === 'assistant' ? 'assistant' : 'user',
+                content: m.parts.map((p) => {
+                    if (p.type === 'text') return { type: 'text', text: p.data };
+                    if (p.type === 'image') {
+                        // 已是 data URI
+                        const m = /^data:([^;]+);base64,(.*)$/.exec(p.data);
+                        if (m) {
+                            return {
+                                type: 'image',
+                                source: {
+                                    type: 'base64',
+                                    media_type: m[1],
+                                    data: m[2],
+                                },
+                            };
+                        }
+                        // 远程 URL：直接传给 Anthropic（它支持 URL）
+                        return {
+                            type: 'image',
+                            source: { type: 'url', url: p.data },
+                        };
+                    }
+                    // audio: Anthropic 不支持音频输入，跳过（避免报错）
+                    return { type: 'text', text: '[audio content not supported]' };
+                }),
+            }));
+        const payload: Record<string, unknown> = {
+            model,
+            messages: contents,
+            max_tokens: options.maxTokens || 1024,
+        };
+        if (systemText) payload.system = systemText;
+        if (options.temperature !== undefined) payload.temperature = options.temperature;
+        return payload;
+    },
+    parseMultimodalChatResponse: (data) => {
+        // Anthropic 响应: { content: [{ type: 'text', text }, { type: 'image', source: {...} }] }
+        const blocks: import('./types').ContentResponsePart[] = [];
+        let text = '';
+        if (Array.isArray(data.content)) {
+            for (const b of data.content) {
+                if (b.type === 'text') {
+                    text += b.text || '';
+                } else if (b.type === 'image') {
+                    const url = b.source?.url;
+                    if (url) {
+                        blocks.push({
+                            type: 'image',
+                            url,
+                            mimeType: guessMimeFromDataUri(url) || 'image/png',
+                        });
+                    } else if (b.source?.type === 'base64') {
+                        blocks.push({
+                            type: 'image',
+                            url: `data:${b.source.media_type};base64,${b.source.data}`,
+                            mimeType: b.source.media_type,
+                        });
+                    }
+                }
+            }
+        }
+        const u = data.usage;
+        const content: string | import('./types').ContentResponsePart[] = blocks.length
+            ? [{ type: 'text', text }, ...blocks]
+            : text;
+        return {
+            role: 'assistant',
+            content,
+            usage: u
+                ? {
+                      inputTokens: u.input_tokens,
+                      outputTokens: u.output_tokens,
+                  }
+                : undefined,
+            raw: data,
+            finishReason: data.stop_reason,
+        };
+    },
+    parseMultimodalStreamChunk: (data) => {
+        const out: import('./types').MultimodalStreamDelta = {};
+        if (data.type === 'content_block_delta' && data.delta?.type === 'text_delta') {
+            out.text = data.delta.text || '';
+        }
+        if (data.type === 'message_delta' && data.usage) {
+            out.usage = {
+                inputTokens: data.usage.input_tokens,
+                outputTokens: data.usage.output_tokens,
+            };
+        }
+        if (data.type === 'message_stop') {
+            out.finishReason = 'stop';
+        }
+        return out;
+    },
 };
 
 const geminiStrategy: ProviderStrategy = {
@@ -238,6 +541,143 @@ const geminiStrategy: ProviderStrategy = {
         }
         return [];
     },
+    // ============ Multimodal ============
+    supportsMultimodalInput: true,
+    supportsMultimodalOutput: true, // Gemini 支持生图（responseModalities）
+    buildMultimodalChatPayload: (_model, messages, options) => {
+        // 抽出 system → systemInstruction
+        const systemText = messages
+            .filter((m) => m.role === 'system')
+            .flatMap((m) => m.parts.filter((p) => p.type === 'text').map((p) => ({ text: p.data })));
+        const contents = messages
+            .filter((m) => m.role !== 'system')
+            .map((m) => ({
+                role: m.role === 'assistant' ? 'model' : 'user',
+                parts: m.parts.map((p) => {
+                    if (p.type === 'text') return { text: p.data };
+                    if (p.type === 'image') {
+                        // 已是 data URI
+                        const m = /^data:([^;]+);base64,(.*)$/.exec(p.data);
+                        if (m) {
+                            return {
+                                inline_data: { mime_type: m[1], data: m[2] },
+                            };
+                        }
+                        // 远程 URL：使用 file_data
+                        return {
+                            file_data: { file_uri: p.data, mime_type: p.mimeType || 'image/jpeg' },
+                        };
+                    }
+                    if (p.type === 'audio') {
+                        const m = /^data:([^;]+);base64,(.*)$/.exec(p.data);
+                        if (m) {
+                            return { inline_data: { mime_type: m[1], data: m[2] } };
+                        }
+                    }
+                    return { text: '' };
+                }),
+            }));
+        const payload: Record<string, unknown> = { contents };
+        if (systemText.length) {
+            payload.systemInstruction = { parts: systemText };
+        }
+        const generationConfig: Record<string, unknown> = {};
+        if (options.maxTokens) generationConfig.maxOutputTokens = options.maxTokens;
+        if (options.temperature !== undefined) generationConfig.temperature = options.temperature;
+        // Gemini 生图：responseModalities 必须含 IMAGE
+        if (options.outputModalities?.includes('image')) {
+            generationConfig.responseModalities = ['TEXT', 'IMAGE'];
+        } else if (options.outputModalities?.length) {
+            generationConfig.responseModalities = options.outputModalities.map((m) =>
+                m.toUpperCase()
+            );
+        }
+        if (Object.keys(generationConfig).length) {
+            payload.generationConfig = generationConfig;
+        }
+        return payload;
+    },
+    parseMultimodalChatResponse: (data) => {
+        const candidate = data.candidates?.[0];
+        if (!candidate) {
+            return { role: 'assistant', content: '', raw: data };
+        }
+        const blocks: import('./types').ContentResponsePart[] = [];
+        let text = '';
+        const parts = candidate.content?.parts || [];
+        for (const part of parts) {
+            if (typeof part.text === 'string') {
+                text += part.text;
+            } else if (part.inline_data) {
+                const mime = part.inline_data.mime_type || 'image/png';
+                blocks.push({
+                    type: 'image',
+                    url: `data:${mime};base64,${part.inline_data.data}`,
+                    mimeType: mime,
+                });
+            } else if (part.file_data) {
+                blocks.push({
+                    type: 'image',
+                    url: part.file_data.file_uri,
+                    mimeType: part.file_data.mime_type,
+                });
+            }
+        }
+        const u = data.usageMetadata;
+        const content: string | import('./types').ContentResponsePart[] = blocks.length
+            ? [{ type: 'text', text }, ...blocks]
+            : text;
+        return {
+            role: 'assistant',
+            content,
+            usage: u
+                ? {
+                      inputTokens: u.promptTokenCount,
+                      outputTokens: u.candidatesTokenCount,
+                      totalTokens: u.totalTokenCount,
+                  }
+                : undefined,
+            raw: data,
+            finishReason: candidate.finishReason,
+        };
+    },
+    parseMultimodalStreamChunk: (data) => {
+        const out: import('./types').MultimodalStreamDelta = {};
+        const candidate = data.candidates?.[0];
+        if (!candidate) return out;
+        let text = '';
+        const blocks: NonNullable<import('./types').MultimodalStreamDelta['images']> = [];
+        const parts = candidate.content?.parts || [];
+        for (const part of parts) {
+            if (typeof part.text === 'string') {
+                text += part.text;
+            } else if (part.inline_data) {
+                const mime = part.inline_data.mime_type || 'image/png';
+                blocks.push({
+                    type: 'image',
+                    url: `data:${mime};base64,${part.inline_data.data}`,
+                    mimeType: mime,
+                });
+            } else if (part.file_data) {
+                blocks.push({
+                    type: 'image',
+                    url: part.file_data.file_uri,
+                    mimeType: part.file_data.mime_type,
+                });
+            }
+        }
+        if (text) out.text = text;
+        if (blocks.length) out.images = blocks;
+        if (candidate.finishReason) out.finishReason = candidate.finishReason;
+        if (data.usageMetadata) {
+            out.usage = {
+                inputTokens: data.usageMetadata.promptTokenCount,
+                outputTokens: data.usageMetadata.candidatesTokenCount,
+                totalTokens: data.usageMetadata.totalTokenCount,
+            };
+        }
+        return out;
+    },
 };
 
 const cohereStrategy: ProviderStrategy = {
@@ -270,6 +710,74 @@ const cohereStrategy: ProviderStrategy = {
         }
         return '';
     },
+    // ============ Multimodal ============
+    supportsMultimodalInput: true,
+    supportsMultimodalOutput: false, // Cohere v2 当前不支持图片输出
+    buildMultimodalChatPayload: (model, messages, options) => {
+        const converted = messages.map((m) => ({
+            role: m.role,
+            content: m.parts.map((p) => {
+                if (p.type === 'text') return { type: 'text', text: p.data };
+                if (p.type === 'image') {
+                    // Cohere v2 image 输入：URL 或 base64
+                    return {
+                        type: 'image_url',
+                        image_url: { url: p.data },
+                    };
+                }
+                // audio：跳过
+                return { type: 'text', text: '[audio content not supported]' };
+            }),
+        }));
+        const payload: Record<string, unknown> = { model, messages: converted };
+        if (options.maxTokens) payload.max_tokens = options.maxTokens;
+        if (options.temperature !== undefined) payload.temperature = options.temperature;
+        return payload;
+    },
+    parseMultimodalChatResponse: (data) => {
+        // Cohere v2 响应: { message: { content: [{ type, text }] } }
+        const blocks: import('./types').ContentResponsePart[] = [];
+        let text = '';
+        const parts = data.message?.content || [];
+        for (const p of parts) {
+            if (p.type === 'text') {
+                text += p.text || '';
+            } else if (p.type === 'image_url' || p.type === 'image') {
+                const url = p.image_url?.url || p.url;
+                if (url) {
+                    blocks.push({
+                        type: 'image',
+                        url,
+                        mimeType: guessMimeFromDataUri(url) || 'image/png',
+                    });
+                }
+            }
+        }
+        const u = data.usage;
+        const content: string | import('./types').ContentResponsePart[] = blocks.length
+            ? [{ type: 'text', text }, ...blocks]
+            : text;
+        return {
+            role: 'assistant',
+            content,
+            usage: u
+                ? {
+                      inputTokens: u.tokens?.input_tokens,
+                      outputTokens: u.tokens?.output_tokens,
+                  }
+                : undefined,
+            raw: data,
+            finishReason: data.finish_reason,
+        };
+    },
+    parseMultimodalStreamChunk: (data) => {
+        const out: import('./types').MultimodalStreamDelta = {};
+        if (data.type === 'content-delta') {
+            const text = data.delta?.message?.content?.[0]?.text;
+            if (text) out.text = text;
+        }
+        return out;
+    },
 };
 
 export const strategyRegistry: Record<string, ProviderStrategy> = {
@@ -472,3 +980,229 @@ export async function testDirectConnection(options: TestConnectionOptions): Prom
         message: result.success ? undefined : result.message,
     };
 }
+
+// ============ Multimodal Chat ============
+
+/**
+ * 把策略解析后的 ResponseMessage 转换为统一对外的 MultimodalChatResult。
+ * 提取 text 与 images，统一错误信息。
+ */
+function normalizeParsedToResult(
+    parsed: ResponseMessage,
+    latencyMs: number,
+    fallbackRaw?: unknown
+): MultimodalChatResult {
+    if (typeof parsed.content === 'string') {
+        return {
+            success: true,
+            text: parsed.content,
+            usage: parsed.usage,
+            latencyMs,
+            finishReason: parsed.finishReason,
+            raw: parsed.raw ?? fallbackRaw,
+        };
+    }
+    // 多模态数组：拆出 images
+    const images: NonNullable<MultimodalChatResult['images']> = [];
+    let text = '';
+    for (const part of parsed.content) {
+        if (part.type === 'text') {
+            text += part.text;
+        } else if (part.type === 'image') {
+            images.push({
+                type: 'image',
+                url: part.url,
+                b64_json: part.b64_json,
+                mimeType: part.mimeType,
+            });
+        }
+    }
+    return {
+        success: true,
+        text: text || undefined,
+        images: images.length ? images : undefined,
+        usage: parsed.usage,
+        latencyMs,
+        finishReason: parsed.finishReason,
+        raw: parsed.raw ?? fallbackRaw,
+    };
+}
+
+/**
+ * 发送多模态聊天请求（输入支持文本/图片/音频；输出可选图片）。
+ * 与 sendDirectChat 并存，是独立 API，不影响纯文本路径。
+ */
+export async function sendMultimodalChat(
+    options: MultimodalChatOptions
+): Promise<MultimodalChatResult> {
+    const strategy = getStrategy(options.apiFormat);
+    if (!strategy.buildMultimodalChatPayload || !strategy.parseMultimodalChatResponse) {
+        return {
+            success: false,
+            message: `协议 ${options.apiFormat} 不支持多模态聊天`,
+        };
+    }
+    if (
+        options.outputModalities?.includes('image') &&
+        !strategy.supportsMultimodalOutput
+    ) {
+        return {
+            success: false,
+            message: `协议 ${options.apiFormat} 不支持图片输出`,
+        };
+    }
+    try {
+        const normalized = await normalizeMessages(options.messages);
+        const endpoint = strategy.getChatEndpoint(options.baseUrl, options.apiKey, options.model);
+        const headers = { ...strategy.buildHeaders(options.apiKey, options.baseUrl), ...(options.extraHeaders || {}) };
+        const payload = strategy.buildMultimodalChatPayload(options.model, normalized, options);
+        const start = performance.now();
+        const controller = new AbortController();
+        const timer = options.timeoutMs ? setTimeout(() => controller.abort(), options.timeoutMs) : null;
+        try {
+            const resp = await fetch(endpoint, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(payload),
+                signal: controller.signal,
+            });
+            const latencyMs = Math.round(performance.now() - start);
+            if (!resp.ok) {
+                const err = await resp.json().catch(() => ({}));
+                return {
+                    success: false,
+                    message: err?.error?.message || `HTTP ${resp.status}`,
+                    latencyMs,
+                    raw: err,
+                };
+            }
+            const data = await resp.json();
+            const parsed = strategy.parseMultimodalChatResponse(data);
+            return normalizeParsedToResult(parsed, latencyMs, data);
+        } finally {
+            if (timer) clearTimeout(timer);
+        }
+    } catch (e: unknown) {
+        const msg = e instanceof Error ? e.message : '网络错误';
+        return { success: false, message: msg };
+    }
+}
+
+/**
+ * 发送多模态聊天请求（SSE 流式）。
+ * 每次收到协议 chunk 都会触发 onDelta 回调：
+ *   - state.text 累计完整文本
+ *   - state.images 累计完整图片数组（浅拷贝）
+ */
+export async function sendMultimodalChatStream(
+    options: MultimodalChatStreamOptions
+): Promise<MultimodalChatResult> {
+    const strategy = getStrategy(options.apiFormat);
+    if (!strategy.buildMultimodalChatPayload || !strategy.parseMultimodalStreamChunk) {
+        return {
+            success: false,
+            message: `协议 ${options.apiFormat} 不支持多模态流式聊天`,
+        };
+    }
+    if (
+        options.outputModalities?.includes('image') &&
+        !strategy.supportsMultimodalOutput
+    ) {
+        return {
+            success: false,
+            message: `协议 ${options.apiFormat} 不支持图片输出`,
+        };
+    }
+    try {
+        const normalized = await normalizeMessages(options.messages);
+        // 流式：OpenAI 加 stream:true；Anthropic 走 stream endpoint；Gemini 走 streamGenerateContent
+        let endpoint = strategy.getChatEndpoint(options.baseUrl, options.apiKey, options.model);
+        const headers = { ...strategy.buildHeaders(options.apiKey, options.baseUrl), ...(options.extraHeaders || {}) };
+        const payload = strategy.buildMultimodalChatPayload(options.model, normalized, options);
+        (payload as Record<string, unknown>).stream = true;
+        // Gemini 流式端点特殊
+        if (options.apiFormat === 'gemini') {
+            endpoint = endpoint.replace(':generateContent', ':streamGenerateContent');
+        }
+        const start = performance.now();
+        const controller = new AbortController();
+        const timer = options.timeoutMs ? setTimeout(() => controller.abort(), options.timeoutMs) : null;
+        let accText = '';
+        const accImages: NonNullable<MultimodalChatResult['images']> = [];
+        let finishReason: string | undefined;
+        let usage: MultimodalChatResult['usage'];
+        try {
+            const resp = await fetch(endpoint, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(payload),
+                signal: controller.signal,
+            });
+            if (!resp.ok) {
+                const err = await resp.json().catch(() => ({}));
+                return {
+                    success: false,
+                    message: err?.error?.message || `HTTP ${resp.status}`,
+                    latencyMs: Math.round(performance.now() - start),
+                    raw: err,
+                };
+            }
+            const reader = resp.body?.getReader();
+            if (!reader) {
+                return { success: false, message: '响应无 body', latencyMs: Math.round(performance.now() - start) };
+            }
+            const decoder = new TextDecoder();
+            let buffer = '';
+            while (true) {
+                const { value, done } = await reader.read();
+                if (done) break;
+                buffer += decoder.decode(value, { stream: true });
+                // SSE 帧分割
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (!trimmed || !trimmed.startsWith('data:')) continue;
+                    const data = trimmed.slice(5).trim();
+                    if (data === '[DONE]') continue;
+                    try {
+                        const parsed = JSON.parse(data);
+                        const chunk = strategy.parseMultimodalStreamChunk!(parsed);
+                        if (chunk.text !== undefined) {
+                            accText += chunk.text;
+                        }
+                        if (chunk.images?.length) {
+                            // 替换为最新累计数组（按协议通常整块出现）
+                            accImages.length = 0;
+                            accImages.push(...chunk.images);
+                        }
+                        if (chunk.finishReason) finishReason = chunk.finishReason;
+                        if (chunk.usage) usage = chunk.usage;
+                        // 触发回调（深拷贝 images 防止外部修改）
+                        options.onDelta({
+                            text: accText,
+                            images: accImages.length ? accImages.slice() : undefined,
+                            finishReason,
+                            usage,
+                        });
+                    } catch {
+                        // 忽略解析错误的帧（心跳等）
+                    }
+                }
+            }
+            return {
+                success: true,
+                text: accText || undefined,
+                images: accImages.length ? accImages.slice() : undefined,
+                usage,
+                finishReason,
+                latencyMs: Math.round(performance.now() - start),
+            };
+        } finally {
+            if (timer) clearTimeout(timer);
+        }
+    } catch (e: unknown) {
+        const msg = e instanceof Error ? e.message : '网络错误';
+        return { success: false, message: msg };
+    }
+}