genai-lite 0.4.3 → 0.5.0

package/dist/adapters/image/OpenAIImageAdapter.js

@@ -0,0 +1,303 @@
+"use strict";
+/**
+ * OpenAI Images API Adapter
+ *
+ * Adapter for OpenAI's image generation API (DALL-E and GPT-Image models).
+ * Supports the /v1/images/generations endpoint.
+ *
+ * Supported models:
+ * - gpt-image-1-mini (default): Fast, efficient, 32K char prompts
+ * - gpt-image-1: Highest quality, 32K char prompts, advanced features
+ * - dall-e-3: High quality, 4K char prompts, only n=1
+ * - dall-e-2: Standard quality, 1K char prompts
+ *
+ * Based on: https://platform.openai.com/docs/api-reference/images/create
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIImageAdapter = void 0;
+const openai_1 = __importDefault(require("openai"));
+const errorUtils_1 = require("../../shared/adapters/errorUtils");
+/**
+ * Prompt length limits per model
+ */
+const PROMPT_LIMITS = {
+    'gpt-image-1': 32000,
+    'gpt-image-1-mini': 32000,
+    'dall-e-3': 4000,
+    'dall-e-2': 1000,
+};
+/**
+ * Adapter for OpenAI's image generation API
+ */
+class OpenAIImageAdapter {
+    constructor(config) {
+        this.id = 'openai-images';
+        this.supports = {
+            supportsMultipleImages: true,
+            supportsB64Json: true,
+            supportsHostedUrls: true,
+            supportsProgressEvents: false,
+            supportsNegativePrompt: false,
+            defaultModelId: 'gpt-image-1-mini',
+        };
+        this.baseURL = config?.baseURL;
+        this.timeout = config?.timeout || 60000;
+    }
+    /**
+     * Validates OpenAI API key format
+     */
+    validateApiKey(apiKey) {
+        // OpenAI API keys typically start with 'sk-' and are at least 20 characters
+        return apiKey.startsWith('sk-') && apiKey.length >= 20;
+    }
+    /**
+     * Generates images using OpenAI's API
+     */
+    async generate(config) {
+        const { request, resolvedPrompt, settings, apiKey } = config;
+        if (!apiKey) {
+            throw new Error('OpenAI API key is required but was not provided');
+        }
+        try {
+            // Validate prompt length
+            this.validatePromptLength(resolvedPrompt, request.modelId);
+            // Validate dall-e-3 constraints
+            if (request.modelId === 'dall-e-3') {
+                const count = request.count || settings.n || 1;
+                if (count > 1) {
+                    throw new Error('dall-e-3 only supports generating 1 image at a time (n=1)');
+                }
+            }
+            // Initialize OpenAI client
+            const client = new openai_1.default({
+                apiKey,
+                ...(this.baseURL && { baseURL: this.baseURL }),
+                timeout: this.timeout,
+            });
+            // Determine if this is a gpt-image-1 model
+            const isGptImageModel = request.modelId.startsWith('gpt-image-1');
+            // Build request parameters
+            const params = {
+                model: request.modelId,
+                prompt: resolvedPrompt,
+                n: request.count || settings.n || 1,
+            };
+            // Add model-specific parameters
+            if (isGptImageModel) {
+                // gpt-image-1 models: use new parameter format
+                this.addGptImageParams(params, settings);
+            }
+            else {
+                // dall-e-2/dall-e-3: use traditional parameters
+                this.addDalleParams(params, settings);
+            }
+            console.log(`OpenAI Image API call for model: ${request.modelId}`, {
+                model: params.model,
+                promptLength: resolvedPrompt.length,
+                n: params.n,
+                isGptImageModel,
+            });
+            // Make API call
+            const response = await client.images.generate(params);
+            if (!response.data || response.data.length === 0) {
+                throw new Error('OpenAI API returned no images in response');
+            }
+            console.log(`OpenAI Image API call successful, generated ${response.data.length} images`);
+            // Process response
+            return await this.processResponse(response, request, isGptImageModel);
+        }
+        catch (error) {
+            console.error('OpenAI Image API error:', error);
+            throw this.handleError(error, request);
+        }
+    }
+    /**
+     * Validates prompt length for the given model
+     */
+    validatePromptLength(prompt, modelId) {
+        const limit = PROMPT_LIMITS[modelId];
+        if (limit && prompt.length > limit) {
+            throw new Error(`Prompt too long for model ${modelId}: ${prompt.length} characters (max: ${limit})`);
+        }
+    }
+    /**
+     * Converts width and height to OpenAI size format (e.g., "1024x1024")
+     */
+    toSizeString(width, height) {
+        return `${width}x${height}`;
+    }
+    /**
+     * Adds gpt-image-1 specific parameters to the request
+     */
+    addGptImageParams(params, settings) {
+        // Size (supports auto, 1024x1024, 1536x1024, 1024x1536)
+        // Convert width/height to OpenAI's size format
+        params.size = this.toSizeString(settings.width, settings.height);
+        // Quality (auto, high, medium, low)
+        if (settings.quality) {
+            params.quality = settings.quality;
+        }
+        // For gpt-image-1, use settings.openai namespace
+        const openaiSettings = settings.openai;
+        if (openaiSettings) {
+            if (openaiSettings.outputFormat) {
+                params.output_format = openaiSettings.outputFormat;
+            }
+            if (openaiSettings.background) {
+                params.background = openaiSettings.background;
+            }
+            if (openaiSettings.moderation) {
+                params.moderation = openaiSettings.moderation;
+            }
+            if (openaiSettings.outputCompression !== undefined) {
+                params.output_compression = openaiSettings.outputCompression;
+            }
+        }
+        // User tracking
+        if (settings.user) {
+            params.user = settings.user;
+        }
+        // Note: gpt-image-1 always returns base64, no response_format parameter needed
+    }
+    /**
+     * Adds dall-e-2/dall-e-3 specific parameters to the request
+     */
+    addDalleParams(params, settings) {
+        // Size (model-specific options)
+        // Convert width/height to OpenAI's size format
+        params.size = this.toSizeString(settings.width, settings.height);
+        // Quality and Style are only supported by dall-e-3
+        const isDallE3 = params.model === 'dall-e-3';
+        if (isDallE3) {
+            // Quality (hd or standard for dall-e-3 only)
+            if (settings.quality) {
+                params.quality = settings.quality;
+            }
+            // Style (vivid or natural for dall-e-3 only)
+            if (settings.style) {
+                params.style = settings.style;
+            }
+        }
+        // Response format (url or b64_json)
+        // Default to b64_json for consistency (gpt-image-1 only returns base64)
+        if (settings.responseFormat === 'url') {
+            params.response_format = 'url';
+        }
+        else {
+            params.response_format = 'b64_json';
+        }
+        // User tracking
+        if (settings.user) {
+            params.user = settings.user;
+        }
+    }
+    /**
+     * Processes the OpenAI API response and converts to ImageGenerationResponse
+     */
+    async processResponse(response, request, isGptImageModel) {
+        const images = [];
+        for (let i = 0; i < response.data.length; i++) {
+            const item = response.data[i];
+            let imageBuffer;
+            let mimeType = 'image/png';
+            let imageUrl;
+            let b64String;
+            if (isGptImageModel) {
+                // gpt-image-1 models always return base64
+                if (!item.b64_json) {
+                    throw new Error(`Expected b64_json in response for gpt-image-1 model, but got: ${JSON.stringify(item)}`);
+                }
+                const b64Data = item.b64_json;
+                b64String = b64Data;
+                imageBuffer = Buffer.from(b64Data, 'base64');
+                // Determine mime type from output_format parameter (if we have access to it)
+                // For now, default to PNG (most common)
+                mimeType = 'image/png';
+            }
+            else {
+                // dall-e-2/dall-e-3: can be url or b64_json
+                if (item.url) {
+                    // Fetch image from URL
+                    imageUrl = item.url;
+                    const imageResponse = await fetch(item.url);
+                    if (!imageResponse.ok) {
+                        throw new Error(`Failed to fetch image from URL: ${imageResponse.statusText}`);
+                    }
+                    const arrayBuffer = await imageResponse.arrayBuffer();
+                    imageBuffer = Buffer.from(arrayBuffer);
+                    // Infer mime type from URL or default to PNG
+                    if (item.url.includes('.jpeg') || item.url.includes('.jpg')) {
+                        mimeType = 'image/jpeg';
+                    }
+                    else if (item.url.includes('.webp')) {
+                        mimeType = 'image/webp';
+                    }
+                }
+                else if (item.b64_json) {
+                    // Base64 encoded
+                    const b64Data = item.b64_json;
+                    b64String = b64Data;
+                    imageBuffer = Buffer.from(b64Data, 'base64');
+                    mimeType = 'image/png';
+                }
+                else {
+                    throw new Error('OpenAI response contained neither url nor b64_json');
+                }
+            }
+            images.push({
+                index: i,
+                mimeType,
+                data: imageBuffer,
+                ...(imageUrl && { url: imageUrl }),
+                ...(b64String && { b64Json: b64String }),
+                prompt: request.prompt,
+                // OpenAI doesn't return seed in the response
+            });
+        }
+        // Extract usage data if available
+        const usage = response.usage
+            ? {
+                inputTokens: response.usage.input_tokens,
+                outputTokens: response.usage.output_tokens,
+            }
+            : undefined;
+        return {
+            object: 'image.result',
+            created: response.created || Math.floor(Date.now() / 1000),
+            providerId: this.id,
+            modelId: request.modelId,
+            data: images,
+            ...(usage && { usage }),
+        };
+    }
+    /**
+     * Handles errors from OpenAI API and converts to standard format
+     */
+    handleError(error, request) {
+        // Use shared error mapping utility
+        const mapped = (0, errorUtils_1.getCommonMappedErrorDetails)(error);
+        // Enhance error message with context
+        let errorMessage = mapped.errorMessage;
+        // Add baseURL context for network errors
+        if (mapped.errorCode === 'NETWORK_ERROR') {
+            const baseUrl = this.baseURL || 'https://api.openai.com/v1';
+            errorMessage = `${errorMessage} (connecting to ${baseUrl})`;
+        }
+        // Add model-specific context for validation errors
+        if (mapped.errorType === 'invalid_request_error' && error.message) {
+            errorMessage = error.message;
+        }
+        // Create enhanced error with all details
+        const enhancedError = new Error(errorMessage);
+        enhancedError.code = mapped.errorCode;
+        enhancedError.type = mapped.errorType;
+        enhancedError.status = mapped.status;
+        enhancedError.providerId = this.id;
+        enhancedError.modelId = request.modelId;
+        return enhancedError;
+    }
+}
+exports.OpenAIImageAdapter = OpenAIImageAdapter;

package/dist/config/image-presets.json

@@ -0,0 +1,194 @@
+[
+    {
+        "id": "openai-gpt-image-1-mini-default",
+        "displayName": "OpenAI - GPT-Image 1 Mini",
+        "description": "Fast and efficient image generation with GPT-Image (32K char prompts)",
+        "providerId": "openai-images",
+        "modelId": "gpt-image-1-mini",
+        "settings": {
+            "width": 1024,
+            "height": 1024,
+            "quality": "auto",
+            "responseFormat": "buffer",
+            "openai": {
+                "outputFormat": "png",
+                "background": "auto",
+                "moderation": "auto"
+            }
+        }
+    },
+    {
+        "id": "openai-gpt-image-1-quality",
+        "displayName": "OpenAI - GPT-Image 1 (High Quality)",
+        "description": "Highest quality OpenAI image model with advanced features (32K char prompts)",
+        "providerId": "openai-images",
+        "modelId": "gpt-image-1",
+        "settings": {
+            "width": 1024,
+            "height": 1024,
+            "quality": "high",
+            "responseFormat": "buffer",
+            "openai": {
+                "outputFormat": "png",
+                "background": "auto",
+                "moderation": "auto"
+            }
+        }
+    },
+    {
+        "id": "openai-dalle-3-hd",
+        "displayName": "OpenAI - DALL-E 3 HD",
+        "description": "High-quality DALL-E 3 with vivid style (4K char prompts)",
+        "providerId": "openai-images",
+        "modelId": "dall-e-3",
+        "settings": {
+            "width": 1024,
+            "height": 1024,
+            "quality": "hd",
+            "style": "vivid",
+            "responseFormat": "buffer"
+        }
+    },
+    {
+        "id": "openai-dalle-3-natural",
+        "displayName": "OpenAI - DALL-E 3 Natural",
+        "description": "DALL-E 3 with natural style for realistic photographs (4K char prompts)",
+        "providerId": "openai-images",
+        "modelId": "dall-e-3",
+        "settings": {
+            "width": 1024,
+            "height": 1024,
+            "quality": "standard",
+            "style": "natural",
+            "responseFormat": "buffer"
+        }
+    },
+    {
+        "id": "openai-dalle-2-default",
+        "displayName": "OpenAI - DALL-E 2",
+        "description": "Cost-effective DALL-E 2 generation (1K char prompts)",
+        "providerId": "openai-images",
+        "modelId": "dall-e-2",
+        "settings": {
+            "width": 1024,
+            "height": 1024,
+            "quality": "standard",
+            "responseFormat": "buffer"
+        }
+    },
+    {
+        "id": "openai-dalle-2-fast",
+        "displayName": "OpenAI - DALL-E 2 Fast",
+        "description": "Rapid prototyping with smaller image size (1K char prompts)",
+        "providerId": "openai-images",
+        "modelId": "dall-e-2",
+        "settings": {
+            "width": 512,
+            "height": 512,
+            "quality": "standard",
+            "responseFormat": "buffer"
+        }
+    },
+    {
+        "id": "genai-electron-sdxl-quality",
+        "displayName": "Local - SDXL Quality",
+        "description": "High-quality SDXL generation for final production images",
+        "providerId": "genai-electron-images",
+        "modelId": "stable-diffusion",
+        "settings": {
+            "width": 1024,
+            "height": 1024,
+            "responseFormat": "buffer",
+            "diffusion": {
+                "steps": 30,
+                "cfgScale": 7.5,
+                "sampler": "dpm++2m"
+            }
+        }
+    },
+    {
+        "id": "genai-electron-sdxl-balanced",
+        "displayName": "Local - SDXL Balanced",
+        "description": "Balanced quality and speed for general use",
+        "providerId": "genai-electron-images",
+        "modelId": "stable-diffusion",
+        "settings": {
+            "width": 768,
+            "height": 768,
+            "responseFormat": "buffer",
+            "diffusion": {
+                "steps": 20,
+                "cfgScale": 7.0,
+                "sampler": "euler_a"
+            }
+        }
+    },
+    {
+        "id": "genai-electron-sdxl-fast",
+        "displayName": "Local - SDXL Fast",
+        "description": "Quick iterations with reduced steps",
+        "providerId": "genai-electron-images",
+        "modelId": "stable-diffusion",
+        "settings": {
+            "width": 512,
+            "height": 512,
+            "responseFormat": "buffer",
+            "diffusion": {
+                "steps": 15,
+                "cfgScale": 6.5,
+                "sampler": "euler_a"
+            }
+        }
+    },
+    {
+        "id": "genai-electron-sdxl-portrait",
+        "displayName": "Local - SDXL Portrait",
+        "description": "Portrait-oriented image generation",
+        "providerId": "genai-electron-images",
+        "modelId": "stable-diffusion",
+        "settings": {
+            "width": 768,
+            "height": 1024,
+            "responseFormat": "buffer",
+            "diffusion": {
+                "steps": 20,
+                "cfgScale": 7.5,
+                "sampler": "dpm++2m"
+            }
+        }
+    },
+    {
+        "id": "genai-electron-sdxl-turbo",
+        "displayName": "Local - SDXL Turbo",
+        "description": "Real-time generation with SDXL Turbo (optimal at 512x512, 1-4 steps)",
+        "providerId": "genai-electron-images",
+        "modelId": "sdxl-turbo",
+        "settings": {
+            "width": 512,
+            "height": 512,
+            "responseFormat": "buffer",
+            "diffusion": {
+                "steps": 4,
+                "cfgScale": 1.0,
+                "sampler": "euler_a"
+            }
+        }
+    },
+    {
+        "id": "genai-electron-sdxl-lightning",
+        "displayName": "Local - SDXL Lightning",
+        "description": "Lightning-fast generation with quality (trained at 1024x1024, 2-8 steps)",
+        "providerId": "genai-electron-images",
+        "modelId": "sdxl-lightning",
+        "settings": {
+            "width": 1024,
+            "height": 1024,
+            "responseFormat": "buffer",
+            "diffusion": {
+                "steps": 8,
+                "cfgScale": 1.0,
+                "sampler": "euler_a"
+            }
+        }
+    }
+]