@juspay/neurolink 9.30.0 → 9.31.1

package/dist/lib/workflow/utils/workflowValidation.js

@@ -19,7 +19,7 @@ export function validateWorkflow(config) {
     // Schema validation
     const schemaResult = validateWorkflowConfig(config);
     if (!schemaResult.success && schemaResult.error) {
-        schemaResult.error.errors.forEach((err) => {
+        schemaResult.error.issues.forEach((err) => {
             errors.push({
                 field: err.path.join("."),
                 message: err.message,

package/dist/mcp/batching/requestBatcher.js

@@ -230,7 +230,7 @@ export class RequestBatcher extends EventEmitter {
                 args: r.args,
                 serverId: r.serverId,
             })));
-            const timeoutMs = 30_000;
+            const timeoutMs = Math.max(5000, Number(process.env.MCP_TOOL_TIMEOUT) || 60000);
             let timeoutHandle;
             const timeoutPromise = new Promise((_, reject) => {
                 timeoutHandle = setTimeout(() => reject(ErrorFactory.toolTimeout("batchExecution", timeoutMs)), timeoutMs);

package/dist/mcp/externalServerManager.js

@@ -174,9 +174,12 @@ export class ExternalServerManager extends EventEmitter {
     constructor(config = {}, options = {}) {
         super();
         // Set defaults for configuration
+        // Default timeout increased to 60s and made configurable via MCP_CLIENT_TIMEOUT
+        // to accommodate MCP server startup latency (especially concurrent stdio servers)
+        const defaultMcpTimeout = Math.max(5000, Number(process.env.MCP_CLIENT_TIMEOUT) || 60000);
         this.config = {
             maxServers: config.maxServers ?? 10,
-            defaultTimeout: config.defaultTimeout ?? 10000,
+            defaultTimeout: config.defaultTimeout ?? defaultMcpTimeout,
             defaultHealthCheckInterval: config.defaultHealthCheckInterval ?? 30000,
             enableAutoRestart: config.enableAutoRestart ?? true,
             maxRestartAttempts: config.maxRestartAttempts ?? 3,
@@ -1401,7 +1404,7 @@ export class ExternalServerManager extends EventEmitter {
                         else {
                             // Other HITL error (configuration, system error, etc.)
                             mcpLogger.error(`[ExternalServerManager] HITL confirmation failed for external 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/mcp/factory.js

@@ -28,7 +28,7 @@ const ServerConfigSchema = z.object({
     ])
         .optional(),
     visibility: z.enum(["public", "private", "organization"]).optional(),
-    metadata: z.record(z.unknown()).optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
     dependencies: z.array(z.string()).optional(),
     capabilities: z.array(z.string()).optional(),
 });

package/dist/mcp/index.d.ts

@@ -17,7 +17,7 @@ export { createMCPServer, getServerInfo, validateServerTools, validateTool, } fr
 export { calculateExpiresAt, createOAuthProviderFromConfig, FileTokenStorage, InMemoryTokenStorage, isTokenExpired, NeuroLinkOAuthProvider, } from "./auth/index.js";
 export { DEFAULT_RATE_LIMIT_CONFIG, globalRateLimiterManager, HTTPRateLimiter, RateLimiterManager, } from "./httpRateLimiter.js";
 export { DEFAULT_HTTP_RETRY_CONFIG, isRetryableHTTPError, isRetryableStatusCode, withHTTPRetry, } from "./httpRetryHandler.js";
-export { CircuitBreakerManager, globalCircuitBreakerManager, MCPCircuitBreaker, } from "./mcpCircuitBreaker.js";
+export { CircuitBreakerManager, globalCircuitBreakerManager, MCPCircuitBreaker, CircuitBreakerOpenError, } from "./mcpCircuitBreaker.js";
 export { MCPToolRegistry } from "./toolRegistry.js";
 export { ExternalServerManager } from "./externalServerManager.js";
 export { MCPClientFactory } from "./mcpClientFactory.js";

package/dist/mcp/index.js

@@ -9,7 +9,7 @@ export { DEFAULT_RATE_LIMIT_CONFIG, globalRateLimiterManager, HTTPRateLimiter, R
 // HTTP Retry Handler
 export { DEFAULT_HTTP_RETRY_CONFIG, isRetryableHTTPError, isRetryableStatusCode, withHTTPRetry, } from "./httpRetryHandler.js";
 // Circuit Breaker
-export { CircuitBreakerManager, globalCircuitBreakerManager, MCPCircuitBreaker, } from "./mcpCircuitBreaker.js";
+export { CircuitBreakerManager, globalCircuitBreakerManager, MCPCircuitBreaker, CircuitBreakerOpenError, } from "./mcpCircuitBreaker.js";
 // Core MCP Components
 export { MCPToolRegistry } from "./toolRegistry.js";
 export { ExternalServerManager } from "./externalServerManager.js";

package/dist/mcp/mcpCircuitBreaker.d.ts

@@ -5,6 +5,7 @@
  */
 import { EventEmitter } from "events";
 import type { CircuitBreakerConfig, CircuitBreakerStats } from "../types/mcpTypes.js";
+export { CircuitBreakerOpenError } from "../types/circuitBreakerErrors.js";
 /**
  * MCPCircuitBreaker
  * Implements circuit breaker pattern for fault tolerance

package/dist/mcp/mcpCircuitBreaker.js

@@ -6,6 +6,16 @@
 import { EventEmitter } from "events";
 import { trace } from "@opentelemetry/api";
 import { mcpLogger } from "../utils/logger.js";
+import { CircuitBreakerOpenError } from "../types/circuitBreakerErrors.js";
+// Re-export CircuitBreakerOpenError from shared types to preserve public API
+export { CircuitBreakerOpenError } from "../types/circuitBreakerErrors.js";
+/**
+ * Default operation timeout for circuit breaker protected operations.
+ * Configurable via MCP_OPERATION_TIMEOUT env var (in milliseconds).
+ * Increased from 30s to 60s to accommodate MCP server startup latency,
+ * especially when multiple servers start concurrently.
+ */
+const DEFAULT_OPERATION_TIMEOUT = Math.max(10000, Number(process.env.MCP_OPERATION_TIMEOUT) || 60000);
 /**
  * MCPCircuitBreaker
  * Implements circuit breaker pattern for fault tolerance
@@ -28,7 +38,7 @@ export class MCPCircuitBreaker extends EventEmitter {
             failureThreshold: config.failureThreshold ?? 5,
             resetTimeout: config.resetTimeout ?? 60000,
             halfOpenMaxCalls: config.halfOpenMaxCalls ?? 3,
-            operationTimeout: config.operationTimeout ?? 30000,
+            operationTimeout: config.operationTimeout ?? DEFAULT_OPERATION_TIMEOUT,
             minimumCallsBeforeCalculation: config.minimumCallsBeforeCalculation ?? 10,
             statisticsWindowSize: config.statisticsWindowSize ?? 300000, // 5 minutes
         };
@@ -43,8 +53,15 @@ export class MCPCircuitBreaker extends EventEmitter {
         try {
             // Check if circuit is open
             if (this.state === "open") {
-                if (Date.now() - this.lastFailureTime < this.config.resetTimeout) {
-                    throw new Error(`Circuit breaker '${this.name}' is open. Next retry at ${new Date(this.lastFailureTime + this.config.resetTimeout)}`);
+                const retryAfterMs = this.config.resetTimeout - (Date.now() - this.lastFailureTime);
+                if (retryAfterMs > 0) {
+                    throw new CircuitBreakerOpenError({
+                        breakerName: this.name,
+                        retryAfter: new Date(this.lastFailureTime + this.config.resetTimeout),
+                        retryAfterMs,
+                        breakerState: "open",
+                        failureCount: this.getStats().failedCalls,
+                    });
                 }
                 // Transition to half-open
                 this.changeState("half-open", "Reset timeout reached");
@@ -52,7 +69,16 @@ export class MCPCircuitBreaker extends EventEmitter {
             // Check half-open call limit
             if (this.state === "half-open" &&
                 this.halfOpenCalls >= this.config.halfOpenMaxCalls) {
-                throw new Error(`Circuit breaker '${this.name}' is half-open but call limit reached`);
+                // Half-open call limit exceeded — revert to open with fresh cooldown
+                this.lastFailureTime = Date.now();
+                this.changeState("open", "Half-open call limit reached, reverting to open");
+                throw new CircuitBreakerOpenError({
+                    breakerName: this.name,
+                    retryAfter: new Date(this.lastFailureTime + this.config.resetTimeout),
+                    retryAfterMs: this.config.resetTimeout,
+                    breakerState: "open",
+                    failureCount: this.getStats().failedCalls,
+                });
             }
             // NLK-GAP-009: Record half-open test event when executing in half-open state
             if (this.state === "half-open") {

package/dist/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/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/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/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/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/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/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/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)