@outputai/llm 0.11.1-next.da26845.0 → 0.12.0

package/src/ai_provider.spec.js

@@ -1,217 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-
-const SHIPPED_PROVIDERS = [
-  { name: 'amazon-bedrock', pkg: '@ai-sdk/amazon-bedrock', exportName: 'createAmazonBedrock' },
-  { name: 'anthropic', pkg: '@ai-sdk/anthropic', exportName: 'createAnthropic' },
-  { name: 'azure', pkg: '@ai-sdk/azure', exportName: 'createAzure' },
-  { name: 'google-vertex', pkg: '@ai-sdk/google-vertex', exportName: 'createVertex' },
-  { name: 'openai', pkg: '@ai-sdk/openai', exportName: 'createOpenAI' },
-  { name: 'perplexity', pkg: '@ai-sdk/perplexity', exportName: 'createPerplexity' }
-];
-
-const makeProviderModules = () => Object.fromEntries(
-  SHIPPED_PROVIDERS.map( ( { name, pkg, exportName } ) => [
-    pkg,
-    {
-      [exportName]: vi.fn( options => ( { name, options } ) )
-    }
-  ] )
-);
-
-const undiciSpies = vi.hoisted( () => ( {
-  EnvHttpProxyAgent: vi.fn(),
-  fetch: vi.fn()
-} ) );
-
-const importWithMockedProviders = async ( {
-  modules = makeProviderModules()
-} = {} ) => {
-  await vi.resetModules();
-
-  for ( const { pkg, exportName } of SHIPPED_PROVIDERS ) {
-    vi.doMock( pkg, () => ( {
-      [exportName]: modules[pkg][exportName]
-    } ) );
-  }
-
-  vi.doMock( 'undici', async importOriginal => {
-    const actual = await importOriginal();
-    undiciSpies.EnvHttpProxyAgent.mockImplementation( function EnvHttpProxyAgent( options ) {
-      return new actual.EnvHttpProxyAgent( options );
-    } );
-    undiciSpies.fetch.mockResolvedValue( new actual.Response( null, { status: 204 } ) );
-
-    return {
-      ...actual,
-      EnvHttpProxyAgent: undiciSpies.EnvHttpProxyAgent,
-      fetch: undiciSpies.fetch
-    };
-  } );
-
-  return {
-    modules,
-    ...( await import( './ai_provider.js' ) )
-  };
-};
-
-afterEach( () => {
-  for ( const { pkg } of SHIPPED_PROVIDERS ) {
-    vi.doUnmock( pkg );
-  }
-  vi.doUnmock( 'undici' );
-  undiciSpies.EnvHttpProxyAgent.mockReset();
-  undiciSpies.fetch.mockReset();
-  vi.resetModules();
-  vi.restoreAllMocks();
-} );
-
-describe( 'getProvider', () => {
-  it( 'does not initialize shipped providers on import', async () => {
-    const { modules } = await importWithMockedProviders();
-
-    for ( const { pkg, exportName } of SHIPPED_PROVIDERS ) {
-      expect( modules[pkg][exportName] ).not.toHaveBeenCalled();
-    }
-  } );
-
-  it( 'initializes each shipped provider with custom fetch when requested', async () => {
-    const { modules, getProvider } = await importWithMockedProviders();
-
-    for ( const { name, pkg, exportName } of SHIPPED_PROVIDERS ) {
-      const provider = getProvider( name );
-
-      expect( provider ).toMatchObject( { name, options: { fetch: expect.any( Function ) } } );
-      expect( modules[pkg][exportName] ).toHaveBeenCalledWith( { fetch: expect.any( Function ) } );
-    }
-
-    expect( undiciSpies.EnvHttpProxyAgent ).toHaveBeenCalledWith( {
-      headersTimeout: 15 * 60 * 1000,
-      bodyTimeout: 15 * 60 * 1000,
-      allowH2: false
-    } );
-  } );
-
-  it( 'passes the custom dispatcher through injected fetch', async () => {
-    const { getProvider } = await importWithMockedProviders();
-    const provider = getProvider( 'openai' );
-    const init = { method: 'POST', body: 'body' };
-
-    await provider.options.fetch( 'https://api.example.test', init );
-
-    expect( undiciSpies.fetch ).toHaveBeenCalledWith(
-      'https://api.example.test',
-      {
-        ...init,
-        dispatcher: undiciSpies.EnvHttpProxyAgent.mock.results[0].value
-      }
-    );
-  } );
-
-  it( 'allows injected fetch callers to override the dispatcher', async () => {
-    const { getProvider } = await importWithMockedProviders();
-    const provider = getProvider( 'openai' );
-    const dispatcher = { name: 'custom-dispatcher' };
-
-    await provider.options.fetch( 'https://api.example.test', { dispatcher } );
-
-    expect( undiciSpies.fetch ).toHaveBeenCalledWith(
-      'https://api.example.test',
-      { dispatcher }
-    );
-  } );
-
-  it( 'can import and initialize all installed shipped providers', async () => {
-    const { getProvider } = await import( './ai_provider.js' );
-
-    for ( const { name } of SHIPPED_PROVIDERS ) {
-      expect( getProvider( name ) ).toEqual( expect.any( Function ) );
-    }
-  } );
-
-  it( 'caches initialized providers', async () => {
-    const { modules, getProvider } = await importWithMockedProviders();
-
-    const first = getProvider( 'openai' );
-    const second = getProvider( 'openai' );
-
-    expect( second ).toBe( first );
-    expect( modules['@ai-sdk/openai'].createOpenAI ).toHaveBeenCalledTimes( 1 );
-  } );
-
-  it( 'uses registered providers before shipped providers', async () => {
-    const { modules, getProvider, registerProvider } = await importWithMockedProviders();
-    const customProvider = vi.fn( model => ( { provider: 'custom', model } ) );
-
-    registerProvider( 'openai', customProvider );
-
-    expect( getProvider( 'openai' ) ).toBe( customProvider );
-    expect( modules['@ai-sdk/openai'].createOpenAI ).not.toHaveBeenCalled();
-  } );
-
-  it( 'throws FatalError for unsupported providers', async () => {
-    const { getProvider } = await importWithMockedProviders();
-
-    expect( () => getProvider( 'not-real' ) ).toThrow( 'Unsupported provider "not-real"' );
-  } );
-
-  it( 'throws a friendly error when provider initialization fails', async () => {
-    const modules = makeProviderModules();
-    modules['@ai-sdk/openai'].createOpenAI.mockImplementation( () => {
-      throw new Error( 'Missing OpenAI API key' );
-    } );
-    const { getProvider } = await importWithMockedProviders( { modules } );
-
-    expect( () => getProvider( 'openai' ) ).toThrow(
-      'Failed to initialize provider "openai": Missing OpenAI API key'
-    );
-  } );
-} );
-
-describe( 'registerProvider', () => {
-  it( 'registers custom providers', async () => {
-    const { getProvider, getProviderNames, registerProvider } = await importWithMockedProviders();
-    const customProvider = vi.fn();
-
-    registerProvider( 'custom', customProvider );
-
-    expect( getProvider( 'custom' ) ).toBe( customProvider );
-    expect( getProviderNames() ).toContain( 'custom' );
-  } );
-
-  it( 'validates provider registration arguments', async () => {
-    const { registerProvider } = await importWithMockedProviders();
-
-    expect( () => registerProvider( '', vi.fn() ) ).toThrow( 'Provider name must be a non-empty string' );
-    expect( () => registerProvider( 'custom', 'not-a-function' ) ).toThrow( 'expected function, received string' );
-  } );
-
-  it.each( [
-    [ 'vertex', 'google-vertex' ],
-    [ 'bedrock', 'amazon-bedrock' ]
-  ] )( 'rejects registering deprecated provider alias %s', async ( alias, canonical ) => {
-    const { registerProvider } = await importWithMockedProviders();
-
-    expect( () => registerProvider( alias, vi.fn() ) ).toThrow(
-      `Cannot register provider "${alias}": that name is a deprecated alias for "${canonical}". Register "${canonical}" instead.`
-    );
-  } );
-} );
-
-describe( 'getProviderNames', () => {
-  it( 'returns shipped and registered provider names without duplicates', async () => {
-    const { getProviderNames, registerProvider } = await importWithMockedProviders();
-
-    registerProvider( 'custom', vi.fn() );
-    registerProvider( 'openai', vi.fn() );
-
-    expect( getProviderNames() ).toEqual( [
-      'amazon-bedrock',
-      'anthropic',
-      'azure',
-      'google-vertex',
-      'openai',
-      'perplexity',
-      'custom'
-    ] );
-  } );
-} );

package/src/ai_sdk_options.spec.js

@@ -1,390 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-
-const loadModelImpl = vi.fn();
-const loadImageModelImpl = vi.fn();
-const loadPromptToolsImpl = vi.fn();
-const buildLoadSkillToolImpl = vi.fn();
-
-vi.mock( './utils/models.js', () => ( {
-  loadTextModel: ( ...args ) => loadModelImpl( ...args ),
-  loadImageModel: ( ...args ) => loadImageModelImpl( ...args )
-} ) );
-
-vi.mock( './utils/tools.js', () => ( {
-  buildLoadSkillTool: ( ...args ) => buildLoadSkillToolImpl( ...args ),
-  loadPromptTools: ( ...args ) => loadPromptToolsImpl( ...args )
-} ) );
-
-vi.mock( 'ai', () => ( {
-  isStepCount: count => ( { type: 'step-count', count } )
-} ) );
-
-const importSut = async () => import( './ai_sdk_options.js' );
-
-const makeTextPrompt = config => ( {
-  name: 'test@v1',
-  config: {
-    provider: 'anthropic',
-    model: 'claude-haiku-4-5',
-    maxSteps: 10,
-    ...config
-  },
-  messages: [
-    { role: 'system', content: 'You are concise.' },
-    { role: 'user', content: 'Hello' }
-  ],
-  instructions: null
-} );
-
-const makeImagePrompt = config => ( {
-  name: 'image@v1',
-  config: {
-    provider: 'openai',
-    model: 'gpt-image-1',
-    ...config
-  },
-  messages: [],
-  instructions: 'Generate a cinematic image of a NASCAR race at sunset.'
-} );
-
-const writerSkill = {
-  name: 'writer',
-  description: 'Writes copy',
-  instructions: 'Do it.'
-};
-
-const skillsCatalog =
-  'Available skills (use load_skill to get full instructions):\n- writer: Writes copy';
-
-describe( 'ai_sdk_options', () => {
-  beforeEach( () => {
-    vi.resetModules();
-    vi.clearAllMocks();
-    loadModelImpl.mockReturnValue( 'MODEL' );
-    loadImageModelImpl.mockReturnValue( 'IMAGE_MODEL' );
-    loadPromptToolsImpl.mockReturnValue( null );
-    buildLoadSkillToolImpl.mockImplementation( skills => ( { type: 'load_skill', skills } ) );
-  } );
-
-  describe( 'loadAiSdkTextOptions', () => {
-    const loadText = async args => {
-      const { loadAiSdkTextOptions } = await importSut();
-      return loadAiSdkTextOptions( { skills: [], ...args } );
-    };
-
-    it( 'maps a loaded prompt to model, instructions, messages, and generation config', async () => {
-      const prompt = makeTextPrompt( {
-        temperature: 0.3,
-        maxOutputTokens: 1000,
-        providerOptions: { anthropic: { effort: 'medium' } }
-      } );
-
-      const result = await loadText( { prompt } );
-
-      expect( loadModelImpl ).toHaveBeenCalledWith( prompt );
-      expect( loadPromptToolsImpl ).toHaveBeenCalledWith( prompt );
-      expect( result ).toEqual( {
-        allowSystemInMessages: true,
-        maxRetries: 0,
-        model: 'MODEL',
-        instructions: [ { role: 'system', content: 'You are concise.' } ],
-        messages: [ { role: 'user', content: 'Hello' } ],
-        providerOptions: prompt.config.providerOptions,
-        temperature: 0.3,
-        maxOutputTokens: 1000
-      } );
-    } );
-
-    it( 'forwards all supported text generation options', async () => {
-      const generationOptions = {
-        frequencyPenalty: 0.2,
-        maxOutputTokens: 2000,
-        presencePenalty: 0.3,
-        providerOptions: { openai: { reasoningEffort: 'low' } },
-        seed: 42,
-        stopSequences: [ 'END' ],
-        temperature: 0.4,
-        topK: 40,
-        topP: 0.9
-      };
-
-      const result = await loadText( { prompt: makeTextPrompt( generationOptions ) } );
-
-      expect( result ).toMatchObject( generationOptions );
-    } );
-
-    it( 'preserves temperature 0', async () => {
-      const result = await loadText( { prompt: makeTextPrompt( { temperature: 0 } ) } );
-
-      expect( result.temperature ).toBe( 0 );
-    } );
-
-    it( 'throws when the prompt has no chat-style messages', async () => {
-      const { loadAiSdkTextOptions } = await importSut();
-
-      expect( () => loadAiSdkTextOptions( { prompt: makeImagePrompt(), skills: [] } ) ).toThrow(
-        'Prompt "image@v1" has no chat-style messages.'
-      );
-      expect( loadModelImpl ).not.toHaveBeenCalled();
-      expect( loadPromptToolsImpl ).not.toHaveBeenCalled();
-    } );
-
-    it( 'forwards per-message providerOptions when splitting system and messages', async () => {
-      const providerOptions = { anthropic: { cacheControl: { type: 'ephemeral', ttl: '1h' } } };
-      const prompt = {
-        name: 'cache@v1',
-        config: {
-          provider: 'anthropic',
-          model: 'claude-sonnet-4-5'
-        },
-        messages: [
-          { role: 'system', content: 'Static', providerOptions },
-          { role: 'user', content: 'Hello' }
-        ],
-        instructions: null
-      };
-
-      const result = await loadText( { prompt } );
-
-      expect( result.instructions ).toEqual( [ {
-        role: 'system',
-        content: 'Static',
-        providerOptions
-      } ] );
-      expect( result.messages ).toEqual( [ { role: 'user', content: 'Hello' } ] );
-    } );
-
-    it( 'returns an empty instructions array when the prompt has no system block', async () => {
-      const prompt = {
-        name: 'no-system@v1',
-        config: { provider: 'anthropic', model: 'claude-haiku-4-5' },
-        messages: [ { role: 'user', content: 'Hello' } ],
-        instructions: null
-      };
-
-      const result = await loadText( { prompt } );
-
-      expect( result.instructions ).toEqual( [] );
-      expect( result.messages ).toEqual( [ { role: 'user', content: 'Hello' } ] );
-    } );
-
-    it( 'groups multiple system blocks into instructions and keeps them out of messages', async () => {
-      const prompt = {
-        name: 'multi-system@v1',
-        config: { provider: 'anthropic', model: 'claude-haiku-4-5' },
-        messages: [
-          { role: 'system', content: 'First' },
-          { role: 'system', content: 'Second' },
-          { role: 'user', content: 'Hello' }
-        ],
-        instructions: null
-      };
-
-      const result = await loadText( { prompt } );
-
-      expect( result.instructions ).toEqual( [
-        { role: 'system', content: 'First' },
-        { role: 'system', content: 'Second' }
-      ] );
-      expect( result.messages ).toEqual( [ { role: 'user', content: 'Hello' } ] );
-    } );
-
-    it( 'omits tools and stopWhen when no tools are present', async () => {
-      const result = await loadText( { prompt: makeTextPrompt() } );
-
-      expect( result.tools ).toBeUndefined();
-      expect( result.stopWhen ).toBeUndefined();
-      expect( buildLoadSkillToolImpl ).not.toHaveBeenCalled();
-    } );
-
-    it( 'sets prompt tools and stopWhen from maxSteps', async () => {
-      const promptTools = { googleSearch: { type: 'google-search-tool' } };
-      loadPromptToolsImpl.mockReturnValue( promptTools );
-
-      const result = await loadText( { prompt: makeTextPrompt( { tools: { googleSearch: {} }, maxSteps: 4 } ) } );
-
-      expect( result.tools ).toEqual( promptTools );
-      expect( result.stopWhen ).toEqual( { type: 'step-count', count: 4 } );
-    } );
-
-    it( 'lets caller tools override prompt tools on the same key', async () => {
-      loadPromptToolsImpl.mockReturnValue( {
-        googleSearch: { from: 'prompt' },
-        urlContext: { from: 'prompt' }
-      } );
-
-      const result = await loadText( {
-        prompt: makeTextPrompt(),
-        tools: { googleSearch: { from: 'caller' } }
-      } );
-
-      expect( result.tools ).toEqual( {
-        googleSearch: { from: 'caller' },
-        urlContext: { from: 'prompt' }
-      } );
-    } );
-
-    it( 'appends the skills catalog to the first system message and adds load_skill', async () => {
-      const providerOptions = { anthropic: { cacheControl: { type: 'ephemeral' } } };
-      const prompt = makeTextPrompt();
-      prompt.messages[0] = { ...prompt.messages[0], providerOptions };
-
-      const result = await loadText( {
-        prompt,
-        skills: [ writerSkill ]
-      } );
-
-      expect( buildLoadSkillToolImpl ).toHaveBeenCalledWith( [ writerSkill ] );
-      expect( result.instructions ).toEqual( [
-        { role: 'system', content: `You are concise.\n\n${skillsCatalog}`, providerOptions }
-      ] );
-      expect( result.messages ).toEqual( [ { role: 'user', content: 'Hello' } ] );
-      expect( result.tools ).toEqual( {
-        load_skill: { type: 'load_skill', skills: [ writerSkill ] }
-      } );
-      expect( result.stopWhen ).toEqual( { type: 'step-count', count: 10 } );
-    } );
-
-    it( 'adds a system message for the skills catalog when none exists', async () => {
-      const prompt = {
-        name: 'no-system@v1',
-        config: { provider: 'anthropic', model: 'claude-haiku-4-5', maxSteps: 10 },
-        messages: [ { role: 'user', content: 'Hello' } ],
-        instructions: null
-      };
-
-      const result = await loadText( { prompt, skills: [ writerSkill ] } );
-
-      expect( result.instructions ).toEqual( [ { role: 'system', content: skillsCatalog } ] );
-      expect( result.messages ).toEqual( [ { role: 'user', content: 'Hello' } ] );
-    } );
-
-    it( 'keeps load_skill when the caller uses the same key', async () => {
-      const result = await loadText( {
-        prompt: makeTextPrompt(),
-        tools: { load_skill: { from: 'caller' }, search: { from: 'caller' } },
-        skills: [ writerSkill ]
-      } );
-
-      expect( result.tools ).toEqual( {
-        load_skill: { type: 'load_skill', skills: [ writerSkill ] },
-        search: { from: 'caller' }
-      } );
-    } );
-
-    it( 'forwards output, abortSignal, and caller stopWhen', async () => {
-      const output = { type: 'object' };
-      const abortSignal = AbortSignal.abort();
-      const stopWhen = { type: 'custom-stop' };
-
-      const result = await loadText( {
-        prompt: makeTextPrompt(),
-        output,
-        abortSignal,
-        stopWhen
-      } );
-
-      expect( result.output ).toBe( output );
-      expect( result.abortSignal ).toBe( abortSignal );
-      expect( result.stopWhen ).toBe( stopWhen );
-    } );
-
-    it( 'does not replace caller stopWhen with maxSteps when tools are present', async () => {
-      loadPromptToolsImpl.mockReturnValue( { googleSearch: { type: 'google-search-tool' } } );
-      const stopWhen = { type: 'custom-stop' };
-
-      const result = await loadText( {
-        prompt: makeTextPrompt( { maxSteps: 4 } ),
-        stopWhen
-      } );
-
-      expect( result.stopWhen ).toBe( stopWhen );
-    } );
-
-    it( 'sets toolChoice only when tools are present', async () => {
-      const withoutTools = await loadText( {
-        prompt: makeTextPrompt(),
-        toolChoice: 'required'
-      } );
-      expect( withoutTools.toolChoice ).toBeUndefined();
-
-      loadPromptToolsImpl.mockReturnValue( { googleSearch: { type: 'google-search-tool' } } );
-      const withTools = await loadText( {
-        prompt: makeTextPrompt(),
-        toolChoice: 'required'
-      } );
-      expect( withTools.toolChoice ).toBe( 'required' );
-    } );
-  } );
-
-  describe( 'loadAiSdkImageOptions', () => {
-    it( 'maps a loaded prompt to image options and ignores text generation config', async () => {
-      const images = [ Buffer.from( 'image-bytes' ) ];
-      const mask = Buffer.from( 'mask-bytes' );
-      const prompt = makeImagePrompt( {
-        n: 2,
-        maxImagesPerCall: 1,
-        size: '1024x1024',
-        aspectRatio: '1:1',
-        seed: 42,
-        temperature: 0.7,
-        maxOutputTokens: 1000,
-        providerOptions: { openai: { quality: 'high' } }
-      } );
-
-      const { loadAiSdkImageOptions } = await importSut();
-      const result = loadAiSdkImageOptions( { prompt, images, mask } );
-
-      expect( loadImageModelImpl ).toHaveBeenCalledWith( prompt );
-      expect( loadModelImpl ).not.toHaveBeenCalled();
-      expect( loadPromptToolsImpl ).not.toHaveBeenCalled();
-      expect( result ).toEqual( {
-        maxRetries: 0,
-        model: 'IMAGE_MODEL',
-        prompt: {
-          text: 'Generate a cinematic image of a NASCAR race at sunset.',
-          images,
-          mask
-        },
-        providerOptions: prompt.config.providerOptions,
-        n: 2,
-        maxImagesPerCall: 1,
-        size: '1024x1024',
-        aspectRatio: '1:1',
-        seed: 42
-      } );
-      expect( result.temperature ).toBeUndefined();
-      expect( result.maxOutputTokens ).toBeUndefined();
-    } );
-
-    it( 'omits undefined image options while preserving explicit 0 seed', async () => {
-      const { loadAiSdkImageOptions } = await importSut();
-      const result = loadAiSdkImageOptions( { prompt: makeImagePrompt( { seed: 0 } ) } );
-
-      expect( result ).toEqual( {
-        maxRetries: 0,
-        model: 'IMAGE_MODEL',
-        prompt: 'Generate a cinematic image of a NASCAR race at sunset.',
-        providerOptions: undefined,
-        seed: 0
-      } );
-    } );
-
-    it( 'throws when the prompt has no instructions', async () => {
-      const { loadAiSdkImageOptions } = await importSut();
-
-      expect( () => loadAiSdkImageOptions( { prompt: makeTextPrompt() } ) ).toThrow(
-        'Prompt "test@v1" has no instructions.'
-      );
-      expect( loadImageModelImpl ).not.toHaveBeenCalled();
-    } );
-
-    it( 'forwards abortSignal', async () => {
-      const abortSignal = AbortSignal.abort();
-      const { loadAiSdkImageOptions } = await importSut();
-      const result = loadAiSdkImageOptions( { prompt: makeImagePrompt(), abortSignal } );
-
-      expect( result.abortSignal ).toBe( abortSignal );
-    } );
-  } );
-} );

package/src/fixtures/image_response_v7_google_vertex.js

@@ -1,72 +0,0 @@
-const base64 = 'iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAYAAACqaXHeAAAAfUlEQVR4Xu3VQREAIAwEMWqnD/y7AyGblcDQy+zed8KNB/ADnIANCG+gEaQABShAAQpgMBwFKEABClAgjAAFKEABClCAAhgMRwEKUIACFAgjQAEKUIACFKAABsNRgAIUoAAFwghQgAIUoAAFKIDBcBSgAAUoQIEwAhTIK/ABN/RggaSa6FYAAAAASUVORK5CYII=';
-const bytes = [
-  137, 80, 78, 71, 13, 10, 26, 10, 0, 0, 0, 13, 73, 72, 68, 82, 0, 0, 0, 64, 0, 0, 0, 64,
-  8, 6, 0, 0, 0, 170, 105, 113, 222, 0, 0, 0, 125, 73, 68, 65, 84, 120, 94, 237, 213, 65, 17,
-  0, 32, 12, 4, 49, 106, 167, 15, 252, 187, 3, 33, 155, 149, 192, 208, 203, 236, 222, 119, 194,
-  141, 7, 240, 3, 156, 128, 13, 8, 111, 160, 17, 164, 0, 5, 40, 64, 1, 10, 96, 48, 28, 5, 40,
-  64, 1, 10, 80, 32, 140, 0, 5, 40, 64, 1, 10, 80, 128, 2, 24, 12, 71, 1, 10, 80, 128, 2, 20,
-  8, 35, 64, 1, 10, 80, 128, 2, 20, 160, 0, 6, 195, 81, 128, 2, 20, 160, 0, 5, 194, 8, 80,
-  128, 2, 20, 160, 0, 5, 40, 128, 193, 112, 20, 160, 0, 5, 40, 64, 129, 48, 2, 20, 200, 43,
-  240, 1, 55, 244, 96, 129, 164, 154, 232, 86, 0, 0, 0, 0, 73, 69, 78, 68, 174, 66, 96, 130
-];
-
-export default {
-  images: [
-    {
-      base64Data: base64,
-      mediaType: 'image/png',
-      // getters
-      base64,
-      uint8Array: new Uint8Array( bytes )
-    }
-  ],
-  warnings: [
-    {
-      type: 'unsupported',
-      feature: 'size',
-      details: 'This model does not support the `size` option. Use `aspectRatio` instead.'
-    }
-  ],
-  responses: [
-    {
-      timestamp: '2026-08-25T00:00:00.000Z',
-      modelId: 'gemini-2.5-flash-image',
-      headers: {
-        'alt-svc': 'h3=":443"; ma=2592000,h3-29=":443"; ma=2592000',
-        'content-encoding': 'gzip',
-        'content-type': 'application/json; charset=UTF-8',
-        date: 'Tue, 25 Aug 2026 00:00:00 GMT',
-        server: 'scaffolding on HTTPServer2',
-        'transfer-encoding': 'chunked',
-        vary: 'Origin, X-Origin, Referer',
-        'x-content-type-options': 'nosniff',
-        'x-frame-options': 'SAMEORIGIN',
-        'x-xss-protection': '0'
-      }
-    }
-  ],
-  providerMetadata: {
-    googleVertex: {
-      images: [
-        {}
-      ]
-    },
-    vertex: {
-      images: [
-        {}
-      ]
-    }
-  },
-  usage: {
-    inputTokens: 157,
-    outputTokens: 1290,
-    totalTokens: 1447
-  },
-  image: {
-    base64Data: base64,
-    mediaType: 'image/png',
-    // getters
-    base64,
-    uint8Array: new Uint8Array( bytes )
-  }
-};