@juspay/neurolink 1.0.0

package/dist/providers/googleVertexAI.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 } from '../core/types.js';
+export declare class GoogleVertexAI implements AIProvider {
+    private modelName;
+    /**
+     * Initializes a new instance of GoogleVertexAI
+     * @param modelName - Optional model name to override the default from config
+     */
+    constructor(modelName?: string | null);
+    /**
+     * Gets the appropriate model instance (Google or Anthropic)
+     * @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(prompt: 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>;
+}

package/dist/providers/googleVertexAI.js

@@ -0,0 +1,283 @@
+import { createVertex } from '@ai-sdk/google-vertex';
+// Cache for anthropic module to avoid repeated imports
+let _createVertexAnthropic = null;
+let _anthropicImportAttempted = false;
+// Function to dynamically import anthropic support
+async function getCreateVertexAnthropic() {
+    if (_anthropicImportAttempted) {
+        return _createVertexAnthropic;
+    }
+    _anthropicImportAttempted = true;
+    try {
+        // Try to import the anthropic module - available in @ai-sdk/google-vertex ^2.2.0+
+        const anthropicModule = await import('@ai-sdk/google-vertex/anthropic');
+        _createVertexAnthropic = anthropicModule.createVertexAnthropic;
+        console.log('[GoogleVertexAI] Anthropic module successfully loaded');
+        return _createVertexAnthropic;
+    }
+    catch (error) {
+        // Anthropic module not available
+        console.warn('[GoogleVertexAI] Anthropic module not available. Install @ai-sdk/google-vertex ^2.2.0 for Anthropic model support.');
+        return null;
+    }
+}
+import { streamText, generateText, Output } from 'ai';
+// Default system context
+const DEFAULT_SYSTEM_CONTEXT = {
+    systemPrompt: 'You are a helpful AI assistant.'
+};
+// Configuration helpers
+const getGCPVertexBreezeProjectId = () => {
+    const projectId = process.env.GOOGLE_VERTEX_PROJECT;
+    if (!projectId) {
+        throw new Error('GOOGLE_VERTEX_PROJECT environment variable is not set');
+    }
+    return projectId;
+};
+const getGCPVertexBreezeLocation = () => {
+    return process.env.GOOGLE_VERTEX_LOCATION || 'us-east5';
+};
+const getGoogleApplicationCredentials = () => {
+    return process.env.GOOGLE_APPLICATION_CREDENTIALS;
+};
+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 functionTag = 'createVertexSettings';
+    const baseSettings = {
+        project: getGCPVertexBreezeProjectId(),
+        location: getGCPVertexBreezeLocation()
+    };
+    // Check for principal account authentication first (recommended for production)
+    if (hasPrincipalAccountAuth()) {
+        const credentialsPath = getGoogleApplicationCredentials();
+        console.log(`[${functionTag}] Principal account auth`, {
+            credentialsPath: credentialsPath ? '[PROVIDED]' : '[NOT_PROVIDED]',
+            authMethod: 'principal_account'
+        });
+        // 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`, {
+        authMethod: 'none',
+        hasPrincipalAccount: hasPrincipalAccountAuth()
+    });
+    // Return base settings and let it fail if no auth is available
+    return baseSettings;
+};
+// Helper function to determine if a model is an Anthropic model
+const isAnthropicModel = (modelName) => {
+    // Anthropic models in Vertex AI contain "claude" anywhere in the model name
+    return modelName.toLowerCase().includes('claude');
+};
+// Lazy initialization cache
+let _vertex = null;
+function getVertexInstance() {
+    if (!_vertex) {
+        _vertex = createVertex(createVertexSettings());
+    }
+    return _vertex;
+}
+// Google Vertex AI class with enhanced error handling and Anthropic model support
+export class GoogleVertexAI {
+    modelName;
+    /**
+     * Initializes a new instance of GoogleVertexAI
+     * @param modelName - Optional model name to override the default from config
+     */
+    constructor(modelName) {
+        const functionTag = 'GoogleVertexAI.constructor';
+        this.modelName = modelName || getVertexModelId();
+        try {
+            console.log(`[${functionTag}] Initialization started`, {
+                modelName: this.modelName,
+                isAnthropic: isAnthropicModel(this.modelName)
+            });
+            const hasPrincipal = hasPrincipalAccountAuth();
+            console.log(`[${functionTag}] Authentication validation`, {
+                hasPrincipalAccountAuth: hasPrincipal,
+                projectId: getGCPVertexBreezeProjectId() || 'MISSING',
+                location: getGCPVertexBreezeLocation() || 'MISSING'
+            });
+            if (hasPrincipal) {
+                console.log(`[${functionTag}] Auth method selected`, {
+                    authMethod: 'principal_account',
+                    hasGoogleApplicationCredentials: !!getGoogleApplicationCredentials()
+                });
+            }
+            else {
+                console.warn(`[${functionTag}] Auth method missing`, {
+                    authMethod: 'none',
+                    hasPrincipalAccountAuth: hasPrincipal
+                });
+            }
+            console.log(`[${functionTag}] Initialization completed`, {
+                modelName: this.modelName,
+                isAnthropic: isAnthropicModel(this.modelName),
+                authMethod: hasPrincipalAccountAuth() ? 'principal_account' : 'none',
+                success: true
+            });
+        }
+        catch (err) {
+            console.error(`[${functionTag}] Initialization failed`, {
+                message: 'Error in initializing Google Vertex AI',
+                modelName: this.modelName,
+                isAnthropic: isAnthropicModel(this.modelName),
+                error: err instanceof Error ? err.message : String(err),
+                stack: err instanceof Error ? err.stack : undefined
+            });
+        }
+    }
+    /**
+     * Gets the appropriate model instance (Google or Anthropic)
+     * @private
+     */
+    async getModel() {
+        if (isAnthropicModel(this.modelName)) {
+            console.log('GoogleVertexAI.getModel - Anthropic model selected', {
+                modelName: this.modelName
+            });
+            const createVertexAnthropic = await getCreateVertexAnthropic();
+            if (!createVertexAnthropic) {
+                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());
+            return vertexAnthropic(this.modelName);
+        }
+        const vertex = getVertexInstance();
+        return vertex(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(prompt, analysisSchema) {
+        const functionTag = 'GoogleVertexAI.streamText';
+        const provider = 'vertex';
+        let chunkCount = 0;
+        try {
+            console.log(`[${functionTag}] Stream request started`, {
+                provider,
+                modelName: this.modelName,
+                isAnthropic: isAnthropicModel(this.modelName),
+                promptLength: prompt.length,
+                hasSchema: !!analysisSchema
+            });
+            const model = await this.getModel();
+            const streamOptions = {
+                model: model,
+                prompt: prompt,
+                system: DEFAULT_SYSTEM_CONTEXT.systemPrompt,
+                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: prompt.length
+            });
+            return 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
+     */
+    async generateText(prompt, analysisSchema) {
+        const functionTag = 'GoogleVertexAI.generateText';
+        const provider = 'vertex';
+        try {
+            console.log(`[${functionTag}] Generate request started`, {
+                provider,
+                modelName: this.modelName,
+                isAnthropic: isAnthropicModel(this.modelName),
+                promptLength: prompt.length
+            });
+            const model = await this.getModel();
+            const generateOptions = {
+                model: model,
+                prompt: prompt,
+                system: DEFAULT_SYSTEM_CONTEXT.systemPrompt
+            };
+            if (analysisSchema) {
+                generateOptions.experimental_output = Output.object({ schema: analysisSchema });
+            }
+            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
+            });
+            return result;
+        }
+        catch (err) {
+            console.error(`[${functionTag}] Exception`, {
+                provider,
+                modelName: this.modelName,
+                message: 'Error in generating text',
+                err: String(err)
+            });
+            return null;
+        }
+    }
+}

package/dist/providers/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Provider exports for Vercel AI SDK integration
+ * This file centralizes all AI provider classes for easy import and usage
+ */
+export { GoogleVertexAI } from './googleVertexAI.js';
+export { AmazonBedrock } from './amazonBedrock.js';
+export { OpenAI } from './openAI.js';
+export type { AIProvider } from '../core/types.js';
+/**
+ * Provider registry for dynamic provider instantiation
+ */
+export declare const PROVIDERS: {
+    readonly vertex: "GoogleVertexAI";
+    readonly bedrock: "AmazonBedrock";
+    readonly openai: "OpenAI";
+};
+/**
+ * Type for valid provider names
+ */
+export type ProviderName = keyof typeof PROVIDERS;
+/**
+ * List of all available provider names
+ */
+export declare const AVAILABLE_PROVIDERS: ProviderName[];

package/dist/providers/index.js

@@ -0,0 +1,19 @@
+/**
+ * Provider exports for Vercel AI SDK integration
+ * This file centralizes all AI provider classes for easy import and usage
+ */
+export { GoogleVertexAI } from './googleVertexAI.js';
+export { AmazonBedrock } from './amazonBedrock.js';
+export { OpenAI } from './openAI.js';
+/**
+ * Provider registry for dynamic provider instantiation
+ */
+export const PROVIDERS = {
+    vertex: 'GoogleVertexAI',
+    bedrock: 'AmazonBedrock',
+    openai: 'OpenAI'
+};
+/**
+ * List of all available provider names
+ */
+export const AVAILABLE_PROVIDERS = Object.keys(PROVIDERS);

package/dist/providers/openAI.d.ts

@@ -0,0 +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';
+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>;
+}

package/dist/providers/openAI.js

@@ -0,0 +1,145 @@
+import { openai } from '@ai-sdk/openai';
+import { streamText, generateText, Output } from 'ai';
+// Default system context
+const DEFAULT_SYSTEM_CONTEXT = {
+    systemPrompt: 'You are a helpful AI assistant.'
+};
+// Configuration helpers
+const getOpenAIApiKey = () => {
+    const apiKey = process.env.OPENAI_API_KEY;
+    if (!apiKey) {
+        throw new Error('OPENAI_API_KEY environment variable is not set');
+    }
+    return apiKey;
+};
+const getOpenAIModel = () => {
+    return process.env.OPENAI_MODEL || 'gpt-4o';
+};
+// OpenAI class with enhanced error handling
+export class OpenAI {
+    modelName;
+    model;
+    constructor(modelName) {
+        const functionTag = 'OpenAI.constructor';
+        this.modelName = modelName || getOpenAIModel();
+        try {
+            console.log(`[${functionTag}] Function called`, { modelName: this.modelName });
+            // Set OpenAI API key as environment variable
+            process.env.OPENAI_API_KEY = getOpenAIApiKey();
+            this.model = openai(this.modelName);
+            console.log(`[${functionTag}] Function result`, {
+                modelName: this.modelName,
+                success: true
+            });
+        }
+        catch (err) {
+            console.error(`[${functionTag}] Exception`, {
+                message: 'Error in initializing OpenAI',
+                modelName: this.modelName,
+                err: String(err)
+            });
+            throw err;
+        }
+    }
+    async streamText(prompt, analysisSchema) {
+        const functionTag = 'OpenAI.streamText';
+        const provider = 'openai';
+        let chunkCount = 0;
+        try {
+            const streamOptions = {
+                model: this.model,
+                prompt: prompt,
+                system: DEFAULT_SYSTEM_CONTEXT.systemPrompt,
+                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 });
+            }
+            console.log(`[${functionTag}] Stream text started`, {
+                provider,
+                modelName: this.modelName,
+                promptLength: prompt.length
+            });
+            const result = streamText(streamOptions);
+            return result;
+        }
+        catch (err) {
+            console.error(`[${functionTag}] Exception`, {
+                provider,
+                modelName: this.modelName,
+                message: 'Error in streaming text',
+                err: String(err)
+            });
+            return null;
+        }
+    }
+    async generateText(prompt, analysisSchema) {
+        const functionTag = 'OpenAI.generateText';
+        const provider = 'openai';
+        try {
+            const generateOptions = {
+                model: this.model,
+                prompt: prompt,
+                system: DEFAULT_SYSTEM_CONTEXT.systemPrompt
+            };
+            if (analysisSchema) {
+                generateOptions.experimental_output = Output.object({ schema: analysisSchema });
+            }
+            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
+            });
+            return result;
+        }
+        catch (err) {
+            console.error(`[${functionTag}] Exception`, {
+                provider,
+                modelName: this.modelName,
+                message: 'Error in generating text',
+                err: String(err)
+            });
+            return null;
+        }
+    }
+}

package/dist/utils/providerUtils.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Utility functions for AI provider management
+ */
+/**
+ * Get the best available provider based on preferences and availability
+ * @param requestedProvider - Optional preferred provider name
+ * @returns The best provider name to use
+ */
+export declare function getBestProvider(requestedProvider?: string): string;
+/**
+ * Get available provider names
+ * @returns Array of available provider names
+ */
+export declare function getAvailableProviders(): string[];
+/**
+ * Validate provider name
+ * @param provider - Provider name to validate
+ * @returns True if provider name is valid
+ */
+export declare function isValidProvider(provider: string): boolean;

package/dist/utils/providerUtils.js

@@ -0,0 +1,63 @@
+/**
+ * Utility functions for AI provider management
+ */
+/**
+ * Get the best available provider based on preferences and availability
+ * @param requestedProvider - Optional preferred provider name
+ * @returns The best provider name to use
+ */
+export function getBestProvider(requestedProvider) {
+    // If a specific provider is requested, return it
+    if (requestedProvider) {
+        return requestedProvider;
+    }
+    // Default fallback order based on environment variables
+    const providers = ['bedrock', 'vertex', 'openai'];
+    // Check which providers have their required environment variables
+    for (const provider of providers) {
+        if (isProviderConfigured(provider)) {
+            console.log(`[getBestProvider] Selected provider: ${provider}`);
+            return provider;
+        }
+    }
+    // Default to bedrock if nothing is configured
+    console.warn('[getBestProvider] No providers configured, defaulting to bedrock');
+    return 'bedrock';
+}
+/**
+ * Check if a provider has the minimum required configuration
+ * @param provider - Provider name to check
+ * @returns True if the provider appears to be configured
+ */
+function isProviderConfigured(provider) {
+    switch (provider.toLowerCase()) {
+        case 'bedrock':
+        case 'amazon':
+        case 'aws':
+            return !!(process.env.AWS_ACCESS_KEY_ID && process.env.AWS_SECRET_ACCESS_KEY);
+        case 'vertex':
+        case 'google':
+        case 'gemini':
+            return !!(process.env.GOOGLE_VERTEX_PROJECT || process.env.GOOGLE_APPLICATION_CREDENTIALS);
+        case 'openai':
+        case 'gpt':
+            return !!process.env.OPENAI_API_KEY;
+        default:
+            return false;
+    }
+}
+/**
+ * Get available provider names
+ * @returns Array of available provider names
+ */
+export function getAvailableProviders() {
+    return ['bedrock', 'vertex', 'openai'];
+}
+/**
+ * Validate provider name
+ * @param provider - Provider name to validate
+ * @returns True if provider name is valid
+ */
+export function isValidProvider(provider) {
+    return getAvailableProviders().includes(provider.toLowerCase());
+}

package/package.json

@@ -0,0 +1,82 @@
+{
+	"name": "@juspay/neurolink",
+	"version": "1.0.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",
+		"preview": "vite preview",
+		"prepare": "svelte-kit sync || echo ''",
+		"prepack": "svelte-kit sync && svelte-package && 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 ."
+	},
+	"files": [
+		"dist",
+		"!dist/**/*.test.*",
+		"!dist/**/*.spec.*"
+	],
+	"sideEffects": [
+		"**/*.css"
+	],
+	"svelte": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"type": "module",
+	"main": "./dist/index.js",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"svelte": "./dist/index.js",
+			"import": "./dist/index.js",
+			"default": "./dist/index.js"
+		}
+	},
+	"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",
+		"zod": "^3.22.0"
+	},
+	"devDependencies": {
+		"@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",
+		"eslint": "^9.0.0",
+		"prettier": "^3.0.0",
+		"publint": "^0.3.2",
+		"svelte": "^5.0.0",
+		"svelte-check": "^4.0.0",
+		"tslib": "^2.4.1",
+		"typescript": "^5.0.0",
+		"vite": "^6.2.6",
+		"vitest": "^2.0.0"
+	},
+	"keywords": [
+		"ai",
+		"llm",
+		"openai",
+		"anthropic",
+		"google",
+		"bedrock",
+		"vertex",
+		"streaming",
+		"tools",
+		"neurolink",
+		"juspay",
+		"svelte"
+	],
+	"pnpm": {
+		"onlyBuiltDependencies": [
+			"esbuild"
+		]
+	}
+}