@juspay/neurolink 5.1.0 → 5.2.0

package/dist/lib/providers/amazon-bedrock.d.ts

@@ -0,0 +1,32 @@
+import type { ZodType, ZodTypeDef } from "zod";
+import { type Schema, type LanguageModelV1 } from "ai";
+import type { AIProviderName } from "../core/types.js";
+import type { StreamOptions, StreamResult } from "../types/stream-types.js";
+import { BaseProvider } from "../core/base-provider.js";
+/**
+ * Amazon Bedrock Provider v2 - BaseProvider Implementation
+ *
+ * PHASE 3.3: Simple BaseProvider wrap around existing @ai-sdk/amazon-bedrock implementation
+ *
+ * Features:
+ * - Extends BaseProvider for shared functionality
+ * - Preserves existing AWS credential configuration
+ * - Maintains inference profile ARN support
+ * - Uses pre-initialized Bedrock instance for efficiency
+ * - Enhanced error handling with setup guidance
+ */
+export declare class AmazonBedrockProvider extends BaseProvider {
+    private bedrock;
+    private model;
+    constructor(modelName?: string);
+    protected getProviderName(): AIProviderName;
+    protected getDefaultModel(): string;
+    /**
+     * Returns the Vercel AI SDK model instance for AWS Bedrock
+     */
+    protected getAISDKModel(): LanguageModelV1;
+    protected executeStream(options: StreamOptions, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
+    protected handleProviderError(error: any): Error;
+    private validateStreamOptions;
+}
+export default AmazonBedrockProvider;

package/dist/lib/providers/amazon-bedrock.js

@@ -0,0 +1,143 @@
+import { createAmazonBedrock } from "@ai-sdk/amazon-bedrock";
+import { streamText } from "ai";
+import { BaseProvider } from "../core/base-provider.js";
+import { logger } from "../utils/logger.js";
+import { TimeoutError, } from "../utils/timeout.js";
+import { DEFAULT_MAX_TOKENS } from "../core/constants.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");
+};
+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;
+};
+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;
+};
+const getAppEnvironment = () => {
+    return process.env.PUBLIC_APP_ENVIRONMENT || "production";
+};
+/**
+ * Amazon Bedrock Provider v2 - BaseProvider Implementation
+ *
+ * PHASE 3.3: Simple BaseProvider wrap around existing @ai-sdk/amazon-bedrock implementation
+ *
+ * Features:
+ * - Extends BaseProvider for shared functionality
+ * - Preserves existing AWS credential configuration
+ * - Maintains inference profile ARN support
+ * - Uses pre-initialized Bedrock instance for efficiency
+ * - Enhanced error handling with setup guidance
+ */
+export class AmazonBedrockProvider extends BaseProvider {
+    bedrock;
+    model;
+    constructor(modelName) {
+        super(modelName, "bedrock");
+        // Initialize AWS configuration
+        const awsConfig = {
+            accessKeyId: getAWSAccessKeyId(),
+            secretAccessKey: getAWSSecretAccessKey(),
+            region: getAWSRegion(),
+        };
+        // Add session token for development environment
+        if (getAppEnvironment() === "dev") {
+            const sessionToken = getAWSSessionToken();
+            if (sessionToken) {
+                awsConfig.sessionToken = sessionToken;
+            }
+        }
+        // Create Bedrock provider instance
+        this.bedrock = createAmazonBedrock(awsConfig);
+        // Pre-initialize model for efficiency
+        this.model = this.bedrock(this.modelName || getBedrockModelId());
+        logger.debug("Amazon Bedrock BaseProvider v2 initialized", {
+            modelName: this.modelName,
+            region: awsConfig.region,
+            hasSessionToken: !!awsConfig.sessionToken,
+            provider: this.providerName,
+        });
+    }
+    getProviderName() {
+        return "bedrock";
+    }
+    getDefaultModel() {
+        return getBedrockModelId();
+    }
+    /**
+     * Returns the Vercel AI SDK model instance for AWS Bedrock
+     */
+    getAISDKModel() {
+        return this.model;
+    }
+    // executeGenerate removed - BaseProvider handles all generation with tools
+    async executeStream(options, analysisSchema) {
+        try {
+            this.validateStreamOptions(options);
+            const result = await streamText({
+                model: this.model,
+                prompt: options.input.text,
+                system: options.systemPrompt,
+                maxTokens: options.maxTokens || DEFAULT_MAX_TOKENS,
+                temperature: options.temperature,
+            });
+            return {
+                stream: (async function* () {
+                    for await (const chunk of result.textStream) {
+                        yield { content: chunk };
+                    }
+                })(),
+                provider: this.providerName,
+                model: this.modelName,
+            };
+        }
+        catch (error) {
+            throw this.handleProviderError(error);
+        }
+    }
+    handleProviderError(error) {
+        if (error.name === "TimeoutError") {
+            return new TimeoutError(`Amazon Bedrock request timed out. Consider increasing timeout or using a lighter model.`, this.defaultTimeout);
+        }
+        if (error.message?.includes("InvalidRequestException")) {
+            return new Error(`❌ Amazon Bedrock Request Error\n\nThe request was invalid: ${error.message}\n\n🔧 Common Solutions:\n1. Check your model ID format\n2. Verify your request parameters\n3. Ensure your AWS account has Bedrock access`);
+        }
+        if (error.message?.includes("AccessDeniedException")) {
+            return new Error(`❌ Amazon Bedrock Access Denied\n\nYour AWS credentials don't have permission to access Bedrock.\n\n🔧 Required Steps:\n1. Ensure your IAM user has bedrock:InvokeModel permission\n2. Check if Bedrock is available in your region\n3. Verify model access is enabled in Bedrock console`);
+        }
+        if (error.message?.includes("ValidationException")) {
+            return new Error(`❌ Amazon Bedrock Validation Error\n\n${error.message}\n\n🔧 Check:\n1. Model ID format (should be ARN or model identifier)\n2. Request parameters are within limits\n3. Region configuration is correct`);
+        }
+        return new Error(`❌ Amazon Bedrock Provider Error\n\n${error.message || "Unknown error occurred"}\n\n🔧 Troubleshooting:\n1. Check AWS credentials and permissions\n2. Verify model availability\n3. Check network connectivity`);
+    }
+    validateStreamOptions(options) {
+        if (!options.input?.text?.trim()) {
+            throw new Error("Prompt is required for streaming");
+        }
+        if (options.maxTokens &&
+            (options.maxTokens < 1 || options.maxTokens > 4096)) {
+            throw new Error("maxTokens must be between 1 and 4096 for Amazon Bedrock");
+        }
+        if (options.temperature &&
+            (options.temperature < 0 || options.temperature > 1)) {
+            throw new Error("temperature must be between 0 and 1");
+        }
+    }
+}
+export default AmazonBedrockProvider;

package/dist/lib/providers/analytics-helper.js

@@ -130,10 +130,13 @@ export function enhanceAnalyticsWithEvaluation(analytics, evaluationResult) {
     return {
         ...analytics,
         evaluation: {
-            relevanceScore: evaluationResult.relevanceScore || 0,
-            accuracyScore: evaluationResult.accuracyScore || 0,
-            completenessScore: evaluationResult.completenessScore || 0,
-            overall: evaluationResult.overall || 0,
+            // FIX: Use correct field names and ensure minimum score of 1
+            relevanceScore: evaluationResult.relevance || evaluationResult.relevanceScore || 1,
+            accuracyScore: evaluationResult.accuracy || evaluationResult.accuracyScore || 1,
+            completenessScore: evaluationResult.completeness ||
+                evaluationResult.completenessScore ||
+                1,
+            overall: evaluationResult.overall || 1,
             evaluationProvider: evaluationResult.evaluationProvider,
             evaluationTime: evaluationResult.evaluationTime,
             evaluationAttempt: evaluationResult.evaluationAttempt,

package/dist/lib/providers/anthropic-baseprovider.d.ts

@@ -0,0 +1,23 @@
+import type { ZodType, ZodTypeDef } from "zod";
+import { type Schema } from "ai";
+import type { AIProviderName } from "../core/types.js";
+import type { StreamOptions, StreamResult } from "../types/stream-types.js";
+import { BaseProvider } from "../core/base-provider.js";
+/**
+ * Anthropic provider implementation using BaseProvider pattern
+ * Migrated from direct API calls to Vercel AI SDK (@ai-sdk/anthropic)
+ * Follows exact Google AI interface patterns for compatibility
+ */
+export declare class AnthropicProviderV2 extends BaseProvider {
+    constructor(modelName?: string);
+    protected getProviderName(): AIProviderName;
+    protected getDefaultModel(): string;
+    /**
+     * Returns the Vercel AI SDK model instance for Anthropic
+     */
+    protected getAISDKModel(): any;
+    protected handleProviderError(error: any): Error;
+    private getApiKey;
+    protected executeStream(options: StreamOptions, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
+}
+export default AnthropicProviderV2;

package/dist/lib/providers/anthropic-baseprovider.js

@@ -0,0 +1,114 @@
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { streamText } from "ai";
+import { BaseProvider } from "../core/base-provider.js";
+import { logger } from "../utils/logger.js";
+import { createTimeoutController, TimeoutError, } from "../utils/timeout.js";
+import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
+/**
+ * Anthropic provider implementation using BaseProvider pattern
+ * Migrated from direct API calls to Vercel AI SDK (@ai-sdk/anthropic)
+ * Follows exact Google AI interface patterns for compatibility
+ */
+export class AnthropicProviderV2 extends BaseProvider {
+    constructor(modelName) {
+        super(modelName, "anthropic");
+        logger.debug("AnthropicProviderV2 initialized", {
+            model: this.modelName,
+            provider: this.providerName,
+        });
+    }
+    // ===================
+    // ABSTRACT METHOD IMPLEMENTATIONS
+    // ===================
+    getProviderName() {
+        return "anthropic";
+    }
+    getDefaultModel() {
+        return process.env.ANTHROPIC_MODEL || "claude-3-5-sonnet-20241022";
+    }
+    /**
+     * Returns the Vercel AI SDK model instance for Anthropic
+     */
+    getAISDKModel() {
+        const apiKey = this.getApiKey();
+        const anthropic = createAnthropic({ apiKey });
+        return anthropic(this.modelName);
+    }
+    handleProviderError(error) {
+        if (error instanceof TimeoutError) {
+            return new Error(`Anthropic request timed out: ${error.message}`);
+        }
+        if (error?.status === 401) {
+            return new Error("Invalid Anthropic API key. Please check your ANTHROPIC_API_KEY environment variable.");
+        }
+        if (error?.status === 429) {
+            return new Error("Anthropic rate limit exceeded. Please try again later.");
+        }
+        if (error?.status === 400) {
+            return new Error(`Anthropic bad request: ${error?.message || "Invalid request parameters"}`);
+        }
+        return new Error(`Anthropic error: ${error?.message || "Unknown error"}`);
+    }
+    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;
+    }
+    // executeGenerate removed - BaseProvider handles all generation with tools
+    async executeStream(options, analysisSchema) {
+        // Note: StreamOptions validation handled differently than TextGenerationOptions
+        const apiKey = this.getApiKey();
+        const anthropicClient = createAnthropic({ apiKey });
+        const model = anthropicClient(this.modelName);
+        const timeout = this.getTimeout(options);
+        const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
+        try {
+            const result = await streamText({
+                model,
+                prompt: options.input.text,
+                system: options.systemPrompt,
+                temperature: options.temperature,
+                maxTokens: options.maxTokens || DEFAULT_MAX_TOKENS,
+                tools: options.tools,
+                toolChoice: "auto",
+                abortSignal: timeoutController?.controller.signal,
+            });
+            timeoutController?.cleanup();
+            // Transform string stream to content object stream (match Google AI pattern)
+            const transformedStream = async function* () {
+                for await (const chunk of result.textStream) {
+                    yield { content: chunk };
+                }
+            };
+            return {
+                stream: transformedStream(),
+                provider: this.providerName,
+                model: this.modelName,
+            };
+        }
+        catch (error) {
+            timeoutController?.cleanup();
+            throw this.handleProviderError(error);
+        }
+    }
+}
+// Export for testing
+export default AnthropicProviderV2;

package/dist/lib/providers/anthropic.d.ts

@@ -1,48 +1,24 @@
-/**
- * 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 type { AIProvider, TextGenerationOptions, EnhancedGenerateResult } from "../core/types.js";
 import type { ZodType, ZodTypeDef } from "zod";
-import type { Schema } from "ai";
+import { type Schema, type LanguageModelV1 } from "ai";
+import type { AIProviderName } from "../core/types.js";
 import type { StreamOptions, StreamResult } from "../types/stream-types.js";
-import { AIProviderName } from "../core/types.js";
-export declare class AnthropicProvider implements AIProvider {
-    readonly name: AIProviderName;
-    private apiKey;
-    private baseURL;
-    private defaultModel;
-    constructor();
-    private getApiKey;
-    private getModel;
-    private makeRequest;
-    /**
-     * PRIMARY METHOD: Stream content using AI (recommended for new code)
-     * Future-ready for multi-modal capabilities with current text focus
-     */
-    stream(optionsOrPrompt: StreamOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
-    generate(optionsOrPrompt: TextGenerationOptions | string, schema?: any): Promise<any>;
-    /**
-     * LEGACY METHOD: Use stream() instead for new code
-     * @deprecated Use stream() method instead
-     */
-    private createAsyncIterable;
-    testConnection(): Promise<{
-        success: boolean;
-        error?: string;
-        responseTime?: number;
-    }>;
-    isConfigured(): boolean;
-    getRequiredConfig(): string[];
-    getOptionalConfig(): string[];
-    getModels(): string[];
-    supportsStreaming(): boolean;
-    supportsSchema(): boolean;
-    getCapabilities(): string[];
+import { BaseProvider } from "../core/base-provider.js";
+/**
+ * Anthropic Provider v2 - BaseProvider Implementation
+ * Fixed syntax and enhanced with proper error handling
+ */
+export declare class AnthropicProvider extends BaseProvider {
+    private model;
+    constructor(modelName?: string, sdk?: any);
+    protected getProviderName(): AIProviderName;
+    protected getDefaultModel(): string;
     /**
-     * Short alias for generate() - CLI-SDK consistency
+     * Returns the Vercel AI SDK model instance for Anthropic
      */
-    gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<EnhancedGenerateResult | null>;
+    protected getAISDKModel(): LanguageModelV1;
+    protected handleProviderError(error: any): Error;
+    protected executeStream(options: StreamOptions, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
+    isAvailable(): Promise<boolean>;
+    getModel(): LanguageModelV1;
 }
+export default AnthropicProvider;