@juspay/neurolink 1.0.0 → 1.1.0

package/dist/providers/googleVertexAI.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 } from '../core/types.js';
+import type { AIProvider, TextGenerationOptions, StreamTextOptions } from '../core/types.js';
 export declare class GoogleVertexAI implements AIProvider {
     private modelName;
     /**
@@ -19,12 +19,12 @@ export declare class GoogleVertexAI implements AIProvider {
      * @param analysisSchema - Optional Zod schema or Schema object for output validation
      * @returns Promise resolving to StreamTextResult or null if operation fails
      */
-    streamText(prompt: string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamTextResult<ToolSet, unknown> | null>;
+    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(prompt: string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<GenerateTextResult<ToolSet, unknown> | null>;
+    generateText(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<GenerateTextResult<ToolSet, unknown> | null>;
 }

package/dist/providers/googleVertexAI.js

@@ -40,37 +40,143 @@ const getGCPVertexBreezeLocation = () => {
 const getGoogleApplicationCredentials = () => {
     return process.env.GOOGLE_APPLICATION_CREDENTIALS;
 };
+const getGoogleServiceAccountKey = () => {
+    return process.env.GOOGLE_SERVICE_ACCOUNT_KEY;
+};
+const getGoogleClientEmail = () => {
+    return process.env.GOOGLE_AUTH_CLIENT_EMAIL;
+};
+const getGooglePrivateKey = () => {
+    return process.env.GOOGLE_AUTH_PRIVATE_KEY;
+};
 const getVertexModelId = () => {
     return process.env.VERTEX_MODEL_ID || 'claude-sonnet-4@20250514';
 };
 const hasPrincipalAccountAuth = () => {
     return !!getGoogleApplicationCredentials();
 };
-// Vertex AI setup with Principal Account Authentication support
-const createVertexSettings = () => {
+const hasServiceAccountKeyAuth = () => {
+    return !!getGoogleServiceAccountKey();
+};
+const hasServiceAccountEnvAuth = () => {
+    return !!(getGoogleClientEmail() && getGooglePrivateKey());
+};
+const hasValidAuth = () => {
+    return hasPrincipalAccountAuth() || hasServiceAccountKeyAuth() || hasServiceAccountEnvAuth();
+};
+// Setup environment for Google authentication
+const setupGoogleAuth = async () => {
+    const functionTag = 'setupGoogleAuth';
+    // Method 2: Service Account Key (JSON string) - Create temporary file
+    if (hasServiceAccountKeyAuth() && !hasPrincipalAccountAuth()) {
+        const serviceAccountKey = getGoogleServiceAccountKey();
+        console.log(`[${functionTag}] Service account key auth (JSON string)`, {
+            hasServiceAccountKey: !!serviceAccountKey,
+            authMethod: 'service_account_key'
+        });
+        try {
+            // Parse to validate JSON
+            JSON.parse(serviceAccountKey);
+            // Write to temporary file and set environment variable using dynamic imports
+            const { writeFileSync } = await import('fs');
+            const { join } = await import('path');
+            const { tmpdir } = await import('os');
+            const tempFile = join(tmpdir(), `gcp-credentials-${Date.now()}.json`);
+            writeFileSync(tempFile, serviceAccountKey);
+            process.env.GOOGLE_APPLICATION_CREDENTIALS = tempFile;
+            console.log(`[${functionTag}] Created temporary credentials file`, {
+                tempFile: '[CREATED]',
+                authMethod: 'service_account_key_temp_file'
+            });
+        }
+        catch (error) {
+            console.error(`[${functionTag}] Failed to parse service account key`, {
+                error: error instanceof Error ? error.message : String(error)
+            });
+            throw new Error('Invalid GOOGLE_SERVICE_ACCOUNT_KEY format. Must be valid JSON.');
+        }
+    }
+    // Method 3: Service Account Environment Variables - Set as individual env vars
+    if (hasServiceAccountEnvAuth() && !hasPrincipalAccountAuth() && !hasServiceAccountKeyAuth()) {
+        const clientEmail = getGoogleClientEmail();
+        const privateKey = getGooglePrivateKey();
+        console.log(`[${functionTag}] Service account env auth (separate variables)`, {
+            hasClientEmail: !!clientEmail,
+            hasPrivateKey: !!privateKey,
+            authMethod: 'service_account_env'
+        });
+        // Create service account object and write to temporary file
+        const serviceAccount = {
+            type: 'service_account',
+            project_id: getGCPVertexBreezeProjectId(),
+            client_email: clientEmail,
+            private_key: privateKey.replace(/\\n/g, '\n'),
+            auth_uri: 'https://accounts.google.com/o/oauth2/auth',
+            token_uri: 'https://oauth2.googleapis.com/token'
+        };
+        try {
+            // Use dynamic imports for ESM compatibility
+            const { writeFileSync } = await import('fs');
+            const { join } = await import('path');
+            const { tmpdir } = await import('os');
+            const tempFile = join(tmpdir(), `gcp-credentials-env-${Date.now()}.json`);
+            writeFileSync(tempFile, JSON.stringify(serviceAccount, null, 2));
+            process.env.GOOGLE_APPLICATION_CREDENTIALS = tempFile;
+            console.log(`[${functionTag}] Created temporary credentials file from env vars`, {
+                tempFile: '[CREATED]',
+                authMethod: 'service_account_env_temp_file'
+            });
+        }
+        catch (error) {
+            console.error(`[${functionTag}] Failed to create service account file from env vars`, {
+                error: error instanceof Error ? error.message : String(error)
+            });
+            throw new Error('Failed to create temporary service account file from environment variables.');
+        }
+    }
+};
+// Vertex AI setup with multiple authentication support
+const createVertexSettings = async () => {
     const functionTag = 'createVertexSettings';
+    // Setup authentication first
+    await setupGoogleAuth();
     const baseSettings = {
         project: getGCPVertexBreezeProjectId(),
         location: getGCPVertexBreezeLocation()
     };
-    // Check for principal account authentication first (recommended for production)
+    // Method 1: Principal Account Authentication (file path) - Recommended for production
     if (hasPrincipalAccountAuth()) {
         const credentialsPath = getGoogleApplicationCredentials();
-        console.log(`[${functionTag}] Principal account auth`, {
+        console.log(`[${functionTag}] Principal account auth (file path)`, {
             credentialsPath: credentialsPath ? '[PROVIDED]' : '[NOT_PROVIDED]',
-            authMethod: 'principal_account'
+            authMethod: 'principal_account_file'
+        });
+        return baseSettings;
+    }
+    // Method 2 & 3: Other methods now set GOOGLE_APPLICATION_CREDENTIALS in setupGoogleAuth()
+    if (hasServiceAccountKeyAuth() || hasServiceAccountEnvAuth()) {
+        console.log(`[${functionTag}] Alternative auth method configured`, {
+            authMethod: hasServiceAccountKeyAuth() ? 'service_account_key' : 'service_account_env',
+            credentialsSet: !!process.env.GOOGLE_APPLICATION_CREDENTIALS
         });
-        // For principal account auth, we don't need to provide explicit credentials
-        // The google-auth-library will use GOOGLE_APPLICATION_CREDENTIALS automatically
         return baseSettings;
     }
-    // Log warning if no valid authentication is available
-    console.warn(`[${functionTag}] No valid auth`, {
+    // No valid authentication found
+    console.error(`[${functionTag}] No valid authentication method found`, {
         authMethod: 'none',
-        hasPrincipalAccount: hasPrincipalAccountAuth()
+        hasPrincipalAccount: hasPrincipalAccountAuth(),
+        hasServiceAccountKey: hasServiceAccountKeyAuth(),
+        hasServiceAccountEnv: hasServiceAccountEnvAuth(),
+        availableMethods: [
+            'GOOGLE_APPLICATION_CREDENTIALS (file path)',
+            'GOOGLE_SERVICE_ACCOUNT_KEY (JSON string)',
+            'GOOGLE_AUTH_CLIENT_EMAIL + GOOGLE_AUTH_PRIVATE_KEY (env vars)'
+        ]
     });
-    // Return base settings and let it fail if no auth is available
-    return baseSettings;
+    throw new Error('No valid Google Vertex AI authentication found. Please provide one of:\n' +
+        '1. GOOGLE_APPLICATION_CREDENTIALS (path to service account file)\n' +
+        '2. GOOGLE_SERVICE_ACCOUNT_KEY (JSON string of service account)\n' +
+        '3. GOOGLE_AUTH_CLIENT_EMAIL + GOOGLE_AUTH_PRIVATE_KEY (environment variables)');
 };
 // Helper function to determine if a model is an Anthropic model
 const isAnthropicModel = (modelName) => {
@@ -79,9 +185,10 @@ const isAnthropicModel = (modelName) => {
 };
 // Lazy initialization cache
 let _vertex = null;
-function getVertexInstance() {
+async function getVertexInstance() {
     if (!_vertex) {
-        _vertex = createVertex(createVertexSettings());
+        const settings = await createVertexSettings();
+        _vertex = createVertex(settings);
     }
     return _vertex;
 }
@@ -149,10 +256,11 @@ export class GoogleVertexAI {
                 throw new Error(`Anthropic model "${this.modelName}" requested but @ai-sdk/google-vertex/anthropic is not available. ` +
                     'Please install @ai-sdk/google-vertex ^2.2.0 or use a Google model instead.');
             }
-            const vertexAnthropic = createVertexAnthropic(createVertexSettings());
+            const settings = await createVertexSettings();
+            const vertexAnthropic = createVertexAnthropic(settings);
             return vertexAnthropic(this.modelName);
         }
-        const vertex = getVertexInstance();
+        const vertex = await getVertexInstance();
         return vertex(this.modelName);
     }
     /**
@@ -161,23 +269,34 @@ export class GoogleVertexAI {
      * @param analysisSchema - Optional Zod schema or Schema object for output validation
      * @returns Promise resolving to StreamTextResult or null if operation fails
      */
-    async streamText(prompt, analysisSchema) {
+    async streamText(optionsOrPrompt, analysisSchema) {
         const functionTag = 'GoogleVertexAI.streamText';
         const provider = 'vertex';
         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,
                 isAnthropic: isAnthropicModel(this.modelName),
                 promptLength: prompt.length,
-                hasSchema: !!analysisSchema
+                temperature,
+                maxTokens,
+                hasSchema: !!finalSchema
             });
             const model = await this.getModel();
             const streamOptions = {
                 model: 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);
@@ -236,37 +355,43 @@ export class GoogleVertexAI {
      * @param analysisSchema - Optional Zod schema or Schema object for output validation
      * @returns Promise resolving to GenerateTextResult or null if operation fails
      */
-    async generateText(prompt, analysisSchema) {
+    async generateText(optionsOrPrompt, analysisSchema) {
         const functionTag = 'GoogleVertexAI.generateText';
         const provider = 'vertex';
         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,
                 isAnthropic: isAnthropicModel(this.modelName),
-                promptLength: prompt.length
+                promptLength: prompt.length,
+                temperature,
+                maxTokens
             });
             const model = await this.getModel();
             const generateOptions = {
                 model: model,
                 prompt: prompt,
-                system: DEFAULT_SYSTEM_CONTEXT.systemPrompt
+                system: systemPrompt,
+                temperature,
+                maxTokens
             };
-            if (analysisSchema) {
-                generateOptions.experimental_output = Output.object({ schema: analysisSchema });
+            if (finalSchema) {
+                generateOptions.experimental_output = Output.object({ schema: finalSchema });
             }
-            console.log(`[${functionTag}] Generate text started`, {
-                provider,
-                modelName: this.modelName,
-                isAnthropic: isAnthropicModel(this.modelName),
-                promptLength: prompt.length
-            });
             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;
         }

package/dist/providers/openAI.d.ts

@@ -1,10 +1,10 @@
 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 OpenAI implements AIProvider {
     private modelName;
     private model;
     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/openAI.js

@@ -41,15 +41,31 @@ export class OpenAI {
             throw err;
         }
     }
-    async streamText(prompt, analysisSchema) {
+    async streamText(optionsOrPrompt, analysisSchema) {
         const functionTag = 'OpenAI.streamText';
         const provider = 'openai';
         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 text started`, {
+                provider,
+                modelName: this.modelName,
+                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);
@@ -85,14 +101,9 @@ export class OpenAI {
                     });
                 }
             };
-            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,
-                promptLength: prompt.length
-            });
             const result = streamText(streamOptions);
             return result;
         }
@@ -106,29 +117,41 @@ export class OpenAI {
             return null;
         }
     }
-    async generateText(prompt, analysisSchema) {
+    async generateText(optionsOrPrompt, analysisSchema) {
         const functionTag = 'OpenAI.generateText';
         const provider = 'openai';
         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 text started`, {
+                provider,
+                modelName: this.modelName,
+                promptLength: prompt.length,
+                temperature,
+                maxTokens
+            });
             const generateOptions = {
                 model: this.model,
                 prompt: prompt,
-                system: DEFAULT_SYSTEM_CONTEXT.systemPrompt
+                system: systemPrompt,
+                temperature,
+                maxTokens
             };
-            if (analysisSchema) {
-                generateOptions.experimental_output = Output.object({ schema: analysisSchema });
+            if (finalSchema) {
+                generateOptions.experimental_output = Output.object({ schema: finalSchema });
             }
-            console.log(`[${functionTag}] Generate text started`, {
-                provider,
-                modelName: this.modelName,
-                promptLength: prompt.length
-            });
             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;
         }

package/dist/utils/providerUtils.js

@@ -11,8 +11,8 @@ export function getBestProvider(requestedProvider) {
     if (requestedProvider) {
         return requestedProvider;
     }
-    // Default fallback order based on environment variables
-    const providers = ['bedrock', 'vertex', 'openai'];
+    // Default fallback order based on environment variables - OpenAI first since it's most reliable
+    const providers = ['openai', 'vertex', 'bedrock'];
     // Check which providers have their required environment variables
     for (const provider of providers) {
         if (isProviderConfigured(provider)) {

package/package.json

@@ -1,21 +1,26 @@
 {
 	"name": "@juspay/neurolink",
-	"version": "1.0.0",
+	"version": "1.1.0",
 	"description": "AI toolkit with multi-provider support for OpenAI, Amazon Bedrock, and Google Vertex AI",
 	"author": "Juspay Technologies",
 	"license": "MIT",
 	"scripts": {
 		"dev": "vite dev",
 		"build": "vite build && npm run prepack",
+		"build:cli": "tsc src/cli/index.ts --outDir dist/cli --target es2022 --module esnext --moduleResolution bundler --allowImportingTsExtensions false --resolveJsonModule --esModuleInterop --allowSyntheticDefaultImports --strict --rootDir src/cli",
+		"cli": "node dist/cli/index.js",
 		"preview": "vite preview",
 		"prepare": "svelte-kit sync || echo ''",
-		"prepack": "svelte-kit sync && svelte-package && publint",
+		"prepack": "svelte-kit sync && svelte-package && npm run build:cli && publint",
 		"check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
 		"check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
 		"test": "vitest",
 		"test:run": "vitest run",
 		"lint": "prettier --check . && eslint .",
-		"format": "prettier --write ."
+		"format": "prettier --write .",
+		"changeset": "changeset",
+		"changeset:version": "changeset version && git add --all",
+		"publish": "npm run build && npm publish --access public"
 	},
 	"files": [
 		"dist",
@@ -29,6 +34,9 @@
 	"types": "./dist/index.d.ts",
 	"type": "module",
 	"main": "./dist/index.js",
+	"bin": {
+		"neurolink": "./dist/cli/index.js"
+	},
 	"exports": {
 		".": {
 			"types": "./dist/index.d.ts",
@@ -38,18 +46,26 @@
 		}
 	},
 	"peerDependencies": {
-		"ai": "^4.0.0",
 		"@ai-sdk/amazon-bedrock": "^1.0.0",
-		"@ai-sdk/openai": "^1.0.0",
 		"@ai-sdk/google-vertex": "^2.2.0",
+		"@ai-sdk/openai": "^1.0.0",
+		"ai": "^4.0.0",
 		"zod": "^3.22.0"
 	},
+	"dependencies": {
+		"chalk": "^5.3.0",
+		"ora": "^7.0.1",
+		"playwright": "^1.52.0",
+		"yargs": "^17.7.2"
+	},
 	"devDependencies": {
+		"@changesets/cli": "^2.26.2",
 		"@sveltejs/adapter-auto": "^6.0.0",
 		"@sveltejs/kit": "^2.16.0",
 		"@sveltejs/package": "^2.0.0",
 		"@sveltejs/vite-plugin-svelte": "^5.0.0",
 		"@types/node": "^20.0.0",
+		"@types/yargs": "^17.0.33",
 		"eslint": "^9.0.0",
 		"prettier": "^3.0.0",
 		"publint": "^0.3.2",