@juspay/neurolink 5.1.0 → 5.2.0

package/dist/providers/amazonBedrock.js

@@ -1,364 +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;
-        }
-    }
-    /**
-     * LEGACY METHOD: Use stream() instead for new code
-     * @deprecated Use stream() method instead
-     */
-    /**
-     * PRIMARY METHOD: Stream content using AI (recommended for new code)
-     * Future-ready for multi-modal capabilities with current text focus
-     */
-    async stream(optionsOrPrompt, analysisSchema) {
-        const functionTag = "AmazonBedrock.stream";
-        const provider = "bedrock";
-        let chunkCount = 0;
-        const startTime = Date.now();
-        try {
-            // 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");
-            }
-            // Extract prompt and other parameters
-            const { prompt = options.input.text, 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 || 0,
-                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.debug(`[${functionTag}] Stream error`, {
-                        provider,
-                        modelName: this.modelName,
-                        error: errorMessage,
-                        stack: errorStack,
-                        promptLength: prompt.length,
-                        chunkCount,
-                    });
-                },
-                onFinish: (event) => {
-                    logger.debug(`[${functionTag}] Stream finished`, {
-                        provider,
-                        modelName: this.modelName,
-                        finishReason: event.finishReason,
-                        usage: event.usage,
-                        totalChunks: chunkCount,
-                        promptLength: prompt.length,
-                        responseLength: event.text?.length || 0,
-                    });
-                },
-                onChunk: (event) => {
-                    chunkCount++;
-                    logger.debug(`[${functionTag}] Stream 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,
-                });
-            }
-            const result = streamText(streamOptions);
-            logger.debug(`[${functionTag}] Stream request completed`, {
-                provider,
-                modelName: this.modelName,
-            });
-            // Convert to StreamResult format
-            return {
-                stream: (async function* () {
-                    for await (const chunk of result.textStream) {
-                        yield { content: chunk };
-                    }
-                })(),
-                provider: "bedrock",
-                model: this.modelName,
-                metadata: {
-                    streamId: `bedrock-${Date.now()}`,
-                    startTime,
-                },
-            };
-        }
-        catch (err) {
-            // Log timeout errors specifically
-            if (err instanceof TimeoutError) {
-                logger.debug(`[${functionTag}] Timeout error`, {
-                    provider,
-                    modelName: this.modelName,
-                    timeout: err.timeout,
-                    message: err.message,
-                });
-            }
-            else {
-                logger.debug(`[${functionTag}] Exception`, {
-                    provider,
-                    modelName: this.modelName,
-                    message: "Error in streaming content",
-                    err: String(err),
-                });
-            }
-            throw err; // Re-throw error to trigger fallback
-        }
-    }
-    async generate(optionsOrPrompt, analysisSchema) {
-        const functionTag = "AmazonBedrock.generate";
-        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 {
-                    content: result.text,
-                    provider: "bedrock",
-                    model: this.modelName || "claude-3-sonnet",
-                    usage: result.usage
-                        ? {
-                            inputTokens: result.usage.promptTokens,
-                            outputTokens: result.usage.completionTokens,
-                            totalTokens: result.usage.totalTokens,
-                        }
-                        : undefined,
-                    responseTime: 0,
-                };
-            }
-            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 generate() - CLI-SDK consistency
-     */
-    /**
-     * Short alias for generate() - CLI-SDK consistency
-     */
-    async gen(optionsOrPrompt, analysisSchema) {
-        return this.generate(optionsOrPrompt, analysisSchema);
-    }
-}

package/dist/providers/azureOpenAI.d.ts

@@ -1,42 +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, EnhancedGenerateResult } from "../core/types.js";
-import type { StreamOptions, StreamResult } from "../types/stream-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;
-    /**
-     * 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?: any): Promise<StreamResult>;
-    generate(optionsOrPrompt: TextGenerationOptions | string, schema?: any): Promise<any>;
-    private createAsyncIterable;
-    testConnection(): Promise<{
-        success: boolean;
-        error?: string;
-        responseTime?: number;
-    }>;
-    isConfigured(): boolean;
-    getRequiredConfig(): string[];
-    getOptionalConfig(): string[];
-    getModels(): string[];
-    supportsStreaming(): boolean;
-    supportsSchema(): boolean;
-    getCapabilities(): string[];
-    gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: any): Promise<EnhancedGenerateResult | null>;
-}