@juspay/neurolink 9.29.1 → 9.31.0

package/dist/middleware/builtin/lifecycle.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Lifecycle Middleware
+ *
+ * Provides onFinish, onError, and onChunk callbacks for observing
+ * generation and streaming lifecycle events.
+ *
+ * This middleware is automatically enabled when lifecycle callbacks
+ * (onFinish, onError, onChunk) are passed in GenerateOptions or StreamOptions.
+ */
+import type { NeuroLinkMiddleware, LifecycleMiddlewareConfig } from "../../types/middlewareTypes.js";
+export declare function createLifecycleMiddleware(config?: LifecycleMiddlewareConfig): NeuroLinkMiddleware;

package/dist/middleware/builtin/lifecycle.js

@@ -0,0 +1,168 @@
+/**
+ * Lifecycle Middleware
+ *
+ * Provides onFinish, onError, and onChunk callbacks for observing
+ * generation and streaming lifecycle events.
+ *
+ * This middleware is automatically enabled when lifecycle callbacks
+ * (onFinish, onError, onChunk) are passed in GenerateOptions or StreamOptions.
+ */
+import { logger } from "../../utils/logger.js";
+import { isRecoverableError } from "../../utils/errorHandling.js";
+export function createLifecycleMiddleware(config = {}) {
+    const metadata = {
+        id: "lifecycle",
+        name: "Lifecycle Callbacks",
+        description: "Provides onFinish, onError, and onChunk callbacks for generation and streaming lifecycle events",
+        priority: 110,
+        defaultEnabled: false,
+    };
+    const middleware = {
+        specificationVersion: "v3",
+        wrapGenerate: async ({ doGenerate, }) => {
+            const startTime = Date.now();
+            try {
+                const result = await doGenerate();
+                if (config.onFinish) {
+                    try {
+                        const content = result.content
+                            ?.map((c) => c.type === "text" ? c.text : "")
+                            .join("") ?? "";
+                        const callbackResult = config.onFinish({
+                            text: content,
+                            usage: result.usage
+                                ? {
+                                    promptTokens: result.usage.inputTokens?.total ?? 0,
+                                    completionTokens: result.usage.outputTokens?.total ?? 0,
+                                }
+                                : undefined,
+                            duration: Date.now() - startTime,
+                            finishReason: String(result.finishReason ?? ""),
+                        });
+                        Promise.resolve(callbackResult).catch((e) => {
+                            logger.warn("[LifecycleMiddleware] onFinish callback error:", e);
+                        });
+                    }
+                    catch (e) {
+                        logger.warn("[LifecycleMiddleware] onFinish callback error:", e);
+                    }
+                }
+                return result;
+            }
+            catch (error) {
+                if (config.onError) {
+                    const err = error instanceof Error ? error : new Error(String(error));
+                    try {
+                        const callbackResult = config.onError({
+                            error: err,
+                            duration: Date.now() - startTime,
+                            recoverable: isRecoverableError(err),
+                        });
+                        Promise.resolve(callbackResult).catch((e) => {
+                            logger.warn("[LifecycleMiddleware] onError callback error:", e);
+                        });
+                    }
+                    catch (e) {
+                        logger.warn("[LifecycleMiddleware] onError callback error:", e);
+                    }
+                }
+                throw error;
+            }
+        },
+        wrapStream: async ({ doStream, }) => {
+            const startTime = Date.now();
+            try {
+                const result = await doStream();
+                if (!config.onChunk && !config.onFinish && !config.onError) {
+                    return result;
+                }
+                let sequenceNumber = 0;
+                let accumulatedText = "";
+                const transformStream = new TransformStream({
+                    transform(chunk, controller) {
+                        try {
+                            if (chunk.type === "text-delta") {
+                                accumulatedText += chunk.textDelta;
+                            }
+                            if (config.onChunk && chunk.type) {
+                                try {
+                                    const callbackResult = config.onChunk({
+                                        type: chunk.type,
+                                        textDelta: chunk.type === "text-delta" ? chunk.textDelta : undefined,
+                                        sequenceNumber: sequenceNumber++,
+                                    });
+                                    Promise.resolve(callbackResult).catch((e) => {
+                                        logger.warn("[LifecycleMiddleware] onChunk callback error:", e);
+                                    });
+                                }
+                                catch (e) {
+                                    logger.warn("[LifecycleMiddleware] onChunk callback error:", e);
+                                }
+                            }
+                            controller.enqueue(chunk);
+                        }
+                        catch (error) {
+                            if (config.onError) {
+                                const err = error instanceof Error ? error : new Error(String(error));
+                                try {
+                                    const callbackResult = config.onError({
+                                        error: err,
+                                        duration: Date.now() - startTime,
+                                        recoverable: isRecoverableError(err),
+                                    });
+                                    Promise.resolve(callbackResult).catch((e) => {
+                                        logger.warn("[LifecycleMiddleware] onError callback error:", e);
+                                    });
+                                }
+                                catch (e) {
+                                    logger.warn("[LifecycleMiddleware] onError callback error:", e);
+                                }
+                            }
+                            throw error;
+                        }
+                    },
+                    flush() {
+                        if (config.onFinish) {
+                            try {
+                                const callbackResult = config.onFinish({
+                                    text: accumulatedText,
+                                    duration: Date.now() - startTime,
+                                });
+                                Promise.resolve(callbackResult).catch((e) => {
+                                    logger.warn("[LifecycleMiddleware] onFinish callback error:", e);
+                                });
+                            }
+                            catch (e) {
+                                logger.warn("[LifecycleMiddleware] onFinish callback error:", e);
+                            }
+                        }
+                    },
+                });
+                return {
+                    ...result,
+                    stream: result.stream.pipeThrough(transformStream),
+                };
+            }
+            catch (error) {
+                if (config.onError) {
+                    const err = error instanceof Error ? error : new Error(String(error));
+                    try {
+                        const callbackResult = config.onError({
+                            error: err,
+                            duration: Date.now() - startTime,
+                            recoverable: isRecoverableError(err),
+                        });
+                        Promise.resolve(callbackResult).catch((e) => {
+                            logger.warn("[LifecycleMiddleware] onError callback error:", e);
+                        });
+                    }
+                    catch (e) {
+                        logger.warn("[LifecycleMiddleware] onError callback error:", e);
+                    }
+                }
+                throw error;
+            }
+        },
+    };
+    return { ...middleware, metadata };
+}

package/dist/middleware/factory.d.ts

@@ -1,4 +1,4 @@
-import type { LanguageModelV1 } from "ai";
+import type { LanguageModel } from "ai";
 import type { MiddlewareContext, MiddlewareConfig, MiddlewareFactoryOptions, MiddlewareChainStats, MiddlewarePreset, NeuroLinkMiddleware, MiddlewareRegistrationOptions } from "../types/middlewareTypes.js";
 import { MiddlewareRegistry } from "./registry.js";
 /**
@@ -25,7 +25,7 @@ export declare class MiddlewareFactory {
     /**
      * Apply middleware to a language model
      */
-    applyMiddleware(model: LanguageModelV1, context: MiddlewareContext, options?: MiddlewareFactoryOptions): LanguageModelV1;
+    applyMiddleware(model: LanguageModel, context: MiddlewareContext, options?: MiddlewareFactoryOptions): LanguageModel;
     private getCreator;
     /**
      * Build middleware configuration from factory options
@@ -65,5 +65,5 @@ export declare class MiddlewareFactory {
     /**
      * Create a middleware-enabled model factory function
      */
-    createModelFactory(baseModelFactory: () => Promise<LanguageModelV1>, defaultOptions?: MiddlewareFactoryOptions): (context: MiddlewareContext, options?: MiddlewareFactoryOptions) => Promise<LanguageModelV1>;
+    createModelFactory(baseModelFactory: () => Promise<LanguageModel>, defaultOptions?: MiddlewareFactoryOptions): (context: MiddlewareContext, options?: MiddlewareFactoryOptions) => Promise<LanguageModel>;
 }

package/dist/middleware/factory.js

@@ -3,6 +3,7 @@ import { MiddlewareRegistry } from "./registry.js";
 import { createAnalyticsMiddleware } from "./builtin/analytics.js";
 import { createGuardrailsMiddleware } from "./builtin/guardrails.js";
 import { createAutoEvaluationMiddleware } from "./builtin/autoEvaluation.js";
+import { createLifecycleMiddleware } from "./builtin/lifecycle.js";
 import { logger } from "../utils/logger.js";
 /**
  * Middleware factory for creating and applying middleware chains.
@@ -26,6 +27,7 @@ export class MiddlewareFactory {
             analytics: createAnalyticsMiddleware,
             guardrails: createGuardrailsMiddleware,
             autoEvaluation: createAutoEvaluationMiddleware,
+            lifecycle: createLifecycleMiddleware,
         };
         // Register built-in presets
         this.registerPreset({
@@ -115,9 +117,10 @@ export class MiddlewareFactory {
                 middlewareCount: middlewareChain.length,
             });
             // Apply middleware using AI SDK's wrapLanguageModel
-            // Cast to the expected AI SDK middleware type
+            // wrapLanguageModel expects LanguageModelV3, narrow from LanguageModel union
+            const modelV3 = model;
             const wrappedModel = wrapLanguageModel({
-                model,
+                model: modelV3,
                 middleware: middlewareChain,
             });
             const processingTime = Date.now() - startTime;
@@ -142,6 +145,7 @@ export class MiddlewareFactory {
             analytics: createAnalyticsMiddleware,
             guardrails: createGuardrailsMiddleware,
             autoEvaluation: createAutoEvaluationMiddleware,
+            lifecycle: createLifecycleMiddleware,
         };
         logger.debug("Getting creator for middleware ID:", id);
         return builtInMiddlewareCreators[id];

package/dist/middleware/index.d.ts

@@ -7,6 +7,7 @@
  */
 import { MiddlewareFactory } from "./factory.js";
 export type { NeuroLinkMiddleware, MiddlewareConfig, MiddlewareContext, MiddlewareConditions, MiddlewareRegistrationOptions, MiddlewareExecutionResult, MiddlewareChainStats, MiddlewarePreset, MiddlewareFactoryOptions, BuiltInMiddlewareType, } from "../types/middlewareTypes.js";
-export type { LanguageModelV1Middleware } from "ai";
+export type { LanguageModelMiddleware } from "ai";
 export { MiddlewareFactory };
+export { createLifecycleMiddleware } from "./builtin/lifecycle.js";
 export default MiddlewareFactory;

package/dist/middleware/index.js

@@ -9,5 +9,7 @@
 import { MiddlewareFactory } from "./factory.js";
 // Factory for creating and applying middleware chains
 export { MiddlewareFactory };
+// Built-in middleware creators
+export { createLifecycleMiddleware } from "./builtin/lifecycle.js";
 // Export the factory as the default export for clean, direct usage
 export default MiddlewareFactory;

package/dist/middleware/registry.d.ts

@@ -1,4 +1,4 @@
-import type { LanguageModelV1Middleware } from "ai";
+import type { LanguageModelMiddleware } from "ai";
 import type { NeuroLinkMiddleware, MiddlewareConfig, MiddlewareContext, MiddlewareRegistrationOptions, MiddlewareExecutionResult } from "../types/middlewareTypes.js";
 /**
  * Manages the registration, configuration, and execution of middleware for a single factory instance.
@@ -30,7 +30,7 @@ export declare class MiddlewareRegistry {
     /**
      * Build middleware chain based on configuration
      */
-    buildChain(context: MiddlewareContext, config?: Record<string, MiddlewareConfig>): LanguageModelV1Middleware[];
+    buildChain(context: MiddlewareContext, config?: Record<string, MiddlewareConfig>): LanguageModelMiddleware[];
     /**
      * Determine if middleware should be applied based on conditions
      */

package/dist/middleware/registry.js

@@ -146,6 +146,7 @@ export class MiddlewareRegistry {
         };
         // Create wrapper that tracks execution
         const wrappedMiddleware = {
+            specificationVersion: "v3",
             metadata: middleware.metadata,
         };
         if (middleware.transformParams) {

package/dist/middleware/utils/guardrailsUtils.d.ts

@@ -1,10 +1,9 @@
 import type { BadWordsConfig, ContentFilteringResult, EvaluationActionResult, PrecallEvaluationConfig, PrecallEvaluationResult } from "../../types/guardrails.js";
-import type { LanguageModelV1CallOptions } from "ai";
 export declare const DEFAULT_EVALUATION_PROMPT = "\nEvaluate the following user input for safety and appropriateness. Respond ONLY with valid JSON:\n\n{\n  \"overall\": \"safe|unsafe|suspicious|inappropriate\",\n  \"safetyScore\": <1-10>,\n  \"appropriatenessScore\": <1-10>,\n  \"confidenceLevel\": <1-10>,\n  \"issues\": [\n    {\n      \"category\": \"explicit_content|hate_speech|violence|personal_info|spam|other\",\n      \"severity\": \"low|medium|high|critical\",\n      \"description\": \"Brief description\"\n    }\n  ],\n  \"suggestedAction\": \"allow|block|sanitize|warn\",\n  \"reasoning\": \"Brief explanation\"\n}\n\nUser Input: \"{USER_INPUT}\"\n";
 /**
- * Extract user input from LanguageModelV1CallOptions
+ * Extract user input from middleware params
  */
-export declare function extractUserInput(params: LanguageModelV1CallOptions): string;
+export declare function extractUserInput(params: any): string;
 export declare function parseEvaluationResponse(rawResponse: string): PrecallEvaluationResult;
 /**
  * Handles the precall guardrails logic, including evaluation and sanitization.
@@ -12,9 +11,9 @@ export declare function parseEvaluationResponse(rawResponse: string): PrecallEva
  * @param config - The precall evaluation configuration.
  * @returns An object indicating if the request should be blocked and the (potentially transformed) params.
  */
-export declare function handlePrecallGuardrails(params: LanguageModelV1CallOptions, config: PrecallEvaluationConfig): Promise<{
+export declare function handlePrecallGuardrails(params: any, config: PrecallEvaluationConfig): Promise<{
     shouldBlock: boolean;
-    transformedParams: LanguageModelV1CallOptions;
+    transformedParams: any;
 }>;
 /**
  * Perform precall evaluation of user input using AI models
@@ -24,7 +23,7 @@ export declare function applyEvaluationActions(evaluation: PrecallEvaluationResu
 /**
  * Apply parameter sanitization to request parameters
  */
-export declare function applySanitization(params: LanguageModelV1CallOptions, sanitizedInput: string): LanguageModelV1CallOptions;
+export declare function applySanitization(params: any, sanitizedInput: string): any;
 export declare function escapeRegExp(string: string): string;
 export declare function createBlockedResponse(): {
     text: string;

package/dist/middleware/utils/guardrailsUtils.js

@@ -22,29 +22,33 @@ Evaluate the following user input for safety and appropriateness. Respond ONLY w
 User Input: "{USER_INPUT}"
 `;
 /**
- * Extract user input from LanguageModelV1CallOptions
+ * Extract user input from middleware params
  */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function extractUserInput(params) {
     if (typeof params.prompt === "string") {
         return params.prompt;
     }
-    return params.prompt
+    return (params.prompt
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         .map((msg) => {
         if (msg.role === "user") {
             if (typeof msg.content === "string") {
                 return msg.content;
             }
             else if (Array.isArray(msg.content)) {
-                return msg.content
+                return (msg.content
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     .filter((part) => part.type === "text")
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     .map((part) => part.text)
-                    .join(" ");
+                    .join(" "));
             }
         }
         return "";
     })
         .filter(Boolean)
-        .join("\n");
+        .join("\n"));
 }
 export function parseEvaluationResponse(rawResponse) {
     try {
@@ -78,7 +82,9 @@ export function parseEvaluationResponse(rawResponse) {
  * @param config - The precall evaluation configuration.
  * @returns An object indicating if the request should be blocked and the (potentially transformed) params.
  */
-export async function handlePrecallGuardrails(params, config) {
+export async function handlePrecallGuardrails(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+params, config) {
     const userInput = extractUserInput(params);
     let transformedParams = params;
     if (userInput.trim()) {
@@ -216,9 +222,11 @@ export function applyEvaluationActions(evaluation, config, userInput) {
 /**
  * Apply parameter sanitization to request parameters
  */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function applySanitization(params, sanitizedInput) {
     const sanitizedParams = { ...params };
     if (Array.isArray(params.prompt)) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const sanitizedPrompt = params.prompt.map((msg) => {
             if (msg.role === "user") {
                 if (typeof msg.content === "string") {
@@ -228,6 +236,7 @@ export function applySanitization(params, sanitizedInput) {
                     };
                 }
                 else if (Array.isArray(msg.content)) {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     const sanitizedContent = msg.content.map((part) => {
                         if (part.type === "text") {
                             return { ...part, text: sanitizedInput };

package/dist/neurolink.d.ts

@@ -22,10 +22,11 @@ import type { ProviderStatus, TextGenerationOptions, TextGenerationResult } from
 import type { MCPExecutableTool, MCPServerInfo, MCPStatus } from "./types/mcpTypes.js";
 import type { ObservabilityConfig } from "./types/observability.js";
 import type { StreamOptions, StreamResult } from "./types/streamTypes.js";
-import type { ToolExecutionContext, ToolExecutionSummary, ToolInfo } from "./types/tools.js";
+import type { ToolExecutionContext, ToolExecutionSummary, ToolInfo, ToolRegistrationOptions } from "./types/tools.js";
 import type { BatchOperationResult } from "./types/typeAliases.js";
 export declare class NeuroLink {
     private mcpInitialized;
+    private mcpSkipped;
     private mcpInitPromise;
     private emitter;
     private toolRegistry;
@@ -64,8 +65,6 @@ export declare class NeuroLink {
     private conversationMemoryConfig?;
     private enableOrchestration;
     private hitlManager?;
-    private mem0Instance?;
-    private mem0Config?;
     private _sessionCostUsd;
     private fileRegistry;
     private cachedFileTools;
@@ -75,14 +74,6 @@ export declare class NeuroLink {
      * Extract and set Langfuse context from options with proper async scoping
      */
     private setLangfuseContextFromOptions;
-    /**
-     * Simple sync config setup for mem0
-     */
-    private initializeMem0Config;
-    /**
-     * Async initialization called during generate/stream
-     */
-    private ensureMem0Ready;
     private initializeMemoryConfig;
     /**
      * Lazy initialization for memory — called during generate/stream.
@@ -186,10 +177,6 @@ export declare class NeuroLink {
     private registerMemoryRetrievalTools;
     /** Format memory context for prompt inclusion */
     private formatMemoryContext;
-    /** Extract memory context from search results */
-    private extractMemoryContext;
-    /** Store conversation turn in mem0 */
-    private storeMem0ConversationTurn;
     /**
      * Retrieve condensed memory for a user.
      * Returns the input text enhanced with memory context, or unchanged if no memory.
@@ -505,9 +492,9 @@ export declare class NeuroLink {
      */
     generate(optionsOrPrompt: GenerateOptions | string): Promise<GenerateResult>;
     /**
-     * Schedule non-blocking Mem0 memory storage after generate completes.
+     * Schedule non-blocking memory storage after generate completes.
      */
-    private scheduleGenerateMem0Storage;
+    private scheduleGenerateMemoryStorage;
     /**
      * Handle PPT generation mode
      */
@@ -639,7 +626,7 @@ export declare class NeuroLink {
      */
     stream(options: StreamOptions): Promise<StreamResult>;
     /**
-     * Prepare stream options: initialize memory, MCP, Mem0 retrieval, orchestration,
+     * Prepare stream options: initialize memory, MCP, retrieval, orchestration,
      * Ollama tool auto-disable, factory processing, and tool detection.
      */
     private prepareStreamOptions;
@@ -660,7 +647,7 @@ export declare class NeuroLink {
     private handleStreamFallback;
     /**
      * Store conversation memory after stream consumption is complete (called from finally block).
-     * Handles both conversation memory storage and Mem0 background storage.
+     * Handles conversation memory storage in the background.
      */
     private storeStreamConversationMemory;
     /**
@@ -901,7 +888,7 @@ export declare class NeuroLink {
      * @param name - Unique name for the tool
      * @param tool - Tool in MCPExecutableTool format (unified MCP protocol type)
      */
-    registerTool(name: string, tool: MCPExecutableTool): void;
+    registerTool(name: string, tool: MCPExecutableTool, options?: ToolRegistrationOptions): void;
     /**
      * Set the context that will be passed to tools during execution
      * This context will be merged with any runtime context passed by the AI model
@@ -1188,6 +1175,7 @@ export declare class NeuroLink {
         successRate: number;
         averageExecutionTime: number;
         lastExecutionTime: number;
+        errorCategories: Record<string, number>;
     }>;
     /**
      * NL-004: Set model alias/deprecation configuration.
@@ -1229,6 +1217,7 @@ export declare class NeuroLink {
                 successRate: number;
                 averageExecutionTime: number;
                 lastExecutionTime: number;
+                errorCategories: Record<string, number>;
             };
             circuitBreaker: {
                 state: "closed" | "open" | "half-open";