@juspay/neurolink 1.2.4 → 1.5.0

package/dist/providers/googleAIStudio.d.ts

@@ -0,0 +1,30 @@
+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 GoogleAIStudio implements AIProvider {
+    private modelName;
+    /**
+     * Initializes a new instance of GoogleAIStudio
+     * @param modelName - Optional model name to override the default from config
+     */
+    constructor(modelName?: string | null);
+    /**
+     * Gets the appropriate model instance
+     * @private
+     */
+    private getModel;
+    /**
+     * Processes text using streaming approach with enhanced error handling callbacks
+     * @param prompt - The input text prompt to analyze
+     * @param analysisSchema - Optional Zod schema or Schema object for output validation
+     * @returns Promise resolving to StreamTextResult or null if operation fails
+     */
+    streamText(optionsOrPrompt: StreamTextOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamTextResult<ToolSet, unknown> | null>;
+    /**
+     * Processes text using non-streaming approach with optional schema validation
+     * @param prompt - The input text prompt to analyze
+     * @param analysisSchema - Optional Zod schema or Schema object for output validation
+     * @returns Promise resolving to GenerateTextResult or null if operation fails
+     */
+    generateText(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<GenerateTextResult<ToolSet, unknown> | null>;
+}

package/dist/providers/googleAIStudio.js

@@ -0,0 +1,215 @@
+import { createGoogleGenerativeAI } from '@ai-sdk/google';
+import { streamText, generateText, Output } from 'ai';
+// Default system context
+const DEFAULT_SYSTEM_CONTEXT = {
+    systemPrompt: 'You are a helpful AI assistant.'
+};
+// Configuration helpers
+const getGoogleAIApiKey = () => {
+    const apiKey = process.env.GOOGLE_AI_API_KEY || process.env.GOOGLE_GENERATIVE_AI_API_KEY;
+    if (!apiKey) {
+        throw new Error('GOOGLE_AI_API_KEY environment variable is not set');
+    }
+    return apiKey;
+};
+const getGoogleAIModelId = () => {
+    return process.env.GOOGLE_AI_MODEL || 'gemini-1.5-pro-latest';
+};
+const hasValidAuth = () => {
+    return !!(process.env.GOOGLE_AI_API_KEY || process.env.GOOGLE_GENERATIVE_AI_API_KEY);
+};
+// Lazy initialization cache
+let _google = null;
+function getGoogleInstance() {
+    if (!_google) {
+        const apiKey = getGoogleAIApiKey();
+        _google = createGoogleGenerativeAI({
+            apiKey: apiKey,
+            headers: {
+                'X-Powered-By': 'NeuroLink'
+            }
+        });
+    }
+    return _google;
+}
+// Google AI Studio class with enhanced error handling
+export class GoogleAIStudio {
+    modelName;
+    /**
+     * Initializes a new instance of GoogleAIStudio
+     * @param modelName - Optional model name to override the default from config
+     */
+    constructor(modelName) {
+        const functionTag = 'GoogleAIStudio.constructor';
+        this.modelName = modelName || getGoogleAIModelId();
+        try {
+            console.log(`[${functionTag}] Initialization started`, {
+                modelName: this.modelName,
+                hasApiKey: hasValidAuth()
+            });
+            console.log(`[${functionTag}] Initialization completed`, {
+                modelName: this.modelName,
+                success: true
+            });
+        }
+        catch (err) {
+            console.error(`[${functionTag}] Initialization failed`, {
+                message: 'Error in initializing Google AI Studio',
+                modelName: this.modelName,
+                error: err instanceof Error ? err.message : String(err),
+                stack: err instanceof Error ? err.stack : undefined
+            });
+        }
+    }
+    /**
+     * Gets the appropriate model instance
+     * @private
+     */
+    getModel() {
+        console.log('GoogleAIStudio.getModel - Google AI model selected', {
+            modelName: this.modelName
+        });
+        const google = getGoogleInstance();
+        return google(this.modelName);
+    }
+    /**
+     * Processes text using streaming approach with enhanced error handling callbacks
+     * @param prompt - The input text prompt to analyze
+     * @param analysisSchema - Optional Zod schema or Schema object for output validation
+     * @returns Promise resolving to StreamTextResult or null if operation fails
+     */
+    async streamText(optionsOrPrompt, analysisSchema) {
+        const functionTag = 'GoogleAIStudio.streamText';
+        const provider = 'google-ai';
+        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,
+                temperature,
+                maxTokens,
+                hasSchema: !!finalSchema
+            });
+            const model = this.getModel();
+            const streamOptions = {
+                model: model,
+                prompt: prompt,
+                system: systemPrompt,
+                temperature,
+                maxTokens,
+                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,
+                        error: errorMessage,
+                        stack: errorStack,
+                        promptLength: prompt.length,
+                        chunkCount
+                    });
+                },
+                onFinish: (event) => {
+                    console.log(`[${functionTag}] Stream text finished`, {
+                        provider,
+                        modelName: this.modelName,
+                        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 });
+            }
+            const result = streamText(streamOptions);
+            return result;
+        }
+        catch (err) {
+            console.error(`[${functionTag}] Exception`, {
+                provider,
+                modelName: this.modelName,
+                message: 'Error in streaming text',
+                err: String(err),
+                promptLength: typeof optionsOrPrompt === 'string' ? optionsOrPrompt.length : optionsOrPrompt.prompt.length
+            });
+            throw err; // Re-throw error to trigger fallback
+        }
+    }
+    /**
+     * Processes text using non-streaming approach with optional schema validation
+     * @param prompt - The input text prompt to analyze
+     * @param analysisSchema - Optional Zod schema or Schema object for output validation
+     * @returns Promise resolving to GenerateTextResult or null if operation fails
+     */
+    async generateText(optionsOrPrompt, analysisSchema) {
+        const functionTag = 'GoogleAIStudio.generateText';
+        const provider = 'google-ai';
+        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}] Generate request started`, {
+                provider,
+                modelName: this.modelName,
+                promptLength: prompt.length,
+                temperature,
+                maxTokens
+            });
+            const model = this.getModel();
+            const generateOptions = {
+                model: 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,
+                responseLength: result.text?.length || 0
+            });
+            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
+        }
+    }
+}

package/dist/providers/googleVertexAI.js

@@ -346,7 +346,7 @@ export class GoogleVertexAI {
                 err: String(err),
                 promptLength: prompt.length
             });
-            return null;
+            throw err; // Re-throw error to trigger fallback
         }
     }
     /**
@@ -402,7 +402,7 @@ export class GoogleVertexAI {
                 message: 'Error in generating text',
                 err: String(err)
             });
-            return null;
+            throw err; // Re-throw error to trigger fallback
         }
     }
 }

package/dist/providers/index.d.ts

@@ -7,6 +7,7 @@ export { AmazonBedrock } from './amazonBedrock.js';
 export { OpenAI } from './openAI.js';
 export { AnthropicProvider } from './anthropic.js';
 export { AzureOpenAIProvider } from './azureOpenAI.js';
+export { GoogleAIStudio } from './googleAIStudio.js';
 export type { AIProvider } from '../core/types.js';
 /**
  * Provider registry for dynamic provider instantiation
@@ -17,6 +18,7 @@ export declare const PROVIDERS: {
     readonly openai: "OpenAI";
     readonly anthropic: "AnthropicProvider";
     readonly azure: "AzureOpenAIProvider";
+    readonly 'google-ai': "GoogleAIStudio";
 };
 /**
  * Type for valid provider names

package/dist/providers/index.js

@@ -7,6 +7,7 @@ export { AmazonBedrock } from './amazonBedrock.js';
 export { OpenAI } from './openAI.js';
 export { AnthropicProvider } from './anthropic.js';
 export { AzureOpenAIProvider } from './azureOpenAI.js';
+export { GoogleAIStudio } from './googleAIStudio.js';
 /**
  * Provider registry for dynamic provider instantiation
  */
@@ -15,7 +16,8 @@ export const PROVIDERS = {
     bedrock: 'AmazonBedrock',
     openai: 'OpenAI',
     anthropic: 'AnthropicProvider',
-    azure: 'AzureOpenAIProvider'
+    azure: 'AzureOpenAIProvider',
+    'google-ai': 'GoogleAIStudio'
 };
 /**
  * List of all available provider names

package/dist/providers/openAI.js

@@ -114,7 +114,7 @@ export class OpenAI {
                 message: 'Error in streaming text',
                 err: String(err)
             });
-            return null;
+            throw err; // Re-throw error to trigger fallback
         }
     }
     async generateText(optionsOrPrompt, analysisSchema) {
@@ -162,7 +162,7 @@ export class OpenAI {
                 message: 'Error in generating text',
                 err: String(err)
             });
-            return null;
+            throw err; // Re-throw error to trigger fallback
         }
     }
 }

package/dist/utils/providerUtils.js

@@ -12,7 +12,7 @@ export function getBestProvider(requestedProvider) {
         return requestedProvider;
     }
     // Default fallback order based on environment variables - OpenAI first since it's most reliable
-    const providers = ['openai', 'vertex', 'bedrock'];
+    const providers = ['openai', 'vertex', 'bedrock', 'anthropic', 'azure', 'google-ai'];
     // Check which providers have their required environment variables
     for (const provider of providers) {
         if (isProviderConfigured(provider)) {
@@ -42,6 +42,15 @@ function isProviderConfigured(provider) {
         case 'openai':
         case 'gpt':
             return !!process.env.OPENAI_API_KEY;
+        case 'anthropic':
+        case 'claude':
+            return !!process.env.ANTHROPIC_API_KEY;
+        case 'azure':
+        case 'azure-openai':
+            return !!process.env.AZURE_OPENAI_API_KEY;
+        case 'google-ai':
+        case 'google-studio':
+            return !!(process.env.GOOGLE_AI_API_KEY || process.env.GOOGLE_GENERATIVE_AI_API_KEY);
         default:
             return false;
     }
@@ -51,7 +60,7 @@ function isProviderConfigured(provider) {
  * @returns Array of available provider names
  */
 export function getAvailableProviders() {
-    return ['bedrock', 'vertex', 'openai'];
+    return ['bedrock', 'vertex', 'openai', 'anthropic', 'azure', 'google-ai'];
 }
 /**
  * Validate provider name

package/package.json

@@ -1,13 +1,38 @@
 {
   "name": "@juspay/neurolink",
-  "version": "1.2.4",
-  "description": "AI toolkit with multi-provider support for OpenAI, Amazon Bedrock, and Google Vertex AI",
-  "author": "Juspay Technologies",
+  "version": "1.5.0",
+  "description": "Universal AI Development Platform with external MCP server integration, multi-provider support, and professional CLI. Connect to 65+ MCP servers for filesystem, GitHub, database operations, and more. Build, test, and deploy AI applications with OpenAI, Anthropic, Google Vertex AI, and AWS Bedrock.",
+  "author": {
+    "name": "Juspay Technologies",
+    "email": "support@juspay.in",
+    "url": "https://juspay.io"
+  },
   "license": "MIT",
+  "homepage": "https://github.com/juspay/neurolink#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/juspay/neurolink.git"
+  },
+  "bugs": {
+    "url": "https://github.com/juspay/neurolink/issues"
+  },
+  "funding": {
+    "type": "individual",
+    "url": "https://github.com/sponsors/juspay"
+  },
+  "engines": {
+    "node": ">=18.0.0",
+    "npm": ">=8.0.0",
+    "pnpm": ">=8.0.0"
+  },
   "files": [
     "dist",
     "!dist/**/*.test.*",
-    "!dist/**/*.spec.*"
+    "!dist/**/*.spec.*",
+    "!dist/**/*.map",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
   ],
   "sideEffects": [
     "**/*.css"
@@ -25,6 +50,12 @@
       "svelte": "./dist/index.js",
       "import": "./dist/index.js",
       "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json",
+    "./cli": {
+      "types": "./dist/cli/index.d.ts",
+      "import": "./dist/cli/index.js",
+      "default": "./dist/cli/index.js"
     }
   },
   "peerDependencies": {
@@ -34,7 +65,19 @@
     "ai": "^4.0.0",
     "zod": "^3.22.0"
   },
+  "peerDependenciesMeta": {
+    "@ai-sdk/amazon-bedrock": {
+      "optional": true
+    },
+    "@ai-sdk/google-vertex": {
+      "optional": true
+    },
+    "@ai-sdk/openai": {
+      "optional": true
+    }
+  },
   "dependencies": {
+    "@ai-sdk/google": "^1.2.19",
     "chalk": "^5.3.0",
     "dotenv": "^16.5.0",
     "inquirer": "^9.2.15",
@@ -55,6 +98,7 @@
     "eslint": "^9.0.0",
     "prettier": "^3.0.0",
     "publint": "^0.3.2",
+    "puppeteer": "^24.10.0",
     "svelte": "^5.0.0",
     "svelte-check": "^4.0.0",
     "tslib": "^2.4.1",
@@ -65,6 +109,11 @@
   "keywords": [
     "ai",
     "llm",
+    "mcp",
+    "model-context-protocol",
+    "lighthouse",
+    "tool-orchestration",
+    "ai-platform",
     "openai",
     "anthropic",
     "google",
@@ -74,12 +123,35 @@
     "tools",
     "neurolink",
     "juspay",
-    "svelte"
+    "svelte",
+    "chatgpt",
+    "gpt-4",
+    "claude",
+    "gemini",
+    "ai-sdk",
+    "typescript",
+    "cli-tool",
+    "developer-tools",
+    "automation",
+    "machine-learning",
+    "artificial-intelligence",
+    "multi-provider",
+    "ai-agents",
+    "prompt-engineering",
+    "ai-workflow",
+    "universal-ai",
+    "ai-development",
+    "llm-integration"
+  ],
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
   ],
   "scripts": {
     "dev": "vite dev",
     "build": "vite build && pnpm run prepack",
-    "build:cli": "echo 'Building CLI...' && tsc src/cli/index.ts --outDir dist/cli --target es2022 --module esnext --moduleResolution bundler --allowImportingTsExtensions false --resolveJsonModule --esModuleInterop --allowSyntheticDefaultImports --strict --rootDir src/cli",
+    "build:cli": "echo 'Building CLI...' && tsc --project tsconfig.cli.json",
     "cli": "node dist/cli/index.js",
     "preview": "vite preview",
     "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",