@loonylabs/tti-middleware 1.0.0

package/dist/middleware/services/tti/providers/google-cloud-provider.js

@@ -0,0 +1,473 @@
+"use strict";
+/**
+ * Google Cloud TTI Provider
+ *
+ * Unified provider for Google Cloud's image generation services:
+ * - Imagen 3 (imagegeneration@006) - High quality text-to-image
+ * - Gemini 2.5 Flash Image - Text-to-image with character consistency
+ *
+ * All requests go through Google Cloud (Vertex AI) with proper DPA.
+ * EU-compliant when using EU regions.
+ *
+ * @see https://cloud.google.com/vertex-ai/generative-ai/pricing
+ * @see https://cloud.google.com/terms/data-processing-addendum
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleCloudTTIProvider = void 0;
+const types_1 = require("../../../types");
+const base_tti_provider_1 = require("./base-tti-provider");
+// ============================================================
+// MODEL DEFINITIONS
+// ============================================================
+const GOOGLE_CLOUD_MODELS = [
+    {
+        id: 'imagen-3',
+        displayName: 'Imagen 3',
+        capabilities: {
+            textToImage: true,
+            characterConsistency: false, // Requires allowlist for Customization API
+            imageEditing: false,
+            maxImagesPerRequest: 4,
+        },
+        availableRegions: [
+            'europe-west1',
+            'europe-west2',
+            'europe-west3',
+            'europe-west4',
+            'europe-west9',
+            'us-central1',
+            'us-east4',
+        ],
+        pricingUrl: 'https://cloud.google.com/vertex-ai/generative-ai/pricing',
+    },
+    {
+        id: 'gemini-flash-image',
+        displayName: 'Gemini 2.5 Flash Image',
+        capabilities: {
+            textToImage: true,
+            characterConsistency: true, // Built-in support!
+            imageEditing: false,
+            maxImagesPerRequest: 1,
+        },
+        // Note: NOT available in europe-west3 (Frankfurt)!
+        availableRegions: [
+            'europe-west1',
+            'europe-west4',
+            'europe-north1',
+            'us-central1',
+            'us-east4',
+        ],
+        pricingUrl: 'https://cloud.google.com/vertex-ai/generative-ai/pricing',
+    },
+];
+// Internal model IDs used in API calls
+const MODEL_ID_MAP = {
+    'imagen-3': 'imagegeneration@006',
+    'gemini-flash-image': 'gemini-2.5-flash-image',
+};
+// ============================================================
+// PROVIDER IMPLEMENTATION
+// ============================================================
+class GoogleCloudTTIProvider extends base_tti_provider_1.BaseTTIProvider {
+    constructor(config) {
+        super(types_1.TTIProvider.GOOGLE_CLOUD);
+        this.lastUsedRegion = null;
+        // Lazy-loaded SDK clients
+        this.aiplatformClient = null;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.genaiClient = null;
+        const projectId = config?.projectId ||
+            process.env.GOOGLE_CLOUD_PROJECT ||
+            process.env.GCLOUD_PROJECT ||
+            '';
+        const region = config?.region ||
+            process.env.GOOGLE_CLOUD_REGION ||
+            process.env.VERTEX_AI_REGION ||
+            'europe-west4'; // Default to Netherlands (supports all models)
+        if (!projectId) {
+            throw new base_tti_provider_1.InvalidConfigError(types_1.TTIProvider.GOOGLE_CLOUD, 'Google Cloud Project ID is required. Set GOOGLE_CLOUD_PROJECT or pass projectId in config.');
+        }
+        this.config = {
+            projectId,
+            region,
+            keyFilename: config?.keyFilename || process.env.GOOGLE_APPLICATION_CREDENTIALS,
+            credentials: config?.credentials,
+        };
+        this.log('info', 'Google Cloud TTI Provider initialized', {
+            projectId: this.config.projectId,
+            region: this.config.region,
+            isEURegion: (0, base_tti_provider_1.isEURegion)(this.config.region),
+            models: this.listModels().map((m) => m.id),
+        });
+    }
+    // ============================================================
+    // ITTIProvider IMPLEMENTATION
+    // ============================================================
+    getDisplayName() {
+        return 'Google Cloud';
+    }
+    listModels() {
+        return GOOGLE_CLOUD_MODELS;
+    }
+    getDefaultModel() {
+        // Default to Gemini Flash Image as it supports character consistency
+        return 'gemini-flash-image';
+    }
+    async generate(request) {
+        this.validateRequest(request);
+        const modelId = request.model || this.getDefaultModel();
+        const modelInfo = this.getModelInfo(modelId);
+        if (!modelInfo) {
+            throw new base_tti_provider_1.InvalidConfigError(this.providerName, `Unknown model: ${modelId}. Available models: ${this.listModels()
+                .map((m) => m.id)
+                .join(', ')}`);
+        }
+        // Validate region availability
+        const effectiveRegion = this.getEffectiveRegion(modelId);
+        this.log('debug', 'Generating image', {
+            model: modelId,
+            region: effectiveRegion,
+            hasReferenceImages: (0, base_tti_provider_1.hasReferenceImages)(request),
+        });
+        // Route to appropriate implementation with retry support
+        switch (modelId) {
+            case 'imagen-3':
+                return this.executeWithRetry(request, () => this.generateWithImagen(request, effectiveRegion), 'Imagen API call');
+            case 'gemini-flash-image':
+                return this.executeWithRetry(request, () => this.generateWithGemini(request, effectiveRegion), 'Gemini API call');
+            default:
+                throw new base_tti_provider_1.InvalidConfigError(this.providerName, `Unknown model: ${modelId}`);
+        }
+    }
+    // ============================================================
+    // PUBLIC HELPER METHODS
+    // ============================================================
+    /**
+     * Get the configured region
+     */
+    getRegion() {
+        return this.config.region;
+    }
+    /**
+     * Check if the configured region is hosted in the EU
+     */
+    isEURegion() {
+        return (0, base_tti_provider_1.isEURegion)(this.config.region);
+    }
+    // ============================================================
+    // PRIVATE: REGION HANDLING
+    // ============================================================
+    /**
+     * Get the effective region for a model, considering availability
+     */
+    getEffectiveRegion(modelId) {
+        const modelInfo = this.getModelInfo(modelId);
+        if (!modelInfo?.availableRegions) {
+            return this.config.region;
+        }
+        // Check if configured region supports this model
+        if (modelInfo.availableRegions.includes(this.config.region)) {
+            return this.config.region;
+        }
+        // Find best alternative (prefer EU regions)
+        const euAlternatives = modelInfo.availableRegions.filter(base_tti_provider_1.isEURegion);
+        if (euAlternatives.length > 0) {
+            const fallback = euAlternatives[0];
+            this.log('warn', `Model ${modelId} not available in ${this.config.region}, using ${fallback}`, { configuredRegion: this.config.region, fallbackRegion: fallback });
+            return fallback;
+        }
+        // No EU region available, use first available
+        const fallback = modelInfo.availableRegions[0];
+        this.log('warn', `Model ${modelId} not available in EU regions, using ${fallback}`, { configuredRegion: this.config.region, fallbackRegion: fallback });
+        return fallback;
+    }
+    // ============================================================
+    // PRIVATE: IMAGEN 3 IMPLEMENTATION
+    // ============================================================
+    async generateWithImagen(request, region) {
+        const startTime = Date.now();
+        const internalModelId = MODEL_ID_MAP['imagen-3'];
+        this.lastUsedRegion = region;
+        try {
+            const { client, helpers } = await this.getAiplatformClient();
+            const endpoint = `projects/${this.config.projectId}/locations/${region}/publishers/google/models/${internalModelId}`;
+            // Build instance
+            const instanceValue = { prompt: request.prompt };
+            const instance = helpers.toValue(instanceValue);
+            // Build parameters
+            const parameterValue = {
+                sampleCount: request.n || 1,
+            };
+            if (request.aspectRatio) {
+                parameterValue.aspectRatio = request.aspectRatio;
+            }
+            // Pass through provider-specific options
+            if (request.providerOptions) {
+                if (request.providerOptions.seed !== undefined) {
+                    parameterValue.seed = request.providerOptions.seed;
+                }
+                if (request.providerOptions.safetyFilterLevel) {
+                    parameterValue.safetyFilterLevel = request.providerOptions.safetyFilterLevel;
+                }
+                if (request.providerOptions.personGeneration) {
+                    parameterValue.personGeneration = request.providerOptions.personGeneration;
+                }
+            }
+            const parameters = helpers.toValue(parameterValue);
+            this.log('debug', 'Sending Imagen request', { endpoint, parameters: parameterValue });
+            const [response] = await client.predict({
+                endpoint,
+                instances: [instance],
+                parameters,
+            });
+            const duration = Date.now() - startTime;
+            if (!response.predictions || response.predictions.length === 0) {
+                throw new base_tti_provider_1.GenerationFailedError(this.providerName, 'No images returned from Imagen API');
+            }
+            return this.processImagenResponse(response.predictions, helpers, duration);
+        }
+        catch (error) {
+            if (error instanceof base_tti_provider_1.InvalidConfigError || error instanceof base_tti_provider_1.GenerationFailedError) {
+                throw error;
+            }
+            throw this.handleError(error, 'during Imagen API call');
+        }
+    }
+    async getAiplatformClient() {
+        if (!this.aiplatformClient) {
+            try {
+                const { v1, helpers } = await Promise.resolve().then(() => __importStar(require('@google-cloud/aiplatform')));
+                const clientOptions = {
+                    apiEndpoint: `${this.config.region}-aiplatform.googleapis.com`,
+                };
+                if (this.config.keyFilename) {
+                    clientOptions.keyFilename = this.config.keyFilename;
+                }
+                else if (this.config.credentials) {
+                    clientOptions.credentials = this.config.credentials;
+                }
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                this.aiplatformClient = new v1.PredictionServiceClient(clientOptions);
+                return {
+                    client: this.aiplatformClient,
+                    helpers: helpers,
+                };
+            }
+            catch (error) {
+                throw new base_tti_provider_1.InvalidConfigError(this.providerName, `Failed to load @google-cloud/aiplatform. Install it with: npm install @google-cloud/aiplatform`, error);
+            }
+        }
+        const { helpers } = await Promise.resolve().then(() => __importStar(require('@google-cloud/aiplatform')));
+        return {
+            client: this.aiplatformClient,
+            helpers: helpers,
+        };
+    }
+    processImagenResponse(predictions, helpers, duration) {
+        const images = [];
+        for (const prediction of predictions) {
+            const predictionObj = helpers.fromValue(prediction);
+            if (predictionObj?.bytesBase64Encoded) {
+                images.push({
+                    base64: predictionObj.bytesBase64Encoded,
+                    contentType: predictionObj.mimeType || 'image/png',
+                });
+            }
+        }
+        if (images.length === 0) {
+            throw new base_tti_provider_1.GenerationFailedError(this.providerName, 'No valid images in Imagen response');
+        }
+        const usage = {
+            imagesGenerated: images.length,
+            modelId: 'imagen-3',
+        };
+        return {
+            images,
+            metadata: {
+                provider: this.providerName,
+                model: 'imagen-3',
+                region: this.lastUsedRegion || this.config.region,
+                duration,
+            },
+            usage,
+        };
+    }
+    // ============================================================
+    // PRIVATE: GEMINI FLASH IMAGE IMPLEMENTATION
+    // ============================================================
+    async generateWithGemini(request, region) {
+        const startTime = Date.now();
+        const internalModelId = MODEL_ID_MAP['gemini-flash-image'];
+        this.lastUsedRegion = region;
+        try {
+            const client = await this.getGenaiClient(region);
+            // Build request parts
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const parts = [];
+            // Add reference images first (for character consistency)
+            if ((0, base_tti_provider_1.hasReferenceImages)(request)) {
+                for (const ref of request.referenceImages) {
+                    parts.push({
+                        inlineData: {
+                            mimeType: ref.mimeType || 'image/png',
+                            data: ref.base64,
+                        },
+                    });
+                }
+                // Build character consistency prompt
+                const fullPrompt = this.buildCharacterConsistencyPrompt(request.prompt, request.subjectDescription, request.referenceImages.length);
+                parts.push({ text: fullPrompt });
+            }
+            else {
+                parts.push({ text: request.prompt });
+            }
+            const contents = [{ role: 'user', parts }];
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const config = {
+                responseModalities: ['TEXT', 'IMAGE'],
+            };
+            // Add temperature if provided
+            if (request.providerOptions?.temperature !== undefined) {
+                config.temperature = request.providerOptions.temperature;
+            }
+            this.log('debug', 'Sending Gemini request', {
+                model: internalModelId,
+                region,
+                hasReferenceImages: (0, base_tti_provider_1.hasReferenceImages)(request),
+            });
+            const response = await client.generateContent({
+                model: internalModelId,
+                contents,
+                config,
+            });
+            const duration = Date.now() - startTime;
+            return this.processGeminiResponse(response, duration);
+        }
+        catch (error) {
+            if (error instanceof base_tti_provider_1.InvalidConfigError || error instanceof base_tti_provider_1.GenerationFailedError) {
+                throw error;
+            }
+            throw this.handleError(error, 'during Gemini API call');
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async getGenaiClient(region) {
+        // Recreate client if region changed
+        if (!this.genaiClient) {
+            try {
+                const { GoogleGenAI } = await Promise.resolve().then(() => __importStar(require('@google/genai')));
+                // Set environment variables for Vertex AI backend
+                process.env.GOOGLE_GENAI_USE_VERTEXAI = 'true';
+                process.env.GOOGLE_CLOUD_PROJECT = this.config.projectId;
+                process.env.GOOGLE_CLOUD_LOCATION = region;
+                this.genaiClient = new GoogleGenAI({
+                    vertexai: true,
+                    project: this.config.projectId,
+                    location: region,
+                });
+                this.log('debug', 'Initialized @google/genai with Vertex AI backend', {
+                    project: this.config.projectId,
+                    location: region,
+                });
+            }
+            catch (error) {
+                throw new base_tti_provider_1.InvalidConfigError(this.providerName, `Failed to load @google/genai. Install it with: npm install @google/genai`, error);
+            }
+        }
+        return {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            generateContent: async (params) => {
+                return this.genaiClient.models.generateContent(params);
+            },
+        };
+    }
+    buildCharacterConsistencyPrompt(userPrompt, subjectDescription, referenceCount) {
+        const referenceText = referenceCount === 1 ? 'the reference image' : `the ${referenceCount} reference images`;
+        return `Using ${referenceText} as a reference for the character "${subjectDescription}", generate a new image where: ${userPrompt}
+
+IMPORTANT: Maintain exact visual consistency with the character in the reference - same style, colors, proportions, and distinctive features. The character should be immediately recognizable as the same one from the reference.`;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    processGeminiResponse(response, duration) {
+        const images = [];
+        const candidates = response?.candidates || response?.response?.candidates;
+        if (!candidates || candidates.length === 0) {
+            throw new base_tti_provider_1.GenerationFailedError(this.providerName, 'No candidates returned from Gemini API');
+        }
+        for (const candidate of candidates) {
+            const parts = candidate?.content?.parts || [];
+            for (const part of parts) {
+                if (part.inlineData?.data) {
+                    images.push({
+                        base64: part.inlineData.data,
+                        contentType: part.inlineData.mimeType || 'image/png',
+                    });
+                }
+            }
+        }
+        if (images.length === 0) {
+            const firstParts = candidates[0]?.content?.parts || [];
+            const partTypes = firstParts.map((p) => {
+                if (p.text)
+                    return `text(${p.text.substring(0, 50)}...)`;
+                if (p.inlineData)
+                    return `inlineData(${p.inlineData.mimeType})`;
+                return 'unknown';
+            });
+            this.log('error', 'No images in Gemini response', {
+                candidateCount: candidates.length,
+                partTypes,
+            });
+            throw new base_tti_provider_1.GenerationFailedError(this.providerName, `No images in response. Model returned: ${partTypes.join(', ')}. ` +
+                'Make sure responseModalities includes IMAGE.');
+        }
+        const usage = {
+            imagesGenerated: images.length,
+            modelId: 'gemini-flash-image',
+        };
+        return {
+            images,
+            metadata: {
+                provider: this.providerName,
+                model: 'gemini-flash-image',
+                region: this.lastUsedRegion || this.config.region,
+                duration,
+            },
+            usage,
+        };
+    }
+}
+exports.GoogleCloudTTIProvider = GoogleCloudTTIProvider;

package/dist/middleware/services/tti/providers/index.d.ts

@@ -0,0 +1,4 @@
+export * from './base-tti-provider';
+export * from './google-cloud-provider';
+export * from './edenai-provider';
+export * from './ionos-provider';

package/dist/middleware/services/tti/providers/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Base provider, errors, and logging
+__exportStar(require("./base-tti-provider"), exports);
+// Provider implementations
+__exportStar(require("./google-cloud-provider"), exports);
+__exportStar(require("./edenai-provider"), exports);
+__exportStar(require("./ionos-provider"), exports);

package/dist/middleware/services/tti/providers/ionos-provider.d.ts

@@ -0,0 +1,26 @@
+/**
+ * IONOS TTI Provider
+ *
+ * IONOS Cloud AI service with OpenAI-compatible API.
+ *
+ * @see https://cloud.ionos.de/
+ */
+import { TTIRequest, TTIResponse, ModelInfo } from '../../../types';
+import { BaseTTIProvider } from './base-tti-provider';
+interface IonosConfig {
+    apiKey: string;
+    apiUrl?: string;
+}
+export declare class IonosProvider extends BaseTTIProvider {
+    private config;
+    private readonly apiUrl;
+    constructor(config?: Partial<IonosConfig>);
+    getDisplayName(): string;
+    listModels(): ModelInfo[];
+    getDefaultModel(): string;
+    generate(request: TTIRequest): Promise<TTIResponse>;
+    private executeGeneration;
+    private aspectRatioToSize;
+    private processResponse;
+}
+export {};

package/dist/middleware/services/tti/providers/ionos-provider.js

@@ -0,0 +1,134 @@
+"use strict";
+/**
+ * IONOS TTI Provider
+ *
+ * IONOS Cloud AI service with OpenAI-compatible API.
+ *
+ * @see https://cloud.ionos.de/
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IonosProvider = void 0;
+const types_1 = require("../../../types");
+const base_tti_provider_1 = require("./base-tti-provider");
+// ============================================================
+// MODEL DEFINITIONS
+// ============================================================
+const IONOS_MODELS = [
+    {
+        id: 'default',
+        displayName: 'IONOS Image Generation',
+        capabilities: {
+            textToImage: true,
+            characterConsistency: false,
+            imageEditing: false,
+            maxImagesPerRequest: 4,
+        },
+        pricingUrl: 'https://cloud.ionos.de/preise',
+    },
+];
+// ============================================================
+// PROVIDER IMPLEMENTATION
+// ============================================================
+class IonosProvider extends base_tti_provider_1.BaseTTIProvider {
+    constructor(config) {
+        super(types_1.TTIProvider.IONOS);
+        this.config = {
+            apiKey: config?.apiKey || process.env.IONOS_API_KEY || '',
+            apiUrl: config?.apiUrl || process.env.IONOS_API_URL,
+        };
+        const baseUrl = this.config.apiUrl || 'https://api.ionos.cloud/ai/v1';
+        this.apiUrl = `${baseUrl.replace(/\/+$/, '')}/images/generations`;
+        if (!this.config.apiKey) {
+            throw new base_tti_provider_1.InvalidConfigError(this.providerName, 'IONOS API key is required (IONOS_API_KEY)');
+        }
+        this.log('info', 'IONOS Provider initialized');
+    }
+    // ============================================================
+    // ITTIProvider IMPLEMENTATION
+    // ============================================================
+    getDisplayName() {
+        return 'IONOS Cloud';
+    }
+    listModels() {
+        return IONOS_MODELS;
+    }
+    getDefaultModel() {
+        return 'default';
+    }
+    async generate(request) {
+        this.validateRequest(request);
+        return this.executeWithRetry(request, () => this.executeGeneration(request), 'IONOS API call');
+    }
+    async executeGeneration(request) {
+        const startTime = Date.now();
+        const body = {
+            prompt: request.prompt,
+            n: request.n || 1,
+            size: request.aspectRatio ? this.aspectRatioToSize(request.aspectRatio) : '1024x1024',
+            response_format: 'url',
+            model: request.model !== 'default' ? request.model : undefined,
+        };
+        this.log('debug', 'Generating image with IONOS', {
+            size: body.size,
+            model: body.model,
+        });
+        try {
+            const response = await fetch(this.apiUrl, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${this.config.apiKey}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(body),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`IONOS API error (${response.status}): ${errorText}`);
+            }
+            const data = (await response.json());
+            const duration = Date.now() - startTime;
+            return this.processResponse(data, duration);
+        }
+        catch (error) {
+            throw this.handleError(error, 'during IONOS API call');
+        }
+    }
+    // ============================================================
+    // PRIVATE METHODS
+    // ============================================================
+    aspectRatioToSize(aspectRatio) {
+        const mapping = {
+            '1:1': '1024x1024',
+            '16:9': '1792x1024',
+            '9:16': '1024x1792',
+            '4:3': '1024x768',
+            '3:4': '768x1024',
+        };
+        return mapping[aspectRatio] || '1024x1024';
+    }
+    processResponse(data, duration) {
+        if (!data.data || data.data.length === 0) {
+            throw new base_tti_provider_1.GenerationFailedError(this.providerName, 'No images returned in response');
+        }
+        const images = data.data.map((item) => {
+            if (item.b64_json) {
+                return { base64: item.b64_json, contentType: 'image/png' };
+            }
+            return { url: item.url };
+        });
+        const usage = {
+            imagesGenerated: images.length,
+            modelId: 'default',
+        };
+        return {
+            images,
+            metadata: {
+                provider: this.providerName,
+                model: 'default',
+                duration,
+            },
+            usage,
+        };
+    }
+}
+exports.IonosProvider = IonosProvider;