genai-lite 0.4.3 → 0.5.1

package/dist/image/config.js

@@ -0,0 +1,221 @@
+"use strict";
+/**
+ * Configuration for image generation providers and models
+ *
+ * This file defines:
+ * - Supported image providers
+ * - Default models for each provider
+ * - Provider capabilities
+ * - Adapter configurations (base URLs, timeouts, etc.)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IMAGE_ADAPTER_CONFIGS = exports.SUPPORTED_IMAGE_PROVIDERS = void 0;
+exports.getImageProviderById = getImageProviderById;
+exports.getImageModelsByProvider = getImageModelsByProvider;
+exports.getImageModelInfo = getImageModelInfo;
+exports.getImageProviderCapabilities = getImageProviderCapabilities;
+/**
+ * Supported image generation providers
+ */
+exports.SUPPORTED_IMAGE_PROVIDERS = [
+    {
+        id: 'openai-images',
+        displayName: 'OpenAI Images',
+        description: 'DALL-E and GPT-Image models from OpenAI',
+        capabilities: {
+            supportsMultipleImages: true,
+            supportsB64Json: true,
+            supportsHostedUrls: true,
+            supportsProgressEvents: false,
+            supportsNegativePrompt: false,
+            defaultModelId: 'gpt-image-1-mini',
+        },
+        models: [
+            {
+                id: 'gpt-image-1-mini',
+                providerId: 'openai-images',
+                displayName: 'GPT-Image 1 Mini',
+                description: 'Fast and efficient image generation with GPT-Image (32K char prompts, supports transparency, webp/jpeg output)',
+                capabilities: {
+                    supportsMultipleImages: true,
+                    supportsB64Json: true,
+                    supportsHostedUrls: false, // gpt-image-1 always returns base64
+                    supportsProgressEvents: false,
+                    supportsNegativePrompt: false,
+                    defaultModelId: 'gpt-image-1-mini',
+                },
+                defaultSettings: {
+                    width: 1024,
+                    height: 1024,
+                    quality: 'auto',
+                    responseFormat: 'buffer',
+                    openai: {
+                        outputFormat: 'png',
+                        background: 'auto',
+                        moderation: 'auto',
+                    },
+                },
+            },
+            {
+                id: 'gpt-image-1',
+                providerId: 'openai-images',
+                displayName: 'GPT-Image 1',
+                description: 'Most advanced OpenAI image model with highest quality (32K char prompts, supports transparency, compression control)',
+                capabilities: {
+                    supportsMultipleImages: true,
+                    supportsB64Json: true,
+                    supportsHostedUrls: false, // gpt-image-1 always returns base64
+                    supportsProgressEvents: false,
+                    supportsNegativePrompt: false,
+                    defaultModelId: 'gpt-image-1',
+                },
+                defaultSettings: {
+                    width: 1024,
+                    height: 1024,
+                    quality: 'auto',
+                    responseFormat: 'buffer',
+                    openai: {
+                        outputFormat: 'png',
+                        background: 'auto',
+                        moderation: 'auto',
+                    },
+                },
+            },
+            {
+                id: 'dall-e-3',
+                providerId: 'openai-images',
+                displayName: 'DALL-E 3',
+                description: 'High-quality DALL-E model with improved prompt adherence (4K char prompts, only n=1)',
+                capabilities: {
+                    supportsMultipleImages: false, // dall-e-3 only supports n=1
+                    supportsB64Json: true,
+                    supportsHostedUrls: true,
+                    supportsProgressEvents: false,
+                    supportsNegativePrompt: false,
+                    defaultModelId: 'dall-e-3',
+                },
+                defaultSettings: {
+                    width: 1024,
+                    height: 1024,
+                    quality: 'standard',
+                    style: 'vivid',
+                    responseFormat: 'buffer',
+                },
+            },
+            {
+                id: 'dall-e-2',
+                providerId: 'openai-images',
+                displayName: 'DALL-E 2',
+                description: 'Previous generation DALL-E model (1K char prompts)',
+                capabilities: {
+                    supportsMultipleImages: true,
+                    supportsB64Json: true,
+                    supportsHostedUrls: true,
+                    supportsProgressEvents: false,
+                    supportsNegativePrompt: false,
+                    defaultModelId: 'dall-e-2',
+                },
+                defaultSettings: {
+                    width: 1024,
+                    height: 1024,
+                    quality: 'standard',
+                    responseFormat: 'buffer',
+                },
+            },
+        ],
+    },
+    {
+        id: 'genai-electron-images',
+        displayName: 'Local Diffusion (genai-electron)',
+        description: 'Local stable-diffusion models via genai-electron wrapper',
+        capabilities: {
+            supportsMultipleImages: true,
+            supportsB64Json: true,
+            supportsHostedUrls: false,
+            supportsProgressEvents: true,
+            supportsNegativePrompt: true,
+            defaultModelId: 'stable-diffusion',
+        },
+        models: [
+            {
+                id: 'stable-diffusion',
+                providerId: 'genai-electron-images',
+                displayName: 'Stable Diffusion',
+                description: 'High-quality local diffusion model',
+                capabilities: {
+                    supportsMultipleImages: true,
+                    supportsB64Json: true,
+                    supportsHostedUrls: false,
+                    supportsProgressEvents: true,
+                    supportsNegativePrompt: true,
+                    defaultModelId: 'stable-diffusion',
+                },
+                defaultSettings: {
+                    width: 512,
+                    height: 512,
+                    responseFormat: 'buffer',
+                    diffusion: {
+                        steps: 20,
+                        cfgScale: 7.5,
+                        sampler: 'dpm++2m',
+                    },
+                },
+            },
+        ],
+    },
+];
+/**
+ * Adapter configurations for each provider
+ * These define base URLs and other adapter-specific settings
+ */
+exports.IMAGE_ADAPTER_CONFIGS = {
+    'openai-images': {
+        baseURL: process.env.OPENAI_API_BASE_URL || 'https://api.openai.com/v1',
+        timeout: 60000, // 60 seconds for image generation
+    },
+    'genai-electron-images': {
+        baseURL: process.env.GENAI_ELECTRON_IMAGE_BASE_URL || 'http://localhost:8081',
+        timeout: 120000, // 120 seconds for local diffusion
+        checkHealth: false, // Optional health checks
+    },
+};
+/**
+ * Gets provider information by ID
+ *
+ * @param providerId - The provider ID to look up
+ * @returns Provider information or null if not found
+ */
+function getImageProviderById(providerId) {
+    return exports.SUPPORTED_IMAGE_PROVIDERS.find(p => p.id === providerId) || null;
+}
+/**
+ * Gets all models for a specific provider
+ *
+ * @param providerId - The provider ID
+ * @returns Array of model information
+ */
+function getImageModelsByProvider(providerId) {
+    const provider = getImageProviderById(providerId);
+    return provider?.models || [];
+}
+/**
+ * Gets model information by provider and model ID
+ *
+ * @param providerId - The provider ID
+ * @param modelId - The model ID
+ * @returns Model information or null if not found
+ */
+function getImageModelInfo(providerId, modelId) {
+    const models = getImageModelsByProvider(providerId);
+    return models.find(m => m.id === modelId) || null;
+}
+/**
+ * Gets default capabilities for a provider
+ *
+ * @param providerId - The provider ID
+ * @returns Provider capabilities or null if not found
+ */
+function getImageProviderCapabilities(providerId) {
+    const provider = getImageProviderById(providerId);
+    return provider?.capabilities || null;
+}

package/dist/image/services/ImageAdapterRegistry.d.ts

@@ -0,0 +1,61 @@
+import type { ImageProviderId } from '../../types/image';
+import type { ImageProviderAdapter } from '../../types/image';
+/**
+ * Information about a registered adapter
+ */
+export interface AdapterInfo {
+    providerId: ImageProviderId;
+    hasAdapter: boolean;
+    adapterInfo?: {
+        name: string;
+    };
+}
+/**
+ * Summary of provider availability
+ */
+export interface ProviderSummary {
+    totalProviders: number;
+    providersWithAdapters: number;
+    availableProviders: string[];
+    unavailableProviders: string[];
+}
+/**
+ * Registry for managing image provider adapters
+ */
+export declare class ImageAdapterRegistry {
+    private imageAdapters;
+    private mockImageAdapter;
+    constructor();
+    /**
+     * Initializes adapters for all supported providers
+     * Note: In Phase 3, we're only setting up the registry structure.
+     * Real adapters (OpenAI, Electron) will be added in Phases 4-5.
+     */
+    private initializeAdapters;
+    /**
+     * Registers an image adapter for a specific provider
+     *
+     * @param providerId - The provider ID
+     * @param adapter - The adapter implementation
+     */
+    registerAdapter(providerId: ImageProviderId, adapter: ImageProviderAdapter): void;
+    /**
+     * Gets the appropriate adapter for a provider
+     *
+     * @param providerId - The provider ID
+     * @returns The adapter to use
+     */
+    getAdapter(providerId: ImageProviderId): ImageProviderAdapter;
+    /**
+     * Gets information about registered adapters
+     *
+     * @returns Map of provider IDs to adapter info
+     */
+    getRegisteredAdapters(): Map<ImageProviderId, AdapterInfo>;
+    /**
+     * Gets a summary of available providers and their adapter status
+     *
+     * @returns Summary of provider availability
+     */
+    getProviderSummary(): ProviderSummary;
+}

package/dist/image/services/ImageAdapterRegistry.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageAdapterRegistry = void 0;
+const MockImageAdapter_1 = require("../../adapters/image/MockImageAdapter");
+const config_1 = require("../config");
+/**
+ * Registry for managing image provider adapters
+ */
+class ImageAdapterRegistry {
+    constructor() {
+        this.imageAdapters = new Map();
+        this.mockImageAdapter = new MockImageAdapter_1.MockImageAdapter();
+        this.initializeAdapters();
+    }
+    /**
+     * Initializes adapters for all supported providers
+     * Note: In Phase 3, we're only setting up the registry structure.
+     * Real adapters (OpenAI, Electron) will be added in Phases 4-5.
+     */
+    initializeAdapters() {
+        console.log('ImageAdapterRegistry: Initializing image adapters');
+        // For Phase 3, we don't have real adapter implementations yet
+        // They will be added in Phase 4 (OpenAI) and Phase 5 (Electron)
+        // For now, all providers will use the mock adapter as fallback
+        console.log(`ImageAdapterRegistry: Registry initialized. Real adapters will be added in Phases 4-5. ` +
+            `Currently using mock adapter as fallback for all providers.`);
+    }
+    /**
+     * Registers an image adapter for a specific provider
+     *
+     * @param providerId - The provider ID
+     * @param adapter - The adapter implementation
+     */
+    registerAdapter(providerId, adapter) {
+        this.imageAdapters.set(providerId, adapter);
+        console.log(`ImageAdapterRegistry: Registered adapter for provider: ${providerId}`);
+    }
+    /**
+     * Gets the appropriate adapter for a provider
+     *
+     * @param providerId - The provider ID
+     * @returns The adapter to use
+     */
+    getAdapter(providerId) {
+        // Check for registered real adapters first
+        const registeredAdapter = this.imageAdapters.get(providerId);
+        if (registeredAdapter) {
+            console.log(`ImageAdapterRegistry: Using registered adapter for provider: ${providerId}`);
+            return registeredAdapter;
+        }
+        // Fall back to mock adapter for unsupported providers
+        console.log(`ImageAdapterRegistry: No real adapter found for ${providerId}, using mock adapter`);
+        return this.mockImageAdapter;
+    }
+    /**
+     * Gets information about registered adapters
+     *
+     * @returns Map of provider IDs to adapter info
+     */
+    getRegisteredAdapters() {
+        const adapterInfo = new Map();
+        for (const [providerId, adapter] of this.imageAdapters.entries()) {
+            adapterInfo.set(providerId, {
+                providerId,
+                hasAdapter: true,
+                adapterInfo: { name: adapter.id },
+            });
+        }
+        return adapterInfo;
+    }
+    /**
+     * Gets a summary of available providers and their adapter status
+     *
+     * @returns Summary of provider availability
+     */
+    getProviderSummary() {
+        const availableProviders = [];
+        const unavailableProviders = [];
+        for (const provider of config_1.SUPPORTED_IMAGE_PROVIDERS) {
+            if (this.imageAdapters.has(provider.id)) {
+                availableProviders.push(provider.id);
+            }
+            else {
+                unavailableProviders.push(provider.id);
+            }
+        }
+        return {
+            totalProviders: config_1.SUPPORTED_IMAGE_PROVIDERS.length,
+            providersWithAdapters: availableProviders.length,
+            availableProviders,
+            unavailableProviders,
+        };
+    }
+}
+exports.ImageAdapterRegistry = ImageAdapterRegistry;

package/dist/image/services/ImageModelResolver.d.ts

@@ -0,0 +1,26 @@
+import type { ImageProviderId, ImageGenerationRequest, ImageGenerationRequestWithPreset, ImageModelInfo, ImageGenerationSettings, ImageFailureResponse, ImagePreset } from '../../types/image';
+import { PresetManager } from '../../shared/services/PresetManager';
+/**
+ * Result of model resolution
+ */
+export interface ModelResolutionResult {
+    providerId?: ImageProviderId;
+    modelId?: string;
+    modelInfo?: ImageModelInfo;
+    settings?: ImageGenerationSettings;
+    error?: ImageFailureResponse;
+}
+/**
+ * Resolves model information from presets or direct IDs
+ */
+export declare class ImageModelResolver {
+    private presetManager;
+    constructor(presetManager: PresetManager<ImagePreset>);
+    /**
+     * Resolves model information from a request
+     *
+     * @param request - The request (with preset or direct IDs)
+     * @returns Resolution result
+     */
+    resolve(request: ImageGenerationRequest | ImageGenerationRequestWithPreset): ModelResolutionResult;
+}

package/dist/image/services/ImageModelResolver.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageModelResolver = void 0;
+const config_1 = require("../config");
+/**
+ * Resolves model information from presets or direct IDs
+ */
+class ImageModelResolver {
+    constructor(presetManager) {
+        this.presetManager = presetManager;
+    }
+    /**
+     * Resolves model information from a request
+     *
+     * @param request - The request (with preset or direct IDs)
+     * @returns Resolution result
+     */
+    resolve(request) {
+        const reqWithPreset = request;
+        // Check if using preset
+        if (reqWithPreset.presetId) {
+            const preset = this.presetManager.resolvePreset(reqWithPreset.presetId);
+            if (!preset) {
+                return {
+                    error: {
+                        object: 'error',
+                        providerId: 'unknown',
+                        error: {
+                            message: `Preset not found: ${reqWithPreset.presetId}`,
+                            code: 'PRESET_NOT_FOUND',
+                            type: 'validation_error',
+                            param: 'presetId',
+                        },
+                    },
+                };
+            }
+            // Get model info
+            const modelInfo = (0, config_1.getImageModelInfo)(preset.providerId, preset.modelId);
+            if (!modelInfo) {
+                return {
+                    error: {
+                        object: 'error',
+                        providerId: preset.providerId,
+                        modelId: preset.modelId,
+                        error: {
+                            message: `Model not found: ${preset.modelId} for provider ${preset.providerId}`,
+                            code: 'MODEL_NOT_FOUND',
+                            type: 'validation_error',
+                        },
+                    },
+                };
+            }
+            return {
+                providerId: preset.providerId,
+                modelId: preset.modelId,
+                modelInfo,
+                settings: preset.settings,
+            };
+        }
+        // Using direct provider ID and model ID
+        const reqDirect = request;
+        if (!reqDirect.providerId || !reqDirect.modelId) {
+            return {
+                error: {
+                    object: 'error',
+                    providerId: reqDirect.providerId || 'unknown',
+                    modelId: reqDirect.modelId,
+                    error: {
+                        message: 'Either presetId or both providerId and modelId must be specified',
+                        code: 'MISSING_MODEL_INFO',
+                        type: 'validation_error',
+                    },
+                },
+            };
+        }
+        const modelInfo = (0, config_1.getImageModelInfo)(reqDirect.providerId, reqDirect.modelId);
+        if (!modelInfo) {
+            return {
+                error: {
+                    object: 'error',
+                    providerId: reqDirect.providerId,
+                    modelId: reqDirect.modelId,
+                    error: {
+                        message: `Model not found: ${reqDirect.modelId} for provider ${reqDirect.providerId}`,
+                        code: 'MODEL_NOT_FOUND',
+                        type: 'validation_error',
+                    },
+                },
+            };
+        }
+        return {
+            providerId: reqDirect.providerId,
+            modelId: reqDirect.modelId,
+            modelInfo,
+        };
+    }
+}
+exports.ImageModelResolver = ImageModelResolver;

package/dist/image/services/ImagePresetManager.d.ts

@@ -0,0 +1,27 @@
+import type { ImagePreset } from "../../types/image";
+/**
+ * Defines how custom image presets interact with the default presets.
+ * 'replace': Use only the custom presets provided. The default set is ignored.
+ * 'extend': Use the default presets, and add/override them with the custom presets. This is the default behavior.
+ */
+export type PresetMode = 'replace' | 'extend';
+/**
+ * Manages image generation presets including loading, merging, and resolution
+ */
+export declare class ImagePresetManager {
+    private presets;
+    constructor(customPresets?: ImagePreset[], mode?: PresetMode);
+    /**
+     * Gets all configured image presets
+     *
+     * @returns Array of image presets
+     */
+    getPresets(): ImagePreset[];
+    /**
+     * Resolves a preset by ID
+     *
+     * @param presetId - The preset ID to resolve
+     * @returns The preset if found, null otherwise
+     */
+    resolvePreset(presetId: string): ImagePreset | null;
+}

package/dist/image/services/ImagePresetManager.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImagePresetManager = void 0;
+const image_presets_json_1 = __importDefault(require("../../config/image-presets.json"));
+// Type assertion for the imported JSON
+const defaultImagePresets = image_presets_json_1.default;
+/**
+ * Manages image generation presets including loading, merging, and resolution
+ */
+class ImagePresetManager {
+    constructor(customPresets = [], mode = 'extend') {
+        // Initialize presets based on mode
+        const finalPresets = new Map();
+        if (mode === 'replace') {
+            // Replace Mode: Only use custom presets.
+            for (const preset of customPresets) {
+                finalPresets.set(preset.id, preset);
+            }
+        }
+        else {
+            // Extend Mode: Load defaults first, then add/override.
+            for (const preset of defaultImagePresets) {
+                finalPresets.set(preset.id, preset);
+            }
+            for (const preset of customPresets) {
+                finalPresets.set(preset.id, preset);
+            }
+        }
+        this.presets = Array.from(finalPresets.values());
+    }
+    /**
+     * Gets all configured image presets
+     *
+     * @returns Array of image presets
+     */
+    getPresets() {
+        return [...this.presets]; // Return a copy to prevent external modification
+    }
+    /**
+     * Resolves a preset by ID
+     *
+     * @param presetId - The preset ID to resolve
+     * @returns The preset if found, null otherwise
+     */
+    resolvePreset(presetId) {
+        return this.presets.find(p => p.id === presetId) || null;
+    }
+}
+exports.ImagePresetManager = ImagePresetManager;

package/dist/image/services/ImageRequestValidator.d.ts

@@ -0,0 +1,37 @@
+import type { ImageGenerationRequest, ImageFailureResponse } from '../../types/image';
+/**
+ * Validates image generation requests
+ */
+export declare class ImageRequestValidator {
+    /**
+     * Validates the basic structure of an image generation request
+     *
+     * @param request - The request to validate
+     * @returns null if valid, ImageFailureResponse if invalid
+     */
+    validateRequestStructure(request: ImageGenerationRequest): ImageFailureResponse | null;
+    /**
+     * Validates the count parameter
+     *
+     * @param request - The request containing the count
+     * @returns null if valid, ImageFailureResponse if invalid
+     */
+    private validateCount;
+    /**
+     * Validates settings
+     *
+     * @param request - The request containing the settings
+     * @returns null if valid, ImageFailureResponse if invalid
+     */
+    private validateSettings;
+    /**
+     * Creates a validation error response
+     *
+     * @param request - The original request
+     * @param message - Error message
+     * @param code - Error code
+     * @param param - Parameter that caused the error
+     * @returns ImageFailureResponse
+     */
+    private createValidationError;
+}