@juspay/neurolink 1.5.3 → 1.9.0

package/dist/providers/agent-enhanced-provider.js

@@ -0,0 +1,242 @@
+/**
+ * Agent-Enhanced Provider for NeuroLink CLI
+ * Integrates direct tools with AI providers for true agent functionality
+ */
+import { generateText, streamText, } from "ai";
+import { google } from "@ai-sdk/google";
+import { openai } from "@ai-sdk/openai";
+import { anthropic } from "@ai-sdk/anthropic";
+import { directAgentTools, getToolsForCategory, } from "../agent/direct-tools.js";
+/**
+ * Agent-Enhanced Provider Class
+ * Provides AI generation with tool calling capabilities
+ */
+export class AgentEnhancedProvider {
+    config;
+    model;
+    constructor(config) {
+        this.config = {
+            maxSteps: 5,
+            toolCategory: "all",
+            enableTools: true,
+            ...config,
+        };
+        // Initialize the AI model based on provider
+        this.model = this.createModel();
+    }
+    createModel() {
+        const { provider, model } = this.config;
+        switch (provider) {
+            case "google-ai":
+                return google(model || process.env.GOOGLE_AI_MODEL || "gemini-2.0-flash-exp");
+            case "openai":
+                return openai(model || process.env.OPENAI_MODEL || "gpt-4o");
+            case "anthropic":
+                return anthropic(model || process.env.ANTHROPIC_MODEL || "claude-3-5-sonnet-20241022");
+            default:
+                throw new Error(`Unsupported provider: ${provider}`);
+        }
+    }
+    async generateText(optionsOrPrompt) {
+        const options = typeof optionsOrPrompt === "string"
+            ? { prompt: optionsOrPrompt }
+            : optionsOrPrompt;
+        const { prompt, temperature = 0.7, maxTokens = 500, systemPrompt, schema, } = options;
+        // Get tools if enabled
+        const tools = this.config.enableTools
+            ? getToolsForCategory(this.config.toolCategory)
+            : {};
+        try {
+            const result = await generateText({
+                model: this.model,
+                prompt: systemPrompt
+                    ? `System: ${systemPrompt}\n\nUser: ${prompt}`
+                    : prompt,
+                tools,
+                maxSteps: this.config.maxSteps,
+                temperature,
+                maxTokens,
+                // Force tool usage for specific patterns
+                toolChoice: this.shouldForceToolUsage(prompt) ? "required" : "auto",
+            });
+            return result;
+        }
+        catch (error) {
+            console.error("[AgentEnhancedProvider] generateText error:", error);
+            throw error;
+        }
+    }
+    async streamText(optionsOrPrompt) {
+        const options = typeof optionsOrPrompt === "string"
+            ? { prompt: optionsOrPrompt }
+            : optionsOrPrompt;
+        const { prompt, temperature = 0.7, maxTokens = 500, systemPrompt, } = options;
+        // Get tools if enabled
+        const tools = this.config.enableTools
+            ? getToolsForCategory(this.config.toolCategory)
+            : {};
+        try {
+            const result = await streamText({
+                model: this.model,
+                prompt: systemPrompt
+                    ? `System: ${systemPrompt}\n\nUser: ${prompt}`
+                    : prompt,
+                tools,
+                maxSteps: this.config.maxSteps,
+                temperature,
+                maxTokens,
+                toolChoice: this.shouldForceToolUsage(prompt) ? "required" : "auto",
+            });
+            return result;
+        }
+        catch (error) {
+            console.error("[AgentEnhancedProvider] streamText error:", error);
+            throw error;
+        }
+    }
+    /**
+     * Determine if we should force tool usage based on prompt patterns
+     */
+    shouldForceToolUsage(prompt) {
+        const forceToolPatterns = [
+            /what time is it/i,
+            /current time/i,
+            /list files/i,
+            /read file/i,
+            /directory/i,
+            /calculate/i,
+            /math/i,
+            /search for/i,
+            /find files/i,
+        ];
+        return forceToolPatterns.some((pattern) => pattern.test(prompt));
+    }
+    getCapabilities() {
+        return [
+            "text-generation",
+            "streaming",
+            "tool-calling",
+            "agent-functionality",
+        ];
+    }
+    getProviderName() {
+        return `agent-${this.config.provider}`;
+    }
+    getModelName() {
+        return this.config.model || `default-${this.config.provider}-model`;
+    }
+    /**
+     * Test agent functionality
+     */
+    async testAgentCapabilities() {
+        const testPrompts = [
+            "What time is it right now?",
+            "List files in current directory",
+            "Calculate 15 * 7",
+            "What is the square root of 144?",
+        ];
+        const results = [];
+        let successCount = 0;
+        for (const prompt of testPrompts) {
+            try {
+                console.log(`Testing: "${prompt}"`);
+                const result = await this.generateText(prompt);
+                if (!result) {
+                    results.push({
+                        prompt,
+                        success: false,
+                        error: "No result returned from generateText",
+                    });
+                    console.log(`❌ No result returned`);
+                    continue;
+                }
+                const toolsCalled = result.toolCalls?.length || 0;
+                const success = toolsCalled > 0;
+                if (success) {
+                    successCount++;
+                }
+                results.push({
+                    prompt,
+                    success,
+                    toolsCalled,
+                    response: result.text.substring(0, 100) + "...",
+                });
+                console.log(`✅ Tools called: ${toolsCalled}, Response: ${result.text.substring(0, 50)}...`);
+            }
+            catch (error) {
+                results.push({
+                    prompt,
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                console.log(`❌ Error: ${error}`);
+            }
+        }
+        return {
+            success: successCount > 0,
+            results,
+        };
+    }
+    /**
+     * Create agent-enhanced provider factory
+     */
+    static createAgent(config) {
+        return new AgentEnhancedProvider(config);
+    }
+    /**
+     * Create multiple agent providers for comparison
+     */
+    static createMultiProviderAgents() {
+        const providers = {};
+        // Only create providers that have API keys configured
+        if (process.env.GOOGLE_AI_API_KEY) {
+            providers["google-ai"] = new AgentEnhancedProvider({
+                provider: "google-ai",
+            });
+        }
+        if (process.env.OPENAI_API_KEY) {
+            providers["openai"] = new AgentEnhancedProvider({ provider: "openai" });
+        }
+        if (process.env.ANTHROPIC_API_KEY) {
+            providers["anthropic"] = new AgentEnhancedProvider({
+                provider: "anthropic",
+            });
+        }
+        return providers;
+    }
+}
+/**
+ * Helper function to create agent provider
+ */
+export function createAgentProvider(provider, options) {
+    return new AgentEnhancedProvider({
+        provider,
+        ...options,
+    });
+}
+/**
+ * Test all available agent providers
+ */
+export async function testAllAgentProviders() {
+    console.log("🧪 Testing All Agent Providers\n");
+    const providers = AgentEnhancedProvider.createMultiProviderAgents();
+    if (Object.keys(providers).length === 0) {
+        console.log("❌ No API keys found. Please configure at least one provider.");
+        return;
+    }
+    for (const [name, provider] of Object.entries(providers)) {
+        console.log(`\n🔬 Testing ${name.toUpperCase()} Agent Provider:`);
+        try {
+            const testResult = await provider.testAgentCapabilities();
+            if (testResult.success) {
+                console.log(`✅ ${name} agent provider working correctly`);
+            }
+            else {
+                console.log(`❌ ${name} agent provider failed tests`);
+            }
+        }
+        catch (error) {
+            console.log(`❌ ${name} provider error:`, error);
+        }
+    }
+}

package/dist/providers/amazonBedrock.d.ts

@@ -1,6 +1,6 @@
-import type { ZodType, ZodTypeDef } from 'zod';
-import { type StreamTextResult, type ToolSet, type Schema, type GenerateTextResult } from 'ai';
-import type { AIProvider, TextGenerationOptions, StreamTextOptions } from '../core/types.js';
+import type { ZodType, ZodTypeDef } from "zod";
+import { type StreamTextResult, type ToolSet, type Schema, type GenerateTextResult } from "ai";
+import type { AIProvider, TextGenerationOptions, StreamTextOptions } from "../core/types.js";
 export declare class AmazonBedrock implements AIProvider {
     private modelName;
     private model;

package/dist/providers/amazonBedrock.js

@@ -1,38 +1,38 @@
-import { createAmazonBedrock } from '@ai-sdk/amazon-bedrock';
-import { streamText, generateText, Output } from 'ai';
-import { logger } from '../utils/logger.js';
+import { createAmazonBedrock } from "@ai-sdk/amazon-bedrock";
+import { streamText, generateText, Output, } from "ai";
+import { logger } from "../utils/logger.js";
 // Default system context
 const DEFAULT_SYSTEM_CONTEXT = {
-    systemPrompt: 'You are a helpful AI assistant.'
+    systemPrompt: "You are a helpful AI assistant.",
 };
 // Configuration helpers
 const getBedrockModelId = () => {
-    return process.env.BEDROCK_MODEL ||
+    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';
+        "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');
+        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');
+        throw new Error("AWS_SECRET_ACCESS_KEY environment variable is not set");
     }
     return secretKey;
 };
 const getAWSRegion = () => {
-    return process.env.AWS_REGION || 'us-east-2';
+    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';
+    return process.env.PUBLIC_APP_ENVIRONMENT || "dev";
 };
 // Amazon Bedrock class with enhanced error handling using createAmazonBedrock
 export class AmazonBedrock {
@@ -40,95 +40,95 @@ export class AmazonBedrock {
     model;
     bedrock;
     constructor(modelName) {
-        const functionTag = 'AmazonBedrock.constructor';
+        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'
+                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()
+                region: getAWSRegion(),
             };
             logger.debug(`[${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
+                hasSessionToken: !!process.env.AWS_SESSION_TOKEN,
             });
             // Add session token for development environment
-            if (getAppEnvironment() === 'dev') {
+            if (getAppEnvironment() === "dev") {
                 const sessionToken = getAWSSessionToken();
                 if (sessionToken) {
                     awsConfig.sessionToken = sessionToken;
                     logger.debug(`[${functionTag}] Session token added`, {
-                        environment: 'dev'
+                        environment: "dev",
                     });
                 }
                 else {
                     logger.warn(`[${functionTag}] Session token missing`, {
-                        environment: 'dev'
+                        environment: "dev",
                     });
                 }
             }
             logger.debug(`[${functionTag}] AWS config created`, {
                 region: awsConfig.region,
-                hasSessionToken: !!awsConfig.sessionToken
+                hasSessionToken: !!awsConfig.sessionToken,
             });
             logger.debug(`[${functionTag}] Bedrock provider creating`, {
-                modelName: this.modelName
+                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
+                modelName: this.modelName,
             });
             logger.debug(`[${functionTag}] Model instance creating`, {
-                modelName: this.modelName
+                modelName: this.modelName,
             });
             this.model = this.bedrock(this.modelName);
             logger.debug(`[${functionTag}] Model instance created`, {
-                modelName: this.modelName
+                modelName: this.modelName,
             });
             logger.debug(`[${functionTag}] Function result`, {
                 modelName: this.modelName,
                 region: awsConfig.region,
                 hasSessionToken: !!awsConfig.sessionToken,
-                success: true
+                success: true,
             });
             logger.debug(`[${functionTag}] Initialization completed`, {
                 modelName: this.modelName,
                 region: awsConfig.region,
-                hasSessionToken: !!awsConfig.sessionToken
+                hasSessionToken: !!awsConfig.sessionToken,
             });
         }
         catch (err) {
             logger.error(`[${functionTag}] Initialization failed`, {
-                message: 'Error in initializing Amazon Bedrock',
+                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
+                stack: err instanceof Error ? err.stack : undefined,
             });
             throw err;
         }
     }
     async streamText(optionsOrPrompt, analysisSchema) {
-        const functionTag = 'AmazonBedrock.streamText';
-        const provider = 'bedrock';
+        const functionTag = "AmazonBedrock.streamText";
+        const provider = "bedrock";
         let chunkCount = 0;
         try {
             // Parse parameters - support both string and options object
-            const options = typeof optionsOrPrompt === 'string'
+            const options = typeof optionsOrPrompt === "string"
                 ? { prompt: optionsOrPrompt }
                 : optionsOrPrompt;
-            const { prompt, temperature = 0.7, maxTokens = 500, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema } = options;
+            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;
             logger.debug(`[${functionTag}] Stream request started`, {
@@ -136,7 +136,7 @@ export class AmazonBedrock {
                 modelName: this.modelName,
                 promptLength: prompt.length,
                 temperature,
-                maxTokens
+                maxTokens,
             });
             const streamOptions = {
                 model: this.model,
@@ -155,7 +155,7 @@ export class AmazonBedrock {
                         error: errorMessage,
                         stack: errorStack,
                         promptLength: prompt.length,
-                        chunkCount
+                        chunkCount,
                     });
                 },
                 onFinish: (event) => {
@@ -167,7 +167,7 @@ export class AmazonBedrock {
                         usage: event.usage,
                         totalChunks: chunkCount,
                         promptLength: prompt.length,
-                        responseLength: event.text?.length || 0
+                        responseLength: event.text?.length || 0,
                     });
                 },
                 onChunk: (event) => {
@@ -177,19 +177,21 @@ export class AmazonBedrock {
                         modelName: this.modelName,
                         chunkNumber: chunkCount,
                         chunkLength: event.chunk.text?.length || 0,
-                        chunkType: event.chunk.type
+                        chunkType: event.chunk.type,
                     });
-                }
+                },
             };
             if (finalSchema) {
-                streamOptions.experimental_output = Output.object({ schema: 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
+                promptLength: prompt.length,
             });
             return result;
         }
@@ -198,21 +200,21 @@ export class AmazonBedrock {
                 provider,
                 modelName: this.modelName,
                 region: getAWSRegion(),
-                message: 'Error in streaming text',
-                err: String(err)
+                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 functionTag = "AmazonBedrock.generateText";
+        const provider = "bedrock";
         try {
             // Parse parameters - support both string and options object
-            const options = typeof optionsOrPrompt === 'string'
+            const options = typeof optionsOrPrompt === "string"
                 ? { prompt: optionsOrPrompt }
                 : optionsOrPrompt;
-            const { prompt, temperature = 0.7, maxTokens = 500, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema } = options;
+            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;
             logger.debug(`[${functionTag}] Generate text started`, {
@@ -221,17 +223,19 @@ export class AmazonBedrock {
                 region: getAWSRegion(),
                 promptLength: prompt.length,
                 temperature,
-                maxTokens
+                maxTokens,
             });
             const generateOptions = {
                 model: this.model,
                 prompt: prompt,
                 system: systemPrompt,
                 temperature,
-                maxTokens
+                maxTokens,
             };
             if (finalSchema) {
-                generateOptions.experimental_output = Output.object({ schema: finalSchema });
+                generateOptions.experimental_output = Output.object({
+                    schema: finalSchema,
+                });
             }
             const result = await generateText(generateOptions);
             logger.debug(`[${functionTag}] Generate text completed`, {
@@ -239,7 +243,7 @@ export class AmazonBedrock {
                 modelName: this.modelName,
                 usage: result.usage,
                 finishReason: result.finishReason,
-                responseLength: result.text?.length || 0
+                responseLength: result.text?.length || 0,
             });
             return result;
         }
@@ -247,8 +251,8 @@ export class AmazonBedrock {
             logger.error(`[${functionTag}] Exception`, {
                 provider,
                 modelName: this.modelName,
-                message: 'Error in generating text',
-                err: String(err)
+                message: "Error in generating text",
+                err: String(err),
             });
             throw err; // Re-throw error to trigger fallback instead of returning null
         }

package/dist/providers/anthropic.d.ts

@@ -4,8 +4,8 @@
  * 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, StreamTextOptions } from '../core/types.js';
-import { AIProviderName } from '../core/types.js';
+import type { AIProvider, TextGenerationOptions, StreamTextOptions } from "../core/types.js";
+import { AIProviderName } from "../core/types.js";
 export declare class AnthropicProvider implements AIProvider {
     readonly name: AIProviderName;
     private apiKey;