@juspay/neurolink 7.44.0 → 7.46.0

package/dist/lib/providers/amazonBedrock.js

@@ -7,8 +7,10 @@ import { convertZodToJsonSchema } from "../utils/schemaConversion.js";
 export class AmazonBedrockProvider extends BaseProvider {
     bedrockClient;
     conversationHistory = [];
-    constructor(modelName, neurolink) {
+    region;
+    constructor(modelName, neurolink, region) {
         super(modelName, "bedrock", neurolink);
+        this.region = region || process.env.AWS_REGION || "us-east-1";
         logger.debug("[AmazonBedrockProvider] Starting constructor with extensive logging for debugging");
         // Log environment variables for debugging
         logger.debug(`[AmazonBedrockProvider] Environment check: AWS_REGION=${process.env.AWS_REGION || "undefined"}, AWS_ACCESS_KEY_ID=${process.env.AWS_ACCESS_KEY_ID ? "SET" : "undefined"}, AWS_SECRET_ACCESS_KEY=${process.env.AWS_SECRET_ACCESS_KEY ? "SET" : "undefined"}`);
@@ -17,14 +19,14 @@ export class AmazonBedrockProvider extends BaseProvider {
             // Absolutely no proxy interference - let AWS SDK handle everything natively
             logger.debug("[AmazonBedrockProvider] Creating BedrockRuntimeClient with clean configuration");
             this.bedrockClient = new BedrockRuntimeClient({
-                region: process.env.AWS_REGION || "us-east-1",
+                region: this.region,
                 // Clean configuration - AWS SDK will handle credentials via:
                 // 1. IAM roles (preferred in production)
                 // 2. Environment variables
                 // 3. AWS config files
                 // 4. Instance metadata
             });
-            logger.debug(`[AmazonBedrockProvider] Successfully created BedrockRuntimeClient with model: ${this.modelName}, region: ${process.env.AWS_REGION || "us-east-1"}`);
+            logger.debug(`[AmazonBedrockProvider] Successfully created BedrockRuntimeClient with model: ${this.modelName}, region: ${this.region}`);
             // Immediate health check to catch credential issues early
             this.performInitialHealthCheck();
         }
@@ -39,7 +41,7 @@ export class AmazonBedrockProvider extends BaseProvider {
      */
     async performInitialHealthCheck() {
         const bedrockClient = new BedrockClient({
-            region: process.env.AWS_REGION || "us-east-1",
+            region: this.region,
         });
         try {
             logger.debug("[AmazonBedrockProvider] Starting initial health check to validate credentials and connectivity");

package/dist/lib/providers/amazonSagemaker.d.ts

@@ -16,7 +16,7 @@ export declare class AmazonSageMakerProvider extends BaseProvider {
     private sagemakerModel;
     private sagemakerConfig;
     private modelConfig;
-    constructor(modelName?: string, endpointName?: string);
+    constructor(modelName?: string, endpointName?: string, region?: string);
     protected getProviderName(): AIProviderName;
     protected getDefaultModel(): string;
     protected getAISDKModel(): LanguageModelV1;

package/dist/lib/providers/amazonSagemaker.js

@@ -17,11 +17,11 @@ export class AmazonSageMakerProvider extends BaseProvider {
     sagemakerModel;
     sagemakerConfig;
     modelConfig;
-    constructor(modelName, endpointName) {
+    constructor(modelName, endpointName, region) {
         super(modelName, "sagemaker");
         try {
             // Load and validate configuration
-            this.sagemakerConfig = getSageMakerConfig();
+            this.sagemakerConfig = getSageMakerConfig(region);
             this.modelConfig = getSageMakerModelConfig(endpointName || getDefaultSageMakerEndpoint());
             // Create the proper LanguageModel (v2) implementation
             this.sagemakerModel = new SageMakerLanguageModel(this.modelName, this.sagemakerConfig, this.modelConfig);

package/dist/lib/providers/googleVertex.d.ts

@@ -25,7 +25,7 @@ export declare class GoogleVertexProvider extends BaseProvider {
     private static readonly MAX_CACHE_SIZE;
     private static maxTokensCache;
     private static maxTokensCacheTime;
-    constructor(modelName?: string, _providerName?: string, sdk?: unknown);
+    constructor(modelName?: string, _providerName?: string, sdk?: unknown, region?: string);
     protected getProviderName(): AIProviderName;
     protected getDefaultModel(): string;
     /**

package/dist/lib/providers/googleVertex.js

@@ -46,10 +46,10 @@ const hasGoogleCredentials = () => {
             process.env.GOOGLE_AUTH_PRIVATE_KEY));
 };
 // Enhanced Vertex settings creation with authentication fallback and proxy support
-const createVertexSettings = async () => {
+const createVertexSettings = async (region) => {
     const baseSettings = {
         project: getVertexProjectId(),
-        location: getVertexLocation(),
+        location: region || getVertexLocation(),
         fetch: createProxyFetch(),
     };
     // 🎯 OPTION 2: Create credentials file from environment variables at runtime
@@ -157,8 +157,7 @@ const createVertexSettings = async () => {
             private_key: requiredEnvVars.private_key.replace(/\\n/g, "\n"),
             client_email: requiredEnvVars.client_email,
             client_id: requiredEnvVars.client_id || "",
-            auth_uri: requiredEnvVars.auth_uri ||
-                "https://accounts.google.com/o/oauth2/auth",
+            auth_uri: requiredEnvVars.auth_uri || "https://accounts.google.com/o/oauth2/auth",
             token_uri: requiredEnvVars.token_uri || "https://oauth2.googleapis.com/token",
             auth_provider_x509_cert_url: requiredEnvVars.auth_provider_x509_cert_url ||
                 "https://www.googleapis.com/oauth2/v1/certs",
@@ -199,8 +198,8 @@ const createVertexSettings = async () => {
     return baseSettings;
 };
 // Create Anthropic-specific Vertex settings with the same authentication and proxy support
-const createVertexAnthropicSettings = async () => {
-    const baseVertexSettings = await createVertexSettings();
+const createVertexAnthropicSettings = async (region) => {
+    const baseVertexSettings = await createVertexSettings(region);
     // GoogleVertexAnthropicProviderSettings extends GoogleVertexProviderSettings
     // so we can use the same settings with proper typing
     return {
@@ -241,7 +240,7 @@ export class GoogleVertexProvider extends BaseProvider {
     // Memory-managed cache for maxTokens handling decisions to optimize streaming performance
     static maxTokensCache = new Map();
     static maxTokensCacheTime = 0;
-    constructor(modelName, _providerName, sdk) {
+    constructor(modelName, _providerName, sdk, region) {
         super(modelName, "vertex", sdk);
         // Validate Google Cloud credentials - now using consolidated utility
         if (!hasGoogleCredentials()) {
@@ -249,7 +248,7 @@ export class GoogleVertexProvider extends BaseProvider {
         }
         // Initialize Google Cloud configuration
         this.projectId = getVertexProjectId();
-        this.location = getVertexLocation();
+        this.location = region || getVertexLocation();
         logger.debug("Google Vertex AI BaseProvider v2 initialized", {
             modelName: this.modelName,
             projectId: this.projectId,
@@ -360,7 +359,7 @@ export class GoogleVertexProvider extends BaseProvider {
             message: "Starting Vertex settings creation with network configuration analysis",
         });
         try {
-            const vertexSettings = await createVertexSettings();
+            const vertexSettings = await createVertexSettings(this.location);
             const vertexSettingsEndTime = process.hrtime.bigint();
             const vertexSettingsDurationNs = vertexSettingsEndTime - vertexSettingsStartTime;
             logger.debug(`[GoogleVertexProvider] ✅ LOG_POINT_V009_VERTEX_SETTINGS_SUCCESS`, {
@@ -920,7 +919,7 @@ export class GoogleVertexProvider extends BaseProvider {
                 projectId: projectValidation.projectId,
                 region: projectValidation.region,
             });
-            const vertexAnthropicSettings = await createVertexAnthropicSettings();
+            const vertexAnthropicSettings = await createVertexAnthropicSettings(this.location);
             // 7. Settings Validation
             if (!vertexAnthropicSettings.project ||
                 !vertexAnthropicSettings.location) {

package/dist/lib/providers/sagemaker/config.d.ts

@@ -8,15 +8,17 @@ import type { SageMakerConfig, SageMakerModelConfig } from "./types.js";
 /**
  * Load and validate SageMaker configuration from environment variables
  *
- * Environment variable priority:
- * 1. SAGEMAKER_* variables (highest priority)
- * 2. AWS_* variables (standard AWS SDK variables)
- * 3. Default values (lowest priority)
+ * Region priority:
+ * 1. region parameter (highest priority)
+ * 2. SAGEMAKER_REGION environment variable
+ * 3. AWS_REGION environment variable
+ * 4. Default value "us-east-1" (lowest priority)
  *
+ * @param region - Optional region parameter override
  * @returns Validated SageMaker configuration
  * @throws {Error} When required configuration is missing or invalid
  */
-export declare function getSageMakerConfig(): SageMakerConfig;
+export declare function getSageMakerConfig(region?: string): SageMakerConfig;
 /**
  * Load and validate SageMaker model configuration
  *

package/dist/lib/providers/sagemaker/config.js

@@ -45,21 +45,26 @@ const modelConfigCache = new Map();
 /**
  * Load and validate SageMaker configuration from environment variables
  *
- * Environment variable priority:
- * 1. SAGEMAKER_* variables (highest priority)
- * 2. AWS_* variables (standard AWS SDK variables)
- * 3. Default values (lowest priority)
+ * Region priority:
+ * 1. region parameter (highest priority)
+ * 2. SAGEMAKER_REGION environment variable
+ * 3. AWS_REGION environment variable
+ * 4. Default value "us-east-1" (lowest priority)
  *
+ * @param region - Optional region parameter override
  * @returns Validated SageMaker configuration
  * @throws {Error} When required configuration is missing or invalid
  */
-export function getSageMakerConfig() {
+export function getSageMakerConfig(region) {
     // Return cached config if available
     if (configCache) {
         return configCache;
     }
     const config = {
-        region: process.env.SAGEMAKER_REGION || process.env.AWS_REGION || "us-east-1",
+        region: region ||
+            process.env.SAGEMAKER_REGION ||
+            process.env.AWS_REGION ||
+            "us-east-1",
         accessKeyId: process.env.AWS_ACCESS_KEY_ID || "",
         secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY || "",
         sessionToken: process.env.AWS_SESSION_TOKEN,

package/dist/lib/types/evaluation.d.ts

@@ -25,6 +25,8 @@ export type EvaluationData = {
     domainAlignment?: number;
     terminologyAccuracy?: number;
     toolEffectiveness?: number;
+    responseContent?: string;
+    queryContent?: string;
     isOffTopic: boolean;
     alertSeverity: AlertSeverity;
     reasoning: string;

package/dist/lib/types/evaluationTypes.d.ts

@@ -0,0 +1,142 @@
+import type { LanguageModelV1CallOptions } from "ai";
+import type { TokenUsage } from "./analytics.js";
+import type { GenerateResult } from "./generateTypes.js";
+import type { ToolExecution } from "./tools.js";
+/**
+ * Represents the analysis of the user's query intent.
+ * This provides a basic understanding of what the user is trying to achieve.
+ */
+export interface QueryIntentAnalysis {
+    /** The type of query, e.g., asking a question or giving a command. */
+    type: "question" | "command" | "greeting" | "unknown";
+    /** The estimated complexity of the query. */
+    complexity: "low" | "medium" | "high";
+    /** Whether the query likely required the use of tools to be answered correctly. */
+    shouldHaveUsedTools: boolean;
+}
+/**
+ * Represents a single turn in an enhanced conversation history,
+ * including tool executions and evaluations for richer context.
+ */
+export interface EnhancedConversationTurn {
+    /** The role of the speaker, either 'user' or 'assistant'. */
+    role: "user" | "assistant";
+    /** The content of the message. */
+    content: string;
+    /** The timestamp of the message. */
+    timestamp: string;
+    /** Any tools that were executed as part of this turn. */
+    toolExecutions?: ToolExecution[];
+    /** The evaluation result for this turn, if applicable. */
+    evaluation?: EvaluationResult;
+}
+/**
+ * Contains all the rich context needed for a thorough, RAGAS-style evaluation.
+ * This object is constructed by the `ContextBuilder` and used by the `RAGASEvaluator`.
+ */
+export interface EnhancedEvaluationContext {
+    /** The original user query. */
+    userQuery: string;
+    /** An analysis of the user's query intent. */
+    queryAnalysis: QueryIntentAnalysis;
+    /** The AI's response that is being evaluated. */
+    aiResponse: string;
+    /** The AI provider that generated the response. */
+    provider: string;
+    /** The specific model that generated the response. */
+    model: string;
+    /** The parameters used for the generation call. */
+    generationParams: {
+        temperature?: number;
+        maxTokens?: number;
+        systemPrompt?: string;
+    };
+    /** A list of tools that were executed. */
+    toolExecutions: ToolExecution[];
+    /** The history of the conversation leading up to this turn. */
+    conversationHistory: EnhancedConversationTurn[];
+    /** The response time of the AI in milliseconds. */
+    responseTime: number;
+    /** The token usage for the generation. */
+    tokenUsage: TokenUsage;
+    /** The results of any previous evaluation attempts for this response. */
+    previousEvaluations?: EvaluationResult[];
+    /** The current attempt number for this evaluation (1-based). */
+    attemptNumber: number;
+}
+/**
+ * Represents the result of a single evaluation attempt, based on RAGAS principles.
+ */
+export interface EvaluationResult {
+    /** The final, overall score for the response, typically from 1 to 10. */
+    finalScore: number;
+    /** How well the response addresses the user's query. */
+    relevanceScore: number;
+    /** The factual accuracy of the information in the response. */
+    accuracyScore: number;
+    /** How completely the response answers the user's query. */
+    completenessScore: number;
+    /** Whether the final score meets the passing threshold. */
+    isPassing: boolean;
+    /** Constructive response from the judge LLM on how to improve the response. */
+    reasoning: string;
+    /** Specific suggestions for improving the response. */
+    suggestedImprovements: string;
+    /** The raw, unparsed response from the judge LLM. */
+    rawEvaluationResponse: string;
+    /** The model used to perform the evaluation. */
+    evaluationModel: string;
+    /** The time taken for the evaluation in milliseconds. */
+    evaluationTime: number;
+    /** The attempt number for this evaluation. */
+    attemptNumber: number;
+}
+/**
+ * Provides detailed information when a response fails quality assurance checks.
+ */
+export interface QualityErrorDetails {
+    /** The history of all evaluation attempts for this response. */
+    evaluationHistory: EvaluationResult[];
+    /** The final score of the last attempt. */
+    finalScore: number;
+    /** The total number of evaluation attempts made. */
+    attempts: number;
+    /** A summary message of the failure. */
+    message: string;
+}
+/**
+ * Configuration for the main `Evaluator` class.
+ */
+export interface EvaluationConfig {
+    /** The minimum score (1-10) for a response to be considered passing. */
+    threshold?: number;
+    /** The evaluation strategy to use. Currently only 'ragas' is supported. */
+    evaluationStrategy?: "ragas" | "custom";
+    /** The model to use for the LLM-as-judge evaluation. */
+    evaluationModel?: string;
+    /** The maximum number of evaluation attempts before failing. */
+    maxAttempts?: number;
+    /** The provider to use for the evaluation model. */
+    provider?: string;
+    /** A custom evaluator function to override the default behavior. */
+    customEvaluator?: (options: LanguageModelV1CallOptions, result: GenerateResult) => Promise<{
+        evaluationResult: EvaluationResult;
+        evalContext: EnhancedEvaluationContext;
+    }>;
+    /** The score below which a response is considered off-topic. */
+    offTopicThreshold?: number;
+    /** The score below which a failing response is considered a high severity alert. */
+    highSeverityThreshold?: number;
+    /** An optional function to generate custom evaluation prompts. */
+    promptGenerator?: GetPromptFunction;
+}
+/**
+ * A function that generates the main body of an evaluation prompt.
+ */
+export type GetPromptFunction = (context: {
+    userQuery: string;
+    history: string;
+    tools: string;
+    retryInfo: string;
+    aiResponse: string;
+}) => string;

package/dist/lib/types/evaluationTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/types/generateTypes.d.ts

@@ -22,6 +22,7 @@ export type GenerateOptions = {
     };
     provider?: AIProviderName | string;
     model?: string;
+    region?: string;
     temperature?: number;
     maxTokens?: number;
     systemPrompt?: string;
@@ -143,6 +144,7 @@ export type TextGenerationOptions = {
     };
     provider?: AIProviderName;
     model?: string;
+    region?: string;
     temperature?: number;
     maxTokens?: number;
     systemPrompt?: string;

package/dist/lib/types/middlewareTypes.d.ts

@@ -1,5 +1,7 @@
 import type { LanguageModelV1Middleware } from "ai";
 import type { JsonValue } from "../types/common.js";
+import type { EvaluationData } from "./evaluation.js";
+import type { GetPromptFunction } from "./evaluationTypes.js";
 /**
  * Metadata interface for NeuroLink middleware
  * Provides additional information about middleware without affecting execution
@@ -33,7 +35,7 @@ export interface MiddlewareConfig {
     /** Whether the middleware is enabled */
     enabled?: boolean;
     /** Middleware-specific configuration */
-    config?: Record<string, JsonValue>;
+    config?: Record<string, unknown>;
     /** Conditions under which to apply this middleware */
     conditions?: MiddlewareConditions;
 }
@@ -108,7 +110,7 @@ export interface MiddlewareChainStats {
 /**
  * Built-in middleware types
  */
-export type BuiltInMiddlewareType = "analytics" | "guardrails" | "logging" | "caching" | "rateLimit" | "retry" | "timeout";
+export type BuiltInMiddlewareType = "analytics" | "guardrails" | "logging" | "caching" | "rateLimit" | "retry" | "timeout" | "autoEvaluation";
 /**
  * Middleware preset configurations
  */
@@ -144,3 +146,27 @@ export interface MiddlewareFactoryOptions {
         collectStats?: boolean;
     };
 }
+/**
+ * Configuration for the Auto-Evaluation Middleware.
+ */
+export interface AutoEvaluationConfig {
+    /** The minimum score (1-10) for a response to be considered passing. */
+    threshold?: number;
+    /** The maximum number of retry attempts before failing. */
+    maxRetries?: number;
+    /** The model to use for the LLM-as-judge evaluation. */
+    evaluationModel?: string;
+    /**
+     * If true, the middleware will wait for the evaluation to complete before returning.
+     * If the evaluation fails, it will throw an error. Defaults to true.
+     */
+    blocking?: boolean;
+    /** A callback function to be invoked with the evaluation result. */
+    onEvaluationComplete?: (evaluation: EvaluationData) => void | Promise<void>;
+    /** The score below which a response is considered off-topic. */
+    offTopicThreshold?: number;
+    /** The score below which a failing response is considered a high severity alert. */
+    highSeverityThreshold?: number;
+    promptGenerator?: GetPromptFunction;
+    provider?: string;
+}

package/dist/lib/types/streamTypes.d.ts

@@ -137,6 +137,7 @@ export interface StreamOptions {
     };
     provider?: AIProviderName | string;
     model?: string;
+    region?: string;
     temperature?: number;
     maxTokens?: number;
     systemPrompt?: string;

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

@@ -0,0 +1,14 @@
+/**
+ * @file Implements the Auto-Evaluation Middleware for ensuring response quality.
+ */
+import type { NeuroLinkMiddleware, AutoEvaluationConfig } from "../../types/middlewareTypes.js";
+/**
+ * Creates the Auto-Evaluation middleware, which intercepts generation requests
+ * to evaluate the quality of the response. If the response quality is below a
+ * configured threshold, it can trigger retries with feedback.
+ *
+ * @param config - Configuration for the auto-evaluation middleware.
+ * @returns A `NeuroLinkMiddleware` object.
+ */
+export declare function createAutoEvaluationMiddleware(config?: AutoEvaluationConfig): NeuroLinkMiddleware;
+export default createAutoEvaluationMiddleware;

package/dist/middleware/builtin/autoEvaluation.js

@@ -0,0 +1,181 @@
+/**
+ * @file Implements the Auto-Evaluation Middleware for ensuring response quality.
+ */
+import { Evaluator } from "../../evaluation/index.js";
+import { logger } from "../../utils/logger.js";
+/**
+ * Creates the Auto-Evaluation middleware, which intercepts generation requests
+ * to evaluate the quality of the response. If the response quality is below a
+ * configured threshold, it can trigger retries with feedback.
+ *
+ * @param config - Configuration for the auto-evaluation middleware.
+ * @returns A `NeuroLinkMiddleware` object.
+ */
+export function createAutoEvaluationMiddleware(config = {}) {
+    const metadata = {
+        id: "autoEvaluation",
+        name: "Auto Evaluation",
+        description: "Automatically evaluates response quality and retries if needed.",
+        priority: 90,
+        defaultEnabled: false, // Should be explicitly enabled
+    };
+    logger.debug("Auto-Evaluation Middleware Config:", config);
+    const middleware = {
+        wrapGenerate: async ({ doGenerate, params }) => {
+            const options = params;
+            const rawResult = await doGenerate();
+            const result = {
+                ...rawResult,
+                content: rawResult.text ?? "",
+                usage: {
+                    input: rawResult.usage.promptTokens,
+                    output: rawResult.usage.completionTokens,
+                    total: rawResult.usage.promptTokens + rawResult.usage.completionTokens,
+                },
+                toolCalls: rawResult.toolCalls?.map((tc) => {
+                    let parsedArgs = tc.args;
+                    if (typeof tc.args === "string") {
+                        try {
+                            parsedArgs = JSON.parse(tc.args);
+                        }
+                        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
+                        }
+                    }
+                    return {
+                        ...tc,
+                        args: parsedArgs,
+                    };
+                }),
+            };
+            const isBlocking = config.blocking !== false;
+            if (isBlocking) {
+                const evaluationResult = await performEvaluation(config, options, result);
+                return {
+                    ...rawResult,
+                    evaluationResult,
+                };
+            }
+            else {
+                performEvaluation(config, options, result).catch((err) => {
+                    logger.error("Non-blocking auto-evaluation error:", err);
+                });
+                return rawResult;
+            }
+        },
+        wrapStream: async ({ doStream, params }) => {
+            const options = params;
+            const rawResult = await doStream();
+            const [streamForUser, streamForEvaluation] = rawResult.stream.tee();
+            // Non-blocking evaluation for streams
+            consumeAndEvaluateStream(config, options, streamForEvaluation).catch((err) => {
+                logger.error("Non-blocking stream auto-evaluation error:", err);
+            });
+            return {
+                ...rawResult,
+                stream: streamForUser,
+            };
+        },
+    };
+    return {
+        ...middleware,
+        metadata,
+    };
+}
+/**
+ * A common function to perform the evaluation logic.
+ * @param config The middleware configuration.
+ * @param options The text generation options.
+ * @param result The generation result.
+ */
+async function performEvaluation(config, options, result) {
+    const isBlocking = config.blocking !== false;
+    const threshold = config.threshold ??
+        (Number(process.env.NEUROLINK_EVALUATION_THRESHOLD) || 7);
+    try {
+        const evaluator = new Evaluator({
+            threshold,
+            provider: config.provider,
+            promptGenerator: config.promptGenerator,
+            evaluationModel: config.evaluationModel,
+        });
+        const evaluationResult = await evaluator.evaluate(options, result, threshold, config);
+        if (config.onEvaluationComplete) {
+            await config.onEvaluationComplete(evaluationResult);
+        }
+    }
+    catch (error) {
+        logger.error("Error during auto-evaluation:", error);
+        if (isBlocking) {
+            throw error;
+        }
+    }
+}
+/**
+ * Consumes a stream to build the full response and then evaluates it.
+ * @param config The middleware configuration.
+ * @param options The generation options.
+ * @param stream The stream to consume.
+ */
+async function consumeAndEvaluateStream(config, options, stream) {
+    let fullText = "";
+    let usage;
+    const toolCalls = [];
+    const reader = stream.getReader();
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            switch (value.type) {
+                case "text-delta":
+                    fullText += value.textDelta;
+                    break;
+                case "tool-call":
+                    {
+                        let parsedArgs;
+                        try {
+                            parsedArgs = JSON.parse(value.args);
+                        }
+                        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 };
+                        }
+                        toolCalls.push({
+                            toolCallId: value.toolCallId,
+                            toolName: value.toolName,
+                            args: parsedArgs,
+                        });
+                    }
+                    break;
+                case "finish":
+                    usage = {
+                        input: value.usage.promptTokens,
+                        output: value.usage.completionTokens,
+                        total: value.usage.promptTokens + value.usage.completionTokens,
+                    };
+                    break;
+            }
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    const result = {
+        content: fullText,
+        usage,
+        toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+    };
+    // For streams, evaluation is always non-blocking from the user's perspective.
+    if (config.blocking) {
+        logger.warn("Auto-evaluation 'blocking' mode is not supported for streaming responses. Evaluation will proceed non-blockingly.");
+    }
+    // Create a new config object to force non-blocking behavior for the evaluation function
+    const nonBlockingConfig = { ...config, blocking: false };
+    await performEvaluation(nonBlockingConfig, options, result);
+}
+export default createAutoEvaluationMiddleware;