@juspay/neurolink 1.2.3 → 1.2.4

package/dist/providers/azureOpenAI.js

@@ -0,0 +1,338 @@
+/**
+ * Azure OpenAI Provider
+ *
+ * Enterprise-grade OpenAI integration through Microsoft Azure.
+ * Supports all OpenAI models with enhanced security and compliance.
+ */
+import { AIProviderName } from '../core/types.js';
+export class AzureOpenAIProvider {
+    name = AIProviderName.AZURE;
+    apiKey;
+    endpoint;
+    deploymentId;
+    apiVersion;
+    constructor() {
+        this.apiKey = this.getApiKey();
+        this.endpoint = this.getEndpoint();
+        this.deploymentId = this.getDeploymentId();
+        this.apiVersion = process.env.AZURE_OPENAI_API_VERSION || '2024-02-15-preview';
+        console.log(`[AzureOpenAIProvider] Initialized with endpoint: ${this.endpoint}, deployment: ${this.deploymentId}`);
+    }
+    getApiKey() {
+        const apiKey = process.env.AZURE_OPENAI_API_KEY;
+        if (!apiKey) {
+            throw new Error('AZURE_OPENAI_API_KEY environment variable is required');
+        }
+        return apiKey;
+    }
+    getEndpoint() {
+        const endpoint = process.env.AZURE_OPENAI_ENDPOINT;
+        if (!endpoint) {
+            throw new Error('AZURE_OPENAI_ENDPOINT environment variable is required');
+        }
+        return endpoint.replace(/\/$/, ''); // Remove trailing slash
+    }
+    getDeploymentId() {
+        const deploymentId = process.env.AZURE_OPENAI_DEPLOYMENT_ID;
+        if (!deploymentId) {
+            throw new Error('AZURE_OPENAI_DEPLOYMENT_ID environment variable is required');
+        }
+        return deploymentId;
+    }
+    getApiUrl(stream = false) {
+        return `${this.endpoint}/openai/deployments/${this.deploymentId}/chat/completions?api-version=${this.apiVersion}`;
+    }
+    async makeRequest(body, stream = false) {
+        const url = this.getApiUrl(stream);
+        const headers = {
+            'Content-Type': 'application/json',
+            'api-key': this.apiKey
+        };
+        console.log(`[AzureOpenAIProvider.makeRequest] ${stream ? 'Streaming' : 'Non-streaming'} request to deployment: ${this.deploymentId}`);
+        console.log(`[AzureOpenAIProvider.makeRequest] Max tokens: ${body.max_tokens || 'default'}, Temperature: ${body.temperature || 'default'}`);
+        const response = await fetch(url, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(body)
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            console.error(`[AzureOpenAIProvider.makeRequest] API error ${response.status}: ${errorText}`);
+            throw new Error(`Azure OpenAI API error ${response.status}: ${errorText}`);
+        }
+        return response;
+    }
+    async generateText(optionsOrPrompt, schema) {
+        console.log('[AzureOpenAIProvider.generateText] Starting text generation');
+        // Parse parameters with backward compatibility
+        const options = typeof optionsOrPrompt === 'string'
+            ? { prompt: optionsOrPrompt }
+            : optionsOrPrompt;
+        const { prompt, temperature = 0.7, maxTokens = 500, systemPrompt = 'You are a helpful AI assistant.' } = options;
+        console.log(`[AzureOpenAIProvider.generateText] Prompt: "${prompt.substring(0, 100)}...", Temperature: ${temperature}, Max tokens: ${maxTokens}`);
+        const messages = [];
+        if (systemPrompt) {
+            messages.push({
+                role: 'system',
+                content: systemPrompt
+            });
+        }
+        messages.push({
+            role: 'user',
+            content: prompt
+        });
+        const requestBody = {
+            messages,
+            temperature,
+            max_tokens: maxTokens
+        };
+        try {
+            const response = await this.makeRequest(requestBody);
+            const data = await response.json();
+            console.log(`[AzureOpenAIProvider.generateText] Success. Generated ${data.usage.completion_tokens} tokens`);
+            const content = data.choices[0]?.message?.content || '';
+            return {
+                content,
+                provider: this.name,
+                model: data.model,
+                usage: {
+                    promptTokens: data.usage.prompt_tokens,
+                    completionTokens: data.usage.completion_tokens,
+                    totalTokens: data.usage.total_tokens
+                },
+                finishReason: data.choices[0]?.finish_reason || 'stop'
+            };
+        }
+        catch (error) {
+            console.error('[AzureOpenAIProvider.generateText] Error:', error);
+            throw error;
+        }
+    }
+    async streamText(optionsOrPrompt, schema) {
+        console.log('[AzureOpenAIProvider.streamText] Starting text streaming');
+        // Parse parameters with backward compatibility
+        const options = typeof optionsOrPrompt === 'string'
+            ? { prompt: optionsOrPrompt }
+            : optionsOrPrompt;
+        const { prompt, temperature = 0.7, maxTokens = 500, systemPrompt = 'You are a helpful AI assistant.' } = options;
+        console.log(`[AzureOpenAIProvider.streamText] Streaming prompt: "${prompt.substring(0, 100)}..."`);
+        const messages = [];
+        if (systemPrompt) {
+            messages.push({
+                role: 'system',
+                content: systemPrompt
+            });
+        }
+        messages.push({
+            role: 'user',
+            content: prompt
+        });
+        const requestBody = {
+            messages,
+            temperature,
+            max_tokens: maxTokens,
+            stream: true
+        };
+        try {
+            const response = await this.makeRequest(requestBody, true);
+            if (!response.body) {
+                throw new Error('No response body received');
+            }
+            // Return a StreamTextResult-like object
+            return {
+                textStream: this.createAsyncIterable(response.body),
+                text: '',
+                usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
+                finishReason: 'stop'
+            };
+        }
+        catch (error) {
+            console.error('[AzureOpenAIProvider.streamText] Error:', error);
+            throw error;
+        }
+    }
+    async *createAsyncIterable(body) {
+        const reader = body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    if (line.trim() === '')
+                        continue;
+                    if (line.startsWith('data: ')) {
+                        const data = line.slice(6);
+                        if (data.trim() === '[DONE]')
+                            continue;
+                        try {
+                            const chunk = JSON.parse(data);
+                            // Extract text content from chunk
+                            if (chunk.choices?.[0]?.delta?.content) {
+                                yield chunk.choices[0].delta.content;
+                            }
+                        }
+                        catch (parseError) {
+                            console.warn('[AzureOpenAIProvider.createAsyncIterable] Failed to parse chunk:', parseError);
+                            continue;
+                        }
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    async *generateTextStream(optionsOrPrompt) {
+        console.log('[AzureOpenAIProvider.generateTextStream] Starting text streaming');
+        // Parse parameters with backward compatibility
+        const options = typeof optionsOrPrompt === 'string'
+            ? { prompt: optionsOrPrompt }
+            : optionsOrPrompt;
+        const { prompt, temperature = 0.7, maxTokens = 500, systemPrompt = 'You are a helpful AI assistant.' } = options;
+        console.log(`[AzureOpenAIProvider.generateTextStream] Streaming prompt: "${prompt.substring(0, 100)}..."`);
+        const messages = [];
+        if (systemPrompt) {
+            messages.push({
+                role: 'system',
+                content: systemPrompt
+            });
+        }
+        messages.push({
+            role: 'user',
+            content: prompt
+        });
+        const requestBody = {
+            messages,
+            temperature,
+            max_tokens: maxTokens,
+            stream: true
+        };
+        try {
+            const response = await this.makeRequest(requestBody, true);
+            if (!response.body) {
+                throw new Error('No response body received');
+            }
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = '';
+            try {
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    const lines = buffer.split('\n');
+                    buffer = lines.pop() || '';
+                    for (const line of lines) {
+                        if (line.trim() === '')
+                            continue;
+                        if (line.startsWith('data: ')) {
+                            const data = line.slice(6);
+                            if (data.trim() === '[DONE]')
+                                continue;
+                            try {
+                                const chunk = JSON.parse(data);
+                                // Extract text content from chunk
+                                if (chunk.choices?.[0]?.delta?.content) {
+                                    yield {
+                                        content: chunk.choices[0].delta.content,
+                                        provider: this.name,
+                                        model: chunk.model || this.deploymentId
+                                    };
+                                }
+                            }
+                            catch (parseError) {
+                                console.warn('[AzureOpenAIProvider.generateTextStream] Failed to parse chunk:', parseError);
+                                continue;
+                            }
+                        }
+                    }
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+            console.log('[AzureOpenAIProvider.generateTextStream] Streaming completed');
+        }
+        catch (error) {
+            console.error('[AzureOpenAIProvider.generateTextStream] Error:', error);
+            throw error;
+        }
+    }
+    async testConnection() {
+        console.log('[AzureOpenAIProvider.testConnection] Testing connection to Azure OpenAI');
+        const startTime = Date.now();
+        try {
+            await this.generateText({
+                prompt: 'Hello',
+                maxTokens: 5
+            });
+            const responseTime = Date.now() - startTime;
+            console.log(`[AzureOpenAIProvider.testConnection] Connection test successful (${responseTime}ms)`);
+            return {
+                success: true,
+                responseTime
+            };
+        }
+        catch (error) {
+            const responseTime = Date.now() - startTime;
+            console.error(`[AzureOpenAIProvider.testConnection] Connection test failed (${responseTime}ms):`, error);
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error',
+                responseTime
+            };
+        }
+    }
+    isConfigured() {
+        try {
+            this.getApiKey();
+            this.getEndpoint();
+            this.getDeploymentId();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    getRequiredConfig() {
+        return ['AZURE_OPENAI_API_KEY', 'AZURE_OPENAI_ENDPOINT', 'AZURE_OPENAI_DEPLOYMENT_ID'];
+    }
+    getOptionalConfig() {
+        return ['AZURE_OPENAI_API_VERSION'];
+    }
+    getModels() {
+        return [
+            'gpt-4',
+            'gpt-4-turbo',
+            'gpt-4-32k',
+            'gpt-35-turbo',
+            'gpt-35-turbo-16k'
+        ];
+    }
+    supportsStreaming() {
+        return true;
+    }
+    supportsSchema() {
+        return true; // Azure OpenAI supports JSON mode and function calling
+    }
+    getCapabilities() {
+        return [
+            'text-generation',
+            'streaming',
+            'conversation',
+            'system-prompts',
+            'json-mode',
+            'function-calling',
+            'enterprise-security',
+            'content-filtering'
+        ];
+    }
+}

package/dist/providers/index.d.ts

@@ -5,6 +5,8 @@
 export { GoogleVertexAI } from './googleVertexAI.js';
 export { AmazonBedrock } from './amazonBedrock.js';
 export { OpenAI } from './openAI.js';
+export { AnthropicProvider } from './anthropic.js';
+export { AzureOpenAIProvider } from './azureOpenAI.js';
 export type { AIProvider } from '../core/types.js';
 /**
  * Provider registry for dynamic provider instantiation
@@ -13,6 +15,8 @@ export declare const PROVIDERS: {
     readonly vertex: "GoogleVertexAI";
     readonly bedrock: "AmazonBedrock";
     readonly openai: "OpenAI";
+    readonly anthropic: "AnthropicProvider";
+    readonly azure: "AzureOpenAIProvider";
 };
 /**
  * Type for valid provider names

package/dist/providers/index.js

@@ -5,13 +5,17 @@
 export { GoogleVertexAI } from './googleVertexAI.js';
 export { AmazonBedrock } from './amazonBedrock.js';
 export { OpenAI } from './openAI.js';
+export { AnthropicProvider } from './anthropic.js';
+export { AzureOpenAIProvider } from './azureOpenAI.js';
 /**
  * Provider registry for dynamic provider instantiation
  */
 export const PROVIDERS = {
     vertex: 'GoogleVertexAI',
     bedrock: 'AmazonBedrock',
-    openai: 'OpenAI'
+    openai: 'OpenAI',
+    anthropic: 'AnthropicProvider',
+    azure: 'AzureOpenAIProvider'
 };
 /**
  * List of all available provider names

package/package.json

@@ -1,98 +1,94 @@
 {
-	"name": "@juspay/neurolink",
-	"version": "1.2.3",
-	"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 && 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 .",
-		"changeset": "changeset",
-		"changeset:version": "changeset version && git add --all",
-		"publish": "npm run build && npm publish --access public"
-	},
-	"files": [
-		"dist",
-		"!dist/**/*.test.*",
-		"!dist/**/*.spec.*"
-	],
-	"sideEffects": [
-		"**/*.css"
-	],
-	"svelte": "./dist/index.js",
-	"types": "./dist/index.d.ts",
-	"type": "module",
-	"main": "./dist/index.js",
-	"bin": {
-		"neurolink": "./dist/cli/index.js"
-	},
-	"exports": {
-		".": {
-			"types": "./dist/index.d.ts",
-			"svelte": "./dist/index.js",
-			"import": "./dist/index.js",
-			"default": "./dist/index.js"
-		}
-	},
-	"peerDependencies": {
-		"@ai-sdk/amazon-bedrock": "^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",
-		"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"
-		]
-	}
-}
+  "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",
+  "license": "MIT",
+  "files": [
+    "dist",
+    "!dist/**/*.test.*",
+    "!dist/**/*.spec.*"
+  ],
+  "sideEffects": [
+    "**/*.css"
+  ],
+  "svelte": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "main": "./dist/index.js",
+  "bin": {
+    "neurolink": "./dist/cli/index.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "svelte": "./dist/index.js",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "peerDependencies": {
+    "@ai-sdk/amazon-bedrock": "^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",
+    "dotenv": "^16.5.0",
+    "inquirer": "^9.2.15",
+    "ora": "^7.0.1",
+    "playwright": "^1.52.0",
+    "yargs": "^17.7.2",
+    "zod": "^3.22.0"
+  },
+  "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/inquirer": "^9.0.7",
+    "@types/node": "^20.0.0",
+    "@types/yargs": "^17.0.33",
+    "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"
+  ],
+  "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",
+    "cli": "node dist/cli/index.js",
+    "preview": "vite preview",
+    "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 .",
+    "changeset": "changeset",
+    "changeset:version": "changeset version && git add --all"
+  }
+}