genai-lite 0.9.1 → 0.9.2

package/dist/adapters/image/GenaiElectronImageAdapter.js

@@ -18,6 +18,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GenaiElectronImageAdapter = void 0;
 const errorUtils_1 = require("../../shared/adapters/errorUtils");
+const types_1 = require("../../llm/clients/types");
 const defaultLogger_1 = require("../../logging/defaultLogger");
 /**
  * Adapter for genai-electron's local diffusion image generation
@@ -157,6 +158,12 @@ class GenaiElectronImageAdapter {
                 const error = state.error || { message: 'Unknown error', code: 'UNKNOWN_ERROR' };
                 throw this.createGenerationError(error.message, error.code);
             }
+            // Handle out-of-band cancellation (terminal status since genai-electron 0.6.0)
+            if (state.status === 'cancelled') {
+                const cancelError = new Error(`Image generation was cancelled on the server (ID: ${generationId})`);
+                cancelError.code = 'GENERATION_CANCELLED';
+                throw cancelError;
+            }
             // Wait before next poll
             await this.sleep(this.pollInterval);
         }
@@ -231,8 +238,15 @@ class GenaiElectronImageAdapter {
         const mapped = (0, errorUtils_1.getCommonMappedErrorDetails)(error);
         // Enhance error message with context
         let errorMessage = mapped.errorMessage;
+        let errorCode = mapped.errorCode;
+        let errorType = mapped.errorType;
         // Special handling for genai-electron specific errors
-        if (error.code === 'SERVER_BUSY') {
+        if (error.code === 'GENERATION_CANCELLED') {
+            errorMessage = error.message;
+            errorCode = types_1.ADAPTER_ERROR_CODES.REQUEST_ABORTED;
+            errorType = 'abort_error';
+        }
+        else if (error.code === 'SERVER_BUSY') {
             errorMessage = 'Image generation server is busy. Wait for current generation to complete.';
             error.type = 'rate_limit_error';
         }
@@ -258,8 +272,8 @@ class GenaiElectronImageAdapter {
         }
         // Create enhanced error with all details
         const enhancedError = new Error(errorMessage);
-        enhancedError.code = mapped.errorCode;
-        enhancedError.type = mapped.errorType;
+        enhancedError.code = errorCode;
+        enhancedError.type = errorType;
         enhancedError.status = mapped.status;
         enhancedError.providerId = this.id;
         enhancedError.modelId = request.modelId;

package/dist/llm/clients/GeminiClientAdapter.d.ts

@@ -75,6 +75,7 @@ export declare class GeminiClientAdapter implements ILLMClientAdapter {
      *
      * @param error - The error from Gemini API
      * @param request - Original request for context
+     * @param context - Adapter-side transport state captured at catch time
      * @returns Standardized LLM failure response
      */
     private createErrorResponse;

package/dist/llm/clients/GeminiClientAdapter.js

@@ -38,6 +38,12 @@ class GeminiClientAdapter {
      * @returns Promise resolving to success or failure response
      */
     async sendMessage(request, apiKey, options) {
+        // The SDK enforces httpOptions.timeout by aborting an internal controller and
+        // wraps any fetch rejection in a plain Error (no name/status/code), so timeouts
+        // and caller aborts cannot be classified from the error object. The adapter owns
+        // the timeout instead and classifies from its own state in the catch block.
+        let timedOut = false;
+        let timeoutHandle;
         try {
             // Initialize Gemini client (note: @google/genai performs no automatic retries)
             const genAI = new genai_1.GoogleGenAI({ apiKey });
@@ -52,6 +58,26 @@ class GeminiClientAdapter {
                 contentsLength: contents.length,
                 safetySettingsCount: safetySettings?.length || 0,
             });
+            let abortSignal = options?.signal;
+            if (options?.timeoutMs !== undefined) {
+                const controller = new AbortController();
+                if (options.signal) {
+                    if (options.signal.aborted) {
+                        controller.abort();
+                    }
+                    else {
+                        options.signal.addEventListener("abort", () => controller.abort(), {
+                            once: true,
+                        });
+                    }
+                }
+                timeoutHandle = setTimeout(() => {
+                    timedOut = true;
+                    controller.abort();
+                }, options.timeoutMs);
+                timeoutHandle.unref?.();
+                abortSignal = controller.signal;
+            }
             // Generate content using the modern API
             const result = await genAI.models.generateContent({
                 model: request.modelId,
@@ -60,9 +86,11 @@ class GeminiClientAdapter {
                     ...generationConfig,
                     safetySettings: safetySettings,
                     ...(systemInstruction && { systemInstruction: systemInstruction }),
-                    ...(options?.signal && { abortSignal: options.signal }),
+                    ...(abortSignal && { abortSignal }),
+                    // Keep the SDK's server-side timeout hint (X-Server-Timeout header),
+                    // padded so the adapter's local timer always fires first
                     ...(options?.timeoutMs !== undefined && {
-                        httpOptions: { timeout: options.timeoutMs },
+                        httpOptions: { timeout: options.timeoutMs + 1000 },
                     }),
                 },
             });
@@ -72,7 +100,15 @@ class GeminiClientAdapter {
         }
         catch (error) {
             this.logger.error("Gemini API error:", error);
-            return this.createErrorResponse(error, request);
+            return this.createErrorResponse(error, request, {
+                timedOut,
+                aborted: options?.signal?.aborted === true,
+            });
+        }
+        finally {
+            if (timeoutHandle !== undefined) {
+                clearTimeout(timeoutHandle);
+            }
         }
     }
     /**
@@ -312,9 +348,38 @@ class GeminiClientAdapter {
      *
      * @param error - The error from Gemini API
      * @param request - Original request for context
+     * @param context - Adapter-side transport state captured at catch time
      * @returns Standardized LLM failure response
      */
-    createErrorResponse(error, request) {
+    createErrorResponse(error, request, context) {
+        // Classify adapter-owned aborts/timeouts first — the SDK surfaces both as
+        // plain Errors the common mapping cannot recognize (see sendMessage)
+        if (context?.aborted) {
+            return {
+                provider: request.providerId,
+                model: request.modelId,
+                error: {
+                    message: "Request was aborted",
+                    code: types_1.ADAPTER_ERROR_CODES.REQUEST_ABORTED,
+                    type: "abort_error",
+                    providerError: error,
+                },
+                object: "error",
+            };
+        }
+        if (context?.timedOut) {
+            return {
+                provider: request.providerId,
+                model: request.modelId,
+                error: {
+                    message: "Request timed out",
+                    code: types_1.ADAPTER_ERROR_CODES.REQUEST_TIMEOUT,
+                    type: "timeout_error",
+                    providerError: error,
+                },
+                object: "error",
+            };
+        }
         // Use shared error mapping utility for common error patterns
         const initialProviderMessage = error?.message;
         let { errorCode, errorMessage, errorType, status, retryAfterMs } = (0, errorUtils_1.getCommonMappedErrorDetails)(error, initialProviderMessage);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genai-lite",
-  "version": "0.9.1",
+  "version": "0.9.2",
   "description": "A lightweight, portable toolkit for interacting with various Generative AI APIs.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",