@juspay/neurolink 7.48.1 → 7.49.0

package/dist/mcp/factory.d.ts

@@ -3,162 +3,7 @@
  * Factory-First Architecture: MCP servers create tools for internal orchestration
  * Compatible with MCP patterns for seamless integration
  */
-import type { ExecutionContext } from "./contracts/mcpContract.js";
-/**
- * MCP Server Categories for organization and discovery
- */
-export type MCPServerCategory = "aiProviders" | "frameworks" | "development" | "business" | "content" | "data" | "integrations" | "automation" | "analysis" | "custom";
-/**
- * Tool execution context - Rich context passed to every tool execution
- * Following standard patterns for rich tool context
- * Extends ExecutionContext for compatibility
- */
-export interface NeuroLinkExecutionContext extends ExecutionContext {
-    aiProvider?: string;
-    modelId?: string;
-    temperature?: number;
-    maxTokens?: number;
-    appId?: string;
-    clientId?: string;
-    clientVersion?: string;
-    organizationId?: string;
-    projectId?: string;
-    environment?: string;
-    environmentType?: "development" | "staging" | "production";
-    platform?: string;
-    device?: string;
-    browser?: string;
-    userAgent?: string;
-    frameworkType?: "react" | "vue" | "svelte" | "next" | "nuxt" | "sveltekit";
-    toolChain?: string[];
-    parentToolId?: string;
-    locale?: string;
-    timezone?: string;
-    ipAddress?: string;
-    requestId?: string;
-    timestamp?: number;
-    permissions?: string[];
-    features?: string[];
-    enableDemoMode?: boolean;
-    securityLevel?: "public" | "private" | "organization";
-    metadata?: Record<string, unknown>;
-    [key: string]: unknown;
-}
-/**
- * Tool execution result - Standardized result format
- */
-export interface ToolResult {
-    success: boolean;
-    data?: unknown;
-    error?: string | Error;
-    usage?: {
-        tokens?: number;
-        cost?: number;
-        provider?: string;
-        model?: string;
-        executionTime?: number;
-    };
-    metadata?: {
-        toolName?: string;
-        serverId?: string;
-        serverTitle?: string;
-        sessionId?: string;
-        timestamp?: number;
-        executionTime?: number;
-        executionId?: string;
-        [key: string]: unknown;
-    };
-}
-/**
- * MCP Tool Interface - Standalone definition to avoid confusion with ToolDefinition execute signature
- */
-/**
- * NeuroLink MCP Tool Interface - Standardized tool definition for MCP integration
- *
- * This interface defines the contract for all tools in the NeuroLink ecosystem,
- * ensuring consistent execution patterns and metadata handling across different
- * MCP servers and tool implementations.
- *
- * Key features:
- * - Promise-based execution with ToolResult return type
- * - Rich context support for session management and permissions
- * - Optional schema validation for input/output
- * - Comprehensive metadata support for tool discovery
- *
- * @example
- * ```typescript
- * const calculatorTool: NeuroLinkMCPTool = {
- *   name: "calculator",
- *   description: "Performs basic arithmetic operations",
- *   category: "math",
- *   inputSchema: z.object({ a: z.number(), b: z.number(), op: z.string() }),
- *   async execute(params, context) {
- *     const { a, b, op } = params as { a: number; b: number; op: string };
- *     const result = op === "add" ? a + b : a - b;
- *     return { success: true, data: result };
- *   }
- * };
- * ```
- */
-export interface NeuroLinkMCPTool {
-    /** Unique tool identifier for MCP registration and execution */
-    name: string;
-    /** Human-readable description of tool functionality */
-    description: string;
-    /** Optional category for tool organization and discovery */
-    category?: string;
-    /** Optional input schema for parameter validation (Zod or JSON Schema) */
-    inputSchema?: unknown;
-    /** Optional output schema for result validation */
-    outputSchema?: unknown;
-    /** Implementation status flag for development tracking */
-    isImplemented?: boolean;
-    /** Required permissions for tool execution in secured environments */
-    permissions?: string[];
-    /** Tool version for compatibility and update management */
-    version?: string;
-    /** Additional metadata for tool information and capabilities */
-    metadata?: Record<string, unknown>;
-    /**
-     * Tool execution function with standardized signature
-     *
-     * @param params - Input parameters for the tool (validated against inputSchema if provided)
-     * @param context - Execution context with session, user, and environment information
-     * @returns Promise resolving to ToolResult with success status, data, and metadata
-     * @throws ValidationError if parameters fail validation
-     */
-    execute: (params: unknown, context: NeuroLinkExecutionContext) => Promise<ToolResult>;
-}
-/**
- * MCP Server Interface - Standard compatible
- */
-export interface NeuroLinkMCPServer {
-    id: string;
-    title: string;
-    description?: string;
-    version?: string;
-    category?: MCPServerCategory;
-    visibility?: "public" | "private" | "organization";
-    tools: Record<string, NeuroLinkMCPTool>;
-    registerTool(tool: NeuroLinkMCPTool): NeuroLinkMCPServer;
-    metadata?: Record<string, unknown>;
-    dependencies?: string[];
-    capabilities?: string[];
-}
-/**
- * MCP Server Configuration for creation
- */
-export interface MCPServerConfig {
-    id: string;
-    title: string;
-    description?: string;
-    version?: string;
-    category?: MCPServerCategory;
-    visibility?: "public" | "private" | "organization";
-    metadata?: Record<string, unknown>;
-    dependencies?: string[];
-    capabilities?: string[];
-}
+import type { MCPServerDomainCategory, NeuroLinkMCPTool, NeuroLinkMCPServer, MCPServerConfig } from "../types/mcpTypes.js";
 /**
  * Create MCP Server Factory Function
  *
@@ -200,7 +45,7 @@ export declare function getServerInfo(server: NeuroLinkMCPServer): {
     id: string;
     title: string;
     description?: string;
-    category?: MCPServerCategory;
+    category?: MCPServerDomainCategory;
     toolCount: number;
     capabilities: string[];
 };

package/dist/mcp/flexibleToolValidator.d.ts

@@ -9,11 +9,7 @@
  * - No context-specific validation or arbitrary pattern restrictions
  * - Designed to support ALL legitimate MCP tools (github.create_repo, filesystem.read_file, etc.)
  */
-export interface FlexibleValidationResult {
-    isValid: boolean;
-    error?: string;
-    warnings?: string[];
-}
+import type { FlexibleValidationResult } from "../types/mcpTypes.js";
 export declare class FlexibleToolValidator {
     private static readonly MAX_TOOL_NAME_LENGTH;
     private static readonly MIN_TOOL_NAME_LENGTH;

package/dist/mcp/index.d.ts

@@ -3,10 +3,11 @@
  * Universal AI Development Platform with Extensible Plugin Architecture
  * Implementation based on research blueprint
  */
-export type { McpMetadata, ExecutionContext, DiscoveredMcp, ToolInfo, ToolExecutionResult, } from "./contracts/mcpContract.js";
+export type { McpMetadata, DiscoveredMcp } from "../types/mcpTypes.js";
+export type { ExecutionContext, ToolInfo, ToolExecutionResult, } from "../types/tools.js";
 export { mcpLogger } from "../utils/logger.js";
 export type { LogLevel } from "../utils/logger.js";
-import type { McpMetadata } from "./contracts/mcpContract.js";
+import type { McpMetadata } from "../types/mcpTypes.js";
 /**
  * Initialize the MCP ecosystem - simplified
  */

package/dist/mcp/mcpCircuitBreaker.d.ts

@@ -4,81 +4,7 @@
  * Provides fault tolerance and prevents cascading failures
  */
 import { EventEmitter } from "events";
-/**
- * Circuit breaker states
- */
-export type CircuitBreakerState = "closed" | "open" | "half-open";
-/**
- * Circuit breaker configuration
- */
-export interface CircuitBreakerConfig {
-    /** Number of failures before opening the circuit */
-    failureThreshold: number;
-    /** Time to wait before attempting reset (milliseconds) */
-    resetTimeout: number;
-    /** Maximum calls allowed in half-open state */
-    halfOpenMaxCalls: number;
-    /** Timeout for individual operations (milliseconds) */
-    operationTimeout: number;
-    /** Minimum number of calls before calculating failure rate */
-    minimumCallsBeforeCalculation: number;
-    /** Window size for calculating failure rate (milliseconds) */
-    statisticsWindowSize: number;
-}
-/**
- * Circuit breaker statistics
- */
-export interface CircuitBreakerStats {
-    /** Current state */
-    state: CircuitBreakerState;
-    /** Total number of calls */
-    totalCalls: number;
-    /** Number of successful calls */
-    successfulCalls: number;
-    /** Number of failed calls */
-    failedCalls: number;
-    /** Current failure rate (0-1) */
-    failureRate: number;
-    /** Calls in current time window */
-    windowCalls: number;
-    /** Last state change timestamp */
-    lastStateChange: Date;
-    /** Next retry time (for open state) */
-    nextRetryTime?: Date;
-    /** Half-open call count */
-    halfOpenCalls: number;
-}
-/**
- * Circuit breaker events
- */
-export interface CircuitBreakerEvents {
-    stateChange: {
-        oldState: CircuitBreakerState;
-        newState: CircuitBreakerState;
-        reason: string;
-        timestamp: Date;
-    };
-    callSuccess: {
-        duration: number;
-        timestamp: Date;
-    };
-    callFailure: {
-        error: string;
-        duration: number;
-        timestamp: Date;
-    };
-    circuitOpen: {
-        failureRate: number;
-        totalCalls: number;
-        timestamp: Date;
-    };
-    circuitHalfOpen: {
-        timestamp: Date;
-    };
-    circuitClosed: {
-        timestamp: Date;
-    };
-}
+import type { CircuitBreakerConfig, CircuitBreakerStats } from "../types/mcpTypes.js";
 /**
  * MCPCircuitBreaker
  * Implements circuit breaker pattern for fault tolerance

package/dist/mcp/mcpClientFactory.d.ts

@@ -8,26 +8,7 @@ import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
 import type { ClientCapabilities } from "@modelcontextprotocol/sdk/types.js";
 import { ChildProcess } from "child_process";
 import type { MCPTransportType } from "../types/externalMcp.js";
-import type { MCPServerInfo } from "../types/mcpTypes.js";
-/**
- * MCP client creation result
- */
-export interface MCPClientResult {
-    /** Whether client creation was successful */
-    success: boolean;
-    /** Created client instance */
-    client?: Client;
-    /** Created transport instance */
-    transport?: Transport;
-    /** Created process (for stdio transport) */
-    process?: ChildProcess;
-    /** Error message if failed */
-    error?: string;
-    /** Creation duration in milliseconds */
-    duration: number;
-    /** Server capabilities reported during handshake */
-    capabilities?: ClientCapabilities;
-}
+import type { MCPServerInfo, MCPClientResult } from "../types/mcpTypes.js";
 /**
  * MCPClientFactory
  * Factory class for creating MCP clients with different transports

package/dist/mcp/mcpClientFactory.js

@@ -205,6 +205,7 @@ export class MCPClientFactory {
                 .filter(([, value]) => value !== undefined)
                 .map(([key, value]) => [key, String(value)])),
             cwd: config.cwd,
+            stderr: "ignore", // Suppress MCP server startup messages
         });
         return { transport, process: childProcess };
     }

package/dist/mcp/registry.d.ts

@@ -1,22 +1,15 @@
 /**
  * MCP Registry - Industry Standard Interface with camelCase
  */
-import type { DiscoveredMcp, ExecutionContext, ToolInfo } from "./contracts/mcpContract.js";
+import type { DiscoveredMcp, McpRegistry } from "../types/mcpTypes.js";
+import type { ToolInfo, ExecutionContext } from "../types/tools.js";
 import type { UnknownRecord } from "../types/common.js";
-/**
- * MCP Registry interface with optional methods for maximum flexibility
- */
-export interface McpRegistry {
-    registerServer?(serverId: string, serverConfig?: unknown, context?: ExecutionContext): Promise<void>;
-    executeTool?<T = unknown>(toolName: string, args?: unknown, context?: ExecutionContext): Promise<T>;
-    listTools?(context?: ExecutionContext): Promise<ToolInfo[]>;
-}
 /**
  * Simple MCP registry for plugin management
  * Maintains backward compatibility with existing code
  */
 export declare class MCPRegistry implements McpRegistry {
-    plugins: Map<string, DiscoveredMcp<import("../types/typeAliases.js").StandardRecord>>;
+    plugins: Map<string, DiscoveredMcp>;
     /**
      * Register a plugin
      */

package/dist/mcp/servers/agent/directToolsServer.d.ts

@@ -5,4 +5,4 @@
 /**
  * Direct Tools Server - Agent direct tools for immediate use
  */
-export declare const directToolsServer: import("../../factory.js").NeuroLinkMCPServer;
+export declare const directToolsServer: import("../../../types/mcpTypes.js").NeuroLinkMCPServer;

package/dist/mcp/servers/aiProviders/aiCoreServer.d.ts

@@ -7,4 +7,4 @@
  * AI Core Server - Central hub for AI provider management
  * Provides provider selection and status checking functionality
  */
-export declare const aiCoreServer: import("../../factory.js").NeuroLinkMCPServer;
+export declare const aiCoreServer: import("../../../types/mcpTypes.js").NeuroLinkMCPServer;

package/dist/mcp/servers/utilities/utilityServer.d.ts

@@ -5,4 +5,4 @@
 /**
  * Utility Server - General utility tools
  */
-export declare const utilityServer: import("../../factory.js").NeuroLinkMCPServer;
+export declare const utilityServer: import("../../../types/mcpTypes.js").NeuroLinkMCPServer;

package/dist/mcp/toolDiscoveryService.d.ts

@@ -5,90 +5,9 @@
  */
 import { EventEmitter } from "events";
 import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import type { ExternalMCPToolInfo, ExternalMCPToolResult, ExternalMCPToolContext } from "../types/externalMcp.js";
+import type { ExternalMCPToolInfo, ExternalMCPToolResult } from "../types/externalMcp.js";
+import type { ToolDiscoveryResult, ExternalToolExecutionOptions } from "../types/mcpTypes.js";
 import type { JsonObject } from "../types/common.js";
-/**
- * Tool discovery result
- */
-export interface ToolDiscoveryResult {
-    /** Whether discovery was successful */
-    success: boolean;
-    /** Number of tools discovered */
-    toolCount: number;
-    /** Discovered tools */
-    tools: ExternalMCPToolInfo[];
-    /** Error message if failed */
-    error?: string;
-    /** Discovery duration in milliseconds */
-    duration: number;
-    /** Server ID */
-    serverId: string;
-}
-/**
- * Tool execution options
- */
-export interface ToolExecutionOptions {
-    /** Execution timeout in milliseconds */
-    timeout?: number;
-    /** Additional context for execution */
-    context?: Partial<ExternalMCPToolContext>;
-    /** Whether to validate input parameters */
-    validateInput?: boolean;
-    /** Whether to validate output */
-    validateOutput?: boolean;
-}
-/**
- * Tool validation result
- */
-export interface ToolValidationResult {
-    /** Whether the tool is valid */
-    isValid: boolean;
-    /** Validation errors */
-    errors: string[];
-    /** Validation warnings */
-    warnings: string[];
-    /** Tool metadata */
-    metadata?: {
-        category?: string;
-        complexity?: "simple" | "moderate" | "complex";
-        requiresAuth?: boolean;
-        isDeprecated?: boolean;
-    };
-}
-/**
- * Tool registry events
- */
-export interface ToolRegistryEvents {
-    toolRegistered: {
-        serverId: string;
-        toolName: string;
-        toolInfo: ExternalMCPToolInfo;
-        timestamp: Date;
-    };
-    toolUnregistered: {
-        serverId: string;
-        toolName: string;
-        timestamp: Date;
-    };
-    toolUpdated: {
-        serverId: string;
-        toolName: string;
-        oldInfo: ExternalMCPToolInfo;
-        newInfo: ExternalMCPToolInfo;
-        timestamp: Date;
-    };
-    discoveryCompleted: {
-        serverId: string;
-        toolCount: number;
-        duration: number;
-        timestamp: Date;
-    };
-    discoveryFailed: {
-        serverId: string;
-        error: string;
-        timestamp: Date;
-    };
-}
 /**
  * ToolDiscoveryService
  * Handles automatic tool discovery and registration from external MCP servers
@@ -134,7 +53,7 @@ export declare class ToolDiscoveryService extends EventEmitter {
     /**
      * Execute a tool
      */
-    executeTool(toolName: string, serverId: string, client: Client, parameters: JsonObject, options?: ToolExecutionOptions): Promise<ExternalMCPToolResult>;
+    executeTool(toolName: string, serverId: string, client: Client, parameters: JsonObject, options?: ExternalToolExecutionOptions): Promise<ExternalMCPToolResult>;
     /**
      * Validate tool parameters
      */

package/dist/mcp/toolRegistry.d.ts

@@ -2,32 +2,10 @@
  * MCP Tool Registry - Extended Registry with Tool Management
  * Updated to match industry standard camelCase interfaces
  */
-import type { ExecutionContext, ToolInfo } from "./contracts/mcpContract.js";
-import type { ToolResult } from "./factory.js";
 import type { MCPServerInfo } from "../types/mcpTypes.js";
+import type { ToolImplementation, ToolInfo, ExecutionContext } from "../types/tools.js";
 import { MCPRegistry } from "./registry.js";
 import type { HITLManager } from "../hitl/hitlManager.js";
-interface ToolImplementation {
-    execute: (params: unknown, context?: ExecutionContext) => Promise<unknown> | unknown;
-    description?: string;
-    inputSchema?: unknown;
-    outputSchema?: unknown;
-    category?: string;
-    permissions?: string[];
-}
-export type ToolExecutionResult = ToolResult;
-/**
- * Tool execution options
- */
-export interface ToolExecutionOptions {
-    timeout?: number;
-    retries?: number;
-    context?: ExecutionContext;
-    preferredSource?: string;
-    fallbackEnabled?: boolean;
-    validateBeforeExecution?: boolean;
-    timeoutMs?: number;
-}
 export declare class MCPToolRegistry extends MCPRegistry {
     private tools;
     private toolImplementations;
@@ -163,4 +141,4 @@ export declare class MCPToolRegistry extends MCPRegistry {
 }
 export declare const toolRegistry: MCPToolRegistry;
 export declare const defaultToolRegistry: MCPToolRegistry;
-export type { ToolInfo } from "./contracts/mcpContract.js";
+export type { ToolInfo } from "../types/tools.js";

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

@@ -1,20 +1,9 @@
-import type { LanguageModelV1 } from "ai";
 import type { NeuroLinkMiddleware } from "../../types/middlewareTypes.js";
+import type { GuardrailsMiddlewareConfig } from "../../types/guardrails.js";
+export type { GuardrailsMiddlewareConfig } from "../../types/guardrails.js";
 /**
- * Configuration for the Guardrails middleware.
- */
-export interface GuardrailsMiddlewareConfig {
-    badWords?: {
-        enabled?: boolean;
-        list?: string[];
-    };
-    modelFilter?: {
-        enabled?: boolean;
-        filterModel?: LanguageModelV1;
-    };
-}
-/**
- * Create Guardrails AI middleware for content filtering and policy enforcement.
- * @param config - Configuration for the guardrails middleware.
+ * Create Guardrails AI middleware for content filtering and policy enforcement
+ * @param config Configuration for the guardrails middleware
+ * @returns NeuroLink middleware instance
  */
 export declare function createGuardrailsMiddleware(config?: GuardrailsMiddlewareConfig): NeuroLinkMiddleware;

package/dist/middleware/builtin/guardrails.js

@@ -1,43 +1,48 @@
 import { generateText } from "ai";
+import { createBlockedResponse, createBlockedStream, applyContentFiltering, handlePrecallGuardrails, } from "../utils/guardrailsUtils.js";
 import { logger } from "../../utils/logger.js";
 /**
- * Create Guardrails AI middleware for content filtering and policy enforcement.
- * @param config - Configuration for the guardrails middleware.
+ * Create Guardrails AI middleware for content filtering and policy enforcement
+ * @param config Configuration for the guardrails middleware
+ * @returns NeuroLink middleware instance
  */
 export function createGuardrailsMiddleware(config = {}) {
     const metadata = {
         id: "guardrails",
         name: "Guardrails AI",
-        description: "Provides content filtering and policy enforcement using custom rules and AI models.",
+        description: "Provides comprehensive content filtering and policy enforcement using custom rules, AI models, and precall evaluation to filter inappropriate content before it reaches the LLM.",
         priority: 90,
         defaultEnabled: true,
     };
+    // WeakMap to store blocking state from transformParams to wrap methods
+    const blockingState = new WeakMap();
     const middleware = {
-        wrapGenerate: async ({ doGenerate, params: _params }) => {
-            logger.debug(`[GuardrailsMiddleware] Applying to generate call.`, {
-                badWordsEnabled: !!config.badWords?.enabled,
-                modelFilterEnabled: !!config.modelFilter?.enabled,
-            });
+        transformParams: async ({ params }) => {
+            if (config.precallEvaluation?.enabled) {
+                const { shouldBlock, transformedParams } = await handlePrecallGuardrails(params, config.precallEvaluation);
+                // Store the blocking state for use in wrap methods
+                blockingState.set(transformedParams, shouldBlock);
+                return transformedParams;
+            }
+            return params;
+        },
+        wrapGenerate: async ({ doGenerate, params }) => {
+            logger.debug(`[GuardrailsMiddleware] Applying to generate call.`);
+            // Check if this request should be blocked (set by transformParams)
+            if (config.precallEvaluation?.enabled && blockingState.get(params)) {
+                return createBlockedResponse();
+            }
             let result = await doGenerate();
-            // 1. Bad Word Filtering
-            if (config.badWords?.enabled && config.badWords.list) {
-                let filteredText = result.text;
-                for (const term of config.badWords.list) {
-                    const regex = new RegExp(term, "gi");
-                    filteredText = filteredText?.replace(regex, "*".repeat(term.length));
-                }
-                if (result.text !== filteredText) {
-                    logger.debug(`[GuardrailsMiddleware] Redacted bad words from text.`);
-                    result = { ...result, text: filteredText ?? "" };
-                }
+            const filterResult = applyContentFiltering(result.text || "", config.badWords, "generate");
+            if (filterResult.hasChanges) {
+                result = { ...result, text: filterResult.filteredText };
             }
-            // 2. Model-based Filtering
             if (config.modelFilter?.enabled && config.modelFilter.filterModel) {
                 logger.debug(`[GuardrailsMiddleware] Invoking model-based filter.`);
                 try {
                     const filterPrompt = `Is the following text safe? Respond with only "safe" or "unsafe".\n\nText: "${result.text}"`;
                     const { text: filterResponse } = await generateText({
-                        model: config.modelFilter.filterModel, // Cast as any to satisfy type, will be resolved in integration
+                        model: config.modelFilter.filterModel,
                         prompt: filterPrompt,
                     });
                     if (filterResponse.toLowerCase().trim() === "unsafe") {
@@ -53,28 +58,28 @@ export function createGuardrailsMiddleware(config = {}) {
             }
             return result;
         },
-        wrapStream: async ({ doStream, params: _params }) => {
-            logger.debug(`[GuardrailsMiddleware] Applying to stream call.`, {
-                badWordsEnabled: !!config.badWords?.enabled,
-            });
-            const { stream, ...rest } = await doStream();
-            // Helper to escape regex special characters
-            function escapeRegExp(string) {
-                return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        wrapStream: async ({ doStream, params }) => {
+            logger.debug(`[GuardrailsMiddleware] Applying to stream call.`);
+            // Check if this request should be blocked (set by transformParams)
+            if (config.precallEvaluation?.enabled && blockingState.get(params)) {
+                return {
+                    stream: createBlockedStream(),
+                    rawCall: { rawPrompt: null, rawSettings: {} },
+                    warnings: [],
+                };
             }
+            const { stream, ...rest } = await doStream();
             const transformStream = new TransformStream({
                 transform(chunk, controller) {
                     let filteredChunk = chunk;
-                    if (config.badWords?.enabled && config.badWords.list) {
-                        for (const term of config.badWords.list) {
-                            const regex = new RegExp(escapeRegExp(term), "gi");
-                            if (typeof filteredChunk === "object" &&
-                                "textDelta" in filteredChunk) {
-                                filteredChunk = {
-                                    ...filteredChunk,
-                                    textDelta: filteredChunk.textDelta.replace(regex, "*".repeat(term.length)),
-                                };
-                            }
+                    if (typeof filteredChunk === "object" &&
+                        "textDelta" in filteredChunk) {
+                        const filterResult = applyContentFiltering(filteredChunk.textDelta, config.badWords, "stream");
+                        if (filterResult.hasChanges) {
+                            filteredChunk = {
+                                ...filteredChunk,
+                                textDelta: filterResult.filteredText,
+                            };
                         }
                     }
                     controller.enqueue(filteredChunk);