@lobehub/chat 1.98.2 → 1.99.1

package/src/libs/model-runtime/openai/index.test.ts

@@ -3,7 +3,8 @@ import OpenAI from 'openai';
 import { Mock, afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 // 引入模块以便于对函数进行spy
-import { ChatStreamCallbacks, LobeOpenAICompatibleRuntime } from '@/libs/model-runtime';
+import { ChatStreamCallbacks } from '@/libs/model-runtime';
+import * as openai from '@/libs/model-runtime/openai';
 
 import * as debugStreamModule from '../utils/debugStream';
 import officalOpenAIModels from './fixtures/openai-models.json';
@@ -12,8 +13,21 @@ import { LobeOpenAI } from './index';
 // Mock the console.error to avoid polluting test output
 vi.spyOn(console, 'error').mockImplementation(() => {});
 
+// Mock fetch for most tests, but will be restored for convertImageUrlToFile tests
+const mockFetch = vi.fn();
+global.fetch = mockFetch;
+
+const convertImageUrlToFileSpy = vi.spyOn(openai, 'convertImageUrlToFile');
+
 describe('LobeOpenAI', () => {
-  let instance: LobeOpenAICompatibleRuntime;
+  let instance: InstanceType<typeof LobeOpenAI>;
+
+  // Create mock params for createImage tests - only gpt-image-1 supported params
+  const mockParams = {
+    prompt: 'test prompt',
+    imageUrls: [] as string[],
+    size: '1024x1024' as const,
+  };
 
   beforeEach(() => {
     instance = new LobeOpenAI({ apiKey: 'test' });
@@ -23,10 +37,35 @@ describe('LobeOpenAI', () => {
       new ReadableStream() as any,
     );
     vi.spyOn(instance['client'].models, 'list').mockResolvedValue({ data: [] } as any);
+
+    // Mock responses.create for responses API tests
+    vi.spyOn(instance['client'].responses, 'create').mockResolvedValue(new ReadableStream() as any);
+
+    // Mock convertImageUrlToFile to return a mock File object
+    convertImageUrlToFileSpy.mockResolvedValue({
+      name: 'image.png',
+      type: 'image/png',
+      size: 1024,
+    } as any);
+
+    // Mock fetch response for most tests
+    mockFetch.mockResolvedValue({
+      ok: true,
+      arrayBuffer: () => Promise.resolve(new ArrayBuffer(8)),
+      headers: {
+        get: (header: string) => {
+          if (header === 'content-type') {
+            return 'image/png';
+          }
+          return null;
+        },
+      },
+    });
   });
 
   afterEach(() => {
     vi.clearAllMocks();
+    mockFetch.mockClear();
   });
 
   describe('chat', () => {
@@ -242,4 +281,359 @@ describe('LobeOpenAI', () => {
       expect(list).toMatchSnapshot();
     });
   });
+
+  describe('createImage', () => {
+    it('should generate an image with gpt-image-1', async () => {
+      // Arrange
+      const mockResponse = { data: [{ b64_json: 'test-base64-string' }] };
+      const generateSpy = vi
+        .spyOn(instance['client'].images, 'generate')
+        .mockResolvedValue(mockResponse as any);
+
+      // Act
+      const result = await instance.createImage({
+        model: 'gpt-image-1',
+        params: {
+          ...mockParams,
+          prompt: 'A cute cat',
+          size: '1024x1024',
+        },
+      });
+
+      // Assert
+      expect(generateSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          model: 'gpt-image-1',
+          prompt: 'A cute cat',
+          n: 1,
+          size: '1024x1024',
+        }),
+      );
+      expect(result.imageUrl).toBe('data:image/png;base64,test-base64-string');
+    });
+
+    it('should edit an image from a URL', async () => {
+      // Arrange
+      const mockResponse = { data: [{ b64_json: 'edited-base64-string' }] };
+      const editSpy = vi
+        .spyOn(instance['client'].images, 'edit')
+        .mockResolvedValue(mockResponse as any);
+
+      // Temporarily restore the spy to use real implementation
+      convertImageUrlToFileSpy.mockRestore();
+
+      const imageUrl = 'https://lobehub.com/_next/static/media/logo.98482105.png';
+
+      // Act
+      const result = await instance.createImage({
+        model: 'gpt-image-1',
+        params: {
+          ...mockParams,
+          prompt: 'A cat in a hat',
+          imageUrls: [imageUrl],
+        },
+      });
+
+      // Assert
+      expect(editSpy).toHaveBeenCalled();
+      const callArg = editSpy.mock.calls[0][0];
+      expect(callArg.model).toBe('gpt-image-1');
+      expect(callArg.prompt).toBe('A cat in a hat');
+      expect(result.imageUrl).toBe('data:image/png;base64,edited-base64-string');
+
+      // Restore the spy for other tests
+      convertImageUrlToFileSpy.mockResolvedValue({
+        name: 'image.png',
+        type: 'image/png',
+        size: 1024,
+      } as any);
+    });
+
+    it('should handle `size` set to `auto`', async () => {
+      // Arrange
+      const mockResponse = { data: [{ b64_json: 'test-base64-string' }] };
+      const generateSpy = vi
+        .spyOn(instance['client'].images, 'generate')
+        .mockResolvedValue(mockResponse as any);
+
+      // Act
+      await instance.createImage({
+        model: 'gpt-image-1',
+        params: {
+          ...mockParams,
+          prompt: 'A cute cat',
+          size: 'auto',
+        },
+      });
+
+      // Assert
+      expect(generateSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          model: 'gpt-image-1',
+          prompt: 'A cute cat',
+          n: 1,
+        }),
+      );
+      // Should not include size when it's 'auto'
+      expect(generateSpy.mock.calls[0][0]).not.toHaveProperty('size');
+    });
+
+    it('should throw an error if convertImageUrlToFile fails', async () => {
+      // Arrange
+      const imageUrl = 'https://example.com/test-image.png';
+
+      // Mock fetch to fail for the image URL, which will cause convertImageUrlToFile to fail
+      vi.mocked(global.fetch).mockRejectedValueOnce(new Error('Network error'));
+
+      // Mock the OpenAI API methods to ensure they don't get called
+      const generateSpy = vi.spyOn(instance['client'].images, 'generate');
+      const editSpy = vi.spyOn(instance['client'].images, 'edit');
+
+      // Act & Assert - Note: imageUrls must be non-empty array to trigger isImageEdit = true
+      await expect(
+        instance.createImage({
+          model: 'gpt-image-1',
+          params: {
+            prompt: 'A cat in a hat',
+            imageUrls: [imageUrl], // This is the key - non-empty array
+          },
+        }),
+      ).rejects.toThrow('Failed to convert image URLs to File objects: Error: Network error');
+
+      // Verify that OpenAI API methods were not called since conversion failed
+      expect(generateSpy).not.toHaveBeenCalled();
+      expect(editSpy).not.toHaveBeenCalled();
+    });
+
+    it('should throw an error when image response is missing data array', async () => {
+      // Arrange
+      const mockInvalidResponse = {}; // missing data property
+      vi.spyOn(instance['client'].images, 'generate').mockResolvedValue(mockInvalidResponse as any);
+
+      // Act & Assert
+      await expect(
+        instance.createImage({
+          model: 'gpt-image-1',
+          params: { ...mockParams, prompt: 'A cute cat' },
+        }),
+      ).rejects.toThrow('Invalid image response: missing or empty data array');
+    });
+
+    it('should throw an error when image response data array is empty', async () => {
+      // Arrange
+      const mockInvalidResponse = { data: [] }; // empty data array
+      vi.spyOn(instance['client'].images, 'generate').mockResolvedValue(mockInvalidResponse as any);
+
+      // Act & Assert
+      await expect(
+        instance.createImage({
+          model: 'gpt-image-1',
+          params: { ...mockParams, prompt: 'A cute cat' },
+        }),
+      ).rejects.toThrow('Invalid image response: missing or empty data array');
+    });
+
+    it('should throw an error when first data item is null', async () => {
+      // Arrange
+      const mockInvalidResponse = { data: [null] }; // first item is null
+      vi.spyOn(instance['client'].images, 'generate').mockResolvedValue(mockInvalidResponse as any);
+
+      // Act & Assert
+      await expect(
+        instance.createImage({
+          model: 'gpt-image-1',
+          params: { ...mockParams, prompt: 'A cute cat' },
+        }),
+      ).rejects.toThrow('Invalid image response: first data item is null or undefined');
+    });
+
+    it('should throw an error when first data item is undefined', async () => {
+      // Arrange
+      const mockInvalidResponse = { data: [undefined] }; // first item is undefined
+      vi.spyOn(instance['client'].images, 'generate').mockResolvedValue(mockInvalidResponse as any);
+
+      // Act & Assert
+      await expect(
+        instance.createImage({
+          model: 'gpt-image-1',
+          params: { ...mockParams, prompt: 'A cute cat' },
+        }),
+      ).rejects.toThrow('Invalid image response: first data item is null or undefined');
+    });
+
+    it('should re-throw OpenAI API errors during image generation', async () => {
+      // Arrange
+      const apiError = new OpenAI.APIError(
+        400,
+        { error: { message: 'Bad Request' } },
+        'Error message',
+        {},
+      );
+      vi.spyOn(instance['client'].images, 'generate').mockRejectedValue(apiError);
+
+      // Act & Assert
+      await expect(
+        instance.createImage({
+          model: 'gpt-image-1',
+          params: { ...mockParams, prompt: 'A cute cat' },
+        }),
+      ).rejects.toThrow(apiError);
+    });
+
+    it('should throw an error for invalid image response', async () => {
+      // Arrange
+      const mockInvalidResponse = { data: [{ url: 'some_url' }] }; // missing b64_json
+      vi.spyOn(instance['client'].images, 'generate').mockResolvedValue(mockInvalidResponse as any);
+
+      // Act & Assert
+      await expect(
+        instance.createImage({
+          model: 'gpt-image-1',
+          params: { ...mockParams, prompt: 'A cute cat' },
+        }),
+      ).rejects.toThrow('Invalid image response: missing b64_json field');
+    });
+  });
+
+  describe('convertImageUrlToFile', () => {
+    beforeEach(() => {
+      // Reset the spy to use the real implementation for these tests
+      convertImageUrlToFileSpy.mockRestore();
+    });
+
+    afterEach(() => {
+      // Restore the spy for other tests
+      convertImageUrlToFileSpy.mockResolvedValue({
+        name: 'image.png',
+        type: 'image/png',
+        size: 1024,
+      } as any);
+    });
+
+    it('should convert the real lobehub logo URL to a FileLike object', async () => {
+      const imageUrl = 'https://lobehub.com/_next/static/media/logo.98482105.png';
+      const file = await openai.convertImageUrlToFile(imageUrl);
+
+      expect(file).toBeDefined();
+      expect((file as any).name).toBe('image.png');
+      expect((file as any).type).toMatch(/^image\//);
+      expect((file as any).size).toBeGreaterThan(0);
+    });
+
+    it('should convert a base64 data URL to a FileLike object', async () => {
+      const dataUrl =
+        'data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEAYABgAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/wAALCAABAAEBAREA/8QAFAABAAAAAAAAAAAAAAAAAAAAA//EABQQAQAAAAAAAAAAAAAAAAAAAAD/2gAIAQEAAD8AN//Z';
+      const file = await openai.convertImageUrlToFile(dataUrl);
+
+      expect(file).toBeDefined();
+      expect((file as any).name).toBe('image.jpeg');
+      expect((file as any).type).toBe('image/jpeg');
+    });
+
+    it('should handle different image mime types from data URL', async () => {
+      const webpDataUrl = 'data:image/webp;base64,UklGRhoAAABXRUJQVlA4TA0AAAAvAAAAEAcQERGIiP4HAA==';
+      const file = await openai.convertImageUrlToFile(webpDataUrl);
+
+      expect(file).toBeDefined();
+      expect((file as any).name).toBe('image.webp');
+      expect((file as any).type).toBe('image/webp');
+    });
+  });
+
+  // Separate describe block for mocked fetch scenarios
+  describe('convertImageUrlToFile - mocked scenarios', () => {
+    beforeEach(() => {
+      // Reset the spy to use the real implementation
+      convertImageUrlToFileSpy.mockRestore();
+    });
+
+    afterEach(() => {
+      // Restore the spy for other tests
+      convertImageUrlToFileSpy.mockResolvedValue({
+        name: 'image.png',
+        type: 'image/png',
+        size: 1024,
+      } as any);
+    });
+
+    it('should throw an error if fetching an image from a URL fails', async () => {
+      // Use vi.mocked for type-safe mocking
+      vi.mocked(global.fetch).mockResolvedValueOnce({
+        ok: false,
+        statusText: 'Not Found',
+      } as any);
+
+      const imageUrl = 'https://example.com/invalid-image.png';
+
+      await expect(openai.convertImageUrlToFile(imageUrl)).rejects.toThrow(
+        'Failed to fetch image from https://example.com/invalid-image.png: Not Found',
+      );
+    });
+
+    it('should use a default mime type of image/png if content-type header is not available', async () => {
+      // Use vi.mocked for type-safe mocking
+      vi.mocked(global.fetch).mockResolvedValueOnce({
+        ok: true,
+        arrayBuffer: () => Promise.resolve(new ArrayBuffer(8)),
+        headers: {
+          get: () => null,
+        },
+      } as any);
+
+      const imageUrl = 'https://example.com/image-no-content-type';
+      const file = await openai.convertImageUrlToFile(imageUrl);
+
+      expect(file).toBeDefined();
+      expect((file as any).type).toBe('image/png');
+    });
+  });
+
+  describe('responses.handlePayload', () => {
+    it('should add web_search_preview tool when enabledSearch is true', async () => {
+      const payload = {
+        messages: [{ content: 'Hello', role: 'user' as const }],
+        model: 'gpt-4o', // 使用常规模型，通过 enabledSearch 触发 responses API
+        temperature: 0.7,
+        enabledSearch: true,
+        tools: [{ type: 'function' as const, function: { name: 'test', description: 'test' } }],
+      };
+
+      await instance.chat(payload);
+
+      const createCall = (instance['client'].responses.create as Mock).mock.calls[0][0];
+      expect(createCall.tools).toEqual([
+        { type: 'function', name: 'test', description: 'test' },
+        { type: 'web_search_preview' },
+      ]);
+    });
+
+    it('should handle computer-use models with truncation and reasoning', async () => {
+      const payload = {
+        messages: [{ content: 'Hello', role: 'user' as const }],
+        model: 'computer-use-preview',
+        temperature: 0.7,
+        reasoning: { effort: 'medium' },
+      };
+
+      await instance.chat(payload);
+
+      const createCall = (instance['client'].responses.create as Mock).mock.calls[0][0];
+      expect(createCall.truncation).toBe('auto');
+      expect(createCall.reasoning).toEqual({ effort: 'medium', summary: 'auto' });
+    });
+
+    it('should handle prunePrefixes models without computer-use truncation', async () => {
+      const payload = {
+        messages: [{ content: 'Hello', role: 'user' as const }],
+        model: 'o1-pro', // prunePrefixes 模型但非 computer-use
+        temperature: 0.7,
+      };
+
+      await instance.chat(payload);
+
+      const createCall = (instance['client'].responses.create as Mock).mock.calls[0][0];
+      expect(createCall.reasoning).toEqual({ summary: 'auto' });
+      expect(createCall.truncation).toBeUndefined();
+    });
+  });
 });

package/src/libs/model-runtime/openai/index.ts

@@ -1,4 +1,9 @@
+import debug from 'debug';
+import { toFile } from 'openai';
+import { FileLike } from 'openai/uploads';
+
 import { responsesAPIModels } from '@/const/models';
+import { RuntimeImageGenParamsValue } from '@/libs/standard-parameters/meta-schema';
 
 import { ChatStreamPayload, ModelProvider } from '../types';
 import { processMultiProviderModelList } from '../utils/modelParse';
@@ -13,6 +18,42 @@ const prunePrefixes = ['o1', 'o3', 'o4', 'codex', 'computer-use'];
 
 const oaiSearchContextSize = process.env.OPENAI_SEARCH_CONTEXT_SIZE; // low, medium, high
 
+const log = debug('lobe-image:openai');
+
+/**
+ * 将图片 URL 转换为 File 对象
+ * @param imageUrl - 图片 URL（可以是 HTTP URL 或 base64 data URL）
+ * @returns FileLike 对象
+ */
+export const convertImageUrlToFile = async (imageUrl: string): Promise<FileLike> => {
+  log('Converting image URL to File: %s', imageUrl.startsWith('data:') ? 'base64 data' : imageUrl);
+
+  let buffer: Buffer;
+  let mimeType: string;
+
+  if (imageUrl.startsWith('data:')) {
+    // 处理 base64 data URL
+    log('Processing base64 image data');
+    const [mimeTypePart, base64Data] = imageUrl.split(',');
+    mimeType = mimeTypePart.split(':')[1].split(';')[0];
+    buffer = Buffer.from(base64Data, 'base64');
+  } else {
+    // 处理 HTTP URL
+    log('Fetching image from URL: %s', imageUrl);
+    const response = await fetch(imageUrl);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch image from ${imageUrl}: ${response.statusText}`);
+    }
+    buffer = Buffer.from(await response.arrayBuffer());
+    mimeType = response.headers.get('content-type') || 'image/png';
+  }
+
+  log('Successfully converted image to buffer, size: %s, mimeType: %s', buffer.length, mimeType);
+
+  // 使用 OpenAI 的 toFile 方法创建 File 对象
+  return toFile(buffer, `image.${mimeType.split('/')[1]}`, { type: mimeType });
+};
+
 export const LobeOpenAI = createOpenAICompatibleRuntime({
   baseURL: 'https://api.openai.com/v1',
   chatCompletion: {
@@ -47,6 +88,91 @@ export const LobeOpenAI = createOpenAICompatibleRuntime({
       return { ...rest, model, stream: payload.stream ?? true };
     },
   },
+  createImage: async (payload) => {
+    const { model, params, client } = payload;
+    log('Creating image with model: %s and params: %O', model, params);
+
+    const defaultInput = {
+      n: 1,
+    };
+
+    // 映射参数名称，将 imageUrls 映射为 image
+    const paramsMap = new Map<RuntimeImageGenParamsValue, string>([['imageUrls', 'image']]);
+    const userInput: Record<string, any> = Object.fromEntries(
+      Object.entries(params).map(([key, value]) => [
+        paramsMap.get(key as RuntimeImageGenParamsValue) ?? key,
+        value,
+      ]),
+    );
+
+    const isImageEdit = Array.isArray(userInput.image) && userInput.image.length > 0;
+    // 如果有 imageUrls 参数，将其转换为 File 对象
+    if (isImageEdit) {
+      log('Converting imageUrls to File objects: %O', userInput.image);
+      try {
+        // 转换所有图片 URL 为 File 对象
+        const imageFiles = await Promise.all(
+          userInput.image.map((url: string) => convertImageUrlToFile(url)),
+        );
+
+        log('Successfully converted %d images to File objects', imageFiles.length);
+
+        // 根据官方文档，如果有多个图片，传递数组；如果只有一个，传递单个 File
+        userInput.image = imageFiles.length === 1 ? imageFiles[0] : imageFiles;
+      } catch (error) {
+        log('Error converting imageUrls to File objects: %O', error);
+        throw new Error(`Failed to convert image URLs to File objects: ${error}`);
+      }
+    } else {
+      delete userInput.image;
+    }
+
+    if (userInput.size === 'auto') {
+      delete userInput.size;
+    }
+
+    const options = {
+      model,
+      ...defaultInput,
+      ...(userInput as any),
+    };
+
+    log('options: %O', options);
+
+    // 判断是否为图片编辑操作
+    const img = isImageEdit
+      ? await client.images.edit(options)
+      : await client.images.generate(options);
+
+    // 检查响应数据的完整性
+    if (!img || !img.data || !Array.isArray(img.data) || img.data.length === 0) {
+      log('Invalid image response: missing data array');
+      throw new Error('Invalid image response: missing or empty data array');
+    }
+
+    const imageData = img.data[0];
+    if (!imageData) {
+      log('Invalid image response: first data item is null/undefined');
+      throw new Error('Invalid image response: first data item is null or undefined');
+    }
+
+    if (!imageData.b64_json) {
+      log('Invalid image response: missing b64_json field');
+      throw new Error('Invalid image response: missing b64_json field');
+    }
+
+    // 确定图片的 MIME 类型，默认为 PNG
+    const mimeType = 'image/png'; // OpenAI 图片生成默认返回 PNG 格式
+
+    // 将 base64 字符串转换为完整的 data URL
+    const dataUrl = `data:${mimeType};base64,${imageData.b64_json}`;
+
+    log('Successfully converted base64 to data URL, length: %d', dataUrl.length);
+
+    return {
+      imageUrl: dataUrl,
+    };
+  },
   debug: {
     chatCompletion: () => process.env.DEBUG_OPENAI_CHAT_COMPLETION === '1',
     responses: () => process.env.DEBUG_OPENAI_RESPONSES === '1',
@@ -79,9 +205,9 @@ export const LobeOpenAI = createOpenAICompatibleRuntime({
         return pruneReasoningPayload({
           ...rest,
           model,
-          reasoning: payload.reasoning ? 
-            { ...payload.reasoning, summary: 'auto' } : 
-            { summary: 'auto' },
+          reasoning: payload.reasoning
+            ? { ...payload.reasoning, summary: 'auto' }
+            : { summary: 'auto' },
           stream: payload.stream ?? true,
           tools: openaiTools as any,
           // computer-use series must set truncation as auto

package/src/libs/model-runtime/runtimeMap.ts

@@ -8,6 +8,7 @@ import { LobeBedrockAI } from './bedrock';
 import { LobeCloudflareAI } from './cloudflare';
 import { LobeCohereAI } from './cohere';
 import { LobeDeepSeekAI } from './deepseek';
+import { LobeFalAI } from './fal';
 import { LobeFireworksAI } from './fireworksai';
 import { LobeGiteeAI } from './giteeai';
 import { LobeGithubAI } from './github';
@@ -63,6 +64,7 @@ export const providerRuntimeMap = {
   cloudflare: LobeCloudflareAI,
   cohere: LobeCohereAI,
   deepseek: LobeDeepSeekAI,
+  fal: LobeFalAI,
   fireworksai: LobeFireworksAI,
   giteeai: LobeGiteeAI,
   github: LobeGithubAI,

package/src/libs/model-runtime/types/image.ts

@@ -0,0 +1,25 @@
+import { RuntimeImageGenParams } from '@/libs/standard-parameters/meta-schema';
+
+export type CreateImagePayload = {
+  model: string;
+  params: RuntimeImageGenParams;
+};
+
+export type CreateImageResponse = {
+  /**
+   * 图片的高度
+   */
+  height?: number;
+
+  /**
+   * 一般是 provider 家的 cdn 地址，多数一段时间后就会失效，需要重新请求
+   */
+  imageUrl: string;
+  // 为什么返回宽高？
+  // 1. 你给的配置宽度和真正最后生成的宽度可能并不一致，这个需要存储到 generation 的 asset 中
+  // 2. 我需要图片宽高用于计算是否需要生成缩略图，很多 provider 一般都会返回宽高，这样也许我可以省去一些计算
+  /**
+   * 图片的宽度
+   */
+  width?: number;
+};

package/src/libs/model-runtime/types/type.ts

@@ -32,6 +32,7 @@ export enum ModelProvider {
   Cloudflare = 'cloudflare',
   Cohere = 'cohere',
   DeepSeek = 'deepseek',
+  Fal = 'fal',
   FireworksAI = 'fireworksai',
   GiteeAI = 'giteeai',
   Github = 'github',

package/src/libs/model-runtime/utils/openaiCompatibleFactory/index.ts

@@ -22,6 +22,7 @@ import {
   TextToSpeechOptions,
   TextToSpeechPayload,
 } from '../../types';
+import { CreateImagePayload, CreateImageResponse } from '../../types/image';
 import { AgentRuntimeError } from '../createError';
 import { debugResponse, debugStream } from '../debugStream';
 import { desensitizeUrl } from '../desensitizeUrl';
@@ -81,6 +82,7 @@ interface OpenAICompatibleFactoryOptions<T extends Record<string, any> = any> {
     noUserId?: boolean;
   };
   constructorOptions?: ConstructorOptions<T>;
+  createImage?: (payload: CreateImagePayload & { client: OpenAI }) => Promise<CreateImageResponse>;
   customClient?: CustomClientOptions<T>;
   debug?: {
     chatCompletion: () => boolean;
@@ -166,6 +168,7 @@ export const createOpenAICompatibleRuntime = <T extends Record<string, any> = an
   debug,
   constructorOptions,
   chatCompletion,
+  createImage,
   models,
   customClient,
   responses,
@@ -307,6 +310,13 @@ export const createOpenAICompatibleRuntime = <T extends Record<string, any> = an
       }
     }
 
+    async createImage(payload: CreateImagePayload) {
+      return createImage!({
+        ...payload,
+        client: this.client,
+      });
+    }
+
     async models() {
       if (typeof models === 'function') return models({ client: this.client });
 

package/src/libs/standard-parameters/index.ts

@@ -0,0 +1 @@
+export * from './meta-schema';