@juspay/neurolink 6.1.0 → 6.2.0

package/dist/lib/utils/timeout.js

@@ -134,5 +134,206 @@ export function createTimeoutPromise(timeout, provider, operation) {
         }
     });
 }
-// Re-export createTimeoutController from timeout-wrapper for convenience
-export { createTimeoutController } from "../providers/timeout-wrapper.js";
+/**
+ * Enhanced timeout manager with proper cleanup and abort controller integration
+ * Consolidated from timeout-manager.ts
+ */
+export class TimeoutManager {
+    activeTimeouts = new Map();
+    /**
+     * Execute operation with timeout and proper cleanup
+     */
+    async executeWithTimeout(operation, config) {
+        const startTime = Date.now();
+        const operationId = this.generateOperationId(config.operation);
+        let retriesUsed = 0;
+        const maxRetries = config.retryOnTimeout ? (config.maxRetries ?? 1) : 0;
+        while (retriesUsed <= maxRetries) {
+            try {
+                const result = await this.performSingleOperation(operation, config, operationId);
+                return {
+                    success: true,
+                    data: result,
+                    timedOut: false,
+                    executionTime: Date.now() - startTime,
+                    retriesUsed,
+                };
+            }
+            catch (error) {
+                this.cleanup(operationId);
+                if (error instanceof TimeoutError && retriesUsed < maxRetries) {
+                    retriesUsed++;
+                    continue;
+                }
+                return {
+                    success: false,
+                    error: error instanceof Error ? error : new Error(String(error)),
+                    timedOut: error instanceof TimeoutError,
+                    executionTime: Date.now() - startTime,
+                    retriesUsed,
+                };
+            }
+        }
+        return {
+            success: false,
+            error: new Error("Maximum retries exceeded"),
+            timedOut: true,
+            executionTime: Date.now() - startTime,
+            retriesUsed,
+        };
+    }
+    async performSingleOperation(operation, config, operationId) {
+        const timeoutMs = this.getTimeoutMs(config);
+        if (!timeoutMs) {
+            return await operation();
+        }
+        const controller = new AbortController();
+        const existingSignal = config.abortSignal;
+        if (existingSignal) {
+            existingSignal.addEventListener("abort", () => {
+                controller.abort(existingSignal.reason);
+            });
+            if (existingSignal.aborted) {
+                throw new Error("Operation aborted before execution");
+            }
+        }
+        const timeoutPromise = this.createTimeoutPromise(timeoutMs, operationId);
+        this.registerTimeout(operationId, timeoutPromise.timer, controller, () => {
+            clearTimeout(timeoutPromise.timer);
+        });
+        try {
+            return await Promise.race([operation(), timeoutPromise.promise]);
+        }
+        finally {
+            this.cleanup(operationId);
+        }
+    }
+    getTimeoutMs(config) {
+        return parseTimeout(config.timeout);
+    }
+    generateOperationId(operation) {
+        return `${operation}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+    createTimeoutPromise(timeoutMs, operationId) {
+        let timer;
+        const promise = new Promise((_, reject) => {
+            timer = setTimeout(() => {
+                reject(new TimeoutError(`Operation timeout after ${timeoutMs}ms`, timeoutMs));
+            }, timeoutMs);
+        });
+        return { promise, timer: timer };
+    }
+    registerTimeout(operationId, timer, controller, cleanup) {
+        this.activeTimeouts.set(operationId, { timer, controller, cleanup });
+    }
+    cleanup(operationId) {
+        const timeoutInfo = this.activeTimeouts.get(operationId);
+        if (timeoutInfo) {
+            timeoutInfo.cleanup();
+            this.activeTimeouts.delete(operationId);
+        }
+    }
+    gracefulShutdown() {
+        for (const [operationId] of this.activeTimeouts) {
+            this.cleanup(operationId);
+        }
+    }
+}
+/**
+ * Wrapper functions consolidated from timeout-wrapper.ts
+ */
+/**
+ * Wrap a promise with timeout
+ * @param promise - The promise to wrap
+ * @param timeout - Timeout duration (number in ms or string with unit)
+ * @param provider - Provider name for error messages
+ * @param operation - Operation type (generate or stream)
+ * @returns The result of the promise or throws TimeoutError
+ */
+export async function withTimeout(promise, timeout, provider, operation) {
+    const timeoutMs = parseTimeout(timeout);
+    if (!timeoutMs) {
+        return promise;
+    }
+    const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => {
+            reject(new TimeoutError(`${provider} ${operation} operation timed out after ${timeoutMs}ms`, timeoutMs, provider, operation));
+        }, timeoutMs);
+    });
+    return Promise.race([promise, timeoutPromise]);
+}
+/**
+ * Wrap a streaming async generator with timeout
+ * @param generator - The async generator to wrap
+ * @param timeout - Timeout duration for the entire stream
+ * @param provider - Provider name for error messages
+ * @returns Wrapped async generator that respects timeout
+ */
+export async function* withStreamingTimeout(generator, timeout, provider) {
+    const timeoutMs = parseTimeout(timeout);
+    if (!timeoutMs) {
+        yield* generator;
+        return;
+    }
+    let timeoutId;
+    const timeoutPromise = new Promise((_, reject) => {
+        timeoutId = setTimeout(() => {
+            reject(new TimeoutError(`${provider} streaming operation timed out after ${timeoutMs}ms`, timeoutMs, provider, "stream"));
+        }, timeoutMs);
+    });
+    try {
+        for await (const item of generator) {
+            const raceResult = await Promise.race([
+                Promise.resolve(item),
+                timeoutPromise,
+            ]);
+            yield raceResult;
+        }
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+/**
+ * Create an abort controller with timeout
+ * @param timeout - Timeout duration
+ * @param provider - Provider name for error messages
+ * @param operation - Operation type
+ * @returns AbortController and cleanup function
+ */
+export function createTimeoutController(timeout, provider, operation) {
+    const timeoutMs = parseTimeout(timeout);
+    if (!timeoutMs) {
+        return null;
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => {
+        controller.abort(new TimeoutError(`${provider} ${operation} operation timed out after ${timeout}`, timeoutMs, provider, operation));
+    }, timeoutMs);
+    const cleanup = () => {
+        clearTimeout(timer);
+    };
+    return { controller, cleanup, timeoutMs };
+}
+/**
+ * Merge abort signals (for combining user abort with timeout)
+ * @param signals - Array of abort signals to merge
+ * @returns Combined abort controller
+ */
+export function mergeAbortSignals(signals) {
+    const controller = new AbortController();
+    for (const signal of signals) {
+        if (signal && !signal.aborted) {
+            signal.addEventListener("abort", () => {
+                if (!controller.signal.aborted) {
+                    controller.abort(signal.reason);
+                }
+            });
+        }
+        if (signal?.aborted) {
+            controller.abort(signal.reason);
+            break;
+        }
+    }
+    return controller;
+}

package/dist/mcp/factory.d.ts

@@ -4,7 +4,7 @@
  * Compatible with Lighthouse MCP patterns for seamless migration
  */
 import { z } from "zod";
-import type { ExecutionContext } from "./contracts/mcp-contract.js";
+import type { ExecutionContext } from "./contracts/mcpContract.js";
 /**
  * MCP Server Categories for organization and discovery
  */

package/dist/mcp/index.d.ts

@@ -3,39 +3,27 @@
  * Universal AI Development Platform with Extensible Plugin Architecture
  * Implementation based on research blueprint
  */
-export { MCP } from "./contracts/mcp-contract.js";
-export type { MCPMetadata, ExecutionContext, MCPConstructor, MCPInstance, DiscoveredMCP, } from "./contracts/mcp-contract.js";
-export { MCPEcosystem, mcpEcosystem } from "./ecosystem.js";
-export { PluginManager, pluginManager } from "./plugin-manager.js";
-export { SecurityManager } from "./security-manager.js";
+export type { McpMetadata, ExecutionContext, DiscoveredMcp, ToolInfo, ToolExecutionResult, } from "./contracts/mcpContract.js";
 export { mcpLogger } from "./logging.js";
 export type { LogLevel } from "./logging.js";
-export { FileSystemMCP } from "./plugins/core/filesystem-mcp.js";
-import type { MCPMetadata } from "./contracts/mcp-contract.js";
+import type { McpMetadata } from "./contracts/mcpContract.js";
 /**
- * Initialize the MCP ecosystem
+ * Initialize the MCP ecosystem - simplified
  */
 export declare function initializeMCPEcosystem(): Promise<void>;
 /**
- * List available MCPs
+ * List available MCPs - simplified
  */
-export declare function listMCPs(): Promise<MCPMetadata[]>;
+export declare function listMCPs(): Promise<McpMetadata[]>;
 /**
- * Execute an MCP operation
+ * Execute an MCP operation - simplified
  */
 export declare function executeMCP<T = unknown>(name: string, config: unknown, args: unknown, context?: {
     sessionId?: string;
     userId?: string;
 }): Promise<T>;
 /**
- * Quick filesystem operations
- */
-export declare function readFile(path: string, basePath?: string): Promise<string | Buffer>;
-export declare function writeFile(path: string, content: string, basePath?: string): Promise<void>;
-export declare function listFiles(path: string, basePath?: string): Promise<string[]>;
-export declare function createDirectory(path: string, basePath?: string): Promise<void>;
-/**
- * Get MCP ecosystem statistics
+ * Get MCP ecosystem statistics - simplified
  */
 export declare function getMCPStats(): Promise<{
     initialized: boolean;

package/dist/mcp/index.js

@@ -3,76 +3,35 @@
  * Universal AI Development Platform with Extensible Plugin Architecture
  * Implementation based on research blueprint
  */
-// Core contracts and types
-export { MCP } from "./contracts/mcp-contract.js";
-// Main ecosystem interface
-export { MCPEcosystem, mcpEcosystem } from "./ecosystem.js";
-// Plugin management
-export { PluginManager, pluginManager } from "./plugin-manager.js";
-// Security
-export { SecurityManager } from "./security-manager.js";
-// Logging
+// Core functionality exports
 export { mcpLogger } from "./logging.js";
-// Core plugins
-export { FileSystemMCP } from "./plugins/core/filesystem-mcp.js";
 /**
- * Quick access functions for common MCP operations
- */
-// Import the ecosystem singleton
-import { mcpEcosystem } from "./ecosystem.js";
-/**
- * Initialize the MCP ecosystem
+ * Initialize the MCP ecosystem - simplified
  */
 export async function initializeMCPEcosystem() {
-    return mcpEcosystem.initialize();
+    // Simplified initialization - no complex ecosystem needed
+    return Promise.resolve();
 }
 /**
- * List available MCPs
+ * List available MCPs - simplified
  */
 export async function listMCPs() {
-    return mcpEcosystem.list();
+    return [];
 }
 /**
- * Execute an MCP operation
+ * Execute an MCP operation - simplified
  */
 export async function executeMCP(name, config, args, context) {
-    return mcpEcosystem.execute(name, config, args, context);
-}
-/**
- * Quick filesystem operations
- */
-export async function readFile(path, basePath) {
-    return mcpEcosystem.filesystem({
-        action: "readFile",
-        path,
-        basePath,
-    });
-}
-export async function writeFile(path, content, basePath) {
-    return mcpEcosystem.filesystem({
-        action: "writeFile",
-        path,
-        content,
-        basePath,
-    });
-}
-export async function listFiles(path, basePath) {
-    return mcpEcosystem.filesystem({
-        action: "listFiles",
-        path,
-        basePath,
-    });
-}
-export async function createDirectory(path, basePath) {
-    return mcpEcosystem.filesystem({
-        action: "createDir",
-        path,
-        basePath,
-    });
+    throw new Error("MCP execution not available - ecosystem removed");
 }
 /**
- * Get MCP ecosystem statistics
+ * Get MCP ecosystem statistics - simplified
  */
 export async function getMCPStats() {
-    return mcpEcosystem.getStats();
+    return {
+        initialized: false,
+        pluginsDiscovered: 0,
+        pluginsBySource: {},
+        availablePlugins: [],
+    };
 }

package/dist/neurolink.d.ts

@@ -40,7 +40,6 @@ export interface MCPServerInfo {
 }
 export declare class NeuroLink {
     private mcpInitialized;
-    private contextManager;
     private customTools;
     private inMemoryServers;
     constructor();
@@ -139,14 +138,7 @@ export declare class NeuroLink {
      * Get all available tools including custom and in-memory ones
      * @returns Array of available tools with metadata
      */
-    getAllAvailableTools(): Promise<{
-        serverId: string;
-        serverTitle: string;
-        toolName: string;
-        namespacedName: string;
-        description: string;
-        isImplemented: boolean;
-    }[]>;
+    getAllAvailableTools(): Promise<import("./mcp/tool-registry.js").ToolInfo[]>;
     /**
      * Get comprehensive status of all AI providers
      * Primary method for provider health checking and diagnostics

package/dist/neurolink.js

@@ -14,18 +14,15 @@ catch (error) {
     // Environment variables should be set externally in production
 }
 import { AIProviderFactory } from "./core/factory.js";
-import { ContextManager } from "./mcp/context-manager.js";
 import { mcpLogger } from "./mcp/logging.js";
 import { toolRegistry } from "./mcp/tool-registry.js";
-import { unifiedRegistry } from "./mcp/unified-registry.js";
 import { logger } from "./utils/logger.js";
-import { getBestProvider } from "./utils/providerUtils-fixed.js";
+import { getBestProvider } from "./utils/providerUtils.js";
 import { ProviderRegistry } from "./factories/provider-registry.js";
 import { validateTool, createMCPServerFromTools, } from "./sdk/tool-registration.js";
 // Core types imported from core/types.js
 export class NeuroLink {
     mcpInitialized = false;
-    contextManager;
     // Tool registration support
     customTools = new Map();
     inMemoryServers = new Map();
@@ -34,7 +31,6 @@ export class NeuroLink {
         ProviderRegistry.setOptions({
             enableManualMCP: false,
         });
-        this.contextManager = new ContextManager();
     }
     /**
      * Initialize MCP registry with enhanced error handling and resource cleanup
@@ -223,12 +219,7 @@ export class NeuroLink {
             if (!this.mcpInitialized) {
                 return null; // Skip MCP if not available
             }
-            // Create execution context
-            const context = this.contextManager.createContext({
-                sessionId: `neurolink-${Date.now()}`,
-                userId: "neurolink-user",
-                aiProvider: options.provider || "auto",
-            });
+            // Context creation removed - was never used
             // Determine provider
             const providerName = options.provider === "auto" || !options.provider
                 ? await getBestProvider()
@@ -402,12 +393,7 @@ export class NeuroLink {
         }
         // Initialize MCP if needed
         await this.initializeMCP();
-        // Create execution context for tool operations
-        const context = this.contextManager.createContext({
-            sessionId: `neurolink-stream-${Date.now()}`,
-            userId: "neurolink-user",
-            aiProvider: options.provider || "auto",
-        });
+        // Context creation removed - was never used
         // Determine provider to use
         const providerName = options.provider === "auto" || !options.provider
             ? await getBestProvider()
@@ -416,7 +402,6 @@ export class NeuroLink {
             mcpLogger.debug(`[${functionTag}] Starting MCP-enabled streaming`, {
                 provider: providerName,
                 prompt: (options.input.text?.substring(0, 100) || "No text") + "...",
-                contextId: context.sessionId,
             });
             // Create provider using the same factory pattern as generate
             const provider = await AIProviderFactory.createBestProvider(providerName, options.model, true, this);
@@ -632,19 +617,14 @@ export class NeuroLink {
             }
             // If not found in custom tools or in-memory servers, try unified registry
             try {
-                // Ensure built-in tools are initialized
-                const { initializeNeuroLinkMCP, isNeuroLinkMCPInitialized } = await import("./mcp/initialize.js");
-                if (!isNeuroLinkMCPInitialized()) {
-                    mcpLogger.debug(`[${functionTag}] Initializing built-in MCP servers`);
-                    await initializeNeuroLinkMCP();
-                }
+                // Built-in tools initialization simplified
+                mcpLogger.debug(`[${functionTag}] MCP initialization simplified`);
                 // Create minimal execution context for external tools
-                const context = this.contextManager.createContext({
+                const context = {
                     sessionId: `neurolink-tool-${Date.now()}`,
                     userId: "neurolink-user",
-                    aiProvider: "auto",
-                });
-                const result = (await unifiedRegistry.executeTool(toolName, params, context));
+                };
+                const result = (await toolRegistry.executeTool(toolName, params, context));
                 return result;
             }
             catch (error) {
@@ -669,8 +649,9 @@ export class NeuroLink {
      * @returns Array of available tools with metadata
      */
     async getAllAvailableTools() {
-        const { getAllAvailableTools } = await import("./mcp/initialize-tools.js");
-        return getAllAvailableTools(this.inMemoryServers);
+        // Simplified tool listing - removed initialize-tools dependency
+        const tools = await toolRegistry.listTools();
+        return tools;
     }
     // ============================================================================
     // PROVIDER DIAGNOSTICS - SDK-First Architecture
@@ -857,25 +838,16 @@ export class NeuroLink {
      * @returns Promise resolving to MCP status details
      */
     async getMCPStatus() {
-        const { unifiedRegistry } = await import("./mcp/unified-registry.js");
         try {
-            const totalServers = unifiedRegistry.getTotalServerCount();
-            const availableServers = unifiedRegistry.getAvailableServerCount();
-            const autoDiscoveredServers = unifiedRegistry.getAutoDiscoveredServers();
-            const allTools = await unifiedRegistry.listAllTools();
+            // Simplified MCP status - unified registry removed
+            const allTools = await toolRegistry.listTools();
             return {
                 mcpInitialized: this.mcpInitialized,
-                totalServers,
-                availableServers,
-                autoDiscoveredCount: autoDiscoveredServers.length,
+                totalServers: 1, // Only tool registry now
+                availableServers: 1,
+                autoDiscoveredCount: 0, // No auto-discovery
                 totalTools: allTools.length,
-                autoDiscoveredServers: autoDiscoveredServers.map((server) => ({
-                    id: server.metadata.name,
-                    name: server.metadata.name,
-                    source: server.source,
-                    status: "discovered",
-                    hasServer: true,
-                })),
+                autoDiscoveredServers: [], // No auto-discovery
                 customToolsCount: this.customTools.size,
                 inMemoryServersCount: this.inMemoryServers.size,
             };
@@ -899,24 +871,8 @@ export class NeuroLink {
      * @returns Promise resolving to array of MCP server information
      */
     async listMCPServers() {
-        const { unifiedRegistry } = await import("./mcp/unified-registry.js");
-        try {
-            const servers = unifiedRegistry.getAutoDiscoveredServers();
-            return servers.map((server) => ({
-                id: server.metadata.name,
-                name: server.metadata.name,
-                source: server.source,
-                status: unifiedRegistry.isConnected(server.metadata.name)
-                    ? "connected"
-                    : "discovered",
-                hasServer: true,
-                metadata: server.metadata,
-            }));
-        }
-        catch (error) {
-            logger.warn("Failed to list MCP servers", { error });
-            return [];
-        }
+        // Simplified MCP servers listing - unified registry removed
+        return [];
     }
     /**
      * Test connectivity to a specific MCP server
@@ -924,13 +880,8 @@ export class NeuroLink {
      * @returns Promise resolving to true if server is reachable
      */
     async testMCPServer(serverId) {
-        const { unifiedRegistry } = await import("./mcp/unified-registry.js");
-        try {
-            return unifiedRegistry.isConnected(serverId);
-        }
-        catch {
-            return false;
-        }
+        // Simplified MCP server testing - unified registry removed
+        return false; // No auto-discovery servers available
     }
 }
 // Create default instance

package/dist/providers/amazon-bedrock.js

@@ -4,32 +4,21 @@ import { BaseProvider } from "../core/base-provider.js";
 import { logger } from "../utils/logger.js";
 import { createTimeoutController, TimeoutError, getDefaultTimeout, } from "../utils/timeout.js";
 import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
+import { validateApiKey, createAWSAccessKeyConfig, createAWSSecretConfig, getAWSRegion, getAWSSessionToken, } from "../utils/providerConfig.js";
 // Configuration helpers
 const getBedrockModelId = () => {
     return (process.env.BEDROCK_MODEL ||
         process.env.BEDROCK_MODEL_ID ||
         "arn:aws:bedrock:us-east-2:225681119357:inference-profile/us.anthropic.claude-3-7-sonnet-20250219-v1:0");
 };
+// Configuration helpers - now using consolidated utility
 const getAWSAccessKeyId = () => {
-    const accessKeyId = process.env.AWS_ACCESS_KEY_ID;
-    if (!accessKeyId) {
-        throw new Error(`❌ AWS Bedrock Provider Configuration Error\n\nMissing required environment variables: AWS_ACCESS_KEY_ID\n\n🔧 Step 1: Get AWS Credentials\n1. Visit: https://console.aws.amazon.com/iam/\n2. Create IAM user with Bedrock permissions\n3. Generate access key\n\n🔧 Step 2: Set Environment Variables\nAdd to your .env file:\nAWS_ACCESS_KEY_ID=your_access_key_here\nAWS_SECRET_ACCESS_KEY=your_secret_key_here\nAWS_REGION=us-east-1\n\n🔧 Step 3: Restart Application\nRestart your application to load the new environment variables.`);
-    }
-    return accessKeyId;
+    return validateApiKey(createAWSAccessKeyConfig());
 };
 const getAWSSecretAccessKey = () => {
-    const secretAccessKey = process.env.AWS_SECRET_ACCESS_KEY;
-    if (!secretAccessKey) {
-        throw new Error(`❌ AWS Bedrock Provider Configuration Error\n\nMissing required environment variables: AWS_SECRET_ACCESS_KEY\n\n🔧 Step 1: Get AWS Credentials\n1. Visit: https://console.aws.amazon.com/iam/\n2. Create IAM user with Bedrock permissions\n3. Generate access key\n\n🔧 Step 2: Set Environment Variables\nAdd to your .env file:\nAWS_ACCESS_KEY_ID=your_access_key_here\nAWS_SECRET_ACCESS_KEY=your_secret_key_here\nAWS_REGION=us-east-1\n\n🔧 Step 3: Restart Application\nRestart your application to load the new environment variables.`);
-    }
-    return secretAccessKey;
-};
-const getAWSRegion = () => {
-    return process.env.AWS_REGION || "us-east-1";
-};
-const getAWSSessionToken = () => {
-    return process.env.AWS_SESSION_TOKEN;
+    return validateApiKey(createAWSSecretConfig());
 };
+// Note: getAWSRegion and getAWSSessionToken are now directly imported from consolidated utility
 const getAppEnvironment = () => {
     return process.env.PUBLIC_APP_ENVIRONMENT || "production";
 };

package/dist/providers/anthropic-baseprovider.js

@@ -4,6 +4,7 @@ import { BaseProvider } from "../core/base-provider.js";
 import { logger } from "../utils/logger.js";
 import { createTimeoutController, TimeoutError, getDefaultTimeout, } from "../utils/timeout.js";
 import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
+import { validateApiKey, createAnthropicBaseConfig, } from "../utils/providerConfig.js";
 /**
  * Anthropic provider implementation using BaseProvider pattern
  * Migrated from direct API calls to Vercel AI SDK (@ai-sdk/anthropic)
@@ -50,28 +51,9 @@ export class AnthropicProviderV2 extends BaseProvider {
         }
         return new Error(`Anthropic error: ${errorWithStatus?.message || String(error) || "Unknown error"}`);
     }
+    // Configuration helper - now using consolidated utility
     getApiKey() {
-        const apiKey = process.env.ANTHROPIC_API_KEY;
-        if (!apiKey) {
-            throw new Error(`❌ ANTHROPIC Provider Configuration Error
-
-Missing required environment variables: ANTHROPIC_API_KEY
-
-🔧 Step 1: Get Credentials
-Get your API key from https://console.anthropic.com/
-
-💡 Step 2: Add to your .env file (or export in CLI):
-ANTHROPIC_API_KEY="sk-ant-your-anthropic-api-key"
-# Optional:
-ANTHROPIC_MODEL="claude-3-5-sonnet-20241022"
-ANTHROPIC_BASE_URL="https://api.anthropic.com"
-
-🚀 Step 3: Test the setup:
-npx neurolink generate "Hello" --provider anthropic
-
-📖 More info: https://docs.neurolink.dev/providers/anthropic`);
-        }
-        return apiKey;
+        return validateApiKey(createAnthropicBaseConfig());
     }
     // executeGenerate removed - BaseProvider handles all generation with tools
     async executeStream(options, analysisSchema) {

package/dist/providers/anthropic.js

@@ -4,16 +4,13 @@ import { BaseProvider } from "../core/base-provider.js";
 import { logger } from "../utils/logger.js";
 import { createTimeoutController, TimeoutError, getDefaultTimeout, } from "../utils/timeout.js";
 import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
-// Configuration helpers
+import { validateApiKey, createAnthropicConfig, getProviderModel, } from "../utils/providerConfig.js";
+// Configuration helpers - now using consolidated utility
 const getAnthropicApiKey = () => {
-    const apiKey = process.env.ANTHROPIC_API_KEY;
-    if (!apiKey) {
-        throw new Error(`❌ Anthropic Provider Configuration Error\n\nMissing required environment variable: ANTHROPIC_API_KEY\n\n🔧 Step 1: Get Anthropic API Key\n1. Visit: https://console.anthropic.com/\n2. Sign in or create an account\n3. Go to API Keys section\n4. Create a new API key\n\n🔧 Step 2: Set Environment Variable\nAdd to your .env file:\nANTHROPIC_API_KEY=your_api_key_here\n\n🔧 Step 3: Restart Application\nRestart your application to load the new environment variables.`);
-    }
-    return apiKey;
+    return validateApiKey(createAnthropicConfig());
 };
 const getDefaultAnthropicModel = () => {
-    return process.env.ANTHROPIC_MODEL || "claude-3-5-sonnet-20241022";
+    return getProviderModel("ANTHROPIC_MODEL", "claude-3-5-sonnet-20241022");
 };
 /**
  * Anthropic Provider v2 - BaseProvider Implementation