@strands-agents/sdk 0.6.0 → 1.0.0-rc.0

package/dist/src/models/__tests__/openai.test.js

@@ -5,6 +5,7 @@ import { OpenAIModel } from '../openai.js';
 import { ContextWindowOverflowError, ModelThrottledError } from '../../errors.js';
 import { collectIterator } from '../../__fixtures__/model-test-helpers.js';
 import { Message, TextBlock, ToolUseBlock, ToolResultBlock, GuardContentBlock } from '../../types/messages.js';
+import { ImageBlock, DocumentBlock, VideoBlock } from '../../types/media.js';
 /**
  * Helper to create a mock OpenAI client with streaming support
  */
@@ -42,22 +43,38 @@ describe('OpenAIModel', () => {
             vi.unstubAllEnvs();
         }
     });
+    // Shared helper to create a mock OpenAI client that captures the request
+    const createMockClientWithCapture = (captureContainer) => {
+        return {
+            chat: {
+                completions: {
+                    create: vi.fn(async (request) => {
+                        captureContainer.request = request;
+                        return (async function* () {
+                            yield { choices: [{ delta: { role: 'assistant' }, index: 0 }] };
+                            yield { choices: [{ finish_reason: 'stop', delta: {}, index: 0 }] };
+                        })();
+                    }),
+                },
+            },
+        };
+    };
     describe('constructor', () => {
         it('creates an instance with required modelId', () => {
-            const provider = new OpenAIModel({ modelId: 'gpt-4o', apiKey: 'sk-test' });
+            const provider = new OpenAIModel({ api: 'chat', modelId: 'gpt-5.4', apiKey: 'sk-test' });
             const config = provider.getConfig();
-            expect(config.modelId).toBe('gpt-4o');
+            expect(config.modelId).toBe('gpt-5.4');
         });
         it('uses custom model ID', () => {
             const customModelId = 'gpt-3.5-turbo';
-            const provider = new OpenAIModel({ modelId: customModelId, apiKey: 'sk-test' });
+            const provider = new OpenAIModel({ api: 'chat', modelId: customModelId, apiKey: 'sk-test' });
             expect(provider.getConfig()).toStrictEqual({
                 modelId: customModelId,
             });
         });
         it('uses API key from constructor parameter', () => {
             const apiKey = 'sk-explicit';
-            new OpenAIModel({ modelId: 'gpt-4o', apiKey });
+            new OpenAIModel({ api: 'chat', modelId: 'gpt-5.4', apiKey });
             expect(OpenAI).toHaveBeenCalledWith(expect.objectContaining({
                 apiKey: apiKey,
             }));
@@ -66,7 +83,7 @@ describe('OpenAIModel', () => {
         if (isNode) {
             it('uses API key from environment variable', () => {
                 vi.stubEnv('OPENAI_API_KEY', 'sk-from-env');
-                new OpenAIModel({ modelId: 'gpt-4o' });
+                new OpenAIModel({ api: 'chat', modelId: 'gpt-5.4' });
                 // OpenAI client should be called without explicit apiKey (uses env var internally)
                 expect(OpenAI).toHaveBeenCalled();
             });
@@ -76,7 +93,7 @@ describe('OpenAIModel', () => {
                 vi.stubEnv('OPENAI_API_KEY', 'sk-from-env');
             }
             const explicitKey = 'sk-explicit';
-            new OpenAIModel({ modelId: 'gpt-4o', apiKey: explicitKey });
+            new OpenAIModel({ api: 'chat', modelId: 'gpt-5.4', apiKey: explicitKey });
             expect(OpenAI).toHaveBeenCalledWith(expect.objectContaining({
                 apiKey: explicitKey,
             }));
@@ -85,11 +102,11 @@ describe('OpenAIModel', () => {
             if (isNode) {
                 vi.stubEnv('OPENAI_API_KEY', '');
             }
-            expect(() => new OpenAIModel({ modelId: 'gpt-4o' })).toThrow("OpenAI API key is required. Provide it via the 'apiKey' option (string or function) or set the OPENAI_API_KEY environment variable.");
+            expect(() => new OpenAIModel({ api: 'chat', modelId: 'gpt-5.4' })).toThrow("OpenAI API key is required. Provide it via the 'apiKey' option (string or function) or set the OPENAI_API_KEY environment variable.");
         });
         it('uses custom client configuration', () => {
             const timeout = 30000;
-            new OpenAIModel({ modelId: 'gpt-4o', apiKey: 'sk-test', clientConfig: { timeout } });
+            new OpenAIModel({ api: 'chat', modelId: 'gpt-5.4', apiKey: 'sk-test', clientConfig: { timeout } });
             expect(OpenAI).toHaveBeenCalledWith(expect.objectContaining({
                 timeout: timeout,
             }));
@@ -97,7 +114,7 @@ describe('OpenAIModel', () => {
         it('uses provided client instance', () => {
             vi.clearAllMocks();
             const mockClient = {};
-            const provider = new OpenAIModel({ modelId: 'gpt-4o', client: mockClient });
+            const provider = new OpenAIModel({ api: 'chat', client: mockClient });
             // Should not create a new OpenAI client
             expect(OpenAI).not.toHaveBeenCalled();
             expect(provider).toBeDefined();
@@ -106,7 +123,8 @@ describe('OpenAIModel', () => {
             vi.clearAllMocks();
             const mockClient = {};
             new OpenAIModel({
-                modelId: 'gpt-4o',
+                api: 'chat',
+                modelId: 'gpt-5.4',
                 apiKey: 'sk-test',
                 client: mockClient,
                 clientConfig: { timeout: 30000 },
@@ -120,12 +138,13 @@ describe('OpenAIModel', () => {
                 vi.stubEnv('OPENAI_API_KEY', '');
             }
             const mockClient = {};
-            expect(() => new OpenAIModel({ modelId: 'gpt-4o', client: mockClient })).not.toThrow();
+            expect(() => new OpenAIModel({ api: 'chat', client: mockClient })).not.toThrow();
         });
         it('accepts function-based API key', () => {
             const apiKeyFn = vi.fn(async () => 'sk-dynamic');
             new OpenAIModel({
-                modelId: 'gpt-4o',
+                api: 'chat',
+                modelId: 'gpt-5.4',
                 apiKey: apiKeyFn,
             });
             expect(OpenAI).toHaveBeenCalledWith(expect.objectContaining({
@@ -138,7 +157,8 @@ describe('OpenAIModel', () => {
                 return 'sk-async-key';
             };
             new OpenAIModel({
-                modelId: 'gpt-4o',
+                api: 'chat',
+                modelId: 'gpt-5.4',
                 apiKey: apiKeyFn,
             });
             expect(OpenAI).toHaveBeenCalledWith(expect.objectContaining({
@@ -148,16 +168,17 @@ describe('OpenAIModel', () => {
     });
     describe('updateConfig', () => {
         it('merges new config with existing config', () => {
-            const provider = new OpenAIModel({ modelId: 'gpt-4o', apiKey: 'sk-test', temperature: 0.5 });
-            provider.updateConfig({ modelId: 'gpt-4o', temperature: 0.8, maxTokens: 2048 });
+            const provider = new OpenAIModel({ api: 'chat', modelId: 'gpt-5.4', apiKey: 'sk-test', temperature: 0.5 });
+            provider.updateConfig({ modelId: 'gpt-5.4', temperature: 0.8, maxTokens: 2048 });
             expect(provider.getConfig()).toStrictEqual({
-                modelId: 'gpt-4o',
+                modelId: 'gpt-5.4',
                 temperature: 0.8,
                 maxTokens: 2048,
             });
         });
         it('preserves fields not included in the update', () => {
             const provider = new OpenAIModel({
+                api: 'chat',
                 apiKey: 'sk-test',
                 modelId: 'gpt-3.5-turbo',
                 temperature: 0.5,
@@ -174,13 +195,14 @@ describe('OpenAIModel', () => {
     describe('getConfig', () => {
         it('returns the current configuration', () => {
             const provider = new OpenAIModel({
-                modelId: 'gpt-4o',
+                api: 'chat',
+                modelId: 'gpt-5.4',
                 apiKey: 'sk-test',
                 maxTokens: 1024,
                 temperature: 0.7,
             });
             expect(provider.getConfig()).toStrictEqual({
-                modelId: 'gpt-4o',
+                modelId: 'gpt-5.4',
                 maxTokens: 1024,
                 temperature: 0.7,
             });
@@ -190,7 +212,7 @@ describe('OpenAIModel', () => {
         describe('validation', () => {
             it('throws error when messages array is empty', async () => {
                 const mockClient = createMockClient(async function* () { });
-                const provider = new OpenAIModel({ modelId: 'gpt-4o', client: mockClient });
+                const provider = new OpenAIModel({ api: 'chat', client: mockClient });
                 await expect(async () => {
                     await collectIterator(provider.stream([]));
                 }).rejects.toThrow('At least one message is required');
@@ -204,7 +226,7 @@ describe('OpenAIModel', () => {
                         choices: [{ finish_reason: 'stop', delta: {}, index: 0 }],
                     };
                 });
-                const provider = new OpenAIModel({ modelId: 'gpt-4o', client: mockClient });
+                const provider = new OpenAIModel({ api: 'chat', client: mockClient });
                 const messages = [new Message({ role: 'user', content: [new TextBlock('Hi')] })];
                 // System prompt that's only whitespace should not be sent
                 const events = await collectIterator(provider.stream(messages, { systemPrompt: '   ' }));
@@ -215,7 +237,8 @@ describe('OpenAIModel', () => {
             it('throws error for streaming with n > 1', async () => {
                 const mockClient = createMockClient(async function* () { });
                 const provider = new OpenAIModel({
-                    modelId: 'gpt-4o',
+                    api: 'chat',
+                    modelId: 'gpt-5.4',
                     client: mockClient,
                     params: { n: 2 },
                 });
@@ -228,7 +251,7 @@ describe('OpenAIModel', () => {
             });
             it('throws error for tool spec without name or description', async () => {
                 const mockClient = createMockClient(async function* () { });
-                const provider = new OpenAIModel({ modelId: 'gpt-4o', client: mockClient });
+                const provider = new OpenAIModel({ api: 'chat', client: mockClient });
                 const messages = [new Message({ role: 'user', content: [new TextBlock('Hi')] })];
                 await expect(async () => {
                     for await (const _ of provider.stream(messages, {
@@ -240,7 +263,7 @@ describe('OpenAIModel', () => {
             });
             it('throws error for empty tool result content', async () => {
                 const mockClient = createMockClient(async function* () { });
-                const provider = new OpenAIModel({ modelId: 'gpt-4o', client: mockClient });
+                const provider = new OpenAIModel({ api: 'chat', client: mockClient });
                 const messages = [
                     new Message({
                         role: 'user',
@@ -268,7 +291,7 @@ describe('OpenAIModel', () => {
                         choices: [{ finish_reason: 'stop', delta: {}, index: 0 }],
                     };
                 });
-                const provider = new OpenAIModel({ modelId: 'gpt-4o', client: mockClient });
+                const provider = new OpenAIModel({ api: 'chat', client: mockClient });
                 const messages = [
                     new Message({ role: 'user', content: [new TextBlock('Run tool')] }),
                     new Message({
@@ -300,7 +323,7 @@ describe('OpenAIModel', () => {
             });
             it('throws error for circular reference in tool input', async () => {
                 const mockClient = createMockClient(async function* () { });
-                const provider = new OpenAIModel({ modelId: 'gpt-4o', client: mockClient });
+                const provider = new OpenAIModel({ api: 'chat', client: mockClient });
                 const circular = { a: 1 };
                 circular.self = circular;
                 const messages = [
@@ -339,7 +362,7 @@ describe('OpenAIModel', () => {
                         choices: [{ finish_reason: 'stop', delta: {}, index: 0 }],
                     };
                 });
-                const provider = new OpenAIModel({ modelId: 'gpt-4o', client: mockClient });
+                const provider = new OpenAIModel({ api: 'chat', client: mockClient });
                 const messages = [new Message({ role: 'user', content: [new TextBlock('Hi')] })];
                 const events = await collectIterator(provider.stream(messages));
                 // Now includes complete content block lifecycle: start, deltas, stop
@@ -375,7 +398,7 @@ describe('OpenAIModel', () => {
                     usage: { prompt_tokens: 10, completion_tokens: 5, total_tokens: 15 },
                 };
             });
-            const provider = new OpenAIModel({ modelId: 'gpt-4o', client: mockClient });
+            const provider = new OpenAIModel({ api: 'chat', client: mockClient });
             const messages = [new Message({ role: 'user', content: [new TextBlock('Hi')] })];
             const events = await collectIterator(provider.stream(messages));
             const metadataEvent = events.find((e) => e.type === 'modelMetadataEvent');
@@ -402,7 +425,7 @@ describe('OpenAIModel', () => {
                     usage: {}, // Empty usage object
                 };
             });
-            const provider = new OpenAIModel({ modelId: 'gpt-4o', client: mockClient });
+            const provider = new OpenAIModel({ api: 'chat', client: mockClient });
             const messages = [new Message({ role: 'user', content: [new TextBlock('Hi')] })];
             const events = await collectIterator(provider.stream(messages));
             const metadataEvent = events.find((e) => e.type === 'modelMetadataEvent');
@@ -431,7 +454,7 @@ describe('OpenAIModel', () => {
                     choices: [{ finish_reason: 'stop', delta: {}, index: 0 }],
                 };
             });
-            const provider = new OpenAIModel({ modelId: 'gpt-4o', client: mockClient });
+            const provider = new OpenAIModel({ api: 'chat', client: mockClient });
             const messages = [new Message({ role: 'user', content: [new TextBlock('Hi')] })];
             const events = await collectIterator(provider.stream(messages));
             // Should not emit event for empty content
@@ -451,7 +474,7 @@ describe('OpenAIModel', () => {
                     choices: [{ finish_reason: 'stop', delta: {}, index: 0 }],
                 };
             });
-            const provider = new OpenAIModel({ modelId: 'gpt-4o', client: mockClient });
+            const provider = new OpenAIModel({ api: 'chat', client: mockClient });
             const messages = [new Message({ role: 'user', content: [new TextBlock('Hi')] })];
             // Suppress console.warn for this test
             vi.spyOn(console, 'warn').mockImplementation(() => { });
@@ -508,7 +531,7 @@ describe('OpenAIModel', () => {
                     choices: [{ finish_reason: 'tool_calls', delta: {}, index: 0 }],
                 };
             });
-            const provider = new OpenAIModel({ modelId: 'gpt-4o', client: mockClient });
+            const provider = new OpenAIModel({ api: 'chat', client: mockClient });
             const messages = [new Message({ role: 'user', content: [new TextBlock('Calculate 2+2')] })];
             const events = await collectIterator(provider.stream(messages));
             // Verify key events in sequence
@@ -583,7 +606,7 @@ describe('OpenAIModel', () => {
                     choices: [{ finish_reason: 'tool_calls', delta: {}, index: 0 }],
                 };
             });
-            const provider = new OpenAIModel({ modelId: 'gpt-4o', client: mockClient });
+            const provider = new OpenAIModel({ api: 'chat', client: mockClient });
             const messages = [new Message({ role: 'user', content: [new TextBlock('Hi')] })];
             const events = await collectIterator(provider.stream(messages));
             // Should emit stop events for both tool calls
@@ -618,7 +641,7 @@ describe('OpenAIModel', () => {
                     choices: [{ finish_reason: 'stop', delta: {}, index: 0 }],
                 };
             });
-            const provider = new OpenAIModel({ modelId: 'gpt-4o', client: mockClient });
+            const provider = new OpenAIModel({ api: 'chat', client: mockClient });
             const messages = [new Message({ role: 'user', content: [new TextBlock('Hi')] })];
             // Suppress console.warn for this test
             vi.spyOn(console, 'warn').mockImplementation(() => { });
@@ -658,7 +681,7 @@ describe('OpenAIModel', () => {
                 yield { choices: [{ delta: { tool_calls: [{ index: 0, function: { arguments: '20}' } }] }, index: 0 }] };
                 yield { choices: [{ finish_reason: 'tool_calls', delta: {}, index: 0 }] };
             });
-            const provider = new OpenAIModel({ modelId: 'gpt-4o', client: mockClient });
+            const provider = new OpenAIModel({ api: 'chat', client: mockClient });
             const messages = [new Message({ role: 'user', content: [new TextBlock('Hi')] })];
             const events = await collectIterator(provider.stream(messages));
             // Extract and concatenate all tool input deltas
@@ -696,7 +719,7 @@ describe('OpenAIModel', () => {
                 };
                 yield { choices: [{ finish_reason: 'tool_calls', delta: {}, index: 0 }] };
             });
-            const provider = new OpenAIModel({ modelId: 'gpt-4o', client: mockClient });
+            const provider = new OpenAIModel({ api: 'chat', client: mockClient });
             const messages = [new Message({ role: 'user', content: [new TextBlock('Calculate 2+2')] })];
             const events = await collectIterator(provider.stream(messages));
             // Should have text deltas followed by tool events
@@ -732,7 +755,7 @@ describe('OpenAIModel', () => {
                         choices: [{ finish_reason: openai, delta: {}, index: 0 }],
                     };
                 });
-                const provider = new OpenAIModel({ modelId: 'gpt-4o', client: mockClient });
+                const provider = new OpenAIModel({ api: 'chat', client: mockClient });
                 const messages = [new Message({ role: 'user', content: [new TextBlock('Hi')] })];
                 const events = await collectIterator(provider.stream(messages));
                 const stopEvent = events.find((e) => e.type === 'modelMessageStopEvent');
@@ -749,7 +772,7 @@ describe('OpenAIModel', () => {
                     choices: [{ finish_reason: 'new_unknown_reason', delta: {}, index: 0 }],
                 };
             });
-            const provider = new OpenAIModel({ modelId: 'gpt-4o', client: mockClient });
+            const provider = new OpenAIModel({ api: 'chat', client: mockClient });
             const messages = [new Message({ role: 'user', content: [new TextBlock('Hi')] })];
             const events = await collectIterator(provider.stream(messages));
             // Should convert unknown stop reason to camelCase
@@ -780,7 +803,8 @@ describe('OpenAIModel', () => {
                 },
             };
             const provider = new OpenAIModel({
-                modelId: 'gpt-4o',
+                api: 'chat',
+                modelId: 'gpt-5.4',
                 client: mockClient,
                 temperature: 0.7,
                 maxTokens: 1000,
@@ -802,7 +826,7 @@ describe('OpenAIModel', () => {
             expect(callCount).toBe(1);
             expect(capturedRequest).toBeDefined();
             expect(capturedRequest).toEqual({
-                model: 'gpt-4o',
+                model: 'gpt-5.4',
                 stream: true,
                 stream_options: { include_usage: true },
                 temperature: 0.7,
@@ -826,26 +850,10 @@ describe('OpenAIModel', () => {
         });
     });
     describe('systemPrompt handling', () => {
-        // Create mock client factory that captures request in provided container
-        const createMockClientWithCapture = (captureContainer) => {
-            return {
-                chat: {
-                    completions: {
-                        create: vi.fn(async (request) => {
-                            captureContainer.request = request;
-                            return (async function* () {
-                                yield { choices: [{ delta: { role: 'assistant' }, index: 0 }] };
-                                yield { choices: [{ finish_reason: 'stop', delta: {}, index: 0 }] };
-                            })();
-                        }),
-                    },
-                },
-            };
-        };
         it('formats array system prompt with text blocks only', async () => {
             const captured = { request: null };
             const mockClient = createMockClientWithCapture(captured);
-            const provider = new OpenAIModel({ modelId: 'gpt-4o', client: mockClient });
+            const provider = new OpenAIModel({ api: 'chat', client: mockClient });
             const messages = [new Message({ role: 'user', content: [new TextBlock('Hello')] })];
             await collectIterator(provider.stream(messages, {
                 systemPrompt: [
@@ -863,7 +871,7 @@ describe('OpenAIModel', () => {
             const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
             const captured = { request: null };
             const mockClient = createMockClientWithCapture(captured);
-            const provider = new OpenAIModel({ modelId: 'gpt-4o', client: mockClient });
+            const provider = new OpenAIModel({ api: 'chat', client: mockClient });
             const messages = [new Message({ role: 'user', content: [new TextBlock('Hello')] })];
             collectIterator(provider.stream(messages, {
                 systemPrompt: [
@@ -885,7 +893,7 @@ describe('OpenAIModel', () => {
         it('handles empty array system prompt', async () => {
             const captured = { request: null };
             const mockClient = createMockClientWithCapture(captured);
-            const provider = new OpenAIModel({ modelId: 'gpt-4o', client: mockClient });
+            const provider = new OpenAIModel({ api: 'chat', client: mockClient });
             const messages = [new Message({ role: 'user', content: [new TextBlock('Hello')] })];
             await collectIterator(provider.stream(messages, {
                 systemPrompt: [],
@@ -897,7 +905,7 @@ describe('OpenAIModel', () => {
         it('formats array system prompt with single text block', async () => {
             const captured = { request: null };
             const mockClient = createMockClientWithCapture(captured);
-            const provider = new OpenAIModel({ modelId: 'gpt-4o', client: mockClient });
+            const provider = new OpenAIModel({ api: 'chat', client: mockClient });
             const messages = [new Message({ role: 'user', content: [new TextBlock('Hello')] })];
             await collectIterator(provider.stream(messages, {
                 systemPrompt: [{ type: 'textBlock', text: 'You are a helpful assistant' }],
@@ -912,7 +920,7 @@ describe('OpenAIModel', () => {
             const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
             const captured = { request: null };
             const mockClient = createMockClientWithCapture(captured);
-            const provider = new OpenAIModel({ modelId: 'gpt-4o', client: mockClient });
+            const provider = new OpenAIModel({ api: 'chat', client: mockClient });
             const messages = [new Message({ role: 'user', content: [new TextBlock('Hello')] })];
             await collectIterator(provider.stream(messages, {
                 systemPrompt: [
@@ -940,7 +948,7 @@ describe('OpenAIModel', () => {
             const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
             const captured = { request: null };
             const mockClient = createMockClientWithCapture(captured);
-            const provider = new OpenAIModel({ modelId: 'gpt-4o', client: mockClient });
+            const provider = new OpenAIModel({ api: 'chat', client: mockClient });
             const messages = [new Message({ role: 'user', content: [new TextBlock('Hello')] })];
             await collectIterator(provider.stream(messages, {
                 systemPrompt: [
@@ -969,7 +977,7 @@ describe('OpenAIModel', () => {
             const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
             const captured = { request: null };
             const mockClient = createMockClientWithCapture(captured);
-            const provider = new OpenAIModel({ modelId: 'gpt-4o', client: mockClient });
+            const provider = new OpenAIModel({ api: 'chat', client: mockClient });
             const messages = [new Message({ role: 'user', content: [new TextBlock('Hello')] })];
             await collectIterator(provider.stream(messages, {
                 systemPrompt: [
@@ -991,27 +999,11 @@ describe('OpenAIModel', () => {
         });
     });
     describe('guard content in messages', () => {
-        // Create mock client factory that captures request in provided container
-        const createMockClientWithCapture = (captureContainer) => {
-            return {
-                chat: {
-                    completions: {
-                        create: vi.fn(async (request) => {
-                            captureContainer.request = request;
-                            return (async function* () {
-                                yield { choices: [{ delta: { role: 'assistant' }, index: 0 }] };
-                                yield { choices: [{ finish_reason: 'stop', delta: {}, index: 0 }] };
-                            })();
-                        }),
-                    },
-                },
-            };
-        };
         it('warns and filters guard content from user messages', async () => {
             const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
             const captured = { request: null };
             const mockClient = createMockClientWithCapture(captured);
-            const provider = new OpenAIModel({ modelId: 'gpt-4o', client: mockClient });
+            const provider = new OpenAIModel({ api: 'chat', client: mockClient });
             const messages = [
                 new Message({
                     role: 'user',
@@ -1029,7 +1021,7 @@ describe('OpenAIModel', () => {
             ];
             await collectIterator(provider.stream(messages));
             // Verify warning was logged
-            expect(warnSpy).toHaveBeenCalledWith('OpenAI ChatCompletions API does not support content type: guardContentBlock.');
+            expect(warnSpy).toHaveBeenCalledWith('block_type=<guardContentBlock> | unsupported content type in openai user message | skipping');
             // Verify guard content filtered out
             expect(captured.request).toBeDefined();
             expect(captured.request.messages).toEqual([
@@ -1047,7 +1039,7 @@ describe('OpenAIModel', () => {
             const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
             const captured = { request: null };
             const mockClient = createMockClientWithCapture(captured);
-            const provider = new OpenAIModel({ modelId: 'gpt-4o', client: mockClient });
+            const provider = new OpenAIModel({ api: 'chat', client: mockClient });
             const imageBytes = new Uint8Array([1, 2, 3, 4]);
             const messages = [
                 new Message({
@@ -1065,7 +1057,7 @@ describe('OpenAIModel', () => {
             ];
             await collectIterator(provider.stream(messages));
             // Verify warning was logged
-            expect(warnSpy).toHaveBeenCalledWith('OpenAI ChatCompletions API does not support content type: guardContentBlock.');
+            expect(warnSpy).toHaveBeenCalledWith('block_type=<guardContentBlock> | unsupported content type in openai user message | skipping');
             // Verify guard content filtered out
             expect(captured.request).toBeDefined();
             expect(captured.request.messages).toEqual([
@@ -1077,7 +1069,7 @@ describe('OpenAIModel', () => {
             const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
             const captured = { request: null };
             const mockClient = createMockClientWithCapture(captured);
-            const provider = new OpenAIModel({ modelId: 'gpt-4o', client: mockClient });
+            const provider = new OpenAIModel({ api: 'chat', client: mockClient });
             const messages = [
                 new Message({
                     role: 'user',
@@ -1093,13 +1085,180 @@ describe('OpenAIModel', () => {
             ];
             await collectIterator(provider.stream(messages));
             // Verify warning was logged
-            expect(warnSpy).toHaveBeenCalledWith('OpenAI ChatCompletions API does not support content type: guardContentBlock.');
+            expect(warnSpy).toHaveBeenCalledWith('block_type=<guardContentBlock> | unsupported content type in openai user message | skipping');
             // Verify no user message added (only guard content)
             expect(captured.request).toBeDefined();
             expect(captured.request.messages).toEqual([]);
             warnSpy.mockRestore();
         });
     });
+    describe('media blocks', () => {
+        it('formats image block in user message as image_url with base64', async () => {
+            const captured = { request: null };
+            const mockClient = createMockClientWithCapture(captured);
+            const provider = new OpenAIModel({ api: 'chat', client: mockClient });
+            const imageBytes = new Uint8Array([72, 101, 108, 108, 111]);
+            const messages = [
+                new Message({
+                    role: 'user',
+                    content: [
+                        new TextBlock('What is in this image?'),
+                        new ImageBlock({ format: 'png', source: { bytes: imageBytes } }),
+                    ],
+                }),
+            ];
+            await collectIterator(provider.stream(messages));
+            const userMsg = captured.request.messages[0];
+            expect(userMsg.role).toBe('user');
+            expect(userMsg.content).toHaveLength(2);
+            expect(userMsg.content[0]).toEqual({ type: 'text', text: 'What is in this image?' });
+            expect(userMsg.content[1]).toEqual({
+                type: 'image_url',
+                image_url: { url: 'data:image/png;base64,SGVsbG8=' },
+            });
+        });
+        it('formats image block in user message with URL source', async () => {
+            const captured = { request: null };
+            const mockClient = createMockClientWithCapture(captured);
+            const provider = new OpenAIModel({ api: 'chat', client: mockClient });
+            const messages = [
+                new Message({
+                    role: 'user',
+                    content: [new ImageBlock({ format: 'jpeg', source: { url: 'https://example.com/img.jpg' } })],
+                }),
+            ];
+            await collectIterator(provider.stream(messages));
+            const userMsg = captured.request.messages[0];
+            expect(userMsg.content[0]).toEqual({
+                type: 'image_url',
+                image_url: { url: 'https://example.com/img.jpg' },
+            });
+        });
+        it('formats document block with bytes source as file in user message', async () => {
+            const captured = { request: null };
+            const mockClient = createMockClientWithCapture(captured);
+            const provider = new OpenAIModel({ api: 'chat', client: mockClient });
+            const docBytes = new Uint8Array([1, 2, 3]);
+            const messages = [
+                new Message({
+                    role: 'user',
+                    content: [new DocumentBlock({ name: 'report.pdf', format: 'pdf', source: { bytes: docBytes } })],
+                }),
+            ];
+            await collectIterator(provider.stream(messages));
+            const userMsg = captured.request.messages[0];
+            expect(userMsg.content[0]).toEqual({
+                type: 'file',
+                file: { file_data: 'data:application/pdf;base64,AQID', filename: 'report.pdf' },
+            });
+        });
+        it('splits image from tool result into separate user message', async () => {
+            const captured = { request: null };
+            const mockClient = createMockClientWithCapture(captured);
+            const provider = new OpenAIModel({ api: 'chat', client: mockClient });
+            const imageBytes = new Uint8Array([72, 101, 108, 108, 111]);
+            const messages = [
+                new Message({
+                    role: 'user',
+                    content: [
+                        new ToolResultBlock({
+                            toolUseId: 'tool-1',
+                            status: 'success',
+                            content: [
+                                new TextBlock('Screenshot captured'),
+                                new ImageBlock({ format: 'png', source: { bytes: imageBytes } }),
+                            ],
+                        }),
+                    ],
+                }),
+            ];
+            await collectIterator(provider.stream(messages));
+            // Tool message with text only
+            const toolMsg = captured.request.messages[0];
+            expect(toolMsg.role).toBe('tool');
+            expect(toolMsg.tool_call_id).toBe('tool-1');
+            expect(toolMsg.content).toBe('Screenshot captured');
+            // Separate user message with image
+            const userMsg = captured.request.messages[1];
+            expect(userMsg.role).toBe('user');
+            expect(userMsg.content[0]).toEqual({
+                type: 'image_url',
+                image_url: { url: 'data:image/png;base64,SGVsbG8=' },
+            });
+        });
+        it('injects placeholder text when tool result contains only images', async () => {
+            const captured = { request: null };
+            const mockClient = createMockClientWithCapture(captured);
+            const provider = new OpenAIModel({ api: 'chat', client: mockClient });
+            const messages = [
+                new Message({
+                    role: 'user',
+                    content: [
+                        new ToolResultBlock({
+                            toolUseId: 'tool-1',
+                            status: 'success',
+                            content: [new ImageBlock({ format: 'png', source: { bytes: new Uint8Array([1]) } })],
+                        }),
+                    ],
+                }),
+            ];
+            await collectIterator(provider.stream(messages));
+            const toolMsg = captured.request.messages[0];
+            expect(toolMsg.content).toContain('Tool successfully returned an image');
+        });
+        it('skips document block in tool result with warning', async () => {
+            const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+            const captured = { request: null };
+            const mockClient = createMockClientWithCapture(captured);
+            const provider = new OpenAIModel({ api: 'chat', client: mockClient });
+            const messages = [
+                new Message({
+                    role: 'user',
+                    content: [
+                        new ToolResultBlock({
+                            toolUseId: 'tool-1',
+                            status: 'success',
+                            content: [
+                                new TextBlock('result'),
+                                new DocumentBlock({ name: 'doc.pdf', format: 'pdf', source: { bytes: new Uint8Array([1]) } }),
+                            ],
+                        }),
+                    ],
+                }),
+            ];
+            await collectIterator(provider.stream(messages));
+            const toolMsg = captured.request.messages[0];
+            expect(toolMsg.content).toBe('result');
+            expect(warnSpy).toHaveBeenCalled();
+            warnSpy.mockRestore();
+        });
+        it('skips video block in tool result with warning', async () => {
+            const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+            const captured = { request: null };
+            const mockClient = createMockClientWithCapture(captured);
+            const provider = new OpenAIModel({ api: 'chat', client: mockClient });
+            const messages = [
+                new Message({
+                    role: 'user',
+                    content: [
+                        new ToolResultBlock({
+                            toolUseId: 'tool-1',
+                            status: 'success',
+                            content: [
+                                new TextBlock('result'),
+                                new VideoBlock({ format: 'mp4', source: { bytes: new Uint8Array([1]) } }),
+                            ],
+                        }),
+                    ],
+                }),
+            ];
+            await collectIterator(provider.stream(messages));
+            const toolMsg = captured.request.messages[0];
+            expect(toolMsg.content).toBe('result');
+            expect(warnSpy).toHaveBeenCalled();
+            warnSpy.mockRestore();
+        });
+    });
     describe('error handling', () => {
         it('throws ContextWindowOverflowError for structured error with code', async () => {
             const mockClient = {
@@ -1113,7 +1272,7 @@ describe('OpenAIModel', () => {
                     },
                 },
             };
-            const provider = new OpenAIModel({ modelId: 'gpt-4o', client: mockClient });
+            const provider = new OpenAIModel({ api: 'chat', client: mockClient });
             const messages = [new Message({ role: 'user', content: [new TextBlock('Hi')] })];
             await expect(async () => {
                 for await (const _ of provider.stream(messages)) {
@@ -1131,7 +1290,7 @@ describe('OpenAIModel', () => {
                     },
                 },
             };
-            const provider = new OpenAIModel({ modelId: 'gpt-4o', client: mockClient });
+            const provider = new OpenAIModel({ api: 'chat', client: mockClient });
             const messages = [new Message({ role: 'user', content: [new TextBlock('Hi')] })];
             await expect(async () => {
                 for await (const _ of provider.stream(messages)) {
@@ -1156,7 +1315,7 @@ describe('OpenAIModel', () => {
                     },
                 },
             };
-            const provider = new OpenAIModel({ modelId: 'gpt-4o', client: mockClient });
+            const provider = new OpenAIModel({ api: 'chat', client: mockClient });
             const messages = [new Message({ role: 'user', content: [new TextBlock('Hi')] })];
             await expect(async () => {
                 for await (const _ of provider.stream(messages)) {
@@ -1174,7 +1333,7 @@ describe('OpenAIModel', () => {
                     },
                 },
             };
-            const provider = new OpenAIModel({ modelId: 'gpt-4o', client: mockClient });
+            const provider = new OpenAIModel({ api: 'chat', client: mockClient });
             const messages = [new Message({ role: 'user', content: [new TextBlock('Hi')] })];
             await expect(async () => {
                 for await (const _ of provider.stream(messages)) {
@@ -1189,7 +1348,7 @@ describe('OpenAIModel', () => {
                 // Stream interruption
                 throw new Error('Network connection lost');
             });
-            const provider = new OpenAIModel({ modelId: 'gpt-4o', client: mockClient });
+            const provider = new OpenAIModel({ api: 'chat', client: mockClient });
             const messages = [new Message({ role: 'user', content: [new TextBlock('Hi')] })];
             await expect(async () => {
                 for await (const _ of provider.stream(messages)) {
@@ -1209,7 +1368,7 @@ describe('OpenAIModel', () => {
                     },
                 },
             };
-            const provider = new OpenAIModel({ modelId: 'gpt-4o', client: mockClient });
+            const provider = new OpenAIModel({ api: 'chat', client: mockClient });
             const messages = [new Message({ role: 'user', content: [new TextBlock('Hi')] })];
             await expect(async () => {
                 for await (const _ of provider.stream(messages)) {
@@ -1229,7 +1388,7 @@ describe('OpenAIModel', () => {
                     },
                 },
             };
-            const provider = new OpenAIModel({ modelId: 'gpt-4o', client: mockClient });
+            const provider = new OpenAIModel({ api: 'chat', client: mockClient });
             const messages = [new Message({ role: 'user', content: [new TextBlock('Hi')] })];
             await expect(async () => {
                 for await (const _ of provider.stream(messages)) {
@@ -1247,7 +1406,7 @@ describe('OpenAIModel', () => {
                     },
                 },
             };
-            const provider = new OpenAIModel({ modelId: 'gpt-4o', client: mockClient });
+            const provider = new OpenAIModel({ api: 'chat', client: mockClient });
             const messages = [new Message({ role: 'user', content: [new TextBlock('Hi')] })];
             await expect(async () => {
                 for await (const _ of provider.stream(messages)) {
@@ -1265,7 +1424,7 @@ describe('OpenAIModel', () => {
                     },
                 },
             };
-            const provider = new OpenAIModel({ modelId: 'gpt-4o', client: mockClient });
+            const provider = new OpenAIModel({ api: 'chat', client: mockClient });
             const messages = [new Message({ role: 'user', content: [new TextBlock('Hi')] })];
             await expect(async () => {
                 for await (const _ of provider.stream(messages)) {
@@ -1274,7 +1433,7 @@ describe('OpenAIModel', () => {
             }).rejects.toThrow(ModelThrottledError);
         });
         it('preserves original error as cause in ModelThrottledError', async () => {
-            const originalError = new Error('Request too large for gpt-4o on tokens per min');
+            const originalError = new Error('Request too large for gpt-5.4 on tokens per min');
             originalError.status = 429;
             const mockClient = {
                 chat: {
@@ -1285,7 +1444,7 @@ describe('OpenAIModel', () => {
                     },
                 },
             };
-            const provider = new OpenAIModel({ modelId: 'gpt-4o', client: mockClient });
+            const provider = new OpenAIModel({ api: 'chat', client: mockClient });
             const messages = [new Message({ role: 'user', content: [new TextBlock('Hi')] })];
             try {
                 for await (const _ of provider.stream(messages)) {
@@ -1297,7 +1456,7 @@ describe('OpenAIModel', () => {
                 expect(error).toBeInstanceOf(ModelThrottledError);
                 const throttleError = error;
                 expect(throttleError.cause).toBe(originalError);
-                expect(throttleError.message).toBe('Request too large for gpt-4o on tokens per min');
+                expect(throttleError.message).toBe('Request too large for gpt-5.4 on tokens per min');
             }
         });
     });