@juspay/neurolink 9.10.0 → 9.11.0

package/dist/providers/amazonBedrock.d.ts

@@ -44,7 +44,7 @@ export declare class AmazonBedrockProvider extends BaseProvider {
      * Uses ListFoundationModels API to validate connectivity and permissions
      */
     checkBedrockHealth(): Promise<void>;
-    handleProviderError(error: unknown): Error;
+    formatProviderError(error: unknown): Error;
     /**
      * Generate embeddings for text using Amazon Bedrock embedding models
      * Uses the native AWS SDK InvokeModel command for Titan embeddings

package/dist/providers/amazonBedrock.js

@@ -4,6 +4,7 @@ import path from "path";
 import { createAnalytics } from "../core/analytics.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
+import { AuthenticationError, ProviderError } from "../types/errors.js";
 import { isAbortError } from "../utils/errorHandling.js";
 import { logger } from "../utils/logger.js";
 import { buildMultimodalMessagesArray } from "../utils/messageBuilder.js";
@@ -224,57 +225,66 @@ export class AmazonBedrockProvider extends BaseProvider {
             logger.debug(`[AmazonBedrockProvider] Calling Bedrock with ${this.conversationHistory.length} messages and ${toolConfig?.tools?.length || 0} tools`);
             // Create command and attempt API call
             const command = new ConverseCommand(commandInput);
-            logger.info(`⏳ [AmazonBedrockProvider] Sending ConverseCommand to Bedrock...`);
+            logger.debug("[Observability] Bedrock API request", {
+                model: commandInput.modelId,
+                region: region,
+                messageCount: commandInput.messages?.length || 0,
+                toolCount: commandInput.toolConfig?.tools?.length || 0,
+                maxTokens: commandInput.inferenceConfig?.maxTokens,
+            });
             const apiCallStartTime = Date.now();
             const response = await this.bedrockClient.send(command);
             const apiCallDuration = Date.now() - apiCallStartTime;
-            logger.info(`✅ [AmazonBedrockProvider] Bedrock API call successful!`);
-            logger.info(`⏱️ [AmazonBedrockProvider] API call duration: ${apiCallDuration}ms`);
-            logger.info(`📊 [AmazonBedrockProvider] Response metadata:`);
-            logger.info(`  - Stop reason: ${response.stopReason}`);
-            logger.info(`  - Usage tokens: ${JSON.stringify(response.usage || {})}`);
-            logger.info(`  - Metrics: ${JSON.stringify(response.metrics || {})}`);
+            logger.debug("[Observability] Bedrock API response", {
+                model: commandInput.modelId,
+                durationMs: apiCallDuration,
+                hasContent: !!response.output?.message?.content?.length,
+                stopReason: response.stopReason,
+                usage: response.usage
+                    ? {
+                        inputTokens: response.usage.inputTokens,
+                        outputTokens: response.usage.outputTokens,
+                        totalTokens: (response.usage.inputTokens || 0) +
+                            (response.usage.outputTokens || 0),
+                    }
+                    : undefined,
+            });
+            logger.info(`[AmazonBedrockProvider] Bedrock API call successful`);
+            logger.info(`[AmazonBedrockProvider] API call duration: ${apiCallDuration}ms`);
             const totalDuration = Date.now() - startTime;
-            logger.info(`🎯 [AmazonBedrockProvider] Total callBedrock duration: ${totalDuration}ms`);
+            logger.info(`[AmazonBedrockProvider] Total callBedrock duration: ${totalDuration}ms`);
             return response;
         }
         catch (error) {
             const errorDuration = Date.now() - startTime;
-            logger.error(`❌ [AmazonBedrockProvider] Bedrock API call failed after ${errorDuration}ms`);
-            logger.error(`🔍 [AmazonBedrockProvider] Error details:`);
+            // Extract AWS metadata for structured logging
+            const awsError = error && typeof error === "object"
+                ? error
+                : null;
+            const metadata = awsError?.$metadata && typeof awsError.$metadata === "object"
+                ? awsError.$metadata
+                : null;
+            logger.debug("[Observability] Bedrock API request failed", {
+                model: this.modelName || this.getDefaultModel(),
+                durationMs: errorDuration,
+                error: error instanceof Error ? error.message : String(error),
+                errorName: error instanceof Error ? error.name : undefined,
+                httpStatus: metadata?.httpStatusCode,
+                awsRequestId: metadata?.requestId,
+                awsErrorCode: awsError?.Code,
+            });
+            logger.error(`[AmazonBedrockProvider] Bedrock API call failed after ${errorDuration}ms`);
             if (error instanceof Error) {
-                logger.error(`  - Error name: ${error.name}`);
-                logger.error(`  - Error message: ${error.message}`);
-                logger.error(`  - Error stack: ${error.stack}`);
+                logger.error(`[AmazonBedrockProvider] Error: ${error.name} - ${error.message}`);
             }
-            // Log AWS SDK specific error details
-            if (error && typeof error === "object") {
-                const awsError = error;
-                if (awsError.$metadata && typeof awsError.$metadata === "object") {
-                    const metadata = awsError.$metadata;
-                    logger.error(`🏭 [AmazonBedrockProvider] AWS SDK metadata:`);
-                    logger.error(`  - HTTP status: ${metadata.httpStatusCode}`);
-                    logger.error(`  - Request ID: ${metadata.requestId}`);
-                    logger.error(`  - Attempts: ${metadata.attempts}`);
-                    logger.error(`  - Total retry delay: ${metadata.totalRetryDelay}`);
-                }
-                if (awsError.Code) {
-                    logger.error(`  - AWS Error Code: ${awsError.Code}`);
-                }
-                if (awsError.Type) {
-                    logger.error(`  - AWS Error Type: ${awsError.Type}`);
-                }
-                if (awsError.Fault) {
-                    logger.error(`  - AWS Fault: ${awsError.Fault}`);
-                }
+            if (metadata) {
+                logger.error(`[AmazonBedrockProvider] AWS SDK metadata`, {
+                    httpStatus: metadata.httpStatusCode,
+                    requestId: metadata.requestId,
+                    attempts: metadata.attempts,
+                    totalRetryDelay: metadata.totalRetryDelay,
+                });
             }
-            // Log environment details for debugging
-            logger.error(`🌍 [AmazonBedrockProvider] Environment diagnostics:`);
-            logger.error(`  - AWS_REGION: ${process.env.AWS_REGION || "not set"}`);
-            logger.error(`  - AWS_PROFILE: ${process.env.AWS_PROFILE || "not set"}`);
-            logger.error(`  - AWS_ACCESS_KEY_ID: ${process.env.AWS_ACCESS_KEY_ID ? "set" : "not set"}`);
-            logger.error(`  - AWS_SECRET_ACCESS_KEY: ${process.env.AWS_SECRET_ACCESS_KEY ? "set" : "not set"}`);
-            logger.error(`  - AWS_SESSION_TOKEN: ${process.env.AWS_SESSION_TOKEN ? "set" : "not set"}`);
             throw error;
         }
     }
@@ -733,6 +743,10 @@ export class AmazonBedrockProvider extends BaseProvider {
                 // Fallback to generate method and convert to streaming format
                 const generateResult = await this.generate({
                     prompt: options.input.text,
+                    input: options.input,
+                    maxTokens: options.maxTokens,
+                    temperature: options.temperature,
+                    systemPrompt: options.systemPrompt,
                 });
                 if (!generateResult) {
                     throw new Error("Generate method returned null result");
@@ -793,8 +807,18 @@ export class AmazonBedrockProvider extends BaseProvider {
             logger.debug("🟦 [TRACE] streamingConversationLoop - testing first streaming call");
             const commandInput = await this.prepareStreamCommand(options);
             const command = new ConverseStreamCommand(commandInput);
+            logger.debug("[Observability] Bedrock streaming API request", {
+                model: commandInput.modelId,
+                messageCount: commandInput.messages?.length || 0,
+                toolCount: commandInput.toolConfig?.tools?.length || 0,
+            });
+            const streamStartTime = Date.now();
             const response = await this.bedrockClient.send(command);
-            logger.debug("🟦 [TRACE] streamingConversationLoop - first streaming call SUCCESS");
+            logger.debug("[Observability] Bedrock streaming API connection established", {
+                model: commandInput.modelId,
+                durationMs: Date.now() - streamStartTime,
+                hasStream: !!response.stream,
+            });
             // Process the first response immediately to avoid waste
             const stream = new ReadableStream({
                 start: async (controller) => {
@@ -925,7 +949,16 @@ export class AmazonBedrockProvider extends BaseProvider {
     }
     async processStreamResponse(commandInput, controller) {
         const command = new ConverseStreamCommand(commandInput);
+        logger.debug("[Observability] Bedrock streaming API request (continuation)", {
+            model: commandInput.modelId,
+            messageCount: commandInput.messages?.length || 0,
+        });
+        const iterationStartTime = Date.now();
         const response = await this.bedrockClient.send(command);
+        logger.debug("[Observability] Bedrock streaming API connection established (continuation)", {
+            model: commandInput.modelId,
+            durationMs: Date.now() - iterationStartTime,
+        });
         if (!response.stream) {
             throw new Error("No stream returned from Bedrock");
         }
@@ -1176,16 +1209,16 @@ export class AmazonBedrockProvider extends BaseProvider {
             }
         }
     }
-    handleProviderError(error) {
+    formatProviderError(error) {
         // Handle AWS SDK specific errors
         const message = error instanceof Error ? error.message : String(error);
         if (message.includes("AccessDeniedException")) {
-            return new Error("AWS Bedrock access denied. Check your credentials and permissions.");
+            return new AuthenticationError("AWS Bedrock access denied. Check your credentials and permissions.", this.providerName);
         }
         if (message.includes("ValidationException")) {
-            return new Error(`AWS Bedrock validation error: ${message}`);
+            return new ProviderError(`Validation error: ${message}`, this.providerName);
         }
-        return new Error(`AWS Bedrock error: ${message}`);
+        return new ProviderError(`AWS Bedrock error: ${message}`, this.providerName);
     }
     /**
      * Generate embeddings for text using Amazon Bedrock embedding models

package/dist/providers/amazonSagemaker.d.ts

@@ -21,7 +21,7 @@ export declare class AmazonSageMakerProvider extends BaseProvider {
     protected getDefaultModel(): string;
     protected getAISDKModel(): LanguageModelV1;
     protected executeStream(_options: StreamOptions, _analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
-    protected handleProviderError(error: unknown): Error;
+    protected formatProviderError(error: unknown): Error;
     /**
      * Get SageMaker-specific provider information
      */

package/dist/providers/amazonSagemaker.js

@@ -64,7 +64,7 @@ export class AmazonSageMakerProvider extends BaseProvider {
             throw this.handleProviderError(error);
         }
     }
-    handleProviderError(error) {
+    formatProviderError(error) {
         if (error instanceof SageMakerError) {
             return error;
         }

package/dist/providers/anthropic.d.ts

@@ -16,7 +16,7 @@ export declare class AnthropicProvider extends BaseProvider {
      * Returns the Vercel AI SDK model instance for Anthropic
      */
     getAISDKModel(): LanguageModelV1;
-    handleProviderError(error: unknown): Error;
+    protected formatProviderError(error: unknown): Error;
     protected executeStream(options: StreamOptions, _analysisSchema?: ValidationSchema): Promise<StreamResult>;
     isAvailable(): Promise<boolean>;
     getModel(): LanguageModelV1;

package/dist/providers/anthropic.js

@@ -49,9 +49,9 @@ export class AnthropicProvider extends BaseProvider {
     getAISDKModel() {
         return this.model;
     }
-    handleProviderError(error) {
+    formatProviderError(error) {
         if (error instanceof TimeoutError) {
-            throw new NetworkError(`Request timed out after ${error.timeout}ms`, this.providerName);
+            return new NetworkError(`Request timed out after ${error.timeout}ms`, this.providerName);
         }
         const errorRecord = error;
         const message = typeof errorRecord?.message === "string"
@@ -59,28 +59,28 @@ export class AnthropicProvider extends BaseProvider {
             : "Unknown error";
         if (message.includes("API_KEY_INVALID") ||
             message.includes("Invalid API key")) {
-            throw new AuthenticationError("Invalid Anthropic API key. Please check your ANTHROPIC_API_KEY environment variable.", this.providerName);
+            return new AuthenticationError("Invalid Anthropic API key. Please check your ANTHROPIC_API_KEY environment variable.", this.providerName);
         }
         if (message.includes("rate limit") ||
             message.includes("too_many_requests") ||
             message.includes("429")) {
-            throw new RateLimitError("Anthropic rate limit exceeded. Please try again later.", this.providerName);
+            return new RateLimitError("Anthropic rate limit exceeded. Please try again later.", this.providerName);
         }
         if (message.includes("ECONNRESET") ||
             message.includes("ENOTFOUND") ||
             message.includes("ECONNREFUSED") ||
             message.includes("network") ||
             message.includes("connection")) {
-            throw new NetworkError(`Connection error: ${message}`, this.providerName);
+            return new NetworkError(`Connection error: ${message}`, this.providerName);
         }
         if (message.includes("500") ||
             message.includes("502") ||
             message.includes("503") ||
             message.includes("504") ||
             message.includes("server error")) {
-            throw new ProviderError(`Server error: ${message}`, this.providerName);
+            return new ProviderError(`Server error: ${message}`, this.providerName);
         }
-        throw new ProviderError(`Anthropic error: ${message}`, this.providerName);
+        return new ProviderError(`Anthropic error: ${message}`, this.providerName);
     }
     // executeGenerate removed - BaseProvider handles all generation with tools
     async executeStream(options, _analysisSchema) {

package/dist/providers/anthropicBaseProvider.d.ts

@@ -16,7 +16,7 @@ export declare class AnthropicProviderV2 extends BaseProvider {
      * Returns the Vercel AI SDK model instance for Anthropic
      */
     protected getAISDKModel(): LanguageModelV1;
-    protected handleProviderError(error: unknown): Error;
+    protected formatProviderError(error: unknown): Error;
     private getApiKey;
     protected executeStream(options: StreamOptions, _analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
 }

package/dist/providers/anthropicBaseProvider.js

@@ -2,6 +2,7 @@ import { createAnthropic } from "@ai-sdk/anthropic";
 import { streamText } from "ai";
 import { AIProviderName, AnthropicModels } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
+import { AuthenticationError, NetworkError, ProviderError, RateLimitError, } from "../types/errors.js";
 import { logger } from "../utils/logger.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { validateApiKey, createAnthropicBaseConfig, } from "../utils/providerConfig.js";
@@ -35,21 +36,21 @@ export class AnthropicProviderV2 extends BaseProvider {
         const anthropic = createAnthropic({ apiKey });
         return anthropic(this.modelName);
     }
-    handleProviderError(error) {
+    formatProviderError(error) {
         if (error instanceof TimeoutError) {
-            return new Error(`Anthropic request timed out: ${error.message}`);
+            return new NetworkError(`Request timed out: ${error.message}`, this.providerName);
         }
         const errorWithStatus = error;
         if (errorWithStatus?.status === 401) {
-            return new Error("Invalid Anthropic API key. Please check your ANTHROPIC_API_KEY environment variable.");
+            return new AuthenticationError("Invalid Anthropic API key. Please check your ANTHROPIC_API_KEY environment variable.", this.providerName);
         }
         if (errorWithStatus?.status === 429) {
-            return new Error("Anthropic rate limit exceeded. Please try again later.");
+            return new RateLimitError("Anthropic rate limit exceeded. Please try again later.", this.providerName);
         }
         if (errorWithStatus?.status === 400) {
-            return new Error(`Anthropic bad request: ${errorWithStatus?.message || "Invalid request parameters"}`);
+            return new ProviderError(`Bad request: ${errorWithStatus?.message || "Invalid request parameters"}`, this.providerName);
         }
-        return new Error(`Anthropic error: ${errorWithStatus?.message || String(error) || "Unknown error"}`);
+        return new ProviderError(`Anthropic error: ${errorWithStatus?.message || String(error) || "Unknown error"}`, this.providerName);
     }
     // Configuration helper - now using consolidated utility
     getApiKey() {

package/dist/providers/azureOpenai.d.ts

@@ -15,7 +15,7 @@ export declare class AzureOpenAIProvider extends BaseProvider {
      * Returns the Vercel AI SDK model instance for Azure OpenAI
      */
     getAISDKModel(): LanguageModelV1;
-    handleProviderError(error: unknown): Error;
+    protected formatProviderError(error: unknown): Error;
     protected executeStream(options: StreamOptions, _analysisSchema?: unknown): Promise<StreamResult>;
 }
 export default AzureOpenAIProvider;

package/dist/providers/azureOpenai.js

@@ -62,7 +62,7 @@ export class AzureOpenAIProvider extends BaseProvider {
     getAISDKModel() {
         return this.azureProvider(this.deployment);
     }
-    handleProviderError(error) {
+    formatProviderError(error) {
         if (error instanceof TimeoutError) {
             return new Error(`Azure OpenAI request timed out: ${error.message}`);
         }

package/dist/providers/googleAiStudio.d.ts

@@ -43,7 +43,7 @@ export declare class GoogleAIStudioProvider extends BaseProvider {
      * 🔧 PHASE 2: Return AI SDK model instance for tool calling
      */
     getAISDKModel(): LanguageModelV1;
-    handleProviderError(error: unknown): Error;
+    protected formatProviderError(error: unknown): Error;
     /**
      * Overrides the BaseProvider's image generation method to implement it for Google AI.
      * This method calls the Google AI API to generate an image from a prompt.

package/dist/providers/googleAiStudio.js

@@ -91,21 +91,21 @@ export class GoogleAIStudioProvider extends BaseProvider {
         const google = createGoogleGenerativeAI({ apiKey });
         return google(this.modelName);
     }
-    handleProviderError(error) {
+    formatProviderError(error) {
         if (error instanceof TimeoutError) {
-            throw new NetworkError(error.message, this.providerName);
+            return new NetworkError(error.message, this.providerName);
         }
         const errorRecord = error;
         const message = typeof errorRecord?.message === "string"
             ? errorRecord.message
             : "Unknown error";
         if (message.includes("API_KEY_INVALID")) {
-            throw new AuthenticationError("Invalid Google AI API key. Please check your GOOGLE_AI_API_KEY environment variable.", this.providerName);
+            return new AuthenticationError("Invalid Google AI API key. Please check your GOOGLE_AI_API_KEY environment variable.", this.providerName);
         }
         if (message.includes("RATE_LIMIT_EXCEEDED")) {
-            throw new RateLimitError("Google AI rate limit exceeded. Please try again later.", this.providerName);
+            return new RateLimitError("Google AI rate limit exceeded. Please try again later.", this.providerName);
         }
-        throw new ProviderError(`Google AI error: ${message}`, this.providerName);
+        return new ProviderError(`Google AI error: ${message}`, this.providerName);
     }
     /**
      * Overrides the BaseProvider's image generation method to implement it for Google AI.

package/dist/providers/googleVertex.d.ts

@@ -130,7 +130,7 @@ export declare class GoogleVertexProvider extends BaseProvider {
      * Override generate to route Gemini 3 models with tools to native SDK
      */
     generate(optionsOrPrompt: TextGenerationOptions | string): Promise<EnhancedGenerateResult | null>;
-    protected handleProviderError(error: unknown): Error;
+    protected formatProviderError(error: unknown): Error;
     /**
      * Memory-safe cache management for model configurations
      * Implements LRU eviction to prevent memory leaks in long-running processes

package/dist/providers/googleVertex.js

@@ -10,7 +10,7 @@ import { BaseProvider } from "../core/baseProvider.js";
 import { DEFAULT_MAX_STEPS, GLOBAL_LOCATION_MODELS, } from "../core/constants.js";
 import { ModelConfigurationManager } from "../core/modelConfiguration.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
-import { AuthenticationError, ProviderError } from "../types/errors.js";
+import { AuthenticationError, NetworkError, ProviderError, RateLimitError, InvalidModelError, } from "../types/errors.js";
 import { ERROR_CODES, NeuroLinkError } from "../utils/errorHandling.js";
 import { FileDetector } from "../utils/fileDetector.js";
 import { logger } from "../utils/logger.js";
@@ -20,6 +20,16 @@ import { convertZodToJsonSchema, inlineJsonSchema, } from "../utils/schemaConver
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { buildNativeToolDeclarations, buildNativeConfig, computeMaxSteps as computeMaxStepsShared, collectStreamChunks, extractTextFromParts, executeNativeToolCalls, handleMaxStepsTermination, pushModelResponseToHistory, } from "./googleNativeGemini3.js";
 // Import proper types for multimodal message handling
+// Keep-alive note: Node.js native fetch and undici (used by createProxyFetch)
+// handle HTTP keep-alive internally. The fetchWithRetry wrapper in proxyFetch.ts
+// provides retry protection for transient ECONNRESET/ETIMEDOUT errors.
+//
+// Auth isolation note: @ai-sdk/google-vertex resolves auth tokens (via
+// generateAuthToken → google-auth-library) BEFORE applying the user AbortSignal
+// to the main API call. Auth token refresh uses gaxios internally, not our
+// custom fetch, so it is inherently isolated from user cancellation signals.
+// The image generation path (getImageGenerationAccessToken) has an additional
+// explicit 15s timeout per attempt for direct REST API calls.
 // Enhanced Anthropic support with direct imports
 // Using the dual provider architecture from Vercel AI SDK
 const hasAnthropicSupport = () => {
@@ -1315,29 +1325,44 @@ export class GoogleVertexProvider extends BaseProvider {
         // Fall back to BaseProvider implementation
         return super.generate(optionsOrPrompt);
     }
-    handleProviderError(error) {
+    formatProviderError(error) {
+        // Pass through AbortError as-is so callers can detect cancellation
         const errorRecord = error;
+        if (typeof errorRecord?.name === "string" &&
+            errorRecord.name === "AbortError") {
+            return error;
+        }
         if (typeof errorRecord?.name === "string" &&
             errorRecord.name === "TimeoutError") {
-            return new TimeoutError(`Google Vertex AI request timed out. Consider increasing timeout or using a lighter model.`, this.defaultTimeout);
+            return new NetworkError(`Google Vertex AI request timed out. Consider increasing timeout or using a lighter model.`, this.providerName);
         }
         const message = typeof errorRecord?.message === "string"
             ? errorRecord.message
             : "Unknown error occurred";
+        const code = typeof errorRecord?.code === "string" ? errorRecord.code : undefined;
+        if (code === "ECONNRESET" ||
+            code === "ENOTFOUND" ||
+            code === "ECONNREFUSED" ||
+            message.includes("ECONNRESET") ||
+            message.includes("ENOTFOUND") ||
+            message.includes("ECONNREFUSED") ||
+            message.includes("connect ETIMEDOUT")) {
+            return new NetworkError(`Google Vertex AI network error: ${message}`, this.providerName);
+        }
         if (message.includes("PERMISSION_DENIED")) {
-            return new Error(`❌ Google Vertex AI Permission Denied\n\nYour Google Cloud credentials don't have permission to access Vertex AI.\n\nRequired Steps:\n1. Ensure your service account has Vertex AI User role\n2. Check if Vertex AI API is enabled in your project\n3. Verify your project ID is correct\n4. Confirm your location/region has Vertex AI available`);
+            return new AuthenticationError(`❌ Google Vertex AI Permission Denied\n\nYour Google Cloud credentials don't have permission to access Vertex AI.\n\nRequired Steps:\n1. Ensure your service account has Vertex AI User role\n2. Check if Vertex AI API is enabled in your project\n3. Verify your project ID is correct\n4. Confirm your location/region has Vertex AI available`, this.providerName);
         }
         if (message.includes("NOT_FOUND")) {
             const modelSuggestions = this.getModelSuggestions(this.modelName);
-            return new Error(`❌ Google Vertex AI Model Not Found\n\n${message}\n\nModel '${this.modelName}' is not available.\n\nSuggested alternatives:\n${modelSuggestions}\n\nTroubleshooting:\n1. Check model name spelling and format\n2. Verify model is available in your region (${this.location})\n3. Ensure your project has access to the model\n4. For Claude models, enable Anthropic integration in Google Cloud Console`);
+            return new InvalidModelError(`❌ Google Vertex AI Model Not Found\n\n${message}\n\nModel '${this.modelName}' is not available.\n\nSuggested alternatives:\n${modelSuggestions}\n\nTroubleshooting:\n1. Check model name spelling and format\n2. Verify model is available in your region (${this.location})\n3. Ensure your project has access to the model\n4. For Claude models, enable Anthropic integration in Google Cloud Console`, this.providerName);
         }
         if (message.includes("QUOTA_EXCEEDED")) {
-            return new Error(`❌ Google Vertex AI Quota Exceeded\n\n${message}\n\nSolutions:\n1. Check your Vertex AI quotas in Google Cloud Console\n2. Request quota increase if needed\n3. Try a different model or reduce request frequency\n4. Consider using a different region`);
+            return new RateLimitError(`❌ Google Vertex AI Quota Exceeded\n\n${message}\n\nSolutions:\n1. Check your Vertex AI quotas in Google Cloud Console\n2. Request quota increase if needed\n3. Try a different model or reduce request frequency\n4. Consider using a different region`, this.providerName);
         }
         if (message.includes("INVALID_ARGUMENT")) {
-            return new Error(`❌ Google Vertex AI Invalid Request\n\n${message}\n\nCheck:\n1. Request parameters are within model limits\n2. Input text is properly formatted\n3. Temperature and other settings are valid\n4. Model supports your request type`);
+            return new ProviderError(`❌ Google Vertex AI Invalid Request\n\n${message}\n\nCheck:\n1. Request parameters are within model limits\n2. Input text is properly formatted\n3. Temperature and other settings are valid\n4. Model supports your request type`, this.providerName);
         }
-        return new Error(`❌ Google Vertex AI Provider Error\n\n${message}\n\nTroubleshooting:\n1. Check Google Cloud credentials and permissions\n2. Verify project ID and location settings\n3. Ensure Vertex AI API is enabled\n4. Check network connectivity`);
+        return new ProviderError(`❌ Google Vertex AI Provider Error\n\n${message}\n\nTroubleshooting:\n1. Check Google Cloud credentials and permissions\n2. Verify project ID and location settings\n3. Ensure Vertex AI API is enabled\n4. Check network connectivity`, this.providerName);
     }
     /**
      * Memory-safe cache management for model configurations
@@ -2048,20 +2073,52 @@ export class GoogleVertexProvider extends BaseProvider {
      * Obtain a Google Auth access token for Vertex AI REST API calls.
      */
     async getImageGenerationAccessToken() {
+        const maxRetries = 3;
+        const baseDelay = 500;
+        const authTimeoutMs = 15000;
         const { GoogleAuth } = await import("google-auth-library");
         // Priority: GOOGLE_APPLICATION_CREDENTIALS_NEUROLINK > GOOGLE_APPLICATION_CREDENTIALS
         const credentialsPath = process.env.GOOGLE_APPLICATION_CREDENTIALS_NEUROLINK ||
             process.env.GOOGLE_APPLICATION_CREDENTIALS;
-        const auth = new GoogleAuth({
-            ...(credentialsPath && { keyFilename: credentialsPath }),
-            scopes: ["https://www.googleapis.com/auth/cloud-platform"],
-        });
-        const client = await auth.getClient();
-        const accessToken = await client.getAccessToken();
-        if (!accessToken.token) {
-            throw new AuthenticationError("Failed to obtain access token from Google Auth", this.providerName);
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            // Enforce per-attempt timeout with AbortController
+            const controller = new AbortController();
+            const authTimer = setTimeout(() => {
+                controller.abort();
+                logger.warn(`[GoogleVertexProvider] Auth token refresh exceeded ${authTimeoutMs}ms timeout (attempt ${attempt}/${maxRetries})`);
+            }, authTimeoutMs);
+            try {
+                const auth = new GoogleAuth({
+                    ...(credentialsPath && { keyFilename: credentialsPath }),
+                    scopes: ["https://www.googleapis.com/auth/cloud-platform"],
+                });
+                const client = await auth.getClient();
+                const accessToken = await client.getAccessToken();
+                if (!accessToken.token) {
+                    throw new AuthenticationError("Failed to obtain access token from Google Auth", this.providerName);
+                }
+                return accessToken.token;
+            }
+            catch (error) {
+                const err = error;
+                const isRetryable = controller.signal.aborted ||
+                    err?.code === "ECONNRESET" ||
+                    err?.code === "ETIMEDOUT" ||
+                    err?.code === "ENOTFOUND" ||
+                    err?.message?.includes("socket hang up") ||
+                    err?.message?.includes("network socket disconnected");
+                if (!isRetryable || attempt === maxRetries) {
+                    throw error;
+                }
+                const delay = baseDelay * Math.pow(2, attempt - 1);
+                logger.warn(`[GoogleVertexProvider] Auth token transient error (${err?.code || err?.message}), retrying in ${delay}ms (attempt ${attempt}/${maxRetries})`);
+                await new Promise((r) => setTimeout(r, delay));
+            }
+            finally {
+                clearTimeout(authTimer);
+            }
         }
-        return accessToken.token;
+        throw new AuthenticationError("Failed to obtain access token after retries", this.providerName);
     }
     /**
      * Build request parts for image generation from prompt, PDFs, and images.

package/dist/providers/huggingFace.d.ts

@@ -68,7 +68,7 @@ export declare class HuggingFaceProvider extends BaseProvider {
     /**
      * Enhanced error handling with HuggingFace-specific guidance
      */
-    handleProviderError(error: unknown): Error;
+    formatProviderError(error: unknown): Error;
     getProviderName(): AIProviderName;
     getDefaultModel(): string;
     /**

package/dist/providers/huggingFace.js

@@ -265,7 +265,7 @@ Available tools will be provided in the function calling format. Use them when t
     /**
      * Enhanced error handling with HuggingFace-specific guidance
      */
-    handleProviderError(error) {
+    formatProviderError(error) {
         if (error instanceof TimeoutError) {
             return new Error(`HuggingFace request timed out: ${error.message}`);
         }

package/dist/providers/litellm.d.ts

@@ -19,7 +19,7 @@ export declare class LiteLLMProvider extends BaseProvider {
      * Returns the Vercel AI SDK model instance for LiteLLM
      */
     protected getAISDKModel(): LanguageModelV1;
-    handleProviderError(error: unknown): Error;
+    formatProviderError(error: unknown): Error;
     /**
      * LiteLLM supports tools for compatible models
      */