genai-lite 0.4.2 → 0.5.0

package/dist/adapters/image/GenaiElectronImageAdapter.js

@@ -0,0 +1,273 @@
+"use strict";
+/**
+ * genai-electron Image Adapter
+ *
+ * Adapter for local diffusion models via genai-electron's image generation server.
+ * Supports stable-diffusion.cpp through HTTP wrapper with async polling for progress.
+ *
+ * Provider ID: 'genai-electron-images'
+ * Default endpoint: http://localhost:8081
+ * Configure via: GENAI_ELECTRON_IMAGE_BASE_URL environment variable
+ *
+ * This adapter uses genai-electron's async image generation API which:
+ * - Returns immediately with a generation ID
+ * - Allows polling for progress updates
+ * - Supports full diffusion settings (negative prompts, steps, samplers, etc.)
+ * - Handles batching via count parameter
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenaiElectronImageAdapter = void 0;
+const errorUtils_1 = require("../../shared/adapters/errorUtils");
+/**
+ * Adapter for genai-electron's local diffusion image generation
+ */
+class GenaiElectronImageAdapter {
+    constructor(config) {
+        this.id = 'genai-electron-images';
+        this.supports = {
+            supportsMultipleImages: true, // via count parameter
+            supportsB64Json: true, // returns base64
+            supportsHostedUrls: false, // local generation only
+            supportsProgressEvents: true, // via polling
+            supportsNegativePrompt: true, // full diffusion support
+            defaultModelId: 'sdxl',
+        };
+        this.baseURL = config?.baseURL || 'http://localhost:8081';
+        this.timeout = config?.timeout || 120000; // 120 seconds for diffusion
+        this.pollInterval = 500; // Poll every 500ms
+    }
+    /**
+     * Generates images using genai-electron's async API with progress polling
+     */
+    async generate(config) {
+        const { request, resolvedPrompt, settings } = config;
+        try {
+            // Build request payload
+            const payload = this.buildRequestPayload(resolvedPrompt, request, settings);
+            console.log(`GenaiElectron Image API: Starting generation`, {
+                prompt: resolvedPrompt.substring(0, 100),
+                count: payload.count,
+                dimensions: `${payload.width}x${payload.height}`,
+                steps: payload.steps,
+            });
+            // Start generation (returns immediately with ID)
+            const generationId = await this.startGeneration(payload);
+            console.log(`GenaiElectron Image API: Generation started with ID: ${generationId}`);
+            // Poll for completion
+            const result = await this.pollForCompletion(generationId, settings.diffusion?.onProgress);
+            console.log(`GenaiElectron Image API: Generation complete (${result.timeTaken}ms)`);
+            // Convert to ImageGenerationResponse
+            return this.convertToResponse(result, request);
+        }
+        catch (error) {
+            console.error('GenaiElectron Image API error:', error);
+            throw this.handleError(error, request);
+        }
+    }
+    /**
+     * Builds the request payload for genai-electron
+     */
+    buildRequestPayload(prompt, request, settings) {
+        const diffusion = settings.diffusion;
+        // Use dimensions from base settings (universal for all providers)
+        const width = settings.width;
+        const height = settings.height;
+        return {
+            prompt,
+            negativePrompt: diffusion?.negativePrompt,
+            width,
+            height,
+            steps: diffusion?.steps || 20,
+            cfgScale: diffusion?.cfgScale || 7.5,
+            seed: diffusion?.seed, // undefined = random
+            sampler: diffusion?.sampler || 'euler_a',
+            count: request.count || 1,
+        };
+    }
+    /**
+     * Starts generation and returns the generation ID
+     */
+    async startGeneration(payload) {
+        const url = `${this.baseURL}/v1/images/generations`;
+        // Create abort controller for timeout
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(payload),
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw this.createHttpError(response.status, errorText, url);
+            }
+            const data = await response.json();
+            return data.id;
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            // Handle AbortError
+            if (error.name === 'AbortError') {
+                throw new Error(`Request timeout after ${this.timeout}ms (connecting to ${this.baseURL})`);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Polls for generation completion with progress updates
+     */
+    async pollForCompletion(generationId, onProgress) {
+        const url = `${this.baseURL}/v1/images/generations/${generationId}`;
+        const startTime = Date.now();
+        while (true) {
+            // Check overall timeout
+            if (Date.now() - startTime > this.timeout) {
+                throw new Error(`Generation timeout after ${this.timeout}ms (ID: ${generationId})`);
+            }
+            // Fetch status
+            const response = await fetch(url);
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw this.createHttpError(response.status, errorText, url);
+            }
+            const state = await response.json();
+            // Handle progress updates
+            if (state.status === 'in_progress' && state.progress && onProgress) {
+                onProgress({
+                    currentStep: state.progress.currentStep,
+                    totalSteps: state.progress.totalSteps,
+                    stage: state.progress.stage,
+                    percentage: state.progress.percentage,
+                });
+            }
+            // Handle completion
+            if (state.status === 'complete') {
+                if (!state.result) {
+                    throw new Error('Generation marked complete but no result available');
+                }
+                return state.result;
+            }
+            // Handle error
+            if (state.status === 'error') {
+                const error = state.error || { message: 'Unknown error', code: 'UNKNOWN_ERROR' };
+                throw this.createGenerationError(error.message, error.code);
+            }
+            // Wait before next poll
+            await this.sleep(this.pollInterval);
+        }
+    }
+    /**
+     * Converts genai-electron result to ImageGenerationResponse
+     */
+    convertToResponse(result, request) {
+        const images = result.images.map((img, index) => {
+            // Convert base64 to Buffer
+            const imageBuffer = Buffer.from(img.image, 'base64');
+            return {
+                index,
+                mimeType: 'image/png',
+                data: imageBuffer,
+                b64Json: img.image, // Preserve base64
+                prompt: request.prompt,
+                seed: img.seed,
+                metadata: {
+                    width: img.width,
+                    height: img.height,
+                },
+            };
+        });
+        return {
+            object: 'image.result',
+            created: Math.floor(Date.now() / 1000),
+            providerId: this.id,
+            modelId: request.modelId,
+            data: images,
+            usage: {
+                cost: 0, // Local generation is free
+                credits: result.timeTaken, // Use timeTaken as credits
+            },
+        };
+    }
+    /**
+     * Creates an HTTP error with context
+     */
+    createHttpError(status, errorText, url) {
+        let errorMessage = `HTTP ${status} error`;
+        try {
+            const errorData = JSON.parse(errorText);
+            if (errorData.error?.message) {
+                errorMessage = errorData.error.message;
+            }
+        }
+        catch {
+            // Not JSON, use raw text
+            if (errorText) {
+                errorMessage = `HTTP ${status}: ${errorText}`;
+            }
+        }
+        const error = new Error(`${errorMessage} (${url})`);
+        error.status = status;
+        error.url = url;
+        return error;
+    }
+    /**
+     * Creates a generation error from genai-electron error codes
+     */
+    createGenerationError(message, code) {
+        const error = new Error(`Generation failed: ${message}`);
+        error.code = code;
+        return error;
+    }
+    /**
+     * Handles errors 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;
+        // Special handling for genai-electron specific errors
+        if (error.code === 'SERVER_BUSY') {
+            errorMessage = 'Image generation server is busy. Wait for current generation to complete.';
+            error.type = 'rate_limit_error';
+        }
+        else if (error.code === 'SERVER_NOT_RUNNING') {
+            errorMessage = `Image generation server is not running (connecting to ${this.baseURL})`;
+            error.type = 'connection_error';
+        }
+        else if (error.code === 'BACKEND_ERROR') {
+            errorMessage = `Diffusion backend error: ${error.message}`;
+            error.type = 'server_error';
+        }
+        else if (error.code === 'IO_ERROR') {
+            errorMessage = `Image I/O error: ${error.message}`;
+            error.type = 'server_error';
+        }
+        // Add baseURL context for network errors
+        if (mapped.errorCode === 'NETWORK_ERROR') {
+            errorMessage = `${errorMessage} (connecting to ${this.baseURL})`;
+        }
+        // Add timeout context
+        if (errorMessage.includes('timeout')) {
+            errorMessage = `${errorMessage}. Try increasing the timeout or reducing generation steps.`;
+        }
+        // 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;
+    }
+    /**
+     * Sleep helper for polling
+     */
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}
+exports.GenaiElectronImageAdapter = GenaiElectronImageAdapter;

package/dist/adapters/image/MockImageAdapter.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Mock Image Adapter for testing and fallback
+ *
+ * This adapter provides a simple mock implementation for testing purposes
+ * and serves as a fallback for unsupported providers during development.
+ */
+import type { ImageProviderAdapter, ImageGenerationRequest, ImageGenerationResponse, ImageProviderCapabilities, ResolvedImageGenerationSettings } from '../../types/image';
+/**
+ * Mock adapter for testing image generation
+ */
+export declare class MockImageAdapter implements ImageProviderAdapter {
+    readonly id = "mock-image-provider";
+    readonly supports: ImageProviderCapabilities;
+    /**
+     * Generates mock images
+     */
+    generate(config: {
+        request: ImageGenerationRequest;
+        resolvedPrompt: string;
+        settings: ResolvedImageGenerationSettings;
+        apiKey: string | null;
+    }): Promise<ImageGenerationResponse>;
+}

package/dist/adapters/image/MockImageAdapter.js

@@ -0,0 +1,55 @@
+"use strict";
+/**
+ * Mock Image Adapter for testing and fallback
+ *
+ * This adapter provides a simple mock implementation for testing purposes
+ * and serves as a fallback for unsupported providers during development.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockImageAdapter = void 0;
+/**
+ * Mock adapter for testing image generation
+ */
+class MockImageAdapter {
+    constructor() {
+        this.id = 'mock-image-provider';
+        this.supports = {
+            supportsMultipleImages: true,
+            supportsB64Json: true,
+            supportsHostedUrls: false,
+            supportsProgressEvents: false,
+            supportsNegativePrompt: true,
+            defaultModelId: 'mock-model',
+        };
+    }
+    /**
+     * Generates mock images
+     */
+    async generate(config) {
+        const { request, resolvedPrompt } = config;
+        const count = request.count || 1;
+        // Create mock image data (1x1 PNG)
+        const mockImageBuffer = Buffer.from('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==', 'base64');
+        // Generate mock images based on count
+        const images = Array.from({ length: count }, (_, index) => ({
+            index,
+            mimeType: 'image/png',
+            data: mockImageBuffer,
+            prompt: resolvedPrompt,
+            seed: Math.floor(Math.random() * 1000000),
+            width: 1,
+            height: 1,
+        }));
+        return {
+            object: 'image.result',
+            created: Math.floor(Date.now() / 1000),
+            providerId: request.providerId,
+            modelId: request.modelId,
+            data: images,
+            usage: {
+                timeTaken: 100, // Mock timing
+            },
+        };
+    }
+}
+exports.MockImageAdapter = MockImageAdapter;

package/dist/adapters/image/OpenAIImageAdapter.d.ts

@@ -0,0 +1,62 @@
+/**
+ * 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
+ */
+import type { ImageProviderAdapter, ImageGenerationRequest, ImageGenerationResponse, ImageProviderCapabilities, ResolvedImageGenerationSettings, ImageProviderAdapterConfig } from '../../types/image';
+/**
+ * Adapter for OpenAI's image generation API
+ */
+export declare class OpenAIImageAdapter implements ImageProviderAdapter {
+    readonly id = "openai-images";
+    readonly supports: ImageProviderCapabilities;
+    private baseURL?;
+    private timeout;
+    constructor(config?: ImageProviderAdapterConfig);
+    /**
+     * Validates OpenAI API key format
+     */
+    validateApiKey(apiKey: string): boolean;
+    /**
+     * Generates images using OpenAI's API
+     */
+    generate(config: {
+        request: ImageGenerationRequest;
+        resolvedPrompt: string;
+        settings: ResolvedImageGenerationSettings;
+        apiKey: string | null;
+    }): Promise<ImageGenerationResponse>;
+    /**
+     * Validates prompt length for the given model
+     */
+    private validatePromptLength;
+    /**
+     * Converts width and height to OpenAI size format (e.g., "1024x1024")
+     */
+    private toSizeString;
+    /**
+     * Adds gpt-image-1 specific parameters to the request
+     */
+    private addGptImageParams;
+    /**
+     * Adds dall-e-2/dall-e-3 specific parameters to the request
+     */
+    private addDalleParams;
+    /**
+     * Processes the OpenAI API response and converts to ImageGenerationResponse
+     */
+    private processResponse;
+    /**
+     * Handles errors from OpenAI API and converts to standard format
+     */
+    private handleError;
+}