@anh3d0nic/qwen-code-termux-ice 21.0.1 → 21.2.0

package/core-dist/src/core/openaiContentGenerator/converter.test.js

@@ -0,0 +1,1966 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { describe, it, expect, beforeEach } from 'vitest';
+import { OpenAIContentConverter } from './converter.js';
+import { Type, FinishReason, } from '@google/genai';
+import { convertToFunctionResponse } from '../coreToolScheduler.js';
+describe('OpenAIContentConverter', () => {
+    let converter;
+    beforeEach(() => {
+        converter = new OpenAIContentConverter('test-model', 'auto', {
+            image: true,
+            pdf: true,
+            audio: true,
+            video: true,
+        });
+    });
+    describe('resetStreamingToolCalls', () => {
+        it('should clear streaming tool calls accumulator', () => {
+            // Access private field for testing
+            const parser = converter.streamingToolCallParser;
+            // Add some test data to the parser
+            parser.addChunk(0, '{"arg": "value"}', 'test-id', 'test-function');
+            parser.addChunk(1, '{"arg2": "value2"}', 'test-id-2', 'test-function-2');
+            // Verify data is present
+            expect(parser.getBuffer(0)).toBe('{"arg": "value"}');
+            expect(parser.getBuffer(1)).toBe('{"arg2": "value2"}');
+            // Call reset method
+            converter.resetStreamingToolCalls();
+            // Verify data is cleared
+            expect(parser.getBuffer(0)).toBe('');
+            expect(parser.getBuffer(1)).toBe('');
+        });
+        it('should be safe to call multiple times', () => {
+            // Call reset multiple times
+            converter.resetStreamingToolCalls();
+            converter.resetStreamingToolCalls();
+            converter.resetStreamingToolCalls();
+            // Should not throw any errors
+            const parser = converter.streamingToolCallParser;
+            expect(parser.getBuffer(0)).toBe('');
+        });
+        it('should be safe to call on empty accumulator', () => {
+            // Call reset on empty accumulator
+            converter.resetStreamingToolCalls();
+            // Should not throw any errors
+            const parser = converter.streamingToolCallParser;
+            expect(parser.getBuffer(0)).toBe('');
+        });
+    });
+    describe('convertGeminiRequestToOpenAI', () => {
+        const createRequestWithFunctionResponse = (response) => {
+            const contents = [
+                {
+                    role: 'model',
+                    parts: [
+                        {
+                            functionCall: {
+                                id: 'call_1',
+                                name: 'shell',
+                                args: {},
+                            },
+                        },
+                    ],
+                },
+                {
+                    role: 'user',
+                    parts: [
+                        {
+                            functionResponse: {
+                                id: 'call_1',
+                                name: 'shell',
+                                response,
+                            },
+                        },
+                    ],
+                },
+            ];
+            return {
+                model: 'models/test',
+                contents,
+            };
+        };
+        it('should extract raw output from function response objects', () => {
+            const request = createRequestWithFunctionResponse({
+                output: 'Raw output text',
+            });
+            const messages = converter.convertGeminiRequestToOpenAI(request);
+            const toolMessage = messages.find((message) => message.role === 'tool');
+            expect(toolMessage).toBeDefined();
+            expect(Array.isArray(toolMessage?.content)).toBe(true);
+            const contentArray = toolMessage?.content;
+            expect(contentArray[0].type).toBe('text');
+            expect(contentArray[0].text).toBe('Raw output text');
+        });
+        it('should prioritize error field when present', () => {
+            const request = createRequestWithFunctionResponse({
+                error: 'Command failed',
+            });
+            const messages = converter.convertGeminiRequestToOpenAI(request);
+            const toolMessage = messages.find((message) => message.role === 'tool');
+            expect(toolMessage).toBeDefined();
+            expect(Array.isArray(toolMessage?.content)).toBe(true);
+            const contentArray = toolMessage?.content;
+            expect(contentArray[0].type).toBe('text');
+            expect(contentArray[0].text).toBe('Command failed');
+        });
+        it('should stringify non-string responses', () => {
+            const request = createRequestWithFunctionResponse({
+                data: { value: 42 },
+            });
+            const messages = converter.convertGeminiRequestToOpenAI(request);
+            const toolMessage = messages.find((message) => message.role === 'tool');
+            expect(toolMessage).toBeDefined();
+            expect(Array.isArray(toolMessage?.content)).toBe(true);
+            const contentArray = toolMessage?.content;
+            expect(contentArray[0].type).toBe('text');
+            expect(contentArray[0].text).toBe('{"data":{"value":42}}');
+        });
+        it('should convert function responses with inlineData to tool message with embedded image_url', () => {
+            const request = {
+                model: 'models/test',
+                contents: [
+                    {
+                        role: 'model',
+                        parts: [
+                            {
+                                functionCall: {
+                                    id: 'call_1',
+                                    name: 'Read',
+                                    args: {},
+                                },
+                            },
+                        ],
+                    },
+                    {
+                        role: 'user',
+                        parts: [
+                            {
+                                functionResponse: {
+                                    id: 'call_1',
+                                    name: 'Read',
+                                    response: { output: 'Image content' },
+                                    parts: [
+                                        {
+                                            inlineData: {
+                                                mimeType: 'image/png',
+                                                data: 'base64encodedimagedata',
+                                            },
+                                        },
+                                    ],
+                                },
+                            },
+                        ],
+                    },
+                ],
+            };
+            const messages = converter.convertGeminiRequestToOpenAI(request);
+            // Should have tool message with both text and image content
+            const toolMessage = messages.find((message) => message.role === 'tool');
+            expect(toolMessage).toBeDefined();
+            expect(toolMessage.tool_call_id).toBe('call_1');
+            expect(Array.isArray(toolMessage?.content)).toBe(true);
+            const contentArray = toolMessage?.content;
+            expect(contentArray).toHaveLength(2);
+            expect(contentArray[0].type).toBe('text');
+            expect(contentArray[0].text).toBe('Image content');
+            expect(contentArray[1].type).toBe('image_url');
+            expect(contentArray[1].image_url?.url).toBe('data:image/png;base64,base64encodedimagedata');
+            // No separate user message should be created
+            const userMessage = messages.find((message) => message.role === 'user');
+            expect(userMessage).toBeUndefined();
+        });
+        it('should convert function responses with fileData to tool message with embedded image_url', () => {
+            const request = {
+                model: 'models/test',
+                contents: [
+                    {
+                        role: 'model',
+                        parts: [
+                            {
+                                functionCall: {
+                                    id: 'call_1',
+                                    name: 'Read',
+                                    args: {},
+                                },
+                            },
+                        ],
+                    },
+                    {
+                        role: 'user',
+                        parts: [
+                            {
+                                functionResponse: {
+                                    id: 'call_1',
+                                    name: 'Read',
+                                    response: { output: 'File content' },
+                                    parts: [
+                                        {
+                                            fileData: {
+                                                mimeType: 'image/jpeg',
+                                                fileUri: 'base64imagedata',
+                                            },
+                                        },
+                                    ],
+                                },
+                            },
+                        ],
+                    },
+                ],
+            };
+            const messages = converter.convertGeminiRequestToOpenAI(request);
+            // Should have tool message with both text and image content
+            const toolMessage = messages.find((message) => message.role === 'tool');
+            expect(toolMessage).toBeDefined();
+            expect(Array.isArray(toolMessage?.content)).toBe(true);
+            const contentArray = toolMessage?.content;
+            expect(contentArray).toHaveLength(2);
+            expect(contentArray[0].type).toBe('text');
+            expect(contentArray[0].text).toBe('File content');
+            expect(contentArray[1].type).toBe('image_url');
+            expect(contentArray[1].image_url?.url).toBe('base64imagedata');
+            // No separate user message should be created
+            const userMessage = messages.find((message) => message.role === 'user');
+            expect(userMessage).toBeUndefined();
+        });
+        it('should convert PDF inlineData to tool message with embedded input_file', () => {
+            const request = {
+                model: 'models/test',
+                contents: [
+                    {
+                        role: 'model',
+                        parts: [
+                            {
+                                functionCall: {
+                                    id: 'call_1',
+                                    name: 'Read',
+                                    args: {},
+                                },
+                            },
+                        ],
+                    },
+                    {
+                        role: 'user',
+                        parts: [
+                            {
+                                functionResponse: {
+                                    id: 'call_1',
+                                    name: 'Read',
+                                    response: { output: 'PDF content' },
+                                    parts: [
+                                        {
+                                            inlineData: {
+                                                mimeType: 'application/pdf',
+                                                data: 'base64pdfdata',
+                                                displayName: 'document.pdf',
+                                            },
+                                        },
+                                    ],
+                                },
+                            },
+                        ],
+                    },
+                ],
+            };
+            const messages = converter.convertGeminiRequestToOpenAI(request);
+            // Should have tool message with both text and file content
+            const toolMessage = messages.find((message) => message.role === 'tool');
+            expect(toolMessage).toBeDefined();
+            expect(Array.isArray(toolMessage?.content)).toBe(true);
+            const contentArray = toolMessage?.content;
+            expect(contentArray).toHaveLength(2);
+            expect(contentArray[0].type).toBe('text');
+            expect(contentArray[0].text).toBe('PDF content');
+            expect(contentArray[1].type).toBe('file');
+            expect(contentArray[1].file?.filename).toBe('document.pdf');
+            expect(contentArray[1].file?.file_data).toBe('data:application/pdf;base64,base64pdfdata');
+            // No separate user message should be created
+            const userMessage = messages.find((message) => message.role === 'user');
+            expect(userMessage).toBeUndefined();
+        });
+        it('should convert audio parts to tool message with embedded input_audio', () => {
+            const request = {
+                model: 'models/test',
+                contents: [
+                    {
+                        role: 'model',
+                        parts: [
+                            {
+                                functionCall: {
+                                    id: 'call_1',
+                                    name: 'Record',
+                                    args: {},
+                                },
+                            },
+                        ],
+                    },
+                    {
+                        role: 'user',
+                        parts: [
+                            {
+                                functionResponse: {
+                                    id: 'call_1',
+                                    name: 'Record',
+                                    response: { output: 'Audio recorded' },
+                                    parts: [
+                                        {
+                                            inlineData: {
+                                                mimeType: 'audio/wav',
+                                                data: 'audiobase64data',
+                                            },
+                                        },
+                                    ],
+                                },
+                            },
+                        ],
+                    },
+                ],
+            };
+            const messages = converter.convertGeminiRequestToOpenAI(request);
+            // Should have tool message with both text and audio content
+            const toolMessage = messages.find((message) => message.role === 'tool');
+            expect(toolMessage).toBeDefined();
+            expect(Array.isArray(toolMessage?.content)).toBe(true);
+            const contentArray = toolMessage?.content;
+            expect(contentArray).toHaveLength(2);
+            expect(contentArray[0].type).toBe('text');
+            expect(contentArray[0].text).toBe('Audio recorded');
+            expect(contentArray[1].type).toBe('input_audio');
+            expect(contentArray[1].input_audio?.data).toBe('data:audio/wav;base64,audiobase64data');
+            expect(contentArray[1].input_audio?.format).toBe('wav');
+            // No separate user message should be created
+            const userMessage = messages.find((message) => message.role === 'user');
+            expect(userMessage).toBeUndefined();
+        });
+        it('should convert image fileData URL to tool message with embedded image_url', () => {
+            const request = {
+                model: 'models/test',
+                contents: [
+                    {
+                        role: 'model',
+                        parts: [
+                            {
+                                functionCall: {
+                                    id: 'call_1',
+                                    name: 'Read',
+                                    args: {},
+                                },
+                            },
+                        ],
+                    },
+                    {
+                        role: 'user',
+                        parts: [
+                            {
+                                functionResponse: {
+                                    id: 'call_1',
+                                    name: 'Read',
+                                    response: { output: 'Image content' },
+                                    parts: [
+                                        {
+                                            fileData: {
+                                                mimeType: 'image/jpeg',
+                                                fileUri: 'https://upload.wikimedia.org/wikipedia/commons/a/a7/Camponotus_flavomarginatus_ant.jpg',
+                                                displayName: 'ant.jpg',
+                                            },
+                                        },
+                                    ],
+                                },
+                            },
+                        ],
+                    },
+                ],
+            };
+            const messages = converter.convertGeminiRequestToOpenAI(request);
+            const toolMessage = messages.find((message) => message.role === 'tool');
+            expect(toolMessage).toBeDefined();
+            expect(Array.isArray(toolMessage?.content)).toBe(true);
+            const contentArray = toolMessage?.content;
+            expect(contentArray).toHaveLength(2);
+            expect(contentArray[0].type).toBe('text');
+            expect(contentArray[0].text).toBe('Image content');
+            expect(contentArray[1].type).toBe('image_url');
+            expect(contentArray[1].image_url?.url).toBe('https://upload.wikimedia.org/wikipedia/commons/a/a7/Camponotus_flavomarginatus_ant.jpg');
+        });
+        it('should convert PDF fileData URL to tool message with embedded file', () => {
+            const request = {
+                model: 'models/test',
+                contents: [
+                    {
+                        role: 'model',
+                        parts: [
+                            {
+                                functionCall: {
+                                    id: 'call_1',
+                                    name: 'Read',
+                                    args: {},
+                                },
+                            },
+                        ],
+                    },
+                    {
+                        role: 'user',
+                        parts: [
+                            {
+                                functionResponse: {
+                                    id: 'call_1',
+                                    name: 'Read',
+                                    response: { output: 'PDF content' },
+                                    parts: [
+                                        {
+                                            fileData: {
+                                                mimeType: 'application/pdf',
+                                                fileUri: 'https://assets.anthropic.com/m/1cd9d098ac3e6467/original/Claude-3-Model-Card-October-Addendum.pdf',
+                                                displayName: 'document.pdf',
+                                            },
+                                        },
+                                    ],
+                                },
+                            },
+                        ],
+                    },
+                ],
+            };
+            const messages = converter.convertGeminiRequestToOpenAI(request);
+            const toolMessage = messages.find((message) => message.role === 'tool');
+            expect(toolMessage).toBeDefined();
+            expect(Array.isArray(toolMessage?.content)).toBe(true);
+            const contentArray = toolMessage?.content;
+            expect(contentArray).toHaveLength(2);
+            expect(contentArray[0].type).toBe('text');
+            expect(contentArray[0].text).toBe('PDF content');
+            expect(contentArray[1].type).toBe('file');
+            expect(contentArray[1].file?.filename).toBe('document.pdf');
+            expect(contentArray[1].file?.file_data).toBe('https://assets.anthropic.com/m/1cd9d098ac3e6467/original/Claude-3-Model-Card-October-Addendum.pdf');
+        });
+        it('should convert video inlineData to tool message with embedded video_url', () => {
+            const request = {
+                model: 'models/test',
+                contents: [
+                    {
+                        role: 'model',
+                        parts: [
+                            {
+                                functionCall: {
+                                    id: 'call_1',
+                                    name: 'Read',
+                                    args: {},
+                                },
+                            },
+                        ],
+                    },
+                    {
+                        role: 'user',
+                        parts: [
+                            {
+                                functionResponse: {
+                                    id: 'call_1',
+                                    name: 'Read',
+                                    response: { output: 'Video content' },
+                                    parts: [
+                                        {
+                                            inlineData: {
+                                                mimeType: 'video/mp4',
+                                                data: 'videobase64data',
+                                                displayName: 'recording.mp4',
+                                            },
+                                        },
+                                    ],
+                                },
+                            },
+                        ],
+                    },
+                ],
+            };
+            const messages = converter.convertGeminiRequestToOpenAI(request);
+            // Should have tool message with both text and video content
+            const toolMessage = messages.find((message) => message.role === 'tool');
+            expect(toolMessage).toBeDefined();
+            expect(Array.isArray(toolMessage?.content)).toBe(true);
+            const contentArray = toolMessage?.content;
+            expect(contentArray).toHaveLength(2);
+            expect(contentArray[0].type).toBe('text');
+            expect(contentArray[0].text).toBe('Video content');
+            expect(contentArray[1].type).toBe('video_url');
+            expect(contentArray[1].video_url?.url).toBe('data:video/mp4;base64,videobase64data');
+            // No separate user message should be created
+            const userMessage = messages.find((message) => message.role === 'user');
+            expect(userMessage).toBeUndefined();
+        });
+        it('should convert video fileData URL to tool message with embedded video_url', () => {
+            const request = {
+                model: 'models/test',
+                contents: [
+                    {
+                        role: 'model',
+                        parts: [
+                            {
+                                functionCall: {
+                                    id: 'call_1',
+                                    name: 'Read',
+                                    args: {},
+                                },
+                            },
+                        ],
+                    },
+                    {
+                        role: 'user',
+                        parts: [
+                            {
+                                functionResponse: {
+                                    id: 'call_1',
+                                    name: 'Read',
+                                    response: { output: 'Video content' },
+                                    parts: [
+                                        {
+                                            fileData: {
+                                                mimeType: 'video/mp4',
+                                                fileUri: 'https://www.youtube.com/watch?v=dQw4w9WgXcQ',
+                                                displayName: 'recording.mp4',
+                                            },
+                                        },
+                                    ],
+                                },
+                            },
+                        ],
+                    },
+                ],
+            };
+            const messages = converter.convertGeminiRequestToOpenAI(request);
+            const toolMessage = messages.find((message) => message.role === 'tool');
+            expect(toolMessage).toBeDefined();
+            expect(Array.isArray(toolMessage?.content)).toBe(true);
+            const contentArray = toolMessage?.content;
+            expect(contentArray).toHaveLength(2);
+            expect(contentArray[0].type).toBe('text');
+            expect(contentArray[0].text).toBe('Video content');
+            expect(contentArray[1].type).toBe('video_url');
+            expect(contentArray[1].video_url?.url).toBe('https://www.youtube.com/watch?v=dQw4w9WgXcQ');
+        });
+        it('should render unsupported inlineData file types as a text block', () => {
+            const request = {
+                model: 'models/test',
+                contents: [
+                    {
+                        role: 'model',
+                        parts: [
+                            {
+                                functionCall: {
+                                    id: 'call_1',
+                                    name: 'Read',
+                                    args: {},
+                                },
+                            },
+                        ],
+                    },
+                    {
+                        role: 'user',
+                        parts: [
+                            {
+                                functionResponse: {
+                                    id: 'call_1',
+                                    name: 'Read',
+                                    response: { output: 'File content' },
+                                    parts: [
+                                        {
+                                            inlineData: {
+                                                mimeType: 'application/zip',
+                                                data: 'base64zipdata',
+                                                displayName: 'archive.zip',
+                                            },
+                                        },
+                                    ],
+                                },
+                            },
+                        ],
+                    },
+                ],
+            };
+            const messages = converter.convertGeminiRequestToOpenAI(request);
+            const toolMessage = messages.find((message) => message.role === 'tool');
+            expect(toolMessage).toBeDefined();
+            expect(Array.isArray(toolMessage?.content)).toBe(true);
+            const contentArray = toolMessage?.content;
+            expect(contentArray).toHaveLength(2);
+            expect(contentArray[0].type).toBe('text');
+            expect(contentArray[0].text).toBe('File content');
+            expect(contentArray[1].type).toBe('text');
+            expect(contentArray[1].text).toContain('Unsupported inline media type');
+            expect(contentArray[1].text).toContain('application/zip');
+            expect(contentArray[1].text).toContain('archive.zip');
+        });
+        it('should render unsupported fileData types (including audio) as a text block', () => {
+            const request = {
+                model: 'models/test',
+                contents: [
+                    {
+                        role: 'model',
+                        parts: [
+                            {
+                                functionCall: {
+                                    id: 'call_1',
+                                    name: 'Read',
+                                    args: {},
+                                },
+                            },
+                        ],
+                    },
+                    {
+                        role: 'user',
+                        parts: [
+                            {
+                                functionResponse: {
+                                    id: 'call_1',
+                                    name: 'Read',
+                                    response: { output: 'File content' },
+                                    parts: [
+                                        {
+                                            fileData: {
+                                                mimeType: 'audio/mpeg',
+                                                fileUri: 'https://example.com/audio.mp3',
+                                                displayName: 'audio.mp3',
+                                            },
+                                        },
+                                    ],
+                                },
+                            },
+                        ],
+                    },
+                ],
+            };
+            const messages = converter.convertGeminiRequestToOpenAI(request);
+            const toolMessage = messages.find((message) => message.role === 'tool');
+            expect(toolMessage).toBeDefined();
+            expect(Array.isArray(toolMessage?.content)).toBe(true);
+            const contentArray = toolMessage?.content;
+            expect(contentArray).toHaveLength(2);
+            expect(contentArray[0].type).toBe('text');
+            expect(contentArray[0].text).toBe('File content');
+            expect(contentArray[1].type).toBe('text');
+            expect(contentArray[1].text).toContain('Unsupported file media type');
+            expect(contentArray[1].text).toContain('audio/mpeg');
+            expect(contentArray[1].text).toContain('audio.mp3');
+        });
+        it('should create tool message with text-only content when no media parts', () => {
+            const request = createRequestWithFunctionResponse({
+                output: 'Plain text output',
+            });
+            const messages = converter.convertGeminiRequestToOpenAI(request);
+            const toolMessage = messages.find((message) => message.role === 'tool');
+            expect(toolMessage).toBeDefined();
+            expect(Array.isArray(toolMessage?.content)).toBe(true);
+            const contentArray = toolMessage?.content;
+            expect(contentArray).toHaveLength(1);
+            expect(contentArray[0].type).toBe('text');
+            expect(contentArray[0].text).toBe('Plain text output');
+            // No user message should be created when there's no media
+            const userMessage = messages.find((message) => message.role === 'user');
+            expect(userMessage).toBeUndefined();
+        });
+        it('should create tool message with empty content for empty function responses', () => {
+            const request = {
+                model: 'models/test',
+                contents: [
+                    {
+                        role: 'model',
+                        parts: [
+                            {
+                                text: 'Let me read that file.',
+                            },
+                            {
+                                functionCall: {
+                                    id: 'call_1',
+                                    name: 'read_file',
+                                    args: { path: 'test.txt' },
+                                },
+                            },
+                        ],
+                    },
+                    {
+                        role: 'user',
+                        parts: [
+                            {
+                                functionResponse: {
+                                    id: 'call_1',
+                                    name: 'read_file',
+                                    response: { output: '' },
+                                },
+                            },
+                        ],
+                    },
+                ],
+            };
+            const messages = converter.convertGeminiRequestToOpenAI(request);
+            // Should create an assistant message with tool call and a tool message with empty content
+            // This is required because OpenAI API expects every tool call to have a corresponding response
+            expect(messages.length).toBeGreaterThanOrEqual(2);
+            const toolMessage = messages.find((m) => m.role === 'tool' &&
+                'tool_call_id' in m &&
+                m.tool_call_id === 'call_1');
+            expect(toolMessage).toBeDefined();
+            expect(toolMessage).toMatchObject({
+                role: 'tool',
+                tool_call_id: 'call_1',
+                content: '',
+            });
+        });
+    });
+    describe('MCP multi-part tool results (issue #1520)', () => {
+        /**
+         * Regression tests for https://github.com/QwenLM/qwen-code/issues/1520
+         *
+         * Ensures that when an MCP tool returns multiple content blocks
+         * (e.g., text + image, or multiple text sections), all content
+         * ends up inside the tool message – NOT in a separate user message.
+         *
+         * These tests simulate the data shape produced by the *fixed*
+         * convertToFunctionResponse(), where all text is joined into
+         * `response.output` and media is placed in `response.parts`.
+         */
+        it('should include all text content in tool message when function response has joined text', () => {
+            // After the fix, convertToFunctionResponse joins multiple text parts
+            // into the FunctionResponse.response.output.
+            const request = {
+                model: 'models/test',
+                contents: [
+                    {
+                        role: 'model',
+                        parts: [
+                            {
+                                functionCall: {
+                                    id: 'call_mcp_1',
+                                    name: 'figma_get_code',
+                                    args: { nodeId: '38:521' },
+                                },
+                            },
+                        ],
+                    },
+                    {
+                        role: 'user',
+                        parts: [
+                            {
+                                functionResponse: {
+                                    id: 'call_mcp_1',
+                                    name: 'figma_get_code',
+                                    response: {
+                                        output: '<div data-node-id="38:521">...</div>\nSUPER CRITICAL: The generated React+Tailwind code MUST be converted...',
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                ],
+            };
+            const messages = converter.convertGeminiRequestToOpenAI(request);
+            const toolMessage = messages.find((m) => m.role === 'tool');
+            expect(toolMessage).toBeDefined();
+            expect(toolMessage.tool_call_id).toBe('call_mcp_1');
+            // All content is in the tool message
+            const toolContent = toolMessage?.content;
+            expect(Array.isArray(toolContent)).toBe(true);
+            const toolTexts = toolContent
+                .filter((p) => p.type === 'text')
+                .map((p) => p.text);
+            expect(toolTexts).toHaveLength(1);
+            expect(toolTexts[0]).toContain('data-node-id');
+            expect(toolTexts[0]).toContain('SUPER CRITICAL');
+            // No user message should be created
+            const userMessages = messages.filter((m) => m.role === 'user');
+            expect(userMessages).toHaveLength(0);
+        });
+        it('should include text and image in tool message when function response has media parts', () => {
+            // After the fix, convertToFunctionResponse puts media into
+            // FunctionResponse.parts, which the OpenAI converter picks up
+            // in createToolMessage().
+            const request = {
+                model: 'models/test',
+                contents: [
+                    {
+                        role: 'model',
+                        parts: [
+                            {
+                                functionCall: {
+                                    id: 'call_mcp_2',
+                                    name: 'figma_get_screenshot',
+                                    args: { nodeId: '38:521' },
+                                },
+                            },
+                        ],
+                    },
+                    {
+                        role: 'user',
+                        parts: [
+                            {
+                                functionResponse: {
+                                    id: 'call_mcp_2',
+                                    name: 'figma_get_screenshot',
+                                    response: {
+                                        output: "[Tool 'figma' provided the following image data with mime-type: image/png]",
+                                    },
+                                    parts: [
+                                        {
+                                            inlineData: {
+                                                mimeType: 'image/png',
+                                                data: 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAACklEQVR4nGMAAQAABQABDQottAAAAABJRU5ErkJggg==',
+                                            },
+                                        },
+                                    ],
+                                },
+                            },
+                        ],
+                    },
+                ],
+            };
+            const messages = converter.convertGeminiRequestToOpenAI(request);
+            const toolMessage = messages.find((m) => m.role === 'tool');
+            expect(toolMessage).toBeDefined();
+            expect(toolMessage.tool_call_id).toBe('call_mcp_2');
+            // Tool message should contain both text and image
+            const toolContent = toolMessage?.content;
+            expect(Array.isArray(toolContent)).toBe(true);
+            const contentArray = toolContent;
+            expect(contentArray).toHaveLength(2);
+            expect(contentArray[0].type).toBe('text');
+            expect(contentArray[0].text).toContain('image data');
+            expect(contentArray[1].type).toBe('image_url');
+            expect(contentArray[1].image_url?.url).toContain('data:image/png');
+            // No user message should be created
+            const userMessages = messages.filter((m) => m.role === 'user');
+            expect(userMessages).toHaveLength(0);
+        });
+    });
+    describe('OpenAI -> Gemini reasoning content', () => {
+        it('should convert reasoning_content to a thought part for non-streaming responses', () => {
+            const response = converter.convertOpenAIResponseToGemini({
+                object: 'chat.completion',
+                id: 'chatcmpl-1',
+                created: 123,
+                model: 'gpt-test',
+                choices: [
+                    {
+                        index: 0,
+                        message: {
+                            role: 'assistant',
+                            content: 'final answer',
+                            reasoning_content: 'chain-of-thought',
+                        },
+                        finish_reason: 'stop',
+                        logprobs: null,
+                    },
+                ],
+            });
+            const parts = response.candidates?.[0]?.content?.parts;
+            expect(parts?.[0]).toEqual(expect.objectContaining({ thought: true, text: 'chain-of-thought' }));
+            expect(parts?.[1]).toEqual(expect.objectContaining({ text: 'final answer' }));
+        });
+        it('should convert reasoning to a thought part for non-streaming responses', () => {
+            const response = converter.convertOpenAIResponseToGemini({
+                object: 'chat.completion',
+                id: 'chatcmpl-2',
+                created: 123,
+                model: 'gpt-test',
+                choices: [
+                    {
+                        index: 0,
+                        message: {
+                            role: 'assistant',
+                            content: 'final answer',
+                            reasoning: 'chain-of-thought',
+                        },
+                        finish_reason: 'stop',
+                        logprobs: null,
+                    },
+                ],
+            });
+            const parts = response.candidates?.[0]?.content?.parts;
+            expect(parts?.[0]).toEqual(expect.objectContaining({ thought: true, text: 'chain-of-thought' }));
+            expect(parts?.[1]).toEqual(expect.objectContaining({ text: 'final answer' }));
+        });
+        it('should convert streaming reasoning_content delta to a thought part', () => {
+            const chunk = converter.convertOpenAIChunkToGemini({
+                object: 'chat.completion.chunk',
+                id: 'chunk-1',
+                created: 456,
+                choices: [
+                    {
+                        index: 0,
+                        delta: {
+                            content: 'visible text',
+                            reasoning_content: 'thinking...',
+                        },
+                        finish_reason: 'stop',
+                        logprobs: null,
+                    },
+                ],
+                model: 'gpt-test',
+            });
+            const parts = chunk.candidates?.[0]?.content?.parts;
+            expect(parts?.[0]).toEqual(expect.objectContaining({ thought: true, text: 'thinking...' }));
+            expect(parts?.[1]).toEqual(expect.objectContaining({ text: 'visible text' }));
+        });
+        it('should convert streaming reasoning delta to a thought part', () => {
+            const chunk = converter.convertOpenAIChunkToGemini({
+                object: 'chat.completion.chunk',
+                id: 'chunk-1b',
+                created: 456,
+                choices: [
+                    {
+                        index: 0,
+                        delta: {
+                            content: 'visible text',
+                            reasoning: 'thinking...',
+                        },
+                        finish_reason: 'stop',
+                        logprobs: null,
+                    },
+                ],
+                model: 'gpt-test',
+            });
+            const parts = chunk.candidates?.[0]?.content?.parts;
+            expect(parts?.[0]).toEqual(expect.objectContaining({ thought: true, text: 'thinking...' }));
+            expect(parts?.[1]).toEqual(expect.objectContaining({ text: 'visible text' }));
+        });
+        it('should not throw when streaming chunk has no delta', () => {
+            const chunk = converter.convertOpenAIChunkToGemini({
+                object: 'chat.completion.chunk',
+                id: 'chunk-2',
+                created: 456,
+                choices: [
+                    {
+                        index: 0,
+                        // Some OpenAI-compatible providers may omit delta entirely.
+                        delta: undefined,
+                        finish_reason: null,
+                        logprobs: null,
+                    },
+                ],
+                model: 'gpt-test',
+            });
+            const parts = chunk.candidates?.[0]?.content?.parts;
+            expect(parts).toEqual([]);
+        });
+    });
+    describe('convertGeminiToolsToOpenAI', () => {
+        it('should convert Gemini tools with parameters field', async () => {
+            const geminiTools = [
+                {
+                    functionDeclarations: [
+                        {
+                            name: 'get_weather',
+                            description: 'Get weather for a location',
+                            parameters: {
+                                type: Type.OBJECT,
+                                properties: {
+                                    location: { type: Type.STRING },
+                                },
+                                required: ['location'],
+                            },
+                        },
+                    ],
+                },
+            ];
+            const result = await converter.convertGeminiToolsToOpenAI(geminiTools);
+            expect(result).toHaveLength(1);
+            expect(result[0]).toEqual({
+                type: 'function',
+                function: {
+                    name: 'get_weather',
+                    description: 'Get weather for a location',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            location: { type: 'string' },
+                        },
+                        required: ['location'],
+                    },
+                },
+            });
+        });
+        it('should convert MCP tools with parametersJsonSchema field', async () => {
+            // MCP tools use parametersJsonSchema which contains plain JSON schema (not Gemini types)
+            const mcpTools = [
+                {
+                    functionDeclarations: [
+                        {
+                            name: 'read_file',
+                            description: 'Read a file from disk',
+                            parametersJsonSchema: {
+                                type: 'object',
+                                properties: {
+                                    path: { type: 'string' },
+                                },
+                                required: ['path'],
+                            },
+                        },
+                    ],
+                },
+            ];
+            const result = await converter.convertGeminiToolsToOpenAI(mcpTools);
+            expect(result).toHaveLength(1);
+            expect(result[0]).toEqual({
+                type: 'function',
+                function: {
+                    name: 'read_file',
+                    description: 'Read a file from disk',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            path: { type: 'string' },
+                        },
+                        required: ['path'],
+                    },
+                },
+            });
+        });
+        it('should handle CallableTool by resolving tool function', async () => {
+            const callableTools = [
+                {
+                    tool: async () => ({
+                        functionDeclarations: [
+                            {
+                                name: 'dynamic_tool',
+                                description: 'A dynamically resolved tool',
+                                parameters: {
+                                    type: Type.OBJECT,
+                                    properties: {},
+                                },
+                            },
+                        ],
+                    }),
+                },
+            ];
+            const result = await converter.convertGeminiToolsToOpenAI(callableTools);
+            expect(result).toHaveLength(1);
+            expect(result[0].function.name).toBe('dynamic_tool');
+        });
+        it('should skip functions without name or description', async () => {
+            const geminiTools = [
+                {
+                    functionDeclarations: [
+                        {
+                            name: 'valid_tool',
+                            description: 'A valid tool',
+                        },
+                        {
+                            name: 'missing_description',
+                            // no description
+                        },
+                        {
+                            // no name
+                            description: 'Missing name',
+                        },
+                    ],
+                },
+            ];
+            const result = await converter.convertGeminiToolsToOpenAI(geminiTools);
+            expect(result).toHaveLength(1);
+            expect(result[0].function.name).toBe('valid_tool');
+        });
+        it('should handle tools without functionDeclarations', async () => {
+            const emptyTools = [{}, { functionDeclarations: [] }];
+            const result = await converter.convertGeminiToolsToOpenAI(emptyTools);
+            expect(result).toHaveLength(0);
+        });
+        it('should handle functions without parameters', async () => {
+            const geminiTools = [
+                {
+                    functionDeclarations: [
+                        {
+                            name: 'no_params_tool',
+                            description: 'A tool without parameters',
+                        },
+                    ],
+                },
+            ];
+            const result = await converter.convertGeminiToolsToOpenAI(geminiTools);
+            expect(result).toHaveLength(1);
+            expect(result[0].function.parameters).toBeUndefined();
+        });
+        it('should not mutate original parametersJsonSchema', async () => {
+            const originalSchema = {
+                type: 'object',
+                properties: { foo: { type: 'string' } },
+            };
+            const mcpTools = [
+                {
+                    functionDeclarations: [
+                        {
+                            name: 'test_tool',
+                            description: 'Test tool',
+                            parametersJsonSchema: originalSchema,
+                        },
+                    ],
+                },
+            ];
+            const result = await converter.convertGeminiToolsToOpenAI(mcpTools);
+            // Verify the result is a copy, not the same reference
+            expect(result[0].function.parameters).not.toBe(originalSchema);
+            expect(result[0].function.parameters).toEqual(originalSchema);
+        });
+    });
+    describe('convertGeminiToolParametersToOpenAI', () => {
+        it('should convert type names to lowercase', () => {
+            const params = {
+                type: 'OBJECT',
+                properties: {
+                    count: { type: 'INTEGER' },
+                    amount: { type: 'NUMBER' },
+                    name: { type: 'STRING' },
+                },
+            };
+            const result = converter.convertGeminiToolParametersToOpenAI(params);
+            expect(result).toEqual({
+                type: 'object',
+                properties: {
+                    count: { type: 'integer' },
+                    amount: { type: 'number' },
+                    name: { type: 'string' },
+                },
+            });
+        });
+        it('should convert string numeric constraints to numbers', () => {
+            const params = {
+                type: 'object',
+                properties: {
+                    value: {
+                        type: 'number',
+                        minimum: '0',
+                        maximum: '100',
+                        multipleOf: '0.5',
+                    },
+                },
+            };
+            const result = converter.convertGeminiToolParametersToOpenAI(params);
+            const properties = result?.['properties'];
+            expect(properties?.['value']).toEqual({
+                type: 'number',
+                minimum: 0,
+                maximum: 100,
+                multipleOf: 0.5,
+            });
+        });
+        it('should convert string length constraints to integers', () => {
+            const params = {
+                type: 'object',
+                properties: {
+                    text: {
+                        type: 'string',
+                        minLength: '1',
+                        maxLength: '100',
+                    },
+                    items: {
+                        type: 'array',
+                        minItems: '0',
+                        maxItems: '10',
+                    },
+                },
+            };
+            const result = converter.convertGeminiToolParametersToOpenAI(params);
+            const properties = result?.['properties'];
+            expect(properties?.['text']).toEqual({
+                type: 'string',
+                minLength: 1,
+                maxLength: 100,
+            });
+            expect(properties?.['items']).toEqual({
+                type: 'array',
+                minItems: 0,
+                maxItems: 10,
+            });
+        });
+        it('should handle nested objects', () => {
+            const params = {
+                type: 'object',
+                properties: {
+                    nested: {
+                        type: 'object',
+                        properties: {
+                            deep: {
+                                type: 'INTEGER',
+                                minimum: '0',
+                            },
+                        },
+                    },
+                },
+            };
+            const result = converter.convertGeminiToolParametersToOpenAI(params);
+            const properties = result?.['properties'];
+            const nested = properties?.['nested'];
+            const nestedProperties = nested?.['properties'];
+            expect(nestedProperties?.['deep']).toEqual({
+                type: 'integer',
+                minimum: 0,
+            });
+        });
+        it('should handle arrays', () => {
+            const params = {
+                type: 'array',
+                items: {
+                    type: 'INTEGER',
+                },
+            };
+            const result = converter.convertGeminiToolParametersToOpenAI(params);
+            expect(result).toEqual({
+                type: 'array',
+                items: {
+                    type: 'integer',
+                },
+            });
+        });
+        it('should return undefined for null or non-object input', () => {
+            expect(converter.convertGeminiToolParametersToOpenAI(null)).toBeNull();
+            expect(converter.convertGeminiToolParametersToOpenAI(undefined)).toBeUndefined();
+        });
+        it('should not mutate the original parameters', () => {
+            const original = {
+                type: 'OBJECT',
+                properties: {
+                    count: { type: 'INTEGER' },
+                },
+            };
+            const originalCopy = JSON.parse(JSON.stringify(original));
+            converter.convertGeminiToolParametersToOpenAI(original);
+            expect(original).toEqual(originalCopy);
+        });
+    });
+    describe('mergeConsecutiveAssistantMessages', () => {
+        it('should merge two consecutive assistant messages with string content', () => {
+            const request = {
+                model: 'models/test',
+                contents: [
+                    {
+                        role: 'model',
+                        parts: [{ text: 'First part' }],
+                    },
+                    {
+                        role: 'model',
+                        parts: [{ text: 'Second part' }],
+                    },
+                ],
+            };
+            const messages = converter.convertGeminiRequestToOpenAI(request);
+            expect(messages).toHaveLength(1);
+            expect(messages[0].role).toBe('assistant');
+            expect(messages[0].content).toBe('First partSecond part');
+        });
+        it('should merge multiple consecutive assistant messages', () => {
+            const request = {
+                model: 'models/test',
+                contents: [
+                    {
+                        role: 'model',
+                        parts: [{ text: 'Part 1' }],
+                    },
+                    {
+                        role: 'model',
+                        parts: [{ text: 'Part 2' }],
+                    },
+                    {
+                        role: 'model',
+                        parts: [{ text: 'Part 3' }],
+                    },
+                ],
+            };
+            const messages = converter.convertGeminiRequestToOpenAI(request);
+            expect(messages).toHaveLength(1);
+            expect(messages[0].role).toBe('assistant');
+            expect(messages[0].content).toBe('Part 1Part 2Part 3');
+        });
+        it('should merge tool_calls from consecutive assistant messages', () => {
+            const request = {
+                model: 'models/test',
+                contents: [
+                    {
+                        role: 'model',
+                        parts: [
+                            {
+                                functionCall: {
+                                    id: 'call_1',
+                                    name: 'tool_1',
+                                    args: {},
+                                },
+                            },
+                        ],
+                    },
+                    {
+                        role: 'user',
+                        parts: [
+                            {
+                                functionResponse: {
+                                    id: 'call_1',
+                                    name: 'tool_1',
+                                    response: { output: 'result_1' },
+                                },
+                            },
+                        ],
+                    },
+                    {
+                        role: 'model',
+                        parts: [
+                            {
+                                functionCall: {
+                                    id: 'call_2',
+                                    name: 'tool_2',
+                                    args: {},
+                                },
+                            },
+                        ],
+                    },
+                    {
+                        role: 'user',
+                        parts: [
+                            {
+                                functionResponse: {
+                                    id: 'call_2',
+                                    name: 'tool_2',
+                                    response: { output: 'result_2' },
+                                },
+                            },
+                        ],
+                    },
+                ],
+            };
+            const messages = converter.convertGeminiRequestToOpenAI(request, {
+                cleanOrphanToolCalls: false,
+            });
+            // Should have: assistant (tool_call_1), tool (result_1), assistant (tool_call_2), tool (result_2)
+            expect(messages).toHaveLength(4);
+            expect(messages[0].role).toBe('assistant');
+            expect(messages[1].role).toBe('tool');
+            expect(messages[2].role).toBe('assistant');
+            expect(messages[3].role).toBe('tool');
+        });
+        it('should not merge assistant messages separated by user messages', () => {
+            const request = {
+                model: 'models/test',
+                contents: [
+                    {
+                        role: 'model',
+                        parts: [{ text: 'First assistant' }],
+                    },
+                    {
+                        role: 'user',
+                        parts: [{ text: 'User message' }],
+                    },
+                    {
+                        role: 'model',
+                        parts: [{ text: 'Second assistant' }],
+                    },
+                ],
+            };
+            const messages = converter.convertGeminiRequestToOpenAI(request);
+            expect(messages).toHaveLength(3);
+            expect(messages[0].role).toBe('assistant');
+            expect(messages[1].role).toBe('user');
+            expect(messages[2].role).toBe('assistant');
+        });
+        it('should handle merging when one message has array content and another has string', () => {
+            const request = {
+                model: 'models/test',
+                contents: [
+                    {
+                        role: 'model',
+                        parts: [{ text: 'Text part' }],
+                    },
+                    {
+                        role: 'model',
+                        parts: [{ text: 'Another text' }],
+                    },
+                ],
+            };
+            const messages = converter.convertGeminiRequestToOpenAI(request);
+            expect(messages).toHaveLength(1);
+            expect(messages[0].content).toBe('Text partAnother text');
+        });
+        it('should merge empty content correctly', () => {
+            const request = {
+                model: 'models/test',
+                contents: [
+                    {
+                        role: 'model',
+                        parts: [{ text: 'First' }],
+                    },
+                    {
+                        role: 'model',
+                        parts: [],
+                    },
+                    {
+                        role: 'model',
+                        parts: [{ text: 'Second' }],
+                    },
+                ],
+            };
+            const messages = converter.convertGeminiRequestToOpenAI(request);
+            // Empty messages should be filtered out
+            expect(messages).toHaveLength(1);
+            expect(messages[0].content).toBe('FirstSecond');
+        });
+    });
+});
+describe('MCP tool result end-to-end through OpenAI converter (issue #1520)', () => {
+    /**
+     * End-to-end regression tests for https://github.com/QwenLM/qwen-code/issues/1520
+     *
+     * Simulates the full pipeline:
+     *   transformMcpContentToParts → convertToFunctionResponse → OpenAI converter
+     *
+     * Verifies that multi-part MCP tool results are properly carried through
+     * into the OpenAI tool message, with no content leaking into user messages.
+     */
+    let converter;
+    beforeEach(() => {
+        converter = new OpenAIContentConverter('test-model', 'auto', {
+            image: true,
+            pdf: true,
+            audio: true,
+            video: true,
+        });
+    });
+    it('should preserve MCP multi-text content in tool message (not leak to user message)', () => {
+        // Step 1: Simulate what transformMcpContentToParts returns for a Figma
+        // tool that returns code + instructions as two text blocks
+        const mcpTransformedParts = [
+            { text: '<div data-node-id="38:521"><h1>Welcome</h1></div>' },
+            {
+                text: 'SUPER CRITICAL: Convert the React+Tailwind code to match the target stack.',
+            },
+        ];
+        // Step 2: convertToFunctionResponse wraps the MCP result
+        const callId = 'call_figma_1';
+        const toolName = 'figma_get_code';
+        const responseParts = convertToFunctionResponse(toolName, callId, mcpTransformedParts);
+        // Step 3: Build the conversation history (model tool call + tool result)
+        const contents = [
+            {
+                role: 'model',
+                parts: [
+                    {
+                        functionCall: {
+                            id: callId,
+                            name: toolName,
+                            args: { nodeId: '38:521' },
+                        },
+                    },
+                ],
+            },
+            {
+                role: 'user',
+                parts: responseParts,
+            },
+        ];
+        // Step 4: Convert to OpenAI format
+        const request = {
+            model: 'models/test',
+            contents,
+        };
+        const messages = converter.convertGeminiRequestToOpenAI(request);
+        const toolMessages = messages.filter((m) => m.role === 'tool');
+        const userMessages = messages.filter((m) => m.role === 'user');
+        const assistantMessages = messages.filter((m) => m.role === 'assistant');
+        expect(toolMessages).toHaveLength(1);
+        expect(assistantMessages).toHaveLength(1);
+        // No content should leak into a user message
+        expect(userMessages).toHaveLength(0);
+        // Tool message should contain the actual MCP content
+        const toolMsg = toolMessages[0];
+        expect(toolMsg.tool_call_id).toBe(callId);
+        const toolContent = toolMsg.content;
+        expect(Array.isArray(toolContent)).toBe(true);
+        const toolTexts = toolContent
+            .filter((p) => p.type === 'text')
+            .map((p) => p.text);
+        expect(toolTexts).toHaveLength(1);
+        expect(toolTexts[0]).toContain('data-node-id');
+        expect(toolTexts[0]).toContain('SUPER CRITICAL');
+    });
+    it('should preserve MCP text+image content in tool message', () => {
+        // Simulates MCP tool returning text description + image (e.g., get_screenshot)
+        const mcpTransformedParts = [
+            {
+                text: "[Tool 'figma' provided the following image data with mime-type: image/png]",
+            },
+            {
+                inlineData: {
+                    mimeType: 'image/png',
+                    data: 'iVBORw0KGgo=',
+                },
+            },
+        ];
+        const callId = 'call_figma_2';
+        const toolName = 'figma_get_screenshot';
+        const responseParts = convertToFunctionResponse(toolName, callId, mcpTransformedParts);
+        const contents = [
+            {
+                role: 'model',
+                parts: [
+                    {
+                        functionCall: {
+                            id: callId,
+                            name: toolName,
+                            args: { nodeId: '38:521' },
+                        },
+                    },
+                ],
+            },
+            {
+                role: 'user',
+                parts: responseParts,
+            },
+        ];
+        const request = {
+            model: 'models/test',
+            contents,
+        };
+        const messages = converter.convertGeminiRequestToOpenAI(request);
+        const toolMessages = messages.filter((m) => m.role === 'tool');
+        const userMessages = messages.filter((m) => m.role === 'user');
+        expect(toolMessages).toHaveLength(1);
+        // No content should leak into a user message
+        expect(userMessages).toHaveLength(0);
+        // Tool message should contain both text description and image
+        const toolMsg = toolMessages[0];
+        const toolContent = toolMsg.content;
+        expect(Array.isArray(toolContent)).toBe(true);
+        const contentArray = toolContent;
+        expect(contentArray).toHaveLength(2);
+        expect(contentArray[0].type).toBe('text');
+        expect(contentArray[0].text).toContain('image data');
+        expect(contentArray[1].type).toBe('image_url');
+        expect(contentArray[1].image_url?.url).toContain('data:image/png');
+    });
+    it('should work correctly when MCP tool returns a single text part', () => {
+        // Single text part — the control case that has always worked
+        const mcpTransformedParts = [
+            { text: 'Single text response from MCP tool' },
+        ];
+        const callId = 'call_mcp_single';
+        const toolName = 'mcp_tool';
+        const responseParts = convertToFunctionResponse(toolName, callId, mcpTransformedParts);
+        const contents = [
+            {
+                role: 'model',
+                parts: [
+                    {
+                        functionCall: {
+                            id: callId,
+                            name: toolName,
+                            args: {},
+                        },
+                    },
+                ],
+            },
+            {
+                role: 'user',
+                parts: responseParts,
+            },
+        ];
+        const request = {
+            model: 'models/test',
+            contents,
+        };
+        const messages = converter.convertGeminiRequestToOpenAI(request);
+        const toolMessages = messages.filter((m) => m.role === 'tool');
+        const userMessages = messages.filter((m) => m.role === 'user');
+        expect(toolMessages).toHaveLength(1);
+        expect(userMessages).toHaveLength(0);
+        const toolMsg = toolMessages[0];
+        const toolContent = toolMsg.content;
+        expect(Array.isArray(toolContent)).toBe(true);
+        const toolTexts = toolContent
+            .filter((p) => p.type === 'text')
+            .map((p) => p.text);
+        expect(toolTexts).toHaveLength(1);
+        expect(toolTexts[0]).toBe('Single text response from MCP tool');
+    });
+    it('should preserve MCP multi-text + multi-image content in tool message', () => {
+        // Simulates a complex MCP response with multiple text blocks and images
+        const mcpTransformedParts = [
+            { text: 'Here is the design mockup:' },
+            {
+                text: "[Tool 'pencil' provided the following image data with mime-type: image/png]",
+            },
+            {
+                inlineData: {
+                    mimeType: 'image/png',
+                    data: 'screenshotBase64Data',
+                },
+            },
+            { text: 'And here are the node details...' },
+        ];
+        const callId = 'call_pencil_1';
+        const toolName = 'mcp__pencil__get_screenshot';
+        const responseParts = convertToFunctionResponse(toolName, callId, mcpTransformedParts);
+        const contents = [
+            {
+                role: 'model',
+                parts: [
+                    {
+                        functionCall: {
+                            id: callId,
+                            name: toolName,
+                            args: { nodeId: 'vHOGa' },
+                        },
+                    },
+                ],
+            },
+            {
+                role: 'user',
+                parts: responseParts,
+            },
+        ];
+        const request = {
+            model: 'models/test',
+            contents,
+        };
+        const messages = converter.convertGeminiRequestToOpenAI(request);
+        const toolMessages = messages.filter((m) => m.role === 'tool');
+        const userMessages = messages.filter((m) => m.role === 'user');
+        expect(toolMessages).toHaveLength(1);
+        expect(userMessages).toHaveLength(0);
+        const toolMsg = toolMessages[0];
+        expect(toolMsg.tool_call_id).toBe(callId);
+        const toolContent = toolMsg.content;
+        expect(Array.isArray(toolContent)).toBe(true);
+        const contentArray = toolContent;
+        // Should have text (all joined) + image
+        expect(contentArray).toHaveLength(2);
+        expect(contentArray[0].type).toBe('text');
+        expect(contentArray[0].text).toContain('design mockup');
+        expect(contentArray[0].text).toContain('image data');
+        expect(contentArray[0].text).toContain('node details');
+        expect(contentArray[1].type).toBe('image_url');
+        expect(contentArray[1].image_url?.url).toContain('data:image/png');
+    });
+});
+describe('Truncated tool call detection in streaming', () => {
+    let converter;
+    beforeEach(() => {
+        converter = new OpenAIContentConverter('test-model');
+    });
+    /**
+     * Helper: feed streaming chunks then a final chunk with finish_reason,
+     * and return the Gemini response for the final chunk.
+     */
+    function feedToolCallChunks(conv, toolCallChunks, finishReason) {
+        // Feed argument chunks (no finish_reason yet)
+        for (const tc of toolCallChunks) {
+            conv.convertOpenAIChunkToGemini({
+                object: 'chat.completion.chunk',
+                id: 'chunk-stream',
+                created: 100,
+                model: 'test-model',
+                choices: [
+                    {
+                        index: 0,
+                        delta: {
+                            tool_calls: [
+                                {
+                                    index: tc.index,
+                                    id: tc.id,
+                                    type: 'function',
+                                    function: {
+                                        name: tc.name,
+                                        arguments: tc.arguments,
+                                    },
+                                },
+                            ],
+                        },
+                        finish_reason: null,
+                        logprobs: null,
+                    },
+                ],
+            });
+        }
+        // Final chunk with finish_reason
+        return conv.convertOpenAIChunkToGemini({
+            object: 'chat.completion.chunk',
+            id: 'chunk-final',
+            created: 101,
+            model: 'test-model',
+            choices: [
+                {
+                    index: 0,
+                    delta: {},
+                    finish_reason: finishReason,
+                    logprobs: null,
+                },
+            ],
+        });
+    }
+    it('should override finishReason to MAX_TOKENS when tool call JSON is truncated and provider reports "stop"', () => {
+        // Simulate: write_file call truncated mid-JSON, provider says "stop"
+        const result = feedToolCallChunks(converter, [
+            {
+                index: 0,
+                id: 'call_1',
+                name: 'write_file',
+                arguments: '{"file_path": "/tmp/test.cpp"',
+                // Missing closing brace and content field — truncated
+            },
+        ], 'stop');
+        expect(result.candidates?.[0]?.finishReason).toBe(FinishReason.MAX_TOKENS);
+    });
+    it('should override finishReason to MAX_TOKENS when provider reports "tool_calls" but JSON is truncated', () => {
+        const result = feedToolCallChunks(converter, [
+            {
+                index: 0,
+                id: 'call_1',
+                name: 'write_file',
+                arguments: '{"file_path": "/tmp/test.cpp", "content": "partial content',
+                // Truncated mid-string
+            },
+        ], 'tool_calls');
+        expect(result.candidates?.[0]?.finishReason).toBe(FinishReason.MAX_TOKENS);
+    });
+    it('should preserve finishReason STOP when tool call JSON is complete', () => {
+        const result = feedToolCallChunks(converter, [
+            {
+                index: 0,
+                id: 'call_1',
+                name: 'write_file',
+                arguments: '{"file_path": "/tmp/test.cpp", "content": "hello"}',
+            },
+        ], 'stop');
+        expect(result.candidates?.[0]?.finishReason).toBe(FinishReason.STOP);
+    });
+    it('should preserve finishReason MAX_TOKENS when provider already reports "length"', () => {
+        const result = feedToolCallChunks(converter, [
+            {
+                index: 0,
+                id: 'call_1',
+                name: 'write_file',
+                arguments: '{"file_path": "/tmp/test.cpp"',
+            },
+        ], 'length');
+        expect(result.candidates?.[0]?.finishReason).toBe(FinishReason.MAX_TOKENS);
+    });
+    it('should still emit the (repaired) function call even when truncated', () => {
+        const result = feedToolCallChunks(converter, [
+            {
+                index: 0,
+                id: 'call_1',
+                name: 'write_file',
+                arguments: '{"file_path": "/tmp/test.cpp"',
+            },
+        ], 'stop');
+        const parts = result.candidates?.[0]?.content?.parts ?? [];
+        const fnCall = parts.find((p) => p.functionCall);
+        expect(fnCall).toBeDefined();
+        expect(fnCall?.functionCall?.name).toBe('write_file');
+        expect(fnCall?.functionCall?.args).toEqual({
+            file_path: '/tmp/test.cpp',
+        });
+    });
+    it('should detect truncation with multi-chunk streaming arguments', () => {
+        // Feed arguments in multiple small chunks like real streaming
+        const conv = new OpenAIContentConverter('test-model');
+        // Chunk 1: start of JSON with tool metadata
+        conv.convertOpenAIChunkToGemini({
+            object: 'chat.completion.chunk',
+            id: 'c1',
+            created: 100,
+            model: 'test-model',
+            choices: [
+                {
+                    index: 0,
+                    delta: {
+                        tool_calls: [
+                            {
+                                index: 0,
+                                id: 'call_1',
+                                type: 'function',
+                                function: { name: 'write_file', arguments: '{"file_' },
+                            },
+                        ],
+                    },
+                    finish_reason: null,
+                    logprobs: null,
+                },
+            ],
+        });
+        // Chunk 2: more arguments
+        conv.convertOpenAIChunkToGemini({
+            object: 'chat.completion.chunk',
+            id: 'c2',
+            created: 100,
+            model: 'test-model',
+            choices: [
+                {
+                    index: 0,
+                    delta: {
+                        tool_calls: [
+                            {
+                                index: 0,
+                                function: { arguments: 'path": "/tmp/f.txt", "conten' },
+                            },
+                        ],
+                    },
+                    finish_reason: null,
+                    logprobs: null,
+                },
+            ],
+        });
+        // Final chunk: finish_reason "stop" but JSON is still incomplete
+        const result = conv.convertOpenAIChunkToGemini({
+            object: 'chat.completion.chunk',
+            id: 'c3',
+            created: 101,
+            model: 'test-model',
+            choices: [
+                {
+                    index: 0,
+                    delta: {},
+                    finish_reason: 'stop',
+                    logprobs: null,
+                },
+            ],
+        });
+        expect(result.candidates?.[0]?.finishReason).toBe(FinishReason.MAX_TOKENS);
+    });
+});
+describe('modality filtering', () => {
+    function makeRequest(parts) {
+        return {
+            model: 'test-model',
+            contents: [{ role: 'user', parts }],
+        };
+    }
+    function getUserContentParts(messages) {
+        const userMsg = messages.find((m) => m.role === 'user');
+        if (!userMsg ||
+            !('content' in userMsg) ||
+            !Array.isArray(userMsg.content)) {
+            return [];
+        }
+        return userMsg.content;
+    }
+    it('replaces image with placeholder when image modality is disabled', () => {
+        const conv = new OpenAIContentConverter('deepseek-chat', 'auto', {});
+        const request = makeRequest([
+            {
+                inlineData: { mimeType: 'image/png', data: 'abc123' },
+                displayName: 'screenshot.png',
+            },
+        ]);
+        const messages = conv.convertGeminiRequestToOpenAI(request);
+        const parts = getUserContentParts(messages);
+        expect(parts).toHaveLength(1);
+        expect(parts[0].type).toBe('text');
+        expect(parts[0].text).toContain('image file');
+        expect(parts[0].text).toContain('does not support image input');
+    });
+    it('keeps image when image modality is enabled', () => {
+        const conv = new OpenAIContentConverter('gpt-4o', 'auto', { image: true });
+        const request = makeRequest([
+            {
+                inlineData: { mimeType: 'image/png', data: 'abc123' },
+            },
+        ]);
+        const messages = conv.convertGeminiRequestToOpenAI(request);
+        const parts = getUserContentParts(messages);
+        expect(parts).toHaveLength(1);
+        expect(parts[0].type).toBe('image_url');
+    });
+    it('replaces PDF with placeholder when pdf modality is disabled', () => {
+        const conv = new OpenAIContentConverter('test-model', 'auto', {
+            image: true,
+        });
+        const request = makeRequest([
+            {
+                inlineData: {
+                    mimeType: 'application/pdf',
+                    data: 'pdf-data',
+                    displayName: 'doc.pdf',
+                },
+            },
+        ]);
+        const messages = conv.convertGeminiRequestToOpenAI(request);
+        const parts = getUserContentParts(messages);
+        expect(parts).toHaveLength(1);
+        expect(parts[0].type).toBe('text');
+        expect(parts[0].text).toContain('pdf file');
+        expect(parts[0].text).toContain('does not support PDF input');
+    });
+    it('keeps PDF when pdf modality is enabled', () => {
+        const conv = new OpenAIContentConverter('claude-sonnet', 'auto', {
+            image: true,
+            pdf: true,
+        });
+        const request = makeRequest([
+            {
+                inlineData: {
+                    mimeType: 'application/pdf',
+                    data: 'pdf-data',
+                    displayName: 'doc.pdf',
+                },
+            },
+        ]);
+        const messages = conv.convertGeminiRequestToOpenAI(request);
+        const parts = getUserContentParts(messages);
+        expect(parts).toHaveLength(1);
+        expect(parts[0].type).toBe('file');
+    });
+    it('replaces video with placeholder when video modality is disabled', () => {
+        const conv = new OpenAIContentConverter('test-model', 'auto', {});
+        const request = makeRequest([
+            {
+                inlineData: { mimeType: 'video/mp4', data: 'vid-data' },
+            },
+        ]);
+        const messages = conv.convertGeminiRequestToOpenAI(request);
+        const parts = getUserContentParts(messages);
+        expect(parts).toHaveLength(1);
+        expect(parts[0].type).toBe('text');
+        expect(parts[0].text).toContain('video file');
+    });
+    it('replaces audio with placeholder when audio modality is disabled', () => {
+        const conv = new OpenAIContentConverter('test-model', 'auto', {});
+        const request = makeRequest([
+            {
+                inlineData: { mimeType: 'audio/wav', data: 'audio-data' },
+            },
+        ]);
+        const messages = conv.convertGeminiRequestToOpenAI(request);
+        const parts = getUserContentParts(messages);
+        expect(parts).toHaveLength(1);
+        expect(parts[0].type).toBe('text');
+        expect(parts[0].text).toContain('audio file');
+    });
+    it('handles mixed content: keeps text + supported media, replaces unsupported', () => {
+        const conv = new OpenAIContentConverter('gpt-4o', 'auto', { image: true });
+        const request = makeRequest([
+            { text: 'Analyze these files' },
+            {
+                inlineData: { mimeType: 'image/png', data: 'img-data' },
+            },
+            {
+                inlineData: { mimeType: 'video/mp4', data: 'vid-data' },
+            },
+        ]);
+        const messages = conv.convertGeminiRequestToOpenAI(request);
+        const parts = getUserContentParts(messages);
+        expect(parts).toHaveLength(3);
+        expect(parts[0].type).toBe('text');
+        expect(parts[0].text).toBe('Analyze these files');
+        expect(parts[1].type).toBe('image_url');
+        expect(parts[2].type).toBe('text');
+        expect(parts[2].text).toContain('video file');
+    });
+    it('defaults to text-only when no modalities are specified', () => {
+        const conv = new OpenAIContentConverter('unknown-model');
+        const request = makeRequest([
+            {
+                inlineData: { mimeType: 'image/png', data: 'img-data' },
+            },
+        ]);
+        const messages = conv.convertGeminiRequestToOpenAI(request);
+        const parts = getUserContentParts(messages);
+        expect(parts).toHaveLength(1);
+        expect(parts[0].type).toBe('text');
+        expect(parts[0].text).toContain('image file');
+    });
+});
+//# sourceMappingURL=converter.test.js.map