@juspay/neurolink 1.0.0

package/dist/core/factory.d.ts

@@ -0,0 +1,40 @@
+import type { AIProvider, AIProviderName, SupportedModelName } from './types.js';
+declare const componentIdentifier = "aiProviderFactory";
+/**
+ * Factory for creating AI provider instances with centralized configuration
+ */
+export declare class AIProviderFactory {
+    /**
+     * Create a provider instance for the specified provider type
+     * @param providerName - Name of the provider ('vertex', 'bedrock', 'openai')
+     * @param modelName - Optional model name override
+     * @returns AIProvider instance
+     */
+    static createProvider(providerName: string, modelName?: string | null): AIProvider;
+    /**
+     * Create a provider instance with specific provider enum and model
+     * @param provider - Provider enum value
+     * @param model - Specific model enum value
+     * @returns AIProvider instance
+     */
+    static createProviderWithModel(provider: AIProviderName, model: SupportedModelName): AIProvider;
+    /**
+     * Create the best available provider automatically
+     * @param requestedProvider - Optional preferred provider
+     * @param modelName - Optional model name override
+     * @returns AIProvider instance
+     */
+    static createBestProvider(requestedProvider?: string, modelName?: string | null): AIProvider;
+    /**
+     * Create primary and fallback provider instances
+     * @param primaryProvider - Primary provider name
+     * @param fallbackProvider - Fallback provider name
+     * @param modelName - Optional model name override
+     * @returns Object with primary and fallback providers
+     */
+    static createProviderWithFallback(primaryProvider: string, fallbackProvider: string, modelName?: string | null): {
+        primary: AIProvider;
+        fallback: AIProvider;
+    };
+}
+export { componentIdentifier };

package/dist/core/factory.js

@@ -0,0 +1,149 @@
+import { GoogleVertexAI, AmazonBedrock, OpenAI } from '../providers/index.js';
+import { getBestProvider } from '../utils/providerUtils.js';
+const componentIdentifier = 'aiProviderFactory';
+/**
+ * Factory for creating AI provider instances with centralized configuration
+ */
+export class AIProviderFactory {
+    /**
+     * Create a provider instance for the specified provider type
+     * @param providerName - Name of the provider ('vertex', 'bedrock', 'openai')
+     * @param modelName - Optional model name override
+     * @returns AIProvider instance
+     */
+    static createProvider(providerName, modelName) {
+        const functionTag = 'AIProviderFactory.createProvider';
+        console.log(`[${functionTag}] Provider creation started`, {
+            providerName,
+            modelName: modelName || 'default'
+        });
+        try {
+            let provider;
+            switch (providerName.toLowerCase()) {
+                case 'vertex':
+                case 'google':
+                case 'gemini':
+                    provider = new GoogleVertexAI(modelName);
+                    break;
+                case 'bedrock':
+                case 'amazon':
+                case 'aws':
+                    provider = new AmazonBedrock(modelName);
+                    break;
+                case 'openai':
+                case 'gpt':
+                    provider = new OpenAI(modelName);
+                    break;
+                default:
+                    throw new Error(`Unknown provider: ${providerName}. Supported providers: vertex, bedrock, openai`);
+            }
+            console.log(`[${functionTag}] Provider creation succeeded`, {
+                providerName,
+                modelName: modelName || 'default',
+                providerType: provider.constructor.name
+            });
+            return provider;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`[${functionTag}] Provider creation failed`, {
+                providerName,
+                modelName: modelName || 'default',
+                error: errorMessage
+            });
+            throw error;
+        }
+    }
+    /**
+     * Create a provider instance with specific provider enum and model
+     * @param provider - Provider enum value
+     * @param model - Specific model enum value
+     * @returns AIProvider instance
+     */
+    static createProviderWithModel(provider, model) {
+        const functionTag = 'AIProviderFactory.createProviderWithModel';
+        console.log(`[${functionTag}] Provider model creation started`, {
+            provider,
+            model
+        });
+        try {
+            const providerInstance = this.createProvider(provider, model);
+            console.log(`[${functionTag}] Provider model creation succeeded`, {
+                provider,
+                model,
+                providerType: providerInstance.constructor.name
+            });
+            return providerInstance;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`[${functionTag}] Provider model creation failed`, {
+                provider,
+                model,
+                error: errorMessage
+            });
+            throw error;
+        }
+    }
+    /**
+     * Create the best available provider automatically
+     * @param requestedProvider - Optional preferred provider
+     * @param modelName - Optional model name override
+     * @returns AIProvider instance
+     */
+    static createBestProvider(requestedProvider, modelName) {
+        const functionTag = 'AIProviderFactory.createBestProvider';
+        try {
+            const bestProvider = getBestProvider(requestedProvider);
+            console.log(`[${functionTag}] Best provider selected`, {
+                requestedProvider: requestedProvider || 'auto',
+                selectedProvider: bestProvider,
+                modelName: modelName || 'default'
+            });
+            return this.createProvider(bestProvider, modelName);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`[${functionTag}] Best provider selection failed`, {
+                requestedProvider: requestedProvider || 'auto',
+                error: errorMessage
+            });
+            throw error;
+        }
+    }
+    /**
+     * Create primary and fallback provider instances
+     * @param primaryProvider - Primary provider name
+     * @param fallbackProvider - Fallback provider name
+     * @param modelName - Optional model name override
+     * @returns Object with primary and fallback providers
+     */
+    static createProviderWithFallback(primaryProvider, fallbackProvider, modelName) {
+        const functionTag = 'AIProviderFactory.createProviderWithFallback';
+        console.log(`[${functionTag}] Fallback provider setup started`, {
+            primaryProvider,
+            fallbackProvider,
+            modelName: modelName || 'default'
+        });
+        try {
+            const primary = this.createProvider(primaryProvider, modelName);
+            const fallback = this.createProvider(fallbackProvider, modelName);
+            console.log(`[${functionTag}] Fallback provider setup succeeded`, {
+                primaryProvider,
+                fallbackProvider,
+                modelName: modelName || 'default'
+            });
+            return { primary, fallback };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`[${functionTag}] Fallback provider setup failed`, {
+                primaryProvider,
+                fallbackProvider,
+                error: errorMessage
+            });
+            throw error;
+        }
+    }
+}
+export { componentIdentifier };

package/dist/core/types.d.ts

@@ -0,0 +1,77 @@
+import type { ZodType, ZodTypeDef } from 'zod';
+import type { StreamTextResult, ToolSet, Schema, GenerateTextResult } from 'ai';
+/**
+ * Supported AI Provider Names
+ */
+export declare enum AIProviderName {
+    BEDROCK = "bedrock",
+    OPENAI = "openai",
+    VERTEX = "vertex"
+}
+/**
+ * Supported Models for Amazon Bedrock
+ */
+export declare enum BedrockModels {
+    CLAUDE_3_SONNET = "anthropic.claude-3-sonnet-20240229-v1:0",
+    CLAUDE_3_HAIKU = "anthropic.claude-3-haiku-20240307-v1:0",
+    CLAUDE_3_5_SONNET = "anthropic.claude-3-5-sonnet-20240620-v1:0",
+    CLAUDE_3_7_SONNET = "arn:aws:bedrock:us-east-2:225681119357:inference-profile/us.anthropic.claude-3-7-sonnet-20250219-v1:0"
+}
+/**
+ * Supported Models for OpenAI
+ */
+export declare enum OpenAIModels {
+    GPT_4 = "gpt-4",
+    GPT_4_TURBO = "gpt-4-turbo",
+    GPT_4O = "gpt-4o",
+    GPT_4O_MINI = "gpt-4o-mini",
+    GPT_3_5_TURBO = "gpt-3.5-turbo"
+}
+/**
+ * Supported Models for Google Vertex AI
+ */
+export declare enum VertexModels {
+    CLAUDE_4_0_SONNET = "claude-sonnet-4@20250514",
+    GEMINI_2_5_FLASH = "gemini-2.5-flash-preview-05-20"
+}
+/**
+ * Union type of all supported model names
+ */
+export type SupportedModelName = BedrockModels | OpenAIModels | VertexModels;
+/**
+ * Provider configuration specifying provider and its available models
+ */
+export interface ProviderConfig {
+    provider: AIProviderName;
+    models: SupportedModelName[];
+}
+/**
+ * Options for AI requests with unified provider configuration
+ */
+export interface StreamingOptions {
+    providers: ProviderConfig[];
+    temperature?: number;
+    maxTokens?: number;
+    systemPrompt?: string;
+}
+/**
+ * AI Provider interface
+ */
+export interface AIProvider {
+    streamText(prompt: string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamTextResult<ToolSet, unknown> | null>;
+    generateText(prompt: string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<GenerateTextResult<ToolSet, unknown> | null>;
+}
+/**
+ * Provider attempt result for iteration tracking
+ */
+export interface ProviderAttempt {
+    provider: AIProviderName;
+    model: SupportedModelName;
+    success: boolean;
+    error?: string;
+    stack?: string;
+}
+/**
+ * Default provider configurations
+ */
+export declare const DEFAULT_PROVIDER_CONFIGS: ProviderConfig[];

package/dist/core/types.js

@@ -0,0 +1,55 @@
+/**
+ * Supported AI Provider Names
+ */
+export var AIProviderName;
+(function (AIProviderName) {
+    AIProviderName["BEDROCK"] = "bedrock";
+    AIProviderName["OPENAI"] = "openai";
+    AIProviderName["VERTEX"] = "vertex";
+})(AIProviderName || (AIProviderName = {}));
+/**
+ * Supported Models for Amazon Bedrock
+ */
+export var BedrockModels;
+(function (BedrockModels) {
+    BedrockModels["CLAUDE_3_SONNET"] = "anthropic.claude-3-sonnet-20240229-v1:0";
+    BedrockModels["CLAUDE_3_HAIKU"] = "anthropic.claude-3-haiku-20240307-v1:0";
+    BedrockModels["CLAUDE_3_5_SONNET"] = "anthropic.claude-3-5-sonnet-20240620-v1:0";
+    BedrockModels["CLAUDE_3_7_SONNET"] = "arn:aws:bedrock:us-east-2:225681119357:inference-profile/us.anthropic.claude-3-7-sonnet-20250219-v1:0";
+})(BedrockModels || (BedrockModels = {}));
+/**
+ * Supported Models for OpenAI
+ */
+export var OpenAIModels;
+(function (OpenAIModels) {
+    OpenAIModels["GPT_4"] = "gpt-4";
+    OpenAIModels["GPT_4_TURBO"] = "gpt-4-turbo";
+    OpenAIModels["GPT_4O"] = "gpt-4o";
+    OpenAIModels["GPT_4O_MINI"] = "gpt-4o-mini";
+    OpenAIModels["GPT_3_5_TURBO"] = "gpt-3.5-turbo";
+})(OpenAIModels || (OpenAIModels = {}));
+/**
+ * Supported Models for Google Vertex AI
+ */
+export var VertexModels;
+(function (VertexModels) {
+    VertexModels["CLAUDE_4_0_SONNET"] = "claude-sonnet-4@20250514";
+    VertexModels["GEMINI_2_5_FLASH"] = "gemini-2.5-flash-preview-05-20";
+})(VertexModels || (VertexModels = {}));
+/**
+ * Default provider configurations
+ */
+export const DEFAULT_PROVIDER_CONFIGS = [
+    {
+        provider: AIProviderName.BEDROCK,
+        models: [BedrockModels.CLAUDE_3_7_SONNET, BedrockModels.CLAUDE_3_5_SONNET]
+    },
+    {
+        provider: AIProviderName.VERTEX,
+        models: [VertexModels.CLAUDE_4_0_SONNET, VertexModels.GEMINI_2_5_FLASH]
+    },
+    {
+        provider: AIProviderName.OPENAI,
+        models: [OpenAIModels.GPT_4O, OpenAIModels.GPT_4O_MINI]
+    }
+];

package/dist/index.d.ts

@@ -0,0 +1,54 @@
+/**
+ * NeuroLink AI Toolkit
+ *
+ * A unified AI provider interface with support for multiple providers,
+ * automatic fallback, streaming, and tool integration.
+ *
+ * Extracted from lighthouse project's proven AI functionality.
+ */
+import { AIProviderFactory } from './core/factory.js';
+export { AIProviderFactory };
+export type { AIProvider, AIProviderName, ProviderConfig, StreamingOptions, ProviderAttempt, SupportedModelName } from './core/types.js';
+export { BedrockModels, OpenAIModels, VertexModels, DEFAULT_PROVIDER_CONFIGS } from './core/types.js';
+export { GoogleVertexAI, AmazonBedrock, OpenAI } from './providers/index.js';
+export type { ProviderName } from './providers/index.js';
+export { PROVIDERS, AVAILABLE_PROVIDERS } from './providers/index.js';
+export { getBestProvider, getAvailableProviders, isValidProvider } from './utils/providerUtils.js';
+export declare const VERSION = "1.0.0";
+/**
+ * Quick start factory function
+ *
+ * @example
+ * ```typescript
+ * import { createAIProvider } from 'neurolink';
+ *
+ * const provider = createAIProvider('bedrock');
+ * const result = await provider.streamText('Hello, AI!');
+ * ```
+ */
+export declare function createAIProvider(providerName?: string, modelName?: string): import("./core/types.js").AIProvider;
+/**
+ * Create provider with automatic fallback
+ *
+ * @example
+ * ```typescript
+ * import { createAIProviderWithFallback } from 'neurolink';
+ *
+ * const { primary, fallback } = createAIProviderWithFallback('bedrock', 'vertex');
+ * ```
+ */
+export declare function createAIProviderWithFallback(primaryProvider?: string, fallbackProvider?: string, modelName?: string): {
+    primary: import("./core/types.js").AIProvider;
+    fallback: import("./core/types.js").AIProvider;
+};
+/**
+ * Create the best available provider based on configuration
+ *
+ * @example
+ * ```typescript
+ * import { createBestAIProvider } from 'neurolink';
+ *
+ * const provider = createBestAIProvider();
+ * ```
+ */
+export declare function createBestAIProvider(requestedProvider?: string, modelName?: string): import("./core/types.js").AIProvider;

package/dist/index.js

@@ -0,0 +1,60 @@
+/**
+ * NeuroLink AI Toolkit
+ *
+ * A unified AI provider interface with support for multiple providers,
+ * automatic fallback, streaming, and tool integration.
+ *
+ * Extracted from lighthouse project's proven AI functionality.
+ */
+// Core exports
+import { AIProviderFactory } from './core/factory.js';
+export { AIProviderFactory };
+// Model enums
+export { BedrockModels, OpenAIModels, VertexModels, DEFAULT_PROVIDER_CONFIGS } from './core/types.js';
+// Provider exports
+export { GoogleVertexAI, AmazonBedrock, OpenAI } from './providers/index.js';
+export { PROVIDERS, AVAILABLE_PROVIDERS } from './providers/index.js';
+// Utility exports
+export { getBestProvider, getAvailableProviders, isValidProvider } from './utils/providerUtils.js';
+// Version
+export const VERSION = '1.0.0';
+/**
+ * Quick start factory function
+ *
+ * @example
+ * ```typescript
+ * import { createAIProvider } from 'neurolink';
+ *
+ * const provider = createAIProvider('bedrock');
+ * const result = await provider.streamText('Hello, AI!');
+ * ```
+ */
+export function createAIProvider(providerName, modelName) {
+    return AIProviderFactory.createProvider(providerName || 'bedrock', modelName);
+}
+/**
+ * Create provider with automatic fallback
+ *
+ * @example
+ * ```typescript
+ * import { createAIProviderWithFallback } from 'neurolink';
+ *
+ * const { primary, fallback } = createAIProviderWithFallback('bedrock', 'vertex');
+ * ```
+ */
+export function createAIProviderWithFallback(primaryProvider, fallbackProvider, modelName) {
+    return AIProviderFactory.createProviderWithFallback(primaryProvider || 'bedrock', fallbackProvider || 'vertex', modelName);
+}
+/**
+ * Create the best available provider based on configuration
+ *
+ * @example
+ * ```typescript
+ * import { createBestAIProvider } from 'neurolink';
+ *
+ * const provider = createBestAIProvider();
+ * ```
+ */
+export function createBestAIProvider(requestedProvider, modelName) {
+    return AIProviderFactory.createBestProvider(requestedProvider, modelName);
+}

package/dist/providers/amazonBedrock.d.ts

@@ -0,0 +1,11 @@
+import type { ZodType, ZodTypeDef } from 'zod';
+import { type StreamTextResult, type ToolSet, type Schema, type GenerateTextResult } from 'ai';
+import type { AIProvider } from '../core/types.js';
+export declare class AmazonBedrock implements AIProvider {
+    private modelName;
+    private model;
+    private bedrock;
+    constructor(modelName?: string | null);
+    streamText(prompt: string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamTextResult<ToolSet, unknown> | null>;
+    generateText(prompt: string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<GenerateTextResult<ToolSet, unknown> | null>;
+}

package/dist/providers/amazonBedrock.js

@@ -0,0 +1,229 @@
+import { createAmazonBedrock } from '@ai-sdk/amazon-bedrock';
+import { streamText, generateText, Output } from 'ai';
+// Default system context
+const DEFAULT_SYSTEM_CONTEXT = {
+    systemPrompt: 'You are a helpful AI assistant.'
+};
+// Configuration helpers
+const getBedrockModelId = () => {
+    return process.env.BEDROCK_MODEL_ID || 'arn:aws:bedrock:us-east-2:account: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 {
+            console.log(`[${functionTag}] Function called`, { modelName: this.modelName });
+            // Configure AWS credentials for custom Bedrock instance
+            const awsConfig = {
+                accessKeyId: getAWSAccessKeyId(),
+                secretAccessKey: getAWSSecretAccessKey(),
+                region: getAWSRegion()
+            };
+            console.log(`[${functionTag}] AWS config validation`, {
+                hasAccessKeyId: !!awsConfig.accessKeyId,
+                hasSecretAccessKey: !!awsConfig.secretAccessKey,
+                region: awsConfig.region || 'MISSING'
+            });
+            // Add session token for development environment
+            if (getAppEnvironment() === 'dev') {
+                const sessionToken = getAWSSessionToken();
+                if (sessionToken) {
+                    awsConfig.sessionToken = sessionToken;
+                    console.log(`[${functionTag}] Session token added`, {
+                        environment: 'dev'
+                    });
+                }
+                else {
+                    console.warn(`[${functionTag}] Session token missing`, {
+                        environment: 'dev'
+                    });
+                }
+            }
+            console.log(`[${functionTag}] AWS config created`, {
+                region: awsConfig.region,
+                hasSessionToken: !!awsConfig.sessionToken
+            });
+            console.log(`[${functionTag}] Bedrock provider creating`, {
+                modelName: this.modelName
+            });
+            // Create custom Bedrock provider instance with environment-based configuration
+            this.bedrock = createAmazonBedrock(awsConfig);
+            console.log(`[${functionTag}] Bedrock provider initialized`, {
+                modelName: this.modelName
+            });
+            console.log(`[${functionTag}] Model instance creating`, {
+                modelName: this.modelName
+            });
+            this.model = this.bedrock(this.modelName);
+            console.log(`[${functionTag}] Model instance created`, {
+                modelName: this.modelName
+            });
+            console.log(`[${functionTag}] Function result`, {
+                modelName: this.modelName,
+                region: awsConfig.region,
+                hasSessionToken: !!awsConfig.sessionToken,
+                success: true
+            });
+            console.log(`[${functionTag}] Initialization completed`, {
+                modelName: this.modelName,
+                region: awsConfig.region,
+                hasSessionToken: !!awsConfig.sessionToken
+            });
+        }
+        catch (err) {
+            console.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(prompt, analysisSchema) {
+        const functionTag = 'AmazonBedrock.streamText';
+        const provider = 'bedrock';
+        let chunkCount = 0;
+        try {
+            console.log(`[${functionTag}] Stream request started`, {
+                provider,
+                modelName: this.modelName,
+                promptLength: prompt.length
+            });
+            const streamOptions = {
+                model: this.model,
+                prompt: prompt,
+                system: DEFAULT_SYSTEM_CONTEXT.systemPrompt,
+                onError: (event) => {
+                    const error = event.error;
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    const errorStack = error instanceof Error ? error.stack : undefined;
+                    console.error(`[${functionTag}] Stream text error`, {
+                        provider,
+                        modelName: this.modelName,
+                        region: getAWSRegion(),
+                        error: errorMessage,
+                        stack: errorStack,
+                        promptLength: prompt.length,
+                        chunkCount
+                    });
+                },
+                onFinish: (event) => {
+                    console.log(`[${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++;
+                    console.debug(`[${functionTag}] Stream text chunk`, {
+                        provider,
+                        modelName: this.modelName,
+                        chunkNumber: chunkCount,
+                        chunkLength: event.chunk.text?.length || 0,
+                        chunkType: event.chunk.type
+                    });
+                }
+            };
+            if (analysisSchema) {
+                streamOptions.experimental_output = Output.object({ schema: analysisSchema });
+            }
+            console.log(`[${functionTag}] Stream text started`, {
+                provider,
+                modelName: this.modelName,
+                region: getAWSRegion(),
+                promptLength: prompt.length
+            });
+            // Direct streamText call - let the real error bubble up
+            const result = streamText(streamOptions);
+            console.log(`[${functionTag}] Stream text call successful`, {
+                provider,
+                modelName: this.modelName,
+                promptLength: prompt.length
+            });
+            return result;
+        }
+        catch (err) {
+            console.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(prompt, analysisSchema) {
+        const functionTag = 'AmazonBedrock.generateText';
+        const provider = 'bedrock';
+        try {
+            const generateOptions = {
+                model: this.model,
+                prompt: prompt,
+                system: DEFAULT_SYSTEM_CONTEXT.systemPrompt
+            };
+            if (analysisSchema) {
+                generateOptions.experimental_output = Output.object({ schema: analysisSchema });
+            }
+            console.log(`[${functionTag}] Generate text started`, {
+                provider,
+                modelName: this.modelName,
+                region: getAWSRegion(),
+                promptLength: prompt.length
+            });
+            const result = await generateText(generateOptions);
+            console.log(`[${functionTag}] Generate text completed`, {
+                provider,
+                modelName: this.modelName,
+                usage: result.usage,
+                finishReason: result.finishReason
+            });
+            return result;
+        }
+        catch (err) {
+            console.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
+        }
+    }
+}