@juspay/neurolink 9.30.0 → 9.31.0

package/dist/lib/mcp/mcpClientFactory.js

@@ -12,11 +12,20 @@ import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/
 import { spawn } from "child_process";
 import { mcpLogger } from "../utils/logger.js";
 import { globalCircuitBreakerManager } from "./mcpCircuitBreaker.js";
+import { CircuitBreakerOpenError } from "../types/circuitBreakerErrors.js";
 import { withHTTPRetry, DEFAULT_HTTP_RETRY_CONFIG, } from "./httpRetryHandler.js";
 import { globalRateLimiterManager } from "./httpRateLimiter.js";
 import { NeuroLinkOAuthProvider, InMemoryTokenStorage } from "./auth/index.js";
 import { SpanSerializer, SpanType, SpanStatus, } from "../observability/index.js";
 import { getMetricsAggregator } from "../observability/index.js";
+/**
+ * Default timeout for MCP client creation in milliseconds.
+ * Configurable via MCP_CLIENT_TIMEOUT env var.
+ * Covers process spawn, transport setup, connection, and handshake.
+ * Set to 60s to accommodate stdio servers that may be slow to start,
+ * especially when multiple MCP servers are started concurrently.
+ */
+const DEFAULT_CLIENT_TIMEOUT = Math.max(5000, Number(process.env.MCP_CLIENT_TIMEOUT) || 60000);
 /**
  * MCPClientFactory
  * Factory class for creating MCP clients with different transports
@@ -36,7 +45,7 @@ export class MCPClientFactory {
      * Create an MCP client for the given server configuration
      * Enhanced with retry logic, rate limiting, and circuit breaker protection
      */
-    static async createClient(config, timeout = 10000) {
+    static async createClient(config, timeout = DEFAULT_CLIENT_TIMEOUT) {
         const startTime = Date.now();
         const obsSpan = SpanSerializer.createSpan(SpanType.MCP_TRANSPORT, "mcp.connect", {
             "mcp.transport": config.transport,
@@ -112,6 +121,26 @@ export class MCPClientFactory {
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
+            // Circuit breaker open: log at warn (not error) since this is expected
+            // protection behavior, and preserve the structured metadata.
+            if (error instanceof CircuitBreakerOpenError) {
+                mcpLogger.warn(`[MCPClientFactory] Client creation blocked by circuit breaker for ${config.id}`, {
+                    serverId: config.id,
+                    breakerState: error.breakerState,
+                    retryAfter: error.retryAfter,
+                    retryAfterMs: error.retryAfterMs,
+                    failureCount: error.failureCount,
+                });
+                obsSpan.durationMs = Date.now() - startTime;
+                const endedObsSpan = SpanSerializer.endSpan(obsSpan, SpanStatus.ERROR);
+                endedObsSpan.statusMessage = `Circuit breaker open: ${errorMessage}`;
+                getMetricsAggregator().recordSpan(endedObsSpan);
+                return {
+                    success: false,
+                    error: errorMessage,
+                    duration: Date.now() - startTime,
+                };
+            }
             mcpLogger.error(`[MCPClientFactory] Failed to create client for ${config.id}:`, error);
             obsSpan.durationMs = Date.now() - startTime;
             const endedObsSpan = SpanSerializer.endSpan(obsSpan, SpanStatus.ERROR);
@@ -283,7 +312,7 @@ export class MCPClientFactory {
             return { transport };
         }
         catch (error) {
-            throw new Error(`Invalid SSE URL: ${error instanceof Error ? error.message : String(error)}`);
+            throw new Error(`Invalid SSE URL: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
         }
     }
     /**
@@ -302,7 +331,7 @@ export class MCPClientFactory {
             return { transport };
         }
         catch (error) {
-            throw new Error(`Invalid WebSocket URL: ${error instanceof Error ? error.message : String(error)}`);
+            throw new Error(`Invalid WebSocket URL: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
         }
     }
     /**
@@ -355,7 +384,7 @@ export class MCPClientFactory {
             return { transport };
         }
         catch (error) {
-            throw new Error(`Invalid HTTP URL: ${error instanceof Error ? error.message : String(error)}`);
+            throw new Error(`Invalid HTTP URL: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
         }
     }
     /**

package/dist/lib/mcp/toolDiscoveryService.js

@@ -5,13 +5,18 @@
  */
 import { EventEmitter } from "events";
 import { mcpLogger } from "../utils/logger.js";
-import { globalCircuitBreakerManager } from "./mcpCircuitBreaker.js";
+import { globalCircuitBreakerManager, CircuitBreakerOpenError, } from "./mcpCircuitBreaker.js";
 import { isObject, isNullish } from "../utils/typeUtils.js";
 import { validateToolName, validateToolDescription, } from "../utils/parameterValidation.js";
 import { withTimeout } from "../utils/errorHandling.js";
 import { SpanKind, SpanStatusCode } from "@opentelemetry/api";
 import { tracers } from "../telemetry/tracers.js";
 const mcpTracer = tracers.mcp;
+/**
+ * Default timeout for MCP tool execution operations in milliseconds.
+ * Configurable via MCP_TOOL_TIMEOUT env var.
+ */
+const DEFAULT_TOOL_TIMEOUT = Math.max(5000, Number(process.env.MCP_TOOL_TIMEOUT) || 60000);
 /**
  * ToolDiscoveryService
  * Handles automatic tool discovery and registration from external MCP servers
@@ -27,7 +32,7 @@ export class ToolDiscoveryService extends EventEmitter {
     /**
      * Discover tools from an external MCP server
      */
-    async discoverTools(serverId, client, timeout = 10000) {
+    async discoverTools(serverId, client, timeout = DEFAULT_TOOL_TIMEOUT) {
         const startTime = Date.now();
         try {
             // Prevent concurrent discovery for same server
@@ -333,10 +338,11 @@ export class ToolDiscoveryService extends EventEmitter {
                 parameters,
             });
             // Create circuit breaker for tool execution
+            const effectiveTimeout = options.timeout || DEFAULT_TOOL_TIMEOUT;
             const circuitBreaker = globalCircuitBreakerManager.getBreaker(`tool-execution-${serverId}-${toolName}`, {
                 failureThreshold: 3,
                 resetTimeout: 30000,
-                operationTimeout: options.timeout || 30000,
+                operationTimeout: effectiveTimeout,
             });
             // Execute tool with circuit breaker protection
             const result = await circuitBreaker.execute(async () => {
@@ -345,11 +351,11 @@ export class ToolDiscoveryService extends EventEmitter {
                     attributes: {
                         "mcp.server_id": serverId,
                         "mcp.tool_name": toolName,
-                        "mcp.timeout_ms": options.timeout || 30000,
+                        "mcp.timeout_ms": effectiveTimeout,
                     },
                 }, async (callSpan) => {
                     try {
-                        const timeout = options.timeout || 30000;
+                        const timeout = effectiveTimeout;
                         const callResult = await withTimeout(client.callTool({
                             name: toolName,
                             arguments: parameters,
@@ -398,6 +404,47 @@ export class ToolDiscoveryService extends EventEmitter {
             // Update tool statistics
             const toolKey = this.createToolKey(serverId, toolName);
             this.updateToolStats(toolKey, false, duration);
+            // Circuit breaker open errors: return a structured isError result with
+            // actionable details so AI models understand the tool is temporarily
+            // unavailable and should NOT retry until the cooldown expires.
+            if (error instanceof CircuitBreakerOpenError) {
+                mcpLogger.warn(`[ToolDiscoveryService] Tool blocked by circuit breaker: ${toolName} on ${serverId}`, {
+                    breakerState: error.breakerState,
+                    retryAfter: error.retryAfter,
+                    retryAfterMs: error.retryAfterMs,
+                    failureCount: error.failureCount,
+                });
+                return {
+                    success: false,
+                    error: error.message,
+                    data: {
+                        isError: true,
+                        content: [
+                            {
+                                type: "text",
+                                text: `TOOL TEMPORARILY UNAVAILABLE: "${toolName}" has been disabled after ` +
+                                    `${error.failureCount} failures. ` +
+                                    `This is a circuit breaker protection — do NOT retry this tool. ` +
+                                    `It will become available again after ${Math.ceil(error.retryAfterMs / 1000)} seconds ` +
+                                    `(at ${error.retryAfter}). ` +
+                                    `Instead, inform the user that the operation failed and suggest trying again later.`,
+                            },
+                        ],
+                    },
+                    duration,
+                    metadata: {
+                        toolName,
+                        serverId,
+                        timestamp: Date.now(),
+                        circuitBreaker: {
+                            state: error.breakerState,
+                            retryAfter: error.retryAfter,
+                            retryAfterMs: error.retryAfterMs,
+                            failureCount: error.failureCount,
+                        },
+                    },
+                };
+            }
             mcpLogger.error(`[ToolDiscoveryService] Tool execution failed: ${toolName}`, error);
             return {
                 success: false,

package/dist/lib/mcp/toolRegistry.js

@@ -157,6 +157,8 @@ export class MCPToolRegistry extends MCPRegistry {
             // For other tools, use fully-qualified serverId.toolName to avoid collisions
             const isCustomTool = serverId.startsWith("custom-tool-");
             const toolId = isCustomTool ? tool.name : `${serverId}.${tool.name}`;
+            const toolTimeoutMs = serverInfo.metadata?.toolTimeoutMs;
+            const toolMaxRetries = serverInfo.metadata?.toolMaxRetries;
             const toolInfo = {
                 name: tool.name,
                 description: tool.description,
@@ -168,6 +170,8 @@ export class MCPToolRegistry extends MCPRegistry {
                     serverId: serverInfo.id,
                 }),
                 permissions: [], // MCPServerInfo.tools doesn't have permissions
+                ...(toolTimeoutMs !== undefined && { timeoutMs: toolTimeoutMs }),
+                ...(toolMaxRetries !== undefined && { maxRetries: toolMaxRetries }),
             };
             // Register only with fully-qualified toolId to avoid collisions
             this.tools.set(toolId, toolInfo);
@@ -183,6 +187,8 @@ export class MCPToolRegistry extends MCPRegistry {
                     existingCategory: serverInfo.metadata?.category,
                     serverId: serverInfo.id,
                 }),
+                ...(toolTimeoutMs !== undefined && { timeoutMs: toolTimeoutMs }),
+                ...(toolMaxRetries !== undefined && { maxRetries: toolMaxRetries }),
             });
             // Tool registered successfully
         }
@@ -347,7 +353,7 @@ export class MCPToolRegistry extends MCPRegistry {
                             else {
                                 // Other HITL error (configuration, system error, etc.)
                                 registryLogger.error(`HITL confirmation failed for tool '${toolName}':`, error);
-                                throw new Error(`HITL confirmation failed: ${error instanceof Error ? error.message : String(error)}`);
+                                throw new Error(`HITL confirmation failed: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
                             }
                         }
                     }

package/dist/lib/memory/memoryRetrievalTools.d.ts

@@ -6,7 +6,6 @@
  * Follows the createFileTools() factory pattern from files/fileTools.ts.
  * @module
  */
-import { z } from "zod";
 import type { RedisConversationMemoryManager } from "../core/redisConversationMemoryManager.js";
 /**
  * Factory function that creates memory retrieval tools bound to a memory manager.
@@ -14,31 +13,15 @@ import type { RedisConversationMemoryManager } from "../core/redisConversationMe
  * @returns Record of tool name to Vercel AI SDK tool definition
  */
 export declare function createMemoryRetrievalTools(memoryManager: RedisConversationMemoryManager): {
-    retrieve_context: import("ai").Tool<z.ZodObject<{
-        sessionId: z.ZodString;
-        messageId: z.ZodOptional<z.ZodString>;
-        role: z.ZodOptional<z.ZodEnum<["user", "assistant", "system", "tool_call", "tool_result"]>>;
-        lastN: z.ZodOptional<z.ZodNumber>;
-        offset: z.ZodOptional<z.ZodNumber>;
-        limit: z.ZodOptional<z.ZodNumber>;
-        search: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
+    retrieve_context: import("ai").Tool<{
         sessionId: string;
-        search?: string | undefined;
-        role?: "system" | "user" | "assistant" | "tool_call" | "tool_result" | undefined;
-        offset?: number | undefined;
-        limit?: number | undefined;
         messageId?: string | undefined;
-        lastN?: number | undefined;
-    }, {
-        sessionId: string;
-        search?: string | undefined;
         role?: "system" | "user" | "assistant" | "tool_call" | "tool_result" | undefined;
+        lastN?: number | undefined;
         offset?: number | undefined;
         limit?: number | undefined;
-        messageId?: string | undefined;
-        lastN?: number | undefined;
-    }>, {
+        search?: string | undefined;
+    }, {
         error: string;
         sessionId: string;
         messageId?: undefined;
@@ -95,72 +78,5 @@ export declare function createMemoryRetrievalTools(memoryManager: RedisConversat
         messageId?: undefined;
         messages?: undefined;
         totalMessages?: undefined;
-    }> & {
-        execute: (args: {
-            sessionId: string;
-            search?: string | undefined;
-            role?: "system" | "user" | "assistant" | "tool_call" | "tool_result" | undefined;
-            offset?: number | undefined;
-            limit?: number | undefined;
-            messageId?: string | undefined;
-            lastN?: number | undefined;
-        }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
-            error: string;
-            sessionId: string;
-            messageId?: undefined;
-            messages?: undefined;
-            totalMessages?: undefined;
-        } | {
-            error: string;
-            messageId: string;
-            sessionId?: undefined;
-            messages?: undefined;
-            totalMessages?: undefined;
-        } | {
-            messages: ({
-                id: string;
-                error: string;
-                role?: undefined;
-                tool?: undefined;
-                matchCount?: undefined;
-                matches?: undefined;
-                totalSize?: undefined;
-                content?: undefined;
-                hasMore?: undefined;
-            } | {
-                id: string;
-                role: "system" | "user" | "assistant" | "tool_call" | "tool_result";
-                tool: string | undefined;
-                matchCount: number;
-                matches: {
-                    line: number;
-                    text: string;
-                }[];
-                totalSize: number;
-                error?: undefined;
-                content?: undefined;
-                hasMore?: undefined;
-            } | {
-                id: string;
-                role: "system" | "user" | "assistant" | "tool_call" | "tool_result";
-                tool: string | undefined;
-                content: string;
-                totalSize: number;
-                hasMore: boolean;
-                error?: undefined;
-                matchCount?: undefined;
-                matches?: undefined;
-            })[];
-            totalMessages: number;
-            error?: undefined;
-            sessionId?: undefined;
-            messageId?: undefined;
-        } | {
-            error: string;
-            sessionId?: undefined;
-            messageId?: undefined;
-            messages?: undefined;
-            totalMessages?: undefined;
-        }>;
-    };
+    }>;
 };

package/dist/lib/memory/memoryRetrievalTools.js

@@ -29,7 +29,7 @@ export function createMemoryRetrievalTools(memoryManager) {
                 "outputs when a result was truncated, review previous assistant responses, " +
                 "or search through conversation history. Supports filtering by role, " +
                 "pagination for large content, and regex search within messages.",
-            parameters: z.object({
+            inputSchema: z.object({
                 sessionId: z.string().describe("Session ID for the conversation"),
                 messageId: z
                     .string()

package/dist/lib/middleware/builtin/analytics.js

@@ -13,6 +13,8 @@ export function createAnalyticsMiddleware() {
         defaultEnabled: true,
     };
     const middleware = {
+        specificationVersion: "v3",
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         wrapGenerate: async ({ doGenerate, params }) => {
             const requestId = `analytics-${Date.now()}`;
             const startTime = Date.now();
@@ -62,6 +64,7 @@ export function createAnalyticsMiddleware() {
                 throw error;
             }
         },
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         wrapStream: async ({ doStream, params }) => {
             const requestId = `analytics-stream-${Date.now()}`;
             const startTime = Date.now();

package/dist/lib/middleware/builtin/autoEvaluation.js

@@ -21,33 +21,51 @@ export function createAutoEvaluationMiddleware(config = {}) {
     };
     logger.debug("Auto-Evaluation Middleware Config:", config);
     const middleware = {
+        specificationVersion: "v3",
         wrapGenerate: async ({ doGenerate, params }) => {
             const options = params;
             const rawResult = await doGenerate();
+            const rawReasoning = rawResult.reasoning;
+            const textParts = rawResult.content
+                .filter((c) => c.type === "text")
+                .map((c) => c.text);
+            const toolCallParts = rawResult.content.filter((c) => c.type === "tool-call");
+            const inputTokens = rawResult.usage.inputTokens.total ?? 0;
+            const outputTokens = rawResult.usage.outputTokens.total ?? 0;
             const result = {
-                ...rawResult,
-                content: rawResult.text ?? "",
+                content: textParts.join(""),
+                finishReason: rawResult.finishReason.unified,
+                reasoning: typeof rawReasoning === "string"
+                    ? rawReasoning
+                    : Array.isArray(rawReasoning)
+                        ? rawReasoning
+                            .map((r) => typeof r === "string"
+                            ? r
+                            : (r?.text ?? JSON.stringify(r)))
+                            .join("\n")
+                        : undefined,
                 usage: {
-                    input: rawResult.usage.promptTokens,
-                    output: rawResult.usage.completionTokens,
-                    total: rawResult.usage.promptTokens + rawResult.usage.completionTokens,
+                    input: inputTokens,
+                    output: outputTokens,
+                    total: inputTokens + outputTokens,
                 },
-                toolCalls: rawResult.toolCalls?.map((tc) => {
-                    let parsedArgs = tc.args;
-                    if (typeof tc.args === "string") {
+                toolCalls: toolCallParts.length > 0
+                    ? toolCallParts.map((tc) => {
+                        let parsedArgs;
                         try {
-                            parsedArgs = JSON.parse(tc.args);
+                            parsedArgs = JSON.parse(tc.input);
                         }
                         catch (e) {
                             logger.warn(`Failed to parse tool call args for tool ${tc.toolName}:`, e);
-                            parsedArgs = tc.args; // Fallback to original string if parsing fails
+                            parsedArgs = { raw: tc.input };
                         }
-                    }
-                    return {
-                        ...tc,
-                        args: parsedArgs,
-                    };
-                }),
+                        return {
+                            toolCallId: tc.toolCallId,
+                            toolName: tc.toolName,
+                            args: parsedArgs,
+                        };
+                    })
+                    : undefined,
             };
             const isBlocking = config.blocking !== false;
             if (isBlocking) {
@@ -131,19 +149,19 @@ async function consumeAndEvaluateStream(config, options, stream) {
             }
             switch (value.type) {
                 case "text-delta":
-                    fullText += value.textDelta;
+                    fullText += value.delta;
                     break;
                 case "tool-call":
                     {
                         let parsedArgs;
                         try {
-                            parsedArgs = JSON.parse(value.args);
+                            parsedArgs = JSON.parse(value.input);
                         }
                         catch (e) {
                             logger.warn(`Failed to parse tool call args for tool ${value.toolName}:`, e);
                             // In case of parsing failure, we can't assign a string.
                             // Let's use an object with the raw string to maintain type safety.
-                            parsedArgs = { raw: value.args };
+                            parsedArgs = { raw: value.input };
                         }
                         toolCalls.push({
                             toolCallId: value.toolCallId,
@@ -153,11 +171,15 @@ async function consumeAndEvaluateStream(config, options, stream) {
                     }
                     break;
                 case "finish":
-                    usage = {
-                        input: value.usage.promptTokens,
-                        output: value.usage.completionTokens,
-                        total: value.usage.promptTokens + value.usage.completionTokens,
-                    };
+                    {
+                        const finishInputTokens = value.usage.inputTokens.total ?? 0;
+                        const finishOutputTokens = value.usage.outputTokens.total ?? 0;
+                        usage = {
+                            input: finishInputTokens,
+                            output: finishOutputTokens,
+                            total: finishInputTokens + finishOutputTokens,
+                        };
+                    }
                     break;
             }
         }

package/dist/lib/middleware/builtin/guardrails.js

@@ -17,6 +17,8 @@ export function createGuardrailsMiddleware(config = {}) {
     // WeakMap to store blocking state from transformParams to wrap methods
     const blockingState = new WeakMap();
     const middleware = {
+        specificationVersion: "v3",
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         transformParams: async ({ params }) => {
             if (config.precallEvaluation?.enabled) {
                 const { shouldBlock, transformedParams } = await handlePrecallGuardrails(params, config.precallEvaluation);
@@ -26,6 +28,7 @@ export function createGuardrailsMiddleware(config = {}) {
             }
             return params;
         },
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         wrapGenerate: async ({ doGenerate, params }) => {
             logger.debug(`[GuardrailsMiddleware] Applying to generate call.`);
             // Check if this request should be blocked (set by transformParams)
@@ -58,6 +61,7 @@ export function createGuardrailsMiddleware(config = {}) {
             }
             return result;
         },
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         wrapStream: async ({ doStream, params }) => {
             logger.debug(`[GuardrailsMiddleware] Applying to stream call.`);
             // Check if this request should be blocked (set by transformParams)

package/dist/lib/middleware/builtin/lifecycle.js

@@ -18,22 +18,26 @@ export function createLifecycleMiddleware(config = {}) {
         defaultEnabled: false,
     };
     const middleware = {
-        wrapGenerate: async ({ doGenerate }) => {
+        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: result.text ?? "",
+                            text: content,
                             usage: result.usage
                                 ? {
-                                    promptTokens: result.usage.promptTokens ?? 0,
-                                    completionTokens: result.usage.completionTokens ?? 0,
+                                    promptTokens: result.usage.inputTokens?.total ?? 0,
+                                    completionTokens: result.usage.outputTokens?.total ?? 0,
                                 }
                                 : undefined,
                             duration: Date.now() - startTime,
-                            finishReason: result.finishReason,
+                            finishReason: String(result.finishReason ?? ""),
                         });
                         Promise.resolve(callbackResult).catch((e) => {
                             logger.warn("[LifecycleMiddleware] onFinish callback error:", e);
@@ -65,7 +69,7 @@ export function createLifecycleMiddleware(config = {}) {
                 throw error;
             }
         },
-        wrapStream: async ({ doStream }) => {
+        wrapStream: async ({ doStream, }) => {
             const startTime = Date.now();
             try {
                 const result = await doStream();

package/dist/lib/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/lib/middleware/factory.js

@@ -117,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;

package/dist/lib/middleware/index.d.ts

@@ -7,7 +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/lib/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/lib/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/lib/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;