@juspay/neurolink 1.0.0 → 1.1.0

package/dist/cli/index.js

@@ -0,0 +1,308 @@
+#!/usr/bin/env node
+/**
+ * NeuroLink CLI - Enhanced Simplified Approach
+ *
+ * Professional CLI experience with minimal maintenance overhead.
+ * Features: Spinners, colors, batch processing, provider testing, rich help
+ * Implementation: ~300 lines using simple JS utility functions
+ */
+import { NeuroLink } from '@juspay/neurolink';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import ora from 'ora';
+import chalk from 'chalk';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+// Get current directory for ESM
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// Utility Functions (Simple, Zero Maintenance)
+function formatOutput(result, format = 'text') {
+    if (format === 'json') {
+        return JSON.stringify(result, null, 2);
+    }
+    // Smart text formatting
+    if (result?.content) {
+        return result.content;
+    }
+    if (typeof result === 'string') {
+        return result;
+    }
+    return JSON.stringify(result, null, 2);
+}
+function handleError(error, context) {
+    console.error(chalk.red(`❌ ${context} failed: ${error.message}`));
+    // Smart hints for common errors (just string matching!)
+    if (error.message.includes('API key')) {
+        console.error(chalk.yellow('💡 Set API key: export OPENAI_API_KEY=sk-...'));
+        console.error(chalk.yellow('💡 Or set: export AWS_REGION=us-east-1'));
+        console.error(chalk.yellow('💡 Or set: export GOOGLE_APPLICATION_CREDENTIALS=/path/to/key.json'));
+    }
+    if (error.message.includes('rate limit')) {
+        console.error(chalk.yellow('💡 Try again in a few moments or use --provider vertex'));
+    }
+    if (error.message.includes('not authorized')) {
+        console.error(chalk.yellow('💡 Check your account permissions for the selected model'));
+        console.error(chalk.yellow('💡 For AWS Bedrock: Use inference profile ARNs'));
+    }
+    process.exit(1);
+}
+function validateConfig() {
+    const hasOpenAI = !!process.env.OPENAI_API_KEY;
+    const hasAWS = !!(process.env.AWS_REGION || process.env.AWS_ACCESS_KEY_ID);
+    const hasGoogle = !!(process.env.GOOGLE_APPLICATION_CREDENTIALS || process.env.GOOGLE_SERVICE_ACCOUNT_KEY);
+    if (!hasOpenAI && !hasAWS && !hasGoogle) {
+        console.error(chalk.red('⚠️  No AI provider credentials found'));
+        console.error(chalk.yellow('💡 Set one of:'));
+        console.error(chalk.yellow('   • OPENAI_API_KEY=sk-...'));
+        console.error(chalk.yellow('   • AWS_REGION=us-east-1 (+ AWS credentials)'));
+        console.error(chalk.yellow('   • GOOGLE_APPLICATION_CREDENTIALS=/path/to/key.json'));
+        console.error(chalk.blue('\n📚 See: https://github.com/juspay/neurolink#setup'));
+        process.exit(1);
+    }
+}
+// Initialize SDK
+const sdk = new NeuroLink();
+// Enhanced CLI with Professional UX
+const cli = yargs(hideBin(process.argv))
+    .scriptName('neurolink')
+    .usage(chalk.blue('🧠 $0 <command> [options]'))
+    .middleware([validateConfig])
+    .version()
+    .help()
+    .strict()
+    .demandCommand(1, chalk.red('❌ Specify a command'))
+    .epilogue(chalk.blue('💡 For more info: https://github.com/juspay/neurolink'))
+    // Generate Text Command - Core functionality with professional UX
+    .command('generate-text <prompt>', 'Generate text using AI providers', (yargs) => yargs
+    .positional('prompt', {
+    type: 'string',
+    description: 'Text prompt for AI generation'
+})
+    .option('provider', {
+    choices: ['auto', 'openai', 'bedrock', 'vertex'],
+    default: 'auto',
+    description: 'AI provider to use (auto-selects best available)'
+})
+    .option('temperature', {
+    type: 'number',
+    default: 0.7,
+    description: 'Creativity level (0.0 = focused, 1.0 = creative)'
+})
+    .option('max-tokens', {
+    type: 'number',
+    default: 500,
+    description: 'Maximum tokens to generate'
+})
+    .option('format', {
+    choices: ['text', 'json'],
+    default: 'text',
+    description: 'Output format'
+})
+    .example('$0 generate-text "Hello world"', 'Basic text generation')
+    .example('$0 generate-text "Write a story" --provider openai', 'Use specific provider')
+    .example('$0 generate-text "Technical doc" --format json', 'Get JSON output'), async (argv) => {
+    const spinner = ora('🤖 Generating text...').start();
+    try {
+        if (!argv.prompt) {
+            throw new Error('Prompt is required');
+        }
+        const result = await sdk.generateText({
+            prompt: argv.prompt,
+            provider: argv.provider === 'auto' ? undefined : argv.provider,
+            temperature: argv.temperature,
+            maxTokens: argv.maxTokens
+        });
+        spinner.succeed(chalk.green('✅ Text generated successfully!'));
+        console.log(formatOutput(result, argv.format));
+        // Show usage info for text format
+        if (argv.format === 'text' && result.usage) {
+            console.log(chalk.blue(`ℹ️  ${result.usage.totalTokens} tokens used`));
+        }
+    }
+    catch (error) {
+        spinner.fail();
+        handleError(error, 'Text generation');
+    }
+})
+    // Stream Text Command - Real-time generation
+    .command('stream <prompt>', 'Stream text generation in real-time', (yargs) => yargs
+    .positional('prompt', {
+    type: 'string',
+    description: 'Text prompt for streaming'
+})
+    .option('provider', {
+    choices: ['auto', 'openai', 'bedrock', 'vertex'],
+    default: 'auto',
+    description: 'AI provider to use'
+})
+    .option('temperature', {
+    type: 'number',
+    default: 0.7,
+    description: 'Creativity level'
+})
+    .example('$0 stream "Tell me a story"', 'Stream a story in real-time')
+    .example('$0 stream "Explain AI" --provider vertex', 'Stream with specific provider'), async (argv) => {
+    console.log(chalk.blue(`🔄 Streaming from ${argv.provider} provider...\n`));
+    try {
+        if (!argv.prompt) {
+            throw new Error('Prompt is required');
+        }
+        const stream = await sdk.generateTextStream({
+            prompt: argv.prompt,
+            provider: argv.provider === 'auto' ? undefined : argv.provider,
+            temperature: argv.temperature
+        });
+        for await (const chunk of stream) {
+            process.stdout.write(chunk.content);
+        }
+        console.log('\n');
+    }
+    catch (error) {
+        handleError(error, 'Text streaming');
+    }
+})
+    // Batch Processing Command - Power user feature with simple implementation
+    .command('batch <file>', 'Process multiple prompts from a file', (yargs) => yargs
+    .positional('file', {
+    type: 'string',
+    description: 'File with prompts (one per line)'
+})
+    .option('output', {
+    type: 'string',
+    description: 'Output file for results (default: stdout)'
+})
+    .option('delay', {
+    type: 'number',
+    default: 1000,
+    description: 'Delay between requests in milliseconds'
+})
+    .option('provider', {
+    choices: ['auto', 'openai', 'bedrock', 'vertex'],
+    default: 'auto',
+    description: 'AI provider to use'
+})
+    .example('$0 batch prompts.txt', 'Process prompts from file')
+    .example('$0 batch prompts.txt --output results.json', 'Save results to file')
+    .example('$0 batch prompts.txt --delay 2000', 'Add 2s delay between requests'), async (argv) => {
+    try {
+        // Validate file argument
+        if (!argv.file) {
+            throw new Error('File path is required');
+        }
+        // Read and validate input file
+        if (!fs.existsSync(argv.file)) {
+            throw new Error(`File not found: ${argv.file}`);
+        }
+        const prompts = fs.readFileSync(argv.file, 'utf8')
+            .split('\n')
+            .map(line => line.trim())
+            .filter(Boolean);
+        if (prompts.length === 0) {
+            throw new Error('No prompts found in file');
+        }
+        const results = [];
+        console.log(chalk.blue(`📦 Processing ${prompts.length} prompts...\n`));
+        // Sequential processing with progress tracking
+        for (let i = 0; i < prompts.length; i++) {
+            const spinner = ora(`Processing ${i + 1}/${prompts.length}: ${prompts[i].substring(0, 50)}...`).start();
+            try {
+                const result = await sdk.generateText({
+                    prompt: prompts[i],
+                    provider: argv.provider === 'auto' ? undefined : argv.provider
+                });
+                results.push({
+                    prompt: prompts[i],
+                    response: result.content
+                });
+                spinner.succeed(`${i + 1}/${prompts.length} completed`);
+            }
+            catch (error) {
+                results.push({
+                    prompt: prompts[i],
+                    error: error.message
+                });
+                spinner.fail(`${i + 1}/${prompts.length} failed: ${error.message}`);
+            }
+            // Add delay between requests (except for last one)
+            if (argv.delay && i < prompts.length - 1) {
+                await new Promise(resolve => setTimeout(resolve, argv.delay));
+            }
+        }
+        // Output results
+        const output = JSON.stringify(results, null, 2);
+        if (argv.output) {
+            fs.writeFileSync(argv.output, output);
+            console.log(chalk.green(`\n✅ Results saved to ${argv.output}`));
+        }
+        else {
+            console.log('\n' + output);
+        }
+    }
+    catch (error) {
+        handleError(error, 'Batch processing');
+    }
+})
+    // Provider Status Command - Testing and diagnostics
+    .command('status', 'Check AI provider connectivity and performance', (yargs) => yargs
+    .option('verbose', {
+    type: 'boolean',
+    default: false,
+    alias: 'v',
+    description: 'Show detailed information'
+})
+    .example('$0 status', 'Check all providers')
+    .example('$0 status --verbose', 'Show detailed status information'), async (argv) => {
+    console.log(chalk.blue('🔍 Checking AI provider status...\n'));
+    const providers = ['openai', 'bedrock', 'vertex'];
+    const results = [];
+    for (const provider of providers) {
+        const spinner = ora(`Testing ${provider}`).start();
+        try {
+            const start = Date.now();
+            await sdk.generateText({
+                prompt: 'test',
+                provider,
+                maxTokens: 1
+            });
+            const duration = Date.now() - start;
+            results.push({
+                provider,
+                status: 'working',
+                responseTime: duration
+            });
+            spinner.succeed(`${provider}: ${chalk.green('✅ Working')} (${duration}ms)`);
+        }
+        catch (error) {
+            results.push({
+                provider,
+                status: 'failed',
+                error: error.message
+            });
+            spinner.fail(`${provider}: ${chalk.red('❌ Failed')} - ${error.message}`);
+        }
+    }
+    // Show summary
+    const working = results.filter(r => r.status === 'working').length;
+    const total = results.length;
+    console.log(chalk.blue(`\n📊 Summary: ${working}/${total} providers working`));
+    if (argv.verbose) {
+        console.log(chalk.blue('\n📋 Detailed Results:'));
+        console.log(JSON.stringify(results, null, 2));
+    }
+})
+    // Get Best Provider Command - Auto-selection testing
+    .command('get-best-provider', 'Show the best available AI provider', () => { }, async () => {
+    const spinner = ora('🎯 Finding best provider...').start();
+    try {
+        const provider = await sdk.getBestProvider();
+        spinner.succeed(chalk.green(`✅ Best provider: ${provider}`));
+    }
+    catch (error) {
+        spinner.fail();
+        handleError(error, 'Provider selection');
+    }
+});
+// Execute CLI
+cli.parse();

package/dist/core/types.d.ts

@@ -55,11 +55,33 @@ export interface StreamingOptions {
     systemPrompt?: string;
 }
 /**
- * AI Provider interface
+ * Text generation options interface
+ */
+export interface TextGenerationOptions {
+    prompt: string;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    systemPrompt?: string;
+    schema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>;
+}
+/**
+ * Stream text options interface
+ */
+export interface StreamTextOptions {
+    prompt: string;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    systemPrompt?: string;
+    schema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>;
+}
+/**
+ * AI Provider interface with flexible parameter support
  */
 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>;
+    streamText(optionsOrPrompt: StreamTextOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamTextResult<ToolSet, unknown> | null>;
+    generateText(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<GenerateTextResult<ToolSet, unknown> | null>;
 }
 /**
  * Provider attempt result for iteration tracking

package/dist/index.d.ts

@@ -14,6 +14,8 @@ 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 { NeuroLink } from './neurolink.js';
+export type { TextGenerationOptions, StreamTextOptions, TextGenerationResult } from './neurolink.js';
 export declare const VERSION = "1.0.0";
 /**
  * Quick start factory function

package/dist/index.js

@@ -16,6 +16,7 @@ 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';
+// Main NeuroLink wrapper class export export { NeuroLink } from './neurolink.js';
 // Version
 export const VERSION = '1.0.0';
 /**

package/dist/neurolink.d.ts

@@ -0,0 +1,53 @@
+/**
+ * NeuroLink - Unified AI Interface
+ *
+ * Simple wrapper around the AI provider system to provide a clean API
+ * for CLI and other consumers.
+ */
+import type { AIProviderName } from './core/types.js';
+export interface TextGenerationOptions {
+    prompt: string;
+    provider?: 'openai' | 'bedrock' | 'vertex' | 'auto';
+    temperature?: number;
+    maxTokens?: number;
+    systemPrompt?: string;
+    schema?: any;
+}
+export interface StreamTextOptions {
+    prompt: string;
+    provider?: 'openai' | 'bedrock' | 'vertex' | 'auto';
+    temperature?: number;
+    maxTokens?: number;
+    systemPrompt?: string;
+}
+export interface TextGenerationResult {
+    content: string;
+    provider?: string;
+    model?: string;
+    usage?: {
+        promptTokens?: number;
+        completionTokens?: number;
+        totalTokens?: number;
+    };
+    responseTime?: number;
+}
+export declare class NeuroLink {
+    /**
+     * Generate text using the best available AI provider
+     */
+    generateText(options: TextGenerationOptions): Promise<TextGenerationResult>;
+    /**
+     * Generate streaming text using the best available AI provider
+     */
+    generateTextStream(options: StreamTextOptions): Promise<AsyncIterable<{
+        content: string;
+    }>>;
+    /**
+     * Get the best available AI provider
+     */
+    getBestProvider(): Promise<string>;
+    /**
+     * Test a specific provider
+     */
+    testProvider(providerName: AIProviderName, testPrompt?: string): Promise<boolean>;
+}

package/dist/neurolink.js

@@ -0,0 +1,101 @@
+/**
+ * NeuroLink - Unified AI Interface
+ *
+ * Simple wrapper around the AI provider system to provide a clean API
+ * for CLI and other consumers.
+ */
+import { AIProviderFactory, createBestAIProvider } from './index.js';
+import { getBestProvider } from './utils/providerUtils.js';
+export class NeuroLink {
+    /**
+     * Generate text using the best available AI provider
+     */
+    async generateText(options) {
+        const startTime = Date.now();
+        try {
+            let provider;
+            let providerName;
+            if (options.provider && options.provider !== 'auto') {
+                provider = AIProviderFactory.createProvider(options.provider);
+                providerName = options.provider;
+            }
+            else {
+                provider = createBestAIProvider();
+                providerName = await getBestProvider();
+            }
+            const result = await provider.generateText({
+                prompt: options.prompt,
+                temperature: options.temperature,
+                maxTokens: options.maxTokens,
+                systemPrompt: options.systemPrompt
+            }, options.schema);
+            if (!result) {
+                throw new Error('No response received from AI provider');
+            }
+            const responseTime = Date.now() - startTime;
+            return {
+                content: result.text,
+                provider: providerName,
+                usage: result.usage,
+                responseTime
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to generate text: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Generate streaming text using the best available AI provider
+     */
+    async generateTextStream(options) {
+        try {
+            let provider;
+            if (options.provider && options.provider !== 'auto') {
+                provider = AIProviderFactory.createProvider(options.provider);
+            }
+            else {
+                provider = createBestAIProvider();
+            }
+            const result = await provider.streamText({
+                prompt: options.prompt,
+                temperature: options.temperature,
+                maxTokens: options.maxTokens,
+                systemPrompt: options.systemPrompt
+            });
+            if (!result) {
+                throw new Error('No stream response received from AI provider');
+            }
+            // Convert the AI SDK stream to our expected format
+            async function* convertStream() {
+                if (result && result.textStream) {
+                    for await (const chunk of result.textStream) {
+                        yield { content: chunk };
+                    }
+                }
+            }
+            return convertStream();
+        }
+        catch (error) {
+            throw new Error(`Failed to stream text: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Get the best available AI provider
+     */
+    async getBestProvider() {
+        return await getBestProvider();
+    }
+    /**
+     * Test a specific provider
+     */
+    async testProvider(providerName, testPrompt = 'test') {
+        try {
+            const provider = AIProviderFactory.createProvider(providerName);
+            await provider.generateText(testPrompt);
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+}

package/dist/providers/amazonBedrock.d.ts

@@ -1,11 +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';
+import type { AIProvider, TextGenerationOptions, StreamTextOptions } 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>;
+    streamText(optionsOrPrompt: StreamTextOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamTextResult<ToolSet, unknown> | null>;
+    generateText(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<GenerateTextResult<ToolSet, unknown> | null>;
 }

package/dist/providers/amazonBedrock.js

@@ -6,7 +6,9 @@ const DEFAULT_SYSTEM_CONTEXT = {
 };
 // 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';
+    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;
@@ -40,7 +42,12 @@ export class AmazonBedrock {
         const functionTag = 'AmazonBedrock.constructor';
         this.modelName = modelName || getBedrockModelId();
         try {
-            console.log(`[${functionTag}] Function called`, { modelName: this.modelName });
+            console.log(`[${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(),
@@ -50,7 +57,9 @@ export class AmazonBedrock {
             console.log(`[${functionTag}] AWS config validation`, {
                 hasAccessKeyId: !!awsConfig.accessKeyId,
                 hasSecretAccessKey: !!awsConfig.secretAccessKey,
-                region: awsConfig.region || 'MISSING'
+                region: awsConfig.region || 'MISSING',
+                accessKeyIdLength: awsConfig.accessKeyId?.length || 0,
+                hasSessionToken: !!process.env.AWS_SESSION_TOKEN
             });
             // Add session token for development environment
             if (getAppEnvironment() === 'dev') {
@@ -109,20 +118,31 @@ export class AmazonBedrock {
             throw err;
         }
     }
-    async streamText(prompt, analysisSchema) {
+    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 = 500, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema } = options;
+            // Use schema from options or fallback parameter
+            const finalSchema = schema || analysisSchema;
             console.log(`[${functionTag}] Stream request started`, {
                 provider,
                 modelName: this.modelName,
-                promptLength: prompt.length
+                promptLength: prompt.length,
+                temperature,
+                maxTokens
             });
             const streamOptions = {
                 model: this.model,
                 prompt: prompt,
-                system: DEFAULT_SYSTEM_CONTEXT.systemPrompt,
+                system: systemPrompt,
+                temperature,
+                maxTokens,
                 onError: (event) => {
                     const error = event.error;
                     const errorMessage = error instanceof Error ? error.message : String(error);
@@ -160,15 +180,9 @@ export class AmazonBedrock {
                     });
                 }
             };
-            if (analysisSchema) {
-                streamOptions.experimental_output = Output.object({ schema: analysisSchema });
+            if (finalSchema) {
+                streamOptions.experimental_output = Output.object({ schema: finalSchema });
             }
-            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`, {
@@ -189,30 +203,42 @@ export class AmazonBedrock {
             throw err; // Re-throw error to trigger fallback
         }
     }
-    async generateText(prompt, analysisSchema) {
+    async generateText(optionsOrPrompt, 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 });
-            }
+            // Parse parameters - support both string and options object
+            const options = typeof optionsOrPrompt === 'string'
+                ? { prompt: optionsOrPrompt }
+                : optionsOrPrompt;
+            const { prompt, temperature = 0.7, maxTokens = 500, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema } = options;
+            // Use schema from options or fallback parameter
+            const finalSchema = schema || analysisSchema;
             console.log(`[${functionTag}] Generate text started`, {
                 provider,
                 modelName: this.modelName,
                 region: getAWSRegion(),
-                promptLength: prompt.length
+                promptLength: prompt.length,
+                temperature,
+                maxTokens
             });
+            const generateOptions = {
+                model: this.model,
+                prompt: prompt,
+                system: systemPrompt,
+                temperature,
+                maxTokens
+            };
+            if (finalSchema) {
+                generateOptions.experimental_output = Output.object({ schema: finalSchema });
+            }
             const result = await generateText(generateOptions);
             console.log(`[${functionTag}] Generate text completed`, {
                 provider,
                 modelName: this.modelName,
                 usage: result.usage,
-                finishReason: result.finishReason
+                finishReason: result.finishReason,
+                responseLength: result.text?.length || 0
             });
             return result;
         }