@juspay/neurolink 1.3.0 → 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', 'anthropic', 'azure'];
+    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)) {
@@ -48,6 +48,9 @@ function isProviderConfigured(provider) {
         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;
     }
@@ -57,7 +60,7 @@ function isProviderConfigured(provider) {
  * @returns Array of available provider names
  */
 export function getAvailableProviders() {
-    return ['bedrock', 'vertex', 'openai', 'anthropic', 'azure'];
+    return ['bedrock', 'vertex', 'openai', 'anthropic', 'azure', 'google-ai'];
 }
 /**
  * Validate provider name

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "1.3.0",
+  "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",
@@ -77,6 +77,7 @@
     }
   },
   "dependencies": {
+    "@ai-sdk/google": "^1.2.19",
     "chalk": "^5.3.0",
     "dotenv": "^16.5.0",
     "inquirer": "^9.2.15",
@@ -97,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",