@juspay/neurolink 5.1.0 → 5.3.0

package/dist/lib/providers/anthropic.js

@@ -1,335 +1,111 @@
-/**
- * Anthropic AI Provider (Direct API)
- *
- * Direct integration with Anthropic's Claude models via their native API.
- * Supports Claude 3.5 Sonnet, Claude 3.5 Haiku, and Claude 3 Opus.
- */
-import { AIProviderName } from "../core/types.js";
+import { anthropic } from "@ai-sdk/anthropic";
+import { streamText } from "ai";
+import { BaseProvider } from "../core/base-provider.js";
 import { logger } from "../utils/logger.js";
-import { createTimeoutController, TimeoutError, getDefaultTimeout, } from "../utils/timeout.js";
+import { createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
-import { evaluateResponse } from "../core/evaluation.js";
-import { createAnalytics } from "../core/analytics.js";
-import { createProxyFetch } from "../proxy/proxy-fetch.js";
-export class AnthropicProvider {
-    name = AIProviderName.ANTHROPIC;
-    apiKey;
-    baseURL;
-    defaultModel;
-    constructor() {
-        this.apiKey = this.getApiKey();
-        this.baseURL =
-            process.env.ANTHROPIC_BASE_URL || "https://api.anthropic.com";
-        this.defaultModel =
-            process.env.ANTHROPIC_MODEL || "claude-3-5-sonnet-20241022";
-        logger.debug(`[AnthropicProvider] Initialized with model: ${this.defaultModel}`);
+// Configuration helpers
+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;
+};
+const getDefaultAnthropicModel = () => {
+    return process.env.ANTHROPIC_MODEL || "claude-3-5-sonnet-20241022";
+};
+/**
+ * Anthropic Provider v2 - BaseProvider Implementation
+ * Fixed syntax and enhanced with proper error handling
+ */
+export class AnthropicProvider extends BaseProvider {
+    model;
+    constructor(modelName, sdk) {
+        super(modelName, "anthropic", sdk);
+        // Initialize Anthropic model with API key validation
+        const apiKey = getAnthropicApiKey();
+        this.model = anthropic(this.modelName || getDefaultAnthropicModel());
+        logger.debug("Anthropic Provider v2 initialized", {
+            modelName: this.modelName,
+            provider: this.providerName,
+        });
     }
-    getApiKey() {
-        const apiKey = process.env.ANTHROPIC_API_KEY;
-        if (!apiKey) {
-            throw new Error("ANTHROPIC_API_KEY environment variable is required");
-        }
-        return apiKey;
+    getProviderName() {
+        return "anthropic";
     }
-    getModel() {
-        return this.defaultModel;
-    }
-    async makeRequest(endpoint, body, stream = false, signal) {
-        const url = `${this.baseURL}/v1/${endpoint}`;
-        const headers = {
-            "Content-Type": "application/json",
-            "x-api-key": this.apiKey,
-            "anthropic-version": "2023-06-01",
-            "anthropic-dangerous-direct-browser-access": "true", // Required for browser usage
-        };
-        logger.debug(`[AnthropicProvider.makeRequest] ${stream ? "Streaming" : "Non-streaming"} request to ${url}`);
-        logger.debug(`[AnthropicProvider.makeRequest] Model: ${body.model}, Max tokens: ${body.max_tokens}`);
-        const proxyFetch = createProxyFetch();
-        const response = await proxyFetch(url, {
-            method: "POST",
-            headers,
-            body: JSON.stringify(body),
-            signal, // Add abort signal for timeout support
-        });
-        if (!response.ok) {
-            const errorText = await response.text();
-            logger.error(`[AnthropicProvider.makeRequest] API error ${response.status}: ${errorText}`);
-            throw new Error(`Anthropic API error ${response.status}: ${errorText}`);
-        }
-        return response;
+    getDefaultModel() {
+        return getDefaultAnthropicModel();
     }
     /**
-     * PRIMARY METHOD: Stream content using AI (recommended for new code)
-     * Future-ready for multi-modal capabilities with current text focus
+     * Returns the Vercel AI SDK model instance for Anthropic
      */
-    async stream(optionsOrPrompt, analysisSchema) {
-        const functionTag = "AnthropicProvider.stream";
-        const provider = "anthropic";
-        const startTime = Date.now();
-        logger.debug(`[${functionTag}] Starting content streaming`);
-        // Parse parameters - support both string and options object
-        const options = typeof optionsOrPrompt === "string"
-            ? { input: { text: optionsOrPrompt } }
-            : optionsOrPrompt;
-        // Validate input
-        if (!options?.input?.text ||
-            typeof options.input.text !== "string" ||
-            options.input.text.trim() === "") {
-            throw new Error("Stream options must include input.text as a non-empty string");
+    getAISDKModel() {
+        return this.model;
+    }
+    handleProviderError(error) {
+        if (error instanceof TimeoutError) {
+            return new Error(`Anthropic request timed out: ${error.message}`);
         }
-        // Extract parameters
-        const { prompt = options.input.text, temperature = 0.7, maxTokens = DEFAULT_MAX_TOKENS, systemPrompt = "You are Claude, an AI assistant created by Anthropic. You are helpful, harmless, and honest.", timeout = getDefaultTimeout(provider, "stream"), } = options;
-        logger.debug(`[${functionTag}] Streaming prompt: "${prompt.substring(0, 100)}...", Timeout: ${timeout}`);
-        // Create timeout controller if timeout is specified
-        const timeoutController = createTimeoutController(timeout, provider, "stream");
-        try {
-            const body = {
-                model: this.getModel(),
-                max_tokens: maxTokens,
-                messages: [
-                    ...(systemPrompt
-                        ? [{ role: "assistant", content: systemPrompt }]
-                        : []),
-                    { role: "user", content: prompt },
-                ],
-                temperature,
-                stream: true,
-            };
-            const response = await this.makeRequest("messages", body, true, timeoutController?.controller.signal);
-            const streamIterable = this.createAsyncIterable(response.body, timeoutController?.controller.signal);
-            // Clean up timeout controller
-            timeoutController?.cleanup();
-            logger.debug(`[${functionTag}] Stream initialized successfully`);
-            // Convert to StreamResult format
-            return {
-                stream: (async function* () {
-                    for await (const chunk of streamIterable) {
-                        yield { content: chunk };
-                    }
-                })(),
-                provider: "anthropic",
-                model: this.getModel(),
-                metadata: {
-                    streamId: `anthropic-${Date.now()}`,
-                    startTime,
-                },
-            };
+        if (error?.message?.includes("API_KEY_INVALID") ||
+            error?.message?.includes("Invalid API key")) {
+            return new Error("Invalid Anthropic API key. Please check your ANTHROPIC_API_KEY environment variable.");
         }
-        catch (error) {
-            // Always cleanup timeout on error
-            timeoutController?.cleanup();
-            if (error.name === "AbortError" || error.message.includes("timeout")) {
-                const timeoutError = new TimeoutError(`${provider} stream operation timed out after ${timeout}`, timeoutController?.timeoutMs || 0, provider, "stream");
-                logger.error(`[${functionTag}] Timeout error`, {
-                    provider,
-                    timeout: timeoutController?.timeoutMs,
-                    message: timeoutError.message,
-                });
-                throw timeoutError;
-            }
-            else {
-                logger.error(`[${functionTag}] Error:`, error);
-            }
-            throw error;
+        if (error?.message?.includes("rate limit")) {
+            return new Error("Anthropic rate limit exceeded. Please try again later.");
         }
-    }
-    async generate(optionsOrPrompt, schema) {
-        const functionTag = "AnthropicProvider.generate";
-        const provider = "anthropic";
-        const startTime = Date.now();
-        logger.debug(`[${functionTag}] Starting text generation`);
-        // Parse parameters with backward compatibility
-        const options = typeof optionsOrPrompt === "string"
-            ? { prompt: optionsOrPrompt }
-            : optionsOrPrompt;
-        const { prompt, temperature = 0.7, maxTokens = DEFAULT_MAX_TOKENS, systemPrompt = "You are Claude, an AI assistant created by Anthropic. You are helpful, harmless, and honest.", timeout = getDefaultTimeout(provider, "generate"), enableAnalytics = false, enableEvaluation = false, context, } = options;
-        logger.debug(`[${functionTag}] Prompt: "${prompt.substring(0, 100)}...", Temperature: ${temperature}, Max tokens: ${maxTokens}, Timeout: ${timeout}`);
-        const requestBody = {
-            model: this.getModel(),
-            max_tokens: maxTokens,
-            messages: [
-                {
-                    role: "user",
-                    content: prompt,
-                },
-            ],
-            temperature,
-            system: systemPrompt,
+        return new Error(`Anthropic error: ${error?.message || "Unknown error"}`);
+    }
+    // executeGenerate removed - BaseProvider handles all generation with tools
+    async executeStream(options, analysisSchema) {
+        // Convert StreamOptions to TextGenerationOptions for validation
+        const validationOptions = {
+            prompt: options.input.text,
+            systemPrompt: options.systemPrompt,
+            temperature: options.temperature,
+            maxTokens: options.maxTokens,
         };
-        // Create timeout controller if timeout is specified
-        const timeoutController = createTimeoutController(timeout, provider, "generate");
+        this.validateOptions(validationOptions);
+        const timeout = this.getTimeout(options);
+        const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
         try {
-            const response = await this.makeRequest("messages", requestBody, false, timeoutController?.controller.signal);
-            const data = await response.json();
-            // Clean up timeout if successful
-            timeoutController?.cleanup();
-            logger.debug(`[${functionTag}] Success. Generated ${data.usage.output_tokens} tokens`);
-            const content = data.content.map((block) => block.text).join("");
-            const result = {
-                content,
-                provider: this.name,
-                model: data.model,
-                usage: {
-                    promptTokens: data.usage.input_tokens,
-                    completionTokens: data.usage.output_tokens,
-                    totalTokens: data.usage.input_tokens + data.usage.output_tokens,
-                },
-                finishReason: data.stop_reason,
-            };
-            // Add analytics if enabled
-            if (options.enableAnalytics) {
-                result.analytics = createAnalytics(provider, this.defaultModel, result, Date.now() - startTime, options.context);
-            }
-            // Add evaluation if enabled
-            if (options.enableEvaluation) {
-                result.evaluation = await evaluateResponse(prompt, result.content, options.context);
-            }
-            return result;
-        }
-        catch (error) {
-            // Always cleanup timeout
+            const result = await streamText({
+                model: this.model,
+                prompt: options.input.text,
+                system: options.systemPrompt || undefined,
+                temperature: options.temperature,
+                maxTokens: options.maxTokens || DEFAULT_MAX_TOKENS,
+                abortSignal: timeoutController?.controller.signal,
+            });
             timeoutController?.cleanup();
-            // Log timeout errors specifically
-            if (error instanceof TimeoutError) {
-                logger.error(`[${functionTag}] Timeout error`, {
-                    provider,
-                    timeout: error.timeout,
-                    message: error.message,
-                });
-            }
-            else if (error?.name === "AbortError") {
-                // Convert AbortError to TimeoutError
-                const timeoutError = new TimeoutError(`${provider} generate operation timed out after ${timeout}`, timeoutController?.timeoutMs || 0, provider, "generate");
-                logger.error(`[${functionTag}] Timeout error`, {
-                    provider,
-                    timeout: timeoutController?.timeoutMs,
-                    message: timeoutError.message,
-                });
-                throw timeoutError;
-            }
-            else {
-                logger.error(`[${functionTag}] Error:`, error);
-            }
-            throw error;
-        }
-    }
-    /**
-     * LEGACY METHOD: Use stream() instead for new code
-     * @deprecated Use stream() method instead
-     */
-    async *createAsyncIterable(body, signal) {
-        const reader = body.getReader();
-        const decoder = new TextDecoder();
-        let buffer = "";
-        try {
-            while (true) {
-                // Check if aborted
-                if (signal?.aborted) {
-                    throw new Error("AbortError");
-                }
-                const { done, value } = await reader.read();
-                if (done) {
-                    break;
-                }
-                buffer += decoder.decode(value, { stream: true });
-                const lines = buffer.split("\n");
-                buffer = lines.pop() || "";
-                for (const line of lines) {
-                    if (line.trim() === "") {
-                        continue;
-                    }
-                    if (line.startsWith("data: ")) {
-                        const data = line.slice(6);
-                        if (data.trim() === "[DONE]") {
-                            continue;
-                        }
-                        try {
-                            const chunk = JSON.parse(data);
-                            // Extract text content from different chunk types
-                            if (chunk.type === "content_block_delta" && chunk.delta?.text) {
-                                yield chunk.delta.text;
-                            }
-                        }
-                        catch (parseError) {
-                            logger.warn("[AnthropicProvider.createAsyncIterable] Failed to parse chunk:", parseError);
-                            continue;
-                        }
-                    }
+            // Transform string stream to content object stream
+            const transformedStream = async function* () {
+                for await (const chunk of result.textStream) {
+                    yield { content: chunk };
                 }
-            }
-        }
-        finally {
-            reader.releaseLock();
-        }
-    }
-    async testConnection() {
-        logger.debug("[AnthropicProvider.testConnection] Testing connection to Anthropic API");
-        const startTime = Date.now();
-        try {
-            await this.generate({
-                prompt: "Hello",
-                maxTokens: 5,
-            });
-            const responseTime = Date.now() - startTime;
-            logger.debug(`[AnthropicProvider.testConnection] Connection test successful (${responseTime}ms)`);
+            };
             return {
-                success: true,
-                responseTime,
+                stream: transformedStream(),
+                provider: this.providerName,
+                model: this.modelName,
             };
         }
         catch (error) {
-            const responseTime = Date.now() - startTime;
-            logger.error(`[AnthropicProvider.testConnection] Connection test failed (${responseTime}ms):`, error);
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : "Unknown error",
-                responseTime,
-            };
+            timeoutController?.cleanup();
+            throw this.handleProviderError(error);
         }
     }
-    isConfigured() {
+    async isAvailable() {
         try {
-            this.getApiKey();
+            getAnthropicApiKey();
             return true;
         }
         catch {
             return false;
         }
     }
-    getRequiredConfig() {
-        return ["ANTHROPIC_API_KEY"];
-    }
-    getOptionalConfig() {
-        return ["ANTHROPIC_MODEL", "ANTHROPIC_BASE_URL"];
-    }
-    getModels() {
-        return [
-            "claude-3-5-sonnet-20241022",
-            "claude-3-5-haiku-20241022",
-            "claude-3-opus-20240229",
-            "claude-3-sonnet-20240229",
-            "claude-3-haiku-20240307",
-        ];
-    }
-    supportsStreaming() {
-        return true;
-    }
-    supportsSchema() {
-        return false; // Anthropic doesn't have native JSON schema support like OpenAI
-    }
-    getCapabilities() {
-        return [
-            "text-generation",
-            "streaming",
-            "conversation",
-            "system-prompts",
-            "long-context", // Claude models support up to 200k tokens
-        ];
-    }
-    /**
-     * Short alias for generate() - CLI-SDK consistency
-     */
-    async gen(optionsOrPrompt, analysisSchema) {
-        return this.generate(optionsOrPrompt, analysisSchema);
+    getModel() {
+        return this.model;
     }
 }
+export default AnthropicProvider;

package/dist/lib/providers/azure-openai.d.ts

@@ -0,0 +1,20 @@
+import { BaseProvider } from "../core/base-provider.js";
+import type { AIProviderName } from "../core/types.js";
+import type { StreamOptions, StreamResult } from "../types/stream-types.js";
+export declare class AzureOpenAIProvider extends BaseProvider {
+    private apiKey;
+    private resourceName;
+    private deployment;
+    private apiVersion;
+    private azureProvider;
+    constructor(modelName?: string);
+    protected getProviderName(): AIProviderName;
+    protected getDefaultModel(): string;
+    /**
+     * Returns the Vercel AI SDK model instance for Azure OpenAI
+     */
+    protected getAISDKModel(): any;
+    protected handleProviderError(error: any): Error;
+    protected executeStream(options: StreamOptions, analysisSchema?: any): Promise<StreamResult>;
+}
+export default AzureOpenAIProvider;

package/dist/lib/providers/azure-openai.js

@@ -0,0 +1,89 @@
+import { createAzure } from "@ai-sdk/azure";
+import { streamText } from "ai";
+import { BaseProvider } from "../core/base-provider.js";
+export class AzureOpenAIProvider extends BaseProvider {
+    apiKey;
+    resourceName;
+    deployment;
+    apiVersion;
+    azureProvider;
+    constructor(modelName) {
+        super(modelName, "azure");
+        this.apiKey = process.env.AZURE_OPENAI_API_KEY || "";
+        const endpoint = process.env.AZURE_OPENAI_ENDPOINT || "";
+        this.resourceName = endpoint
+            .replace("https://", "")
+            .replace(/\/+$/, "") // Remove trailing slashes
+            .replace(".openai.azure.com", "");
+        this.deployment =
+            modelName ||
+                process.env.AZURE_OPENAI_DEPLOYMENT ||
+                process.env.AZURE_OPENAI_DEPLOYMENT_ID ||
+                "gpt-4o";
+        this.apiVersion = process.env.AZURE_API_VERSION || "2024-10-01-preview";
+        if (!this.apiKey) {
+            throw new Error("AZURE_OPENAI_API_KEY environment variable is required");
+        }
+        if (!this.resourceName) {
+            throw new Error("AZURE_OPENAI_ENDPOINT environment variable is required");
+        }
+        // Create the Azure provider instance
+        this.azureProvider = createAzure({
+            resourceName: this.resourceName,
+            apiKey: this.apiKey,
+            apiVersion: this.apiVersion,
+        });
+        console.log("Azure Vercel Provider initialized", {
+            deployment: this.deployment,
+            resourceName: this.resourceName,
+            provider: "azure-vercel",
+        });
+    }
+    getProviderName() {
+        return "azure";
+    }
+    getDefaultModel() {
+        return this.deployment;
+    }
+    /**
+     * Returns the Vercel AI SDK model instance for Azure OpenAI
+     */
+    getAISDKModel() {
+        return this.azureProvider(this.deployment);
+    }
+    handleProviderError(error) {
+        if (error?.message?.includes("401")) {
+            return new Error("Invalid Azure OpenAI API key or endpoint.");
+        }
+        return new Error(`Azure OpenAI error: ${error?.message || "Unknown error"}`);
+    }
+    // executeGenerate removed - BaseProvider handles all generation with tools
+    async executeStream(options, analysisSchema) {
+        try {
+            const stream = await streamText({
+                model: this.azureProvider(this.deployment),
+                prompt: options.input?.text || "",
+                maxTokens: options.maxTokens || 1000,
+                temperature: options.temperature || 0.7,
+                system: options.systemPrompt,
+            });
+            return {
+                stream: (async function* () {
+                    for await (const chunk of stream.textStream) {
+                        yield { content: chunk };
+                    }
+                })(),
+                provider: "azure",
+                model: this.deployment,
+                metadata: {
+                    streamId: `azure-${Date.now()}`,
+                    startTime: Date.now(),
+                },
+            };
+        }
+        catch (error) {
+            throw this.handleProviderError(error);
+        }
+    }
+}
+export default AzureOpenAIProvider;

package/dist/lib/providers/function-calling-provider.d.ts

@@ -16,10 +16,15 @@ export declare class FunctionCallingProvider implements AIProvider {
     private enableFunctionCalling;
     private sessionId;
     private userId;
+    private cachedToolsObject;
+    private cachedToolMap;
+    private cacheTimestamp;
+    private readonly cacheExpiryMs;
     constructor(baseProvider: AIProvider, options?: {
         enableFunctionCalling?: boolean;
         sessionId?: string;
         userId?: string;
+        cacheExpiryMs?: number;
     });
     /**
      * PRIMARY METHOD: Stream content using AI (recommended for new code)
@@ -31,7 +36,11 @@ export declare class FunctionCallingProvider implements AIProvider {
      */
     generate(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<GenerateResult>;
     /**
-     * Generate text using AI SDK's native function calling
+     * Generate text with tools using the AI SDK's generate function (with tools object)
+     */
+    private generateWithToolsObject;
+    /**
+     * Generate text using AI SDK's native function calling (legacy array-based)
      */
     private generateWithTools;
     /**
@@ -44,7 +53,11 @@ export declare class FunctionCallingProvider implements AIProvider {
      */
     private sanitizeToolName;
     /**
-     * Convert our tools to AI SDK format with proper execution
+     * Wrap tools with proper execution context (for object-based tools)
+     */
+    private wrapToolsWithExecution;
+    /**
+     * Convert our tools to AI SDK format with proper execution (legacy array-based)
      */
     private convertToAISDKTools;
     /**
@@ -54,6 +67,53 @@ export declare class FunctionCallingProvider implements AIProvider {
     /**
      * Alias for generate() - CLI-SDK consistency
      */
+    /**
+     * Clear cached tools - Cache Invalidation Strategy
+     *
+     * WHEN TO CALL clearToolsCache():
+     *
+     * 1. **MCP Server Changes**: When MCP servers are added, removed, or restarted
+     *    - After calling unifiedRegistry.addServer() or removeServer()
+     *    - When MCP server configurations change
+     *    - After MCP server restart or reconnection
+     *
+     * 2. **Tool Registration Changes**: When custom tools are modified
+     *    - After registering new SDK tools via registerTool()
+     *    - When tool implementations change
+     *    - After unregistering tools
+     *
+     * 3. **Provider Reinitialization**: When the provider context changes
+     *    - Before switching between different AI providers
+     *    - When session context changes significantly
+     *    - After provider authentication refresh
+     *
+     * 4. **Error Recovery**: When tool execution encounters systematic failures
+     *    - After MCP connection errors are resolved
+     *    - When tool discovery needs to be re-run
+     *    - During error recovery workflows
+     *
+     * 5. **Development/Testing**: During development and testing cycles
+     *    - Between test cases that modify tool availability
+     *    - When testing different tool configurations
+     *    - During hot reloading scenarios
+     *
+     * CACHE LIFECYCLE:
+     * - Cache is populated on first generate() call via getAvailableFunctionTools()
+     * - Cache persists across multiple generate() calls for performance
+     * - Cache is invalidated by calling this method
+     * - Next generate() call will rebuild cache from current tool state
+     *
+     * PERFORMANCE IMPACT:
+     * - Clearing cache forces tool discovery on next usage (~100-500ms overhead)
+     * - Recommended to clear cache proactively rather than reactively
+     * - Consider batching tool changes before clearing cache
+     *
+     * THREAD SAFETY:
+     * - This method is not thread-safe
+     * - Avoid calling during active generate() operations
+     * - Safe to call between separate AI generation requests
+     */
+    clearToolsCache(): void;
     /**
      * Short alias for generate() - CLI-SDK consistency
      */
@@ -66,6 +126,7 @@ export declare function createFunctionCallingProvider(baseProvider: AIProvider,
     enableFunctionCalling?: boolean;
     sessionId?: string;
     userId?: string;
+    cacheExpiryMs?: number;
 }): AIProvider;
 /**
  * Enhanced MCP Provider Factory that creates function-calling enabled providers
@@ -77,4 +138,5 @@ export declare function createMCPAwareProviderV3(baseProvider: AIProvider, optio
     enableFunctionCalling?: boolean;
     sessionId?: string;
     userId?: string;
+    cacheExpiryMs?: number;
 }): AIProvider;