@juspay/neurolink 5.0.0 → 5.2.0

package/dist/providers/amazonBedrock.js

@@ -1,334 +0,0 @@
-import { createAmazonBedrock } from "@ai-sdk/amazon-bedrock";
-import { streamText, generateText, Output, } from "ai";
-import { logger } from "../utils/logger.js";
-import { createTimeoutController, TimeoutError, getDefaultTimeout, } from "../utils/timeout.js";
-import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
-import { evaluateResponse } from "../core/evaluation.js";
-import { createAnalytics } from "../core/analytics.js";
-// Default system context
-const DEFAULT_SYSTEM_CONTEXT = {
-    systemPrompt: "You are a helpful AI assistant.",
-};
-// 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 keyId = process.env.AWS_ACCESS_KEY_ID;
-    if (!keyId) {
-        throw new Error("AWS_ACCESS_KEY_ID environment variable is not set");
-    }
-    return keyId;
-};
-const getAWSSecretAccessKey = () => {
-    const secretKey = process.env.AWS_SECRET_ACCESS_KEY;
-    if (!secretKey) {
-        throw new Error("AWS_SECRET_ACCESS_KEY environment variable is not set");
-    }
-    return secretKey;
-};
-const getAWSRegion = () => {
-    return process.env.AWS_REGION || "us-east-2";
-};
-const getAWSSessionToken = () => {
-    return process.env.AWS_SESSION_TOKEN;
-};
-const getAppEnvironment = () => {
-    return process.env.PUBLIC_APP_ENVIRONMENT || "dev";
-};
-// Amazon Bedrock class with enhanced error handling using createAmazonBedrock
-export class AmazonBedrock {
-    modelName;
-    model;
-    bedrock;
-    constructor(modelName) {
-        const functionTag = "AmazonBedrock.constructor";
-        this.modelName = modelName || getBedrockModelId();
-        try {
-            logger.debug(`[${functionTag}] Function called`, {
-                modelName: this.modelName,
-                envBedrockModel: process.env.BEDROCK_MODEL,
-                envBedrockModelId: process.env.BEDROCK_MODEL_ID,
-                fallbackModel: "arn:aws:bedrock:us-east-2:225681119357:inference-profile/us.anthropic.claude-3-7-sonnet-20250219-v1:0",
-            });
-            // Configure AWS credentials for custom Bedrock instance
-            const awsConfig = {
-                accessKeyId: getAWSAccessKeyId(),
-                secretAccessKey: getAWSSecretAccessKey(),
-                region: getAWSRegion(),
-            };
-            logger.debug(`[${functionTag}] AWS config validation`, {
-                hasAccessKeyId: !!awsConfig.accessKeyId,
-                hasSecretAccessKey: !!awsConfig.secretAccessKey,
-                region: awsConfig.region || "MISSING",
-                accessKeyIdLength: awsConfig.accessKeyId?.length || 0,
-                hasSessionToken: !!process.env.AWS_SESSION_TOKEN,
-            });
-            // Add session token for development environment
-            if (getAppEnvironment() === "dev") {
-                const sessionToken = getAWSSessionToken();
-                if (sessionToken) {
-                    awsConfig.sessionToken = sessionToken;
-                    logger.debug(`[${functionTag}] Session token added`, {
-                        environment: "dev",
-                    });
-                }
-                else {
-                    logger.warn(`[${functionTag}] Session token missing`, {
-                        environment: "dev",
-                    });
-                }
-            }
-            logger.debug(`[${functionTag}] AWS config created`, {
-                region: awsConfig.region,
-                hasSessionToken: !!awsConfig.sessionToken,
-            });
-            logger.debug(`[${functionTag}] Bedrock provider creating`, {
-                modelName: this.modelName,
-            });
-            // Create custom Bedrock provider instance with environment-based configuration
-            this.bedrock = createAmazonBedrock(awsConfig);
-            logger.debug(`[${functionTag}] Bedrock provider initialized`, {
-                modelName: this.modelName,
-            });
-            logger.debug(`[${functionTag}] Model instance creating`, {
-                modelName: this.modelName,
-            });
-            this.model = this.bedrock(this.modelName);
-            logger.debug(`[${functionTag}] Model instance created`, {
-                modelName: this.modelName,
-            });
-            logger.debug(`[${functionTag}] Function result`, {
-                modelName: this.modelName,
-                region: awsConfig.region,
-                hasSessionToken: !!awsConfig.sessionToken,
-                success: true,
-            });
-            logger.debug(`[${functionTag}] Initialization completed`, {
-                modelName: this.modelName,
-                region: awsConfig.region,
-                hasSessionToken: !!awsConfig.sessionToken,
-            });
-        }
-        catch (err) {
-            logger.error(`[${functionTag}] Initialization failed`, {
-                message: "Error in initializing Amazon Bedrock",
-                modelName: this.modelName,
-                region: getAWSRegion(),
-                error: err instanceof Error ? err.message : String(err),
-                stack: err instanceof Error ? err.stack : undefined,
-            });
-            throw err;
-        }
-    }
-    async streamText(optionsOrPrompt, analysisSchema) {
-        const functionTag = "AmazonBedrock.streamText";
-        const provider = "bedrock";
-        let chunkCount = 0;
-        try {
-            // Parse parameters - support both string and options object
-            const options = typeof optionsOrPrompt === "string"
-                ? { prompt: optionsOrPrompt }
-                : optionsOrPrompt;
-            const { prompt, temperature = 0.7, maxTokens = DEFAULT_MAX_TOKENS, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, timeout = getDefaultTimeout(provider, "stream"), } = options;
-            // Use schema from options or fallback parameter
-            const finalSchema = schema || analysisSchema;
-            logger.debug(`[${functionTag}] Stream request started`, {
-                provider,
-                modelName: this.modelName,
-                promptLength: prompt.length,
-                temperature,
-                maxTokens,
-                timeout,
-            });
-            // Create timeout controller if timeout is specified
-            const timeoutController = createTimeoutController(timeout, provider, "stream");
-            const streamOptions = {
-                model: this.model,
-                prompt: prompt,
-                system: systemPrompt,
-                temperature,
-                maxTokens,
-                // Add abort signal if available
-                ...(timeoutController && {
-                    abortSignal: timeoutController.controller.signal,
-                }),
-                onError: (event) => {
-                    const error = event.error;
-                    const errorMessage = error instanceof Error ? error.message : String(error);
-                    const errorStack = error instanceof Error ? error.stack : undefined;
-                    logger.error(`[${functionTag}] Stream text error`, {
-                        provider,
-                        modelName: this.modelName,
-                        region: getAWSRegion(),
-                        error: errorMessage,
-                        stack: errorStack,
-                        promptLength: prompt.length,
-                        chunkCount,
-                    });
-                },
-                onFinish: (event) => {
-                    logger.debug(`[${functionTag}] Stream text finished`, {
-                        provider,
-                        modelName: this.modelName,
-                        region: getAWSRegion(),
-                        finishReason: event.finishReason,
-                        usage: event.usage,
-                        totalChunks: chunkCount,
-                        promptLength: prompt.length,
-                        responseLength: event.text?.length || 0,
-                    });
-                },
-                onChunk: (event) => {
-                    chunkCount++;
-                    logger.debug(`[${functionTag}] Stream text chunk`, {
-                        provider,
-                        modelName: this.modelName,
-                        chunkNumber: chunkCount,
-                        chunkLength: event.chunk.text?.length || 0,
-                        chunkType: event.chunk.type,
-                    });
-                },
-            };
-            if (finalSchema) {
-                streamOptions.experimental_output = Output.object({
-                    schema: finalSchema,
-                });
-            }
-            // Direct streamText call - let the real error bubble up
-            const result = streamText(streamOptions);
-            logger.debug(`[${functionTag}] Stream text call successful`, {
-                provider,
-                modelName: this.modelName,
-                promptLength: prompt.length,
-            });
-            // For streaming, we can't clean up immediately, but the timeout will auto-clean
-            // The user should handle the stream and any timeout errors
-            return result;
-        }
-        catch (err) {
-            // Log timeout errors specifically
-            if (err instanceof TimeoutError) {
-                logger.error(`[${functionTag}] Timeout error`, {
-                    provider,
-                    modelName: this.modelName,
-                    region: getAWSRegion(),
-                    timeout: err.timeout,
-                    message: err.message,
-                });
-            }
-            else {
-                logger.error(`[${functionTag}] Exception`, {
-                    provider,
-                    modelName: this.modelName,
-                    region: getAWSRegion(),
-                    message: "Error in streaming text",
-                    err: String(err),
-                });
-            }
-            throw err; // Re-throw error to trigger fallback
-        }
-    }
-    async generateText(optionsOrPrompt, analysisSchema) {
-        const functionTag = "AmazonBedrock.generateText";
-        const provider = "bedrock";
-        const startTime = Date.now();
-        try {
-            // Parse parameters - support both string and options object
-            const options = typeof optionsOrPrompt === "string"
-                ? { prompt: optionsOrPrompt }
-                : optionsOrPrompt;
-            const { prompt, temperature = 0.7, maxTokens = DEFAULT_MAX_TOKENS, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, timeout = getDefaultTimeout(provider, "generate"), } = options;
-            // Use schema from options or fallback parameter
-            const finalSchema = schema || analysisSchema;
-            logger.debug(`[${functionTag}] Generate text started`, {
-                provider,
-                modelName: this.modelName,
-                region: getAWSRegion(),
-                promptLength: prompt.length,
-                temperature,
-                maxTokens,
-                timeout,
-            });
-            // Create timeout controller if timeout is specified
-            const timeoutController = createTimeoutController(timeout, provider, "generate");
-            const generateOptions = {
-                model: this.model,
-                prompt: prompt,
-                system: systemPrompt,
-                temperature,
-                maxTokens,
-                // Add abort signal if available
-                ...(timeoutController && {
-                    abortSignal: timeoutController.controller.signal,
-                }),
-            };
-            if (finalSchema) {
-                generateOptions.experimental_output = Output.object({
-                    schema: finalSchema,
-                });
-            }
-            try {
-                const result = await generateText(generateOptions);
-                // Clean up timeout if successful
-                timeoutController?.cleanup();
-                logger.debug(`[${functionTag}] Generate text completed`, {
-                    provider,
-                    modelName: this.modelName,
-                    usage: result.usage,
-                    finishReason: result.finishReason,
-                    responseLength: result.text?.length || 0,
-                    timeout,
-                });
-                // Add analytics if enabled
-                if (options.enableAnalytics) {
-                    result.analytics = createAnalytics(provider, this.modelName, result, Date.now() - startTime, options.context);
-                }
-                // Add evaluation if enabled
-                if (options.enableEvaluation) {
-                    result.evaluation = await evaluateResponse(prompt, result.text, options.context);
-                }
-                return result;
-            }
-            finally {
-                // Always cleanup timeout
-                timeoutController?.cleanup();
-            }
-        }
-        catch (err) {
-            // Log timeout errors specifically
-            if (err instanceof TimeoutError) {
-                logger.error(`[${functionTag}] Timeout error`, {
-                    provider,
-                    modelName: this.modelName,
-                    region: getAWSRegion(),
-                    timeout: err.timeout,
-                    message: err.message,
-                });
-            }
-            else {
-                logger.error(`[${functionTag}] Exception`, {
-                    provider,
-                    modelName: this.modelName,
-                    message: "Error in generating text",
-                    err: String(err),
-                });
-            }
-            throw err; // Re-throw error to trigger fallback instead of returning null
-        }
-    }
-    /**
-     * Alias for generateText() - CLI-SDK consistency
-     */
-    async generate(optionsOrPrompt, analysisSchema) {
-        return this.generateText(optionsOrPrompt, analysisSchema);
-    }
-    /**
-     * Short alias for generateText() - CLI-SDK consistency
-     */
-    async gen(optionsOrPrompt, analysisSchema) {
-        return this.generateText(optionsOrPrompt, analysisSchema);
-    }
-}

package/dist/providers/azureOpenAI.d.ts

@@ -1,39 +0,0 @@
-/**
- * Azure OpenAI Provider
- *
- * Enterprise-grade OpenAI integration through Microsoft Azure.
- * Supports all OpenAI models with enhanced security and compliance.
- */
-import type { AIProvider, TextGenerationOptions, StreamTextOptions, EnhancedGenerateTextResult } from "../core/types.js";
-import { AIProviderName } from "../core/types.js";
-export declare class AzureOpenAIProvider implements AIProvider {
-    readonly name: AIProviderName;
-    private apiKey;
-    private endpoint;
-    private deploymentId;
-    private apiVersion;
-    constructor();
-    private getApiKey;
-    private getEndpoint;
-    private getDeploymentId;
-    private getApiUrl;
-    private makeRequest;
-    generateText(optionsOrPrompt: TextGenerationOptions | string, schema?: any): Promise<any>;
-    streamText(optionsOrPrompt: StreamTextOptions | string, schema?: any): Promise<any>;
-    private createAsyncIterable;
-    generateTextStream(optionsOrPrompt: StreamTextOptions | string): AsyncGenerator<any, void, unknown>;
-    testConnection(): Promise<{
-        success: boolean;
-        error?: string;
-        responseTime?: number;
-    }>;
-    isConfigured(): boolean;
-    getRequiredConfig(): string[];
-    getOptionalConfig(): string[];
-    getModels(): string[];
-    supportsStreaming(): boolean;
-    supportsSchema(): boolean;
-    getCapabilities(): string[];
-    generate(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: any): Promise<EnhancedGenerateTextResult | null>;
-    gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: any): Promise<EnhancedGenerateTextResult | null>;
-}