@loonylabs/tti-middleware 1.2.0 → 1.4.0

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

@@ -100,10 +100,26 @@ export declare abstract class BaseTTIProvider implements ITTIProvider {
      * Sleep for a specified duration
      */
     protected sleep(ms: number): Promise<void>;
+    /**
+     * Wrap an operation with a timeout. If the operation doesn't resolve
+     * within timeoutMs, the returned promise rejects with a timeout error.
+     * The original operation continues running (promises can't be cancelled),
+     * but its result is ignored.
+     */
+    private withTimeout;
+    /**
+     * Check if an error is a timeout error (from our withTimeout wrapper).
+     */
+    private isTimeoutError;
     /**
      * Execute a generation function with retry logic for transient errors.
      * Retries on: 429, 408, 5xx, network timeouts, TCP disconnects.
      * Does NOT retry on: 400, 401, 403, and other client errors.
+     *
+     * Each attempt is wrapped with a per-attempt timeout (configurable via
+     * retry.timeoutMs, default 45s). Timeout errors have their own retry
+     * counter (timeoutRetries, default 2) independent from the general
+     * maxRetries used for quota/server errors.
      */
     protected executeWithRetry<T>(request: TTIRequest, operation: () => Promise<T>, operationName: string): Promise<T>;
     /**

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

@@ -246,6 +246,8 @@ class BaseTTIProvider {
             backoffMultiplier,
             maxDelayMs: retryOption.maxDelayMs ?? types_1.DEFAULT_RETRY_OPTIONS.maxDelayMs,
             jitter: retryOption.jitter ?? types_1.DEFAULT_RETRY_OPTIONS.jitter,
+            timeoutMs: retryOption.timeoutMs ?? types_1.DEFAULT_RETRY_OPTIONS.timeoutMs,
+            timeoutRetries: retryOption.timeoutRetries ?? types_1.DEFAULT_RETRY_OPTIONS.timeoutRetries,
         };
     }
     /**
@@ -270,10 +272,43 @@ class BaseTTIProvider {
     sleep(ms) {
         return new Promise((resolve) => setTimeout(resolve, ms));
     }
+    /**
+     * Wrap an operation with a timeout. If the operation doesn't resolve
+     * within timeoutMs, the returned promise rejects with a timeout error.
+     * The original operation continues running (promises can't be cancelled),
+     * but its result is ignored.
+     */
+    withTimeout(operation, timeoutMs, operationName) {
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                reject(new Error(`timeout: ${operationName} did not complete within ${timeoutMs}ms`));
+            }, timeoutMs);
+            operation()
+                .then((result) => {
+                clearTimeout(timer);
+                resolve(result);
+            })
+                .catch((error) => {
+                clearTimeout(timer);
+                reject(error);
+            });
+        });
+    }
+    /**
+     * Check if an error is a timeout error (from our withTimeout wrapper).
+     */
+    isTimeoutError(error) {
+        return error.message.toLowerCase().startsWith('timeout:');
+    }
     /**
      * Execute a generation function with retry logic for transient errors.
      * Retries on: 429, 408, 5xx, network timeouts, TCP disconnects.
      * Does NOT retry on: 400, 401, 403, and other client errors.
+     *
+     * Each attempt is wrapped with a per-attempt timeout (configurable via
+     * retry.timeoutMs, default 45s). Timeout errors have their own retry
+     * counter (timeoutRetries, default 2) independent from the general
+     * maxRetries used for quota/server errors.
      */
     async executeWithRetry(request, operation, operationName) {
         const retryConfig = this.resolveRetryConfig(request);
@@ -281,29 +316,71 @@ class BaseTTIProvider {
         if (!retryConfig) {
             return operation();
         }
+        const timeoutMs = retryConfig.timeoutMs || 0;
+        const maxTimeoutRetries = retryConfig.timeoutRetries ?? 2;
         let lastError = null;
-        const maxAttempts = 1 + retryConfig.maxRetries; // initial + retries
-        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        let generalRetryCount = 0;
+        let timeoutRetryCount = 0;
+        const maxGeneralRetries = retryConfig.maxRetries;
+        // Total attempt cap to prevent infinite loops
+        const absoluteMaxAttempts = 1 + maxGeneralRetries + maxTimeoutRetries;
+        for (let attempt = 1; attempt <= absoluteMaxAttempts; attempt++) {
+            const attemptStart = Date.now();
             try {
-                return await operation();
+                this.log('info', `${operationName} attempt ${attempt}${timeoutMs ? ` (timeout: ${timeoutMs}ms)` : ''} [retries: general=${generalRetryCount}/${maxGeneralRetries}, timeout=${timeoutRetryCount}/${maxTimeoutRetries}]`, {
+                    attempt,
+                    timeoutMs: timeoutMs || 'none',
+                    generalRetries: `${generalRetryCount}/${maxGeneralRetries}`,
+                    timeoutRetries: `${timeoutRetryCount}/${maxTimeoutRetries}`,
+                });
+                // Wrap with timeout if configured
+                const result = timeoutMs > 0
+                    ? await this.withTimeout(operation, timeoutMs, operationName)
+                    : await operation();
+                const duration = Date.now() - attemptStart;
+                this.log('info', `${operationName} completed in ${duration}ms`, {
+                    attempt,
+                    durationMs: duration,
+                });
+                return result;
             }
             catch (error) {
+                const duration = Date.now() - attemptStart;
                 lastError = error;
-                // Only retry on retryable errors
-                if (!this.isRetryableError(error)) {
+                const isTimeout = this.isTimeoutError(error);
+                // Non-retryable errors: fail immediately
+                if (!isTimeout && !this.isRetryableError(error)) {
+                    this.log('error', `${operationName} failed with non-retryable error after ${duration}ms: ${error.message}`, { attempt, durationMs: duration });
                     throw error;
                 }
-                // Check if we have retries left
-                if (attempt < maxAttempts) {
-                    const delay = this.calculateRetryDelay(attempt, retryConfig);
-                    this.log('warn', `Transient error during ${operationName}. Retry ${attempt}/${retryConfig.maxRetries} in ${delay}ms...`, { attempt, maxRetries: retryConfig.maxRetries, delayMs: delay, error: error.message });
+                // Check retry budget for this error type
+                if (isTimeout) {
+                    timeoutRetryCount++;
+                    if (timeoutRetryCount > maxTimeoutRetries) {
+                        this.log('error', `${operationName} timeout retry budget exhausted (${maxTimeoutRetries} retries, ${duration}ms on last attempt)`, { attempt, timeoutRetryCount, durationMs: duration });
+                        throw error;
+                    }
+                    // Short fixed delay before timeout retry (no exponential backoff)
+                    this.log('warn', `${operationName} timed out after ${duration}ms. Timeout retry ${timeoutRetryCount}/${maxTimeoutRetries} in 2s...`, { attempt, timeoutRetryCount, maxTimeoutRetries, durationMs: duration });
+                    await this.sleep(2000);
+                }
+                else {
+                    generalRetryCount++;
+                    if (generalRetryCount > maxGeneralRetries) {
+                        this.log('error', `${operationName} general retry budget exhausted (${maxGeneralRetries} retries): ${error.message}`, { attempt, generalRetryCount, durationMs: duration });
+                        throw error;
+                    }
+                    const delay = this.calculateRetryDelay(generalRetryCount, retryConfig);
+                    this.log('warn', `Transient error during ${operationName} after ${duration}ms. Retry ${generalRetryCount}/${maxGeneralRetries} in ${delay}ms: ${error.message}`, { attempt, generalRetryCount, maxGeneralRetries, delayMs: delay, durationMs: duration });
                     await this.sleep(delay);
                 }
             }
         }
-        // All retries exhausted
-        this.log('error', `All ${retryConfig.maxRetries} retries exhausted for ${operationName}`, {
+        // Safety: should not reach here
+        this.log('error', `All retries exhausted for ${operationName}`, {
             lastError: lastError?.message,
+            generalRetryCount,
+            timeoutRetryCount,
         });
         throw lastError;
     }

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

@@ -273,13 +273,14 @@ class GoogleCloudTTIProvider extends base_tti_provider_1.BaseTTIProvider {
                 }
             }
             const parameters = helpers.toValue(parameterValue);
-            this.log('debug', 'Sending Imagen request', { endpoint, parameters: parameterValue });
+            this.log('info', 'Sending Imagen request to Vertex AI', { endpoint, parameters: parameterValue });
             const [response] = await client.predict({
                 endpoint,
                 instances: [instance],
                 parameters,
             });
             const duration = Date.now() - startTime;
+            this.log('info', `Imagen response received in ${duration}ms`, { duration, hasPredictions: !!response.predictions?.length });
             if (!response.predictions || response.predictions.length === 0) {
                 throw new base_tti_provider_1.GenerationFailedError(this.providerName, 'No images returned from Imagen API');
             }
@@ -392,14 +393,22 @@ class GoogleCloudTTIProvider extends base_tti_provider_1.BaseTTIProvider {
             const config = {
                 responseModalities: ['TEXT', 'IMAGE'],
             };
+            // Add imageConfig with aspectRatio if provided
+            if (request.aspectRatio) {
+                config.imageConfig = {
+                    aspectRatio: request.aspectRatio,
+                };
+            }
             // Add temperature if provided
             if (request.providerOptions?.temperature !== undefined) {
                 config.temperature = request.providerOptions.temperature;
             }
-            this.log('debug', 'Sending Gemini request', {
+            this.log('info', 'Sending Gemini generateContent request to Vertex AI', {
                 model: internalModelId,
                 region,
                 hasReferenceImages: (0, base_tti_provider_1.hasReferenceImages)(request),
+                referenceImageCount: request.referenceImages?.length || 0,
+                aspectRatio: request.aspectRatio,
             });
             const response = await client.generateContent({
                 model: internalModelId,
@@ -407,6 +416,10 @@ class GoogleCloudTTIProvider extends base_tti_provider_1.BaseTTIProvider {
                 config,
             });
             const duration = Date.now() - startTime;
+            this.log('info', `Gemini response received in ${duration}ms`, {
+                duration,
+                hasCandidates: !!(response?.candidates || response?.response),
+            });
             return this.processGeminiResponse(response, duration);
         }
         catch (error) {

package/dist/middleware/types/index.d.ts

@@ -198,6 +198,21 @@ export interface RetryOptions {
      * When enabled, actual delay is randomized between 0 and the computed delay.
      */
     jitter?: boolean;
+    /**
+     * Timeout per attempt in milliseconds (default: 45000 = 45s).
+     * If the provider SDK call doesn't resolve within this time,
+     * the attempt is aborted and counted as a retryable timeout error.
+     * Set to 0 to disable timeout.
+     */
+    timeoutMs?: number;
+    /**
+     * Maximum retries specifically for timeout errors (default: 2).
+     * Timeout retries are tracked independently from other transient errors
+     * (429, 5xx, etc.) which use the general `maxRetries` counter.
+     * This prevents a hung service from burning through all retries with
+     * long waits, while still allowing many retries for quota errors.
+     */
+    timeoutRetries?: number;
     /**
      * @deprecated Use `backoffMultiplier` instead. Will be removed in v2.0.
      * When true, equivalent to backoffMultiplier of 1.0 with linear scaling (delayMs * attempt).

package/dist/middleware/types/index.js

@@ -37,4 +37,6 @@ exports.DEFAULT_RETRY_OPTIONS = {
     backoffMultiplier: 2.0,
     maxDelayMs: 30000,
     jitter: true,
+    timeoutMs: 45000,
+    timeoutRetries: 2,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loonylabs/tti-middleware",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "Provider-agnostic Text-to-Image middleware with GDPR compliance. Supports Google Cloud (Imagen, Gemini), Eden AI, and IONOS.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -55,7 +55,7 @@
   "homepage": "https://github.com/loonylabs-dev/tti-middleware#readme",
   "peerDependencies": {
     "@google-cloud/aiplatform": ">=3.0.0",
-    "@google/genai": ">=0.14.0"
+    "@google/genai": ">=1.40.0"
   },
   "peerDependenciesMeta": {
     "@google-cloud/aiplatform": {
@@ -67,7 +67,7 @@
   },
   "devDependencies": {
     "@google-cloud/aiplatform": "^3.29.0",
-    "@google/genai": "^0.14.0",
+    "@google/genai": "^1.40.0",
     "@types/jest": "^29.5.8",
     "@types/node": "^20.10.0",
     "@typescript-eslint/eslint-plugin": "^6.13.0",