@juspay/neurolink 9.1.1 → 9.3.0

package/dist/core/infrastructure/baseRegistry.js

@@ -0,0 +1,49 @@
+import { logger } from "../../utils/logger.js";
+export class BaseRegistry {
+    items = new Map();
+    initialized = false;
+    initPromise = null;
+    async ensureInitialized() {
+        if (this.initialized) {
+            return;
+        }
+        if (this.initPromise) {
+            return this.initPromise;
+        }
+        this.initPromise = this.registerAll();
+        await this.initPromise;
+        this.initialized = true;
+    }
+    register(id, factory, metadata) {
+        this.items.set(id, { factory, metadata });
+        logger.debug(`Registered ${id} in registry`);
+    }
+    async get(id) {
+        await this.ensureInitialized();
+        const entry = this.items.get(id);
+        if (!entry) {
+            return undefined;
+        }
+        if (!entry.instance) {
+            entry.instance = await entry.factory();
+        }
+        return entry.instance;
+    }
+    has(id) {
+        return this.items.has(id);
+    }
+    list() {
+        return Array.from(this.items.entries()).map(([id, entry]) => ({
+            id,
+            metadata: entry.metadata,
+        }));
+    }
+    clear() {
+        this.items.clear();
+        this.initialized = false;
+        this.initPromise = null;
+    }
+    isInitialized() {
+        return this.initialized;
+    }
+}

package/dist/core/infrastructure/index.d.ts

@@ -0,0 +1,5 @@
+export { createErrorFactory, type ErrorCode, NeuroLinkFeatureError, } from "./baseError.js";
+export { BaseFactory, type FactoryFunction, type FactoryRegistration, } from "./baseFactory.js";
+export { BaseRegistry, type RegistryEntry } from "./baseRegistry.js";
+export { type RetryOptions, withRetry } from "./retry.js";
+export { TypedEventEmitter } from "./typedEventEmitter.js";

package/dist/core/infrastructure/index.js

@@ -0,0 +1,5 @@
+export { createErrorFactory, NeuroLinkFeatureError, } from "./baseError.js";
+export { BaseFactory, } from "./baseFactory.js";
+export { BaseRegistry } from "./baseRegistry.js";
+export { withRetry } from "./retry.js";
+export { TypedEventEmitter } from "./typedEventEmitter.js";

package/dist/core/infrastructure/retry.d.ts

@@ -0,0 +1,7 @@
+export type RetryOptions = {
+    maxRetries: number;
+    baseDelayMs: number;
+    maxDelayMs?: number;
+    shouldRetry?: (error: Error) => boolean;
+};
+export declare function withRetry<T>(operation: () => Promise<T>, options: RetryOptions): Promise<T>;

package/dist/core/infrastructure/retry.js

@@ -0,0 +1,20 @@
+export async function withRetry(operation, options) {
+    const { maxRetries, baseDelayMs, maxDelayMs = 30000, shouldRetry } = options;
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            lastError = error;
+            if (shouldRetry && !shouldRetry(lastError)) {
+                throw lastError;
+            }
+            if (attempt < maxRetries) {
+                const delay = Math.min(baseDelayMs * 2 ** attempt, maxDelayMs);
+                await new Promise((resolve) => setTimeout(resolve, delay));
+            }
+        }
+    }
+    throw lastError;
+}

package/dist/core/infrastructure/typedEventEmitter.d.ts

@@ -0,0 +1,8 @@
+export declare class TypedEventEmitter<TEvents extends Record<string, unknown[]>> {
+    private emitter;
+    on<K extends keyof TEvents>(event: K, listener: (...args: TEvents[K]) => void): this;
+    off<K extends keyof TEvents>(event: K, listener: (...args: TEvents[K]) => void): this;
+    emit<K extends keyof TEvents>(event: K, ...args: TEvents[K]): boolean;
+    once<K extends keyof TEvents>(event: K, listener: (...args: TEvents[K]) => void): this;
+    removeAllListeners<K extends keyof TEvents>(event?: K): this;
+}

package/dist/core/infrastructure/typedEventEmitter.js

@@ -0,0 +1,23 @@
+import { EventEmitter } from "events";
+export class TypedEventEmitter {
+    emitter = new EventEmitter();
+    on(event, listener) {
+        this.emitter.on(event, listener);
+        return this;
+    }
+    off(event, listener) {
+        this.emitter.off(event, listener);
+        return this;
+    }
+    emit(event, ...args) {
+        return this.emitter.emit(event, ...args);
+    }
+    once(event, listener) {
+        this.emitter.once(event, listener);
+        return this;
+    }
+    removeAllListeners(event) {
+        this.emitter.removeAllListeners(event);
+        return this;
+    }
+}

package/dist/core/redisConversationMemoryManager.d.ts

@@ -3,7 +3,6 @@
  * Redis-based implementation of conversation storage with same interface as ConversationMemoryManager
  */
 import type { ConversationMemoryConfig, ConversationMemoryStats, ChatMessage, RedisStorageConfig, SessionMetadata, RedisConversationObject, StoreConversationTurnOptions } from "../types/conversation.js";
-import type { TypedEventEmitter, NeuroLinkEvents } from "../types/common.js";
 /**
  * Redis-based implementation of the ConversationMemoryManager
  * Uses the same interface but stores data in Redis
@@ -13,10 +12,6 @@ export declare class RedisConversationMemoryManager {
     private isInitialized;
     private redisConfig;
     private redisClient;
-    /**
-     * Event emitter for conversation memory events
-     */
-    private eventEmitter?;
     /**
      * Temporary storage for tool execution data to prevent race conditions
      * Key format: "${sessionId}:${userId}"
@@ -32,7 +27,7 @@ export declare class RedisConversationMemoryManager {
      * Key format: "${sessionId}:${userId}"
      */
     private summarizationInProgress;
-    constructor(config: ConversationMemoryConfig, redisConfig?: RedisStorageConfig, eventEmitter?: TypedEventEmitter<NeuroLinkEvents>);
+    constructor(config: ConversationMemoryConfig, redisConfig?: RedisStorageConfig);
     /**
      * Initialize the memory manager with Redis connection
      */

package/dist/core/redisConversationMemoryManager.js

@@ -19,10 +19,6 @@ export class RedisConversationMemoryManager {
     isInitialized = false;
     redisConfig;
     redisClient = null;
-    /**
-     * Event emitter for conversation memory events
-     */
-    eventEmitter;
     /**
      * Temporary storage for tool execution data to prevent race conditions
      * Key format: "${sessionId}:${userId}"
@@ -38,10 +34,9 @@ export class RedisConversationMemoryManager {
      * Key format: "${sessionId}:${userId}"
      */
     summarizationInProgress = new Set();
-    constructor(config, redisConfig = {}, eventEmitter) {
+    constructor(config, redisConfig = {}) {
         this.config = config;
         this.redisConfig = getNormalizedConfig(redisConfig);
-        this.eventEmitter = eventEmitter;
     }
     /**
      * Initialize the memory manager with Redis connection
@@ -258,14 +253,6 @@ export class RedisConversationMemoryManager {
                             if (this.redisConfig.ttl > 0) {
                                 await this.redisClient?.expire(updatedRedisKey, this.redisConfig.ttl);
                             }
-                            if (this.eventEmitter) {
-                                this.eventEmitter.emit("conversation:titleGenerated", {
-                                    sessionId: options.sessionId,
-                                    userId: normalizedUserId,
-                                    title,
-                                    timestamp: Date.now(),
-                                });
-                            }
                         }
                     }
                     catch (titleError) {
@@ -700,11 +687,12 @@ export class RedisConversationMemoryManager {
             const titleGenerator = new NeuroLink({
                 conversationMemory: { enabled: false },
             });
-            const fallbackTitlePrompt = `\nYou are an expert at generating ultra-concise conversation titles.\n\nGenerate a single clear, descriptive title that accurately reflects the core topic of the user's message.\n\nStrict rules:\n- The title MUST be 18 characters or fewer (including spaces).\n- Output ONLY the title text (no quotes, no punctuation, no explanations).\n- Use natural words; abbreviations are allowed only if they improve clarity.\n- Avoid generic words like "issue", "problem", "help", or "discussion".\n- Do not say you cannot generate a title.\n- Always return exactly one valid title within the character limit.\n\nUser message:\n"${userMessage}"\n`;
-            const envPrompt = process.env.NEUROLINK_TITLE_PROMPT;
-            const titlePrompt = envPrompt
-                ? envPrompt.replace(/\$\{userMessage\}/g, userMessage)
-                : fallbackTitlePrompt;
+            const titlePrompt = `Generate a clear, concise, and descriptive title (5–8 words maximum) for a conversation based on the following user message. 
+The title must meaningfully reflect the topic or intent of the message. 
+Do not output anything unrelated, vague, or generic. 
+Do not say you cannot create a title. Always return a valid title.
+
+User message: "${userMessage}`;
             const result = await titleGenerator.generate({
                 input: { text: titlePrompt },
                 provider: this.config.summarizationProvider || "vertex",

package/dist/factories/providerFactory.d.ts

@@ -1,6 +1,6 @@
-import type { AIProvider } from "../types/index.js";
+import type { AIProviderName } from "../constants/enums.js";
 import type { UnknownRecord } from "../types/common.js";
-import { AIProviderName } from "../constants/enums.js";
+import type { AIProvider } from "../types/index.js";
 /**
  * Provider constructor interface - supports both sync constructors and async factory functions
  */
@@ -30,8 +30,10 @@ export declare class ProviderFactory {
     aliases?: string[]): void;
     /**
      * Create a provider instance
+     * @param providerName - Provider name (optional, uses NEUROLINK_PROVIDER env var or 'vertex' as default)
+     * @param modelName - Model name (optional, uses provider-specific env var or registry default)
      */
-    static createProvider(providerName: AIProviderName | string, modelName?: string, sdk?: UnknownRecord, region?: string): Promise<AIProvider>;
+    static createProvider(providerName?: AIProviderName | string, modelName?: string, sdk?: UnknownRecord, region?: string): Promise<AIProvider>;
     /**
      * Check if a provider is registered
      */

package/dist/factories/providerFactory.js

@@ -1,5 +1,4 @@
 import { logger } from "../utils/logger.js";
-import { AIProviderName } from "../constants/enums.js";
 /**
  * True Factory Pattern implementation for AI Providers
  * Uses registration-based approach to eliminate switch statements
@@ -19,31 +18,39 @@ export class ProviderFactory {
             aliases,
         };
         // Register main name
-        this.providers.set(name.toLowerCase(), registration);
+        ProviderFactory.providers.set(name.toLowerCase(), registration);
         // Register aliases
         aliases.forEach((alias) => {
-            this.providers.set(alias.toLowerCase(), registration);
+            ProviderFactory.providers.set(alias.toLowerCase(), registration);
         });
         logger.debug(`Registered provider: ${name} with model ${defaultModel || "from-env"}`);
     }
     /**
      * Create a provider instance
+     * @param providerName - Provider name (optional, uses NEUROLINK_PROVIDER env var or 'vertex' as default)
+     * @param modelName - Model name (optional, uses provider-specific env var or registry default)
      */
     static async createProvider(providerName, modelName, sdk, region) {
         // Note: Providers are registered explicitly by ProviderRegistry to avoid circular dependencies
-        const normalizedName = providerName.toLowerCase();
-        const registration = this.providers.get(normalizedName);
+        // Use environment variable or default if not specified
+        const resolvedProviderName = providerName ||
+            process.env.NEUROLINK_PROVIDER ||
+            process.env.AI_PROVIDER ||
+            "vertex";
+        const normalizedName = resolvedProviderName.toLowerCase();
+        const registration = ProviderFactory.providers.get(normalizedName);
         if (!registration) {
-            throw new Error(`Unknown provider: ${providerName}. Available providers: ${this.getAvailableProviders().join(", ")}`);
+            throw new Error(`Unknown provider: ${resolvedProviderName}. Available providers: ${ProviderFactory.getAvailableProviders().join(", ")}`);
         }
         // Respect environment variables before falling back to registry default
         let model = modelName;
         if (!model) {
             // Check for provider-specific environment variables
-            if (providerName.toLowerCase().includes("vertex")) {
-                model = process.env.VERTEX_MODEL;
+            if (resolvedProviderName.toLowerCase().includes("vertex")) {
+                // Use gemini-2.5-flash as default - latest GA model with best price-performance
+                model = process.env.VERTEX_MODEL || "gemini-2.5-flash";
             }
-            else if (providerName.toLowerCase().includes("bedrock")) {
+            else if (resolvedProviderName.toLowerCase().includes("bedrock")) {
                 model = process.env.BEDROCK_MODEL || process.env.BEDROCK_MODEL_ID;
             }
             // Fallback to registry default if no env var
@@ -55,7 +62,7 @@ export class ProviderFactory {
             }
             let result;
             try {
-                const factoryResult = registration.constructor(model, providerName, sdk, region);
+                const factoryResult = registration.constructor(model, resolvedProviderName, sdk, region);
                 // Handle both sync and async results
                 result =
                     factoryResult instanceof Promise
@@ -67,7 +74,7 @@ export class ProviderFactory {
                     registration.constructor.prototype.constructor ===
                         registration.constructor) {
                     try {
-                        result = new registration.constructor(model, providerName, sdk, region);
+                        result = new registration.constructor(model, resolvedProviderName, sdk, region);
                     }
                     catch (constructorError) {
                         throw new Error(`Both factory function and constructor failed. Factory error: ${factoryError}. Constructor error: ${constructorError}`);
@@ -80,27 +87,27 @@ export class ProviderFactory {
             return result;
         }
         catch (error) {
-            logger.error(`Failed to create provider ${providerName}:`, error);
-            throw new Error(`Failed to create provider ${providerName}: ${error}`);
+            logger.error(`Failed to create provider ${resolvedProviderName}:`, error);
+            throw new Error(`Failed to create provider ${resolvedProviderName}: ${error}`);
         }
     }
     /**
      * Check if a provider is registered
      */
     static hasProvider(providerName) {
-        return this.providers.has(providerName.toLowerCase());
+        return ProviderFactory.providers.has(providerName.toLowerCase());
     }
     /**
      * Get list of available providers
      */
     static getAvailableProviders() {
-        return Array.from(this.providers.keys()).filter((name, index, arr) => arr.indexOf(name) === index);
+        return Array.from(ProviderFactory.providers.keys()).filter((name, index, arr) => arr.indexOf(name) === index);
     }
     /**
      * Get provider registration info
      */
     static getProviderInfo(providerName) {
-        return this.providers.get(providerName.toLowerCase());
+        return ProviderFactory.providers.get(providerName.toLowerCase());
     }
     /**
      * Normalize provider names using aliases (PHASE 1: Factory Pattern)
@@ -108,11 +115,11 @@ export class ProviderFactory {
     static normalizeProviderName(providerName) {
         const normalized = providerName.toLowerCase();
         // Check direct registration
-        if (this.providers.has(normalized)) {
+        if (ProviderFactory.providers.has(normalized)) {
             return normalized;
         }
         // Check aliases from all registrations
-        for (const [name, registration] of this.providers.entries()) {
+        for (const [name, registration] of ProviderFactory.providers.entries()) {
             if (registration.aliases?.includes(normalized)) {
                 return name;
             }
@@ -123,16 +130,16 @@ export class ProviderFactory {
      * Clear all registrations (mainly for testing)
      */
     static clearRegistrations() {
-        this.providers.clear();
-        this.initialized = false;
+        ProviderFactory.providers.clear();
+        ProviderFactory.initialized = false;
     }
     /**
      * Ensure providers are initialized
      */
     static ensureInitialized() {
-        if (!this.initialized) {
-            this.initializeDefaultProviders();
-            this.initialized = true;
+        if (!ProviderFactory.initialized) {
+            ProviderFactory.initializeDefaultProviders();
+            ProviderFactory.initialized = true;
         }
     }
     /**
@@ -148,7 +155,7 @@ export class ProviderFactory {
      * Used by NeuroLink SDK for streaming and generation
      */
     static async createBestProvider(providerName, modelName, enableMCP, sdk) {
-        return await this.createProvider(providerName, modelName, sdk);
+        return await ProviderFactory.createProvider(providerName, modelName, sdk);
     }
 }
 /**

package/dist/image-gen/ImageGenService.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Image Generation Service
+ *
+ * Handles AI image generation using NeuroLink SDK with configurable providers
+ * and models. Supports reference images and PDFs for contextual generation.
+ *
+ * @packageDocumentation
+ * @module @juspay/neurolink/image-gen
+ * @category ImageGeneration
+ *
+ * @example
+ * ```typescript
+ * import { ImageGenService } from '@juspay/neurolink';
+ *
+ * const service = new ImageGenService();
+ *
+ * const result = await service.generate({
+ *   prompt: 'A serene mountain landscape at sunset',
+ *   style: 'photorealistic',
+ *   aspectRatio: '16:9'
+ * });
+ *
+ * if (result.success && result.imageBuffer) {
+ *   fs.writeFileSync('output.png', result.imageBuffer);
+ * }
+ * ```
+ */
+import type { ImageGenConfig, ImageGenOptions, ImageGenResult } from "./types.js";
+/**
+ * Image generation service for AI-powered image creation
+ *
+ * Uses NeuroLink SDK to generate images with support for:
+ * - Multiple providers (Vertex AI, OpenAI, etc.)
+ * - Reference images for style guidance
+ * - PDF documents for contextual generation
+ * - Configurable aspect ratios and styles
+ *
+ * @example Basic usage
+ * ```typescript
+ * const service = new ImageGenService();
+ * const result = await service.generate({
+ *   prompt: 'A cute robot playing chess'
+ * });
+ * ```
+ *
+ * @example With custom configuration
+ * ```typescript
+ * const service = new ImageGenService({
+ *   defaultProvider: 'openai',
+ *   defaultModel: 'dall-e-3',
+ *   timeout: 60000
+ * });
+ * ```
+ */
+export declare class ImageGenService {
+    private config;
+    private neurolinkInstance;
+    private instanceId;
+    /**
+     * Create a new ImageGenService instance
+     *
+     * @param config - Optional configuration overrides
+     */
+    constructor(config?: Partial<ImageGenConfig>);
+    /**
+     * Get or create the NeuroLink instance
+     * Uses dynamic import to avoid circular dependencies
+     *
+     * @returns NeuroLink instance for image generation
+     */
+    private getNeuroLink;
+    /**
+     * Generate an image from a text prompt
+     *
+     * @param options - Generation options including prompt, style, etc.
+     * @returns Promise resolving to generation result
+     *
+     * @example Simple generation
+     * ```typescript
+     * const result = await service.generate({
+     *   prompt: 'A futuristic cityscape'
+     * });
+     * ```
+     *
+     * @example With reference images
+     * ```typescript
+     * const referenceImage = fs.readFileSync('style-reference.jpg');
+     * const result = await service.generate({
+     *   prompt: 'A portrait in this style',
+     *   images: [referenceImage],
+     *   aspectRatio: '1:1'
+     * });
+     * ```
+     */
+    generate(options: ImageGenOptions): Promise<ImageGenResult>;
+    /**
+     * Extract image data from various result formats
+     *
+     * Handles multiple output formats:
+     * - result.imageOutput?.base64
+     * - result.images?.[0]
+     * - data:image URI in content
+     * - Buffer directly
+     *
+     * @param result - Raw result from NeuroLink generate
+     * @returns Extracted image data or null
+     */
+    private extractImageFromResult;
+    /**
+     * Check if image generation is enabled
+     */
+    isEnabled(): boolean;
+    /**
+     * Get the default model
+     */
+    getModel(): string;
+    /**
+     * Get the default provider
+     */
+    getProvider(): string;
+    /**
+     * Get the service configuration
+     */
+    getConfig(): Readonly<ImageGenConfig>;
+    /**
+     * Get the service instance ID (for debugging)
+     */
+    getInstanceId(): string;
+    /**
+     * Update service configuration
+     *
+     * @param config - Partial configuration to merge
+     */
+    updateConfig(config: Partial<ImageGenConfig>): void;
+    /**
+     * Enable image generation
+     */
+    enable(): void;
+    /**
+     * Disable image generation
+     */
+    disable(): void;
+}