@voltagent/core 0.1.37 → 0.1.38

package/dist/index.d.ts

@@ -2956,7 +2956,7 @@ declare class Agent<TProvider extends {
      */
     private _endOtelToolSpan;
     /**
-     * Create an enhanced fullStream that includes SubAgent events
+     * Create an enhanced fullStream with real-time SubAgent event injection
      */
     private createEnhancedFullStream;
     /**
@@ -3335,34 +3335,6 @@ declare const updateSinglePackage: (packageName: string, packagePath?: string) =
 declare function safeJsonParse(value: string | null | undefined): any;
 declare function serializeValueForDebug(value: unknown): unknown;
 
-/**
- * Utility for merging multiple async streams with event queue integration
- */
-interface StreamMergerOptions {
-    /**
-     * Polling interval for checking events (in milliseconds)
-     * Default: 16ms (~60fps for smooth UI updates)
-     */
-    pollingInterval?: number;
-    /**
-     * Post-stream polling interval when main stream is finished (in milliseconds)
-     * Default: 10ms
-     */
-    postStreamInterval?: number;
-}
-/**
- * Creates an enhanced stream that merges an original async iterable with events
- * from a shared queue, ensuring chronological order and smooth UI updates.
- *
- * @param originalStream - The main stream to merge with
- * @param eventsQueue - Shared array that other sources push events to
- * @param options - Configuration options for polling intervals
- * @returns Enhanced async iterable that yields events from both sources
- */
-declare function createMergedStream<T>(originalStream: AsyncIterable<T>, eventsQueue: T[], options?: StreamMergerOptions): AsyncIterable<T>;
-/**
- * Helper type for SubAgent events that can be merged into a main stream
- */
 interface SubAgentEvent {
     type: string;
     data: any;
@@ -3370,6 +3342,23 @@ interface SubAgentEvent {
     subAgentId: string;
     subAgentName: string;
 }
+interface StreamEventForwarderOptions {
+    forwarder?: (event: any) => Promise<void>;
+    filterTypes?: string[];
+    addSubAgentPrefix?: boolean;
+}
+/**
+ * Forwards SubAgent events to a stream with optional filtering and prefixing
+ * @param event - The SubAgent event to forward
+ * @param options - Configuration options for forwarding
+ */
+declare function streamEventForwarder(event: SubAgentEvent, options?: StreamEventForwarderOptions): Promise<void>;
+/**
+ * Creates a configured streamEventForwarder function
+ * @param options - Configuration options
+ * @returns A configured forwarder function
+ */
+declare function createStreamEventForwarder(options?: StreamEventForwarderOptions): (event: SubAgentEvent) => Promise<void>;
 
 /**
  * Creates an AgentTool from a retriever, allowing it to be used as a tool in an agent.
@@ -3972,4 +3961,4 @@ declare class VoltAgent {
     shutdownTelemetry(): Promise<void>;
 }
 
-export { Agent, AgentErrorEvent, AgentHistoryEntry, AgentHookOnEnd, AgentHookOnHandoff, AgentHookOnStart, AgentHookOnToolEnd, AgentHookOnToolStart, AgentHooks, AgentOptions, AgentRegistry, AgentResponse, AgentStartEvent, AgentStartEventMetadata, AgentSuccessEvent, AgentSuccessEventMetadata, AgentTool, AllowedVariableValue, AnyToolConfig, AsyncIterableStream, BaseEventMetadata, BaseLLMOptions, BaseMessage, BaseRetriever, BaseTimelineEvent, BaseTool, BaseToolCall, ClientInfo, Conversation, ConversationQueryOptions, CreateConversationInput, CreateReasoningToolsOptions, CustomEndpointDefinition, CustomEndpointError, CustomEndpointHandler, DEFAULT_INSTRUCTIONS, DataContent, ErrorStreamPart, EventStatus, ExtractVariableNames, FEW_SHOT_EXAMPLES, FilePart, FinishStreamPart, GenerateObjectOptions, GenerateTextOptions, HTTPServerConfig, HistoryStatus, HttpMethod, ImagePart, InMemoryStorage, InferGenerateObjectResponse, InferGenerateTextResponse, InferMessage, InferModel, InferProviderParams, InferStreamResponse, InferTool, LLMProvider, LibSQLStorage, MCPClient, MCPClientConfig, MCPClientEvents, MCPConfiguration, MCPOptions, MCPServerConfig, MCPToolCall, MCPToolResult, Memory, MemoryEventMetadata, MemoryManager, MemoryMessage, MemoryOptions, MemoryReadErrorEvent, MemoryReadStartEvent, MemoryReadSuccessEvent, MemoryWriteErrorEvent, MemoryWriteStartEvent, MemoryWriteSuccessEvent, MessageContent, MessageFilterOptions, MessageRole, ModelToolCall, NewTimelineEvent, NextAction, NodeType, OnEndHookArgs, OnHandoffHookArgs, OnStartHookArgs, OnToolEndHookArgs, OnToolStartHookArgs, OperationContext, PackageUpdateInfo, PromptCreator, PromptTemplate, ProviderObjectResponse, ProviderObjectStreamResponse, ProviderParams, ProviderResponse, ProviderTextResponse, ProviderTextStreamResponse, ReadableStreamType, ReasoningStep, ReasoningStepSchema, ReasoningStreamPart, ReasoningToolExecuteOptions, RetrieveOptions, Retriever, RetrieverErrorEvent, RetrieverOptions, RetrieverStartEvent, RetrieverSuccessEvent, SSEServerConfig, ServerOptions, SourceStreamPart, StandardEventData, StandardTimelineEvent, StdioServerConfig, StepChunkCallback, StepFinishCallback, StepWithContent, StreamMergerOptions, StreamObjectFinishResult, StreamObjectOnFinishCallback, StreamObjectOptions, StreamPart, StreamTextFinishResult, StreamTextOnFinishCallback, StreamTextOptions, StreamableHTTPServerConfig, SubAgentEvent, TemplateVariables, TextDeltaStreamPart, TextPart, TimelineEventCoreLevel, TimelineEventCoreStatus, TimelineEventCoreType, Tool, ToolCall, ToolCallStreamPart, ToolErrorEvent, ToolErrorInfo, ToolExecuteOptions, ToolExecutionContext, ToolManager, ToolOptions, ToolResultStreamPart, ToolSchema, ToolStartEvent, ToolStatus, ToolStatusInfo, ToolSuccessEvent, Toolkit, ToolsetMap, ToolsetWithTools, TransportError, Usage, UsageInfo, Voice, VoiceEventData, VoiceEventType, VoiceMetadata, VoiceOptions, VoltAgent, VoltAgentError, VoltAgentExporter, VoltAgentExporterOptions, VoltAgentOptions, checkForUpdates, createAsyncIterableStream, createHooks, createMergedStream, createNodeId, createPrompt, createReasoningTools, createRetrieverTool, createTool, createToolkit, VoltAgent as default, getNodeTypeFromNodeId, registerCustomEndpoint, registerCustomEndpoints, safeJsonParse, serializeValueForDebug, tool, updateAllPackages, updateSinglePackage, zodSchemaToJsonUI };
+export { Agent, AgentErrorEvent, AgentHistoryEntry, AgentHookOnEnd, AgentHookOnHandoff, AgentHookOnStart, AgentHookOnToolEnd, AgentHookOnToolStart, AgentHooks, AgentOptions, AgentRegistry, AgentResponse, AgentStartEvent, AgentStartEventMetadata, AgentSuccessEvent, AgentSuccessEventMetadata, AgentTool, AllowedVariableValue, AnyToolConfig, AsyncIterableStream, BaseEventMetadata, BaseLLMOptions, BaseMessage, BaseRetriever, BaseTimelineEvent, BaseTool, BaseToolCall, ClientInfo, Conversation, ConversationQueryOptions, CreateConversationInput, CreateReasoningToolsOptions, CustomEndpointDefinition, CustomEndpointError, CustomEndpointHandler, DEFAULT_INSTRUCTIONS, DataContent, ErrorStreamPart, EventStatus, ExtractVariableNames, FEW_SHOT_EXAMPLES, FilePart, FinishStreamPart, GenerateObjectOptions, GenerateTextOptions, HTTPServerConfig, HistoryStatus, HttpMethod, ImagePart, InMemoryStorage, InferGenerateObjectResponse, InferGenerateTextResponse, InferMessage, InferModel, InferProviderParams, InferStreamResponse, InferTool, LLMProvider, LibSQLStorage, MCPClient, MCPClientConfig, MCPClientEvents, MCPConfiguration, MCPOptions, MCPServerConfig, MCPToolCall, MCPToolResult, Memory, MemoryEventMetadata, MemoryManager, MemoryMessage, MemoryOptions, MemoryReadErrorEvent, MemoryReadStartEvent, MemoryReadSuccessEvent, MemoryWriteErrorEvent, MemoryWriteStartEvent, MemoryWriteSuccessEvent, MessageContent, MessageFilterOptions, MessageRole, ModelToolCall, NewTimelineEvent, NextAction, NodeType, OnEndHookArgs, OnHandoffHookArgs, OnStartHookArgs, OnToolEndHookArgs, OnToolStartHookArgs, OperationContext, PackageUpdateInfo, PromptCreator, PromptTemplate, ProviderObjectResponse, ProviderObjectStreamResponse, ProviderParams, ProviderResponse, ProviderTextResponse, ProviderTextStreamResponse, ReadableStreamType, ReasoningStep, ReasoningStepSchema, ReasoningStreamPart, ReasoningToolExecuteOptions, RetrieveOptions, Retriever, RetrieverErrorEvent, RetrieverOptions, RetrieverStartEvent, RetrieverSuccessEvent, SSEServerConfig, ServerOptions, SourceStreamPart, StandardEventData, StandardTimelineEvent, StdioServerConfig, StepChunkCallback, StepFinishCallback, StepWithContent, StreamEventForwarderOptions, StreamObjectFinishResult, StreamObjectOnFinishCallback, StreamObjectOptions, StreamPart, StreamTextFinishResult, StreamTextOnFinishCallback, StreamTextOptions, StreamableHTTPServerConfig, SubAgentEvent, TemplateVariables, TextDeltaStreamPart, TextPart, TimelineEventCoreLevel, TimelineEventCoreStatus, TimelineEventCoreType, Tool, ToolCall, ToolCallStreamPart, ToolErrorEvent, ToolErrorInfo, ToolExecuteOptions, ToolExecutionContext, ToolManager, ToolOptions, ToolResultStreamPart, ToolSchema, ToolStartEvent, ToolStatus, ToolStatusInfo, ToolSuccessEvent, Toolkit, ToolsetMap, ToolsetWithTools, TransportError, Usage, UsageInfo, Voice, VoiceEventData, VoiceEventType, VoiceMetadata, VoiceOptions, VoltAgent, VoltAgentError, VoltAgentExporter, VoltAgentExporterOptions, VoltAgentOptions, checkForUpdates, createAsyncIterableStream, createHooks, createNodeId, createPrompt, createReasoningTools, createRetrieverTool, createStreamEventForwarder, createTool, createToolkit, VoltAgent as default, getNodeTypeFromNodeId, registerCustomEndpoint, registerCustomEndpoints, safeJsonParse, serializeValueForDebug, streamEventForwarder, tool, updateAllPackages, updateSinglePackage, zodSchemaToJsonUI };

package/dist/index.js

@@ -57,11 +57,11 @@ __export(src_exports, {
   checkForUpdates: () => checkForUpdates,
   createAsyncIterableStream: () => createAsyncIterableStream,
   createHooks: () => createHooks,
-  createMergedStream: () => createMergedStream,
   createNodeId: () => createNodeId,
   createPrompt: () => createPrompt,
   createReasoningTools: () => createReasoningTools,
   createRetrieverTool: () => createRetrieverTool,
+  createStreamEventForwarder: () => createStreamEventForwarder,
   createTool: () => createTool,
   createToolkit: () => createToolkit,
   default: () => src_default,
@@ -70,6 +70,7 @@ __export(src_exports, {
   registerCustomEndpoints: () => registerCustomEndpoints,
   safeJsonParse: () => safeJsonParse,
   serializeValueForDebug: () => serializeValueForDebug,
+  streamEventForwarder: () => streamEventForwarder,
   tool: () => tool,
   updateAllPackages: () => updateAllPackages,
   updateSinglePackage: () => updateSinglePackage,
@@ -1656,15 +1657,6 @@ app.openapi(streamRoute, async (c) => {
               }
             }
             if (!streamClosed) {
-              const completionData = {
-                done: true,
-                timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-                type: "completion"
-              };
-              const completionMessage = `data: ${JSON.stringify(completionData)}
-
-`;
-              safeEnqueue(completionMessage);
               safeClose();
             }
           } catch (iterationError) {
@@ -3074,46 +3066,74 @@ function serializeValueForDebug(value) {
 }
 __name(serializeValueForDebug, "serializeValueForDebug");
 
-// src/utils/stream-merger/index.ts
-async function* createMergedStream(originalStream, eventsQueue, options = {}) {
+// src/utils/stream-event-forwarder/index.ts
+async function streamEventForwarder(event, options = {}) {
   const {
-    pollingInterval = 16,
-    // ~60fps
-    postStreamInterval = 10
+    forwarder,
+    filterTypes = ["text", "reasoning", "source"],
+    addSubAgentPrefix = true
   } = options;
-  const originalIterator = originalStream[Symbol.asyncIterator]();
-  let originalStreamPromise = originalIterator.next();
-  let streamFinished = false;
-  let processedEventCount = 0;
-  while (true) {
-    while (processedEventCount < eventsQueue.length) {
-      const event = eventsQueue[processedEventCount];
-      processedEventCount++;
-      yield event;
-    }
-    if (!streamFinished) {
-      const timeoutPromise = new Promise(
-        (resolve) => setTimeout(() => resolve("timeout"), pollingInterval)
+  try {
+    if (!event || typeof event !== "object") {
+      dev_logger_default.warn("[StreamEventForwarder] Invalid event structure:", event);
+      return;
+    }
+    if (!event.type || !event.subAgentId || !event.subAgentName) {
+      dev_logger_default.warn("[StreamEventForwarder] Missing required event fields:", {
+        type: event.type,
+        subAgentId: event.subAgentId,
+        subAgentName: event.subAgentName
+      });
+      return;
+    }
+    if (filterTypes.includes(event.type)) {
+      dev_logger_default.info(
+        "[StreamEventForwarder] Filtered out",
+        event.type,
+        "event from",
+        event.subAgentName
       );
-      const result = await Promise.race([originalStreamPromise, timeoutPromise]);
-      if (result === "timeout") {
-        continue;
-      }
-      if (result.done) {
-        streamFinished = true;
-        continue;
-      }
-      yield result.value;
-      originalStreamPromise = originalIterator.next();
-    } else {
-      if (processedEventCount >= eventsQueue.length) {
-        break;
+      return;
+    }
+    if (!forwarder) {
+      return;
+    }
+    const prefixedData = {
+      ...event.data,
+      timestamp: event.timestamp,
+      type: event.type,
+      subAgentId: event.subAgentId,
+      subAgentName: event.subAgentName
+    };
+    if (addSubAgentPrefix) {
+      if (event.type === "tool-call" && prefixedData.toolCall) {
+        prefixedData.toolCall = {
+          ...prefixedData.toolCall,
+          toolName: `${event.subAgentName}: ${prefixedData.toolCall.toolName}`
+        };
+      } else if (event.type === "tool-result" && prefixedData.toolResult) {
+        prefixedData.toolResult = {
+          ...prefixedData.toolResult,
+          toolName: `${event.subAgentName}: ${prefixedData.toolResult.toolName}`
+        };
       }
-      await new Promise((resolve) => setTimeout(resolve, postStreamInterval));
     }
+    await forwarder(prefixedData);
+    dev_logger_default.info(
+      "[StreamEventForwarder] Forwarded",
+      event.type,
+      "event from",
+      event.subAgentName
+    );
+  } catch (error) {
+    dev_logger_default.error("[StreamEventForwarder] Error forwarding event:", error);
   }
 }
-__name(createMergedStream, "createMergedStream");
+__name(streamEventForwarder, "streamEventForwarder");
+function createStreamEventForwarder(options = {}) {
+  return (event) => streamEventForwarder(event, options);
+}
+__name(createStreamEventForwarder, "createStreamEventForwarder");
 
 // src/memory/libsql/index.ts
 async function debugDelay() {
@@ -7199,23 +7219,15 @@ ${context}`;
     });
     if (this.subAgentManager.hasSubAgents()) {
       const forwardEvent = /* @__PURE__ */ __name(async (event) => {
-        if (internalStreamForwarder) {
-          try {
-            dev_logger_default.info(
-              `[Agent ${this.id}] Received SubAgent event: ${event.type} from ${event.subAgentName}`
-            );
-            const prefixedData = {
-              ...event.data,
-              timestamp: event.timestamp,
-              type: event.type,
-              subAgentId: event.subAgentId,
-              subAgentName: event.subAgentName
-            };
-            await internalStreamForwarder(prefixedData);
-          } catch (error) {
-            dev_logger_default.error(`Error forwarding SubAgent event: ${error}`);
-          }
-        }
+        dev_logger_default.info(
+          `[Agent ${this.id}] Received SubAgent event: ${event.type} from ${event.subAgentName}`
+        );
+        await streamEventForwarder(event, {
+          forwarder: internalStreamForwarder,
+          filterTypes: [],
+          // Don't filter any events in this context
+          addSubAgentPrefix: true
+        });
       }, "forwardEvent");
       const delegateTool = this.subAgentManager.createDelegateTool({
         sourceAgent: this,
@@ -7394,61 +7406,45 @@ ${context}`;
     }
   }
   /**
-   * Create an enhanced fullStream that includes SubAgent events
+   * Create an enhanced fullStream with real-time SubAgent event injection
    */
-  createEnhancedFullStream(originalStream, subAgentEventsQueue) {
-    const processedEvents = [];
+  createEnhancedFullStream(originalStream, streamController, subAgentStatus) {
     return {
       async *[Symbol.asyncIterator]() {
-        let lastProcessedCount = 0;
-        const enhancedStream = createMergedStream(originalStream, processedEvents, {
-          pollingInterval: 16,
-          // ~60fps
-          postStreamInterval: 10
-        });
-        for await (const event of enhancedStream) {
-          while (lastProcessedCount < subAgentEventsQueue.length) {
-            const subAgentEvent = subAgentEventsQueue[lastProcessedCount];
-            lastProcessedCount++;
-            let enhancedEvent = {
-              type: subAgentEvent.event.type,
-              subAgentId: subAgentEvent.event.subAgentId,
-              subAgentName: subAgentEvent.event.subAgentName,
-              timestamp: subAgentEvent.timestamp
-            };
-            switch (subAgentEvent.event.type) {
-              case "tool-call":
-                if (subAgentEvent.event.toolCall) {
-                  enhancedEvent = {
-                    ...enhancedEvent,
-                    toolCallId: subAgentEvent.event.toolCall.toolCallId,
-                    toolName: subAgentEvent.event.toolCall.toolName,
-                    args: subAgentEvent.event.toolCall.args
-                  };
+        const mergedStream = new ReadableStream({
+          start(controller) {
+            streamController.current = controller;
+            (async () => {
+              try {
+                for await (const chunk of originalStream) {
+                  controller.enqueue(chunk);
                 }
-                break;
-              case "tool-result":
-                if (subAgentEvent.event.toolResult) {
-                  enhancedEvent = {
-                    ...enhancedEvent,
-                    toolCallId: subAgentEvent.event.toolResult.toolCallId,
-                    toolName: subAgentEvent.event.toolResult.toolName,
-                    result: subAgentEvent.event.toolResult.result
-                  };
+                await new Promise((resolve) => setTimeout(resolve, 100));
+                for (const [subAgentId, status] of subAgentStatus.entries()) {
+                  if (status.isActive && !status.isCompleted) {
+                    status.isCompleted = true;
+                    dev_logger_default.info(`[Enhanced Stream] SubAgent ${subAgentId} marked as completed`);
+                  }
                 }
-                break;
-              default: {
-                const { subAgentId, subAgentName, type, timestamp: timestamp2, ...eventData } = subAgentEvent.event;
-                enhancedEvent = {
-                  ...enhancedEvent,
-                  ...eventData
-                };
-                break;
+                controller.close();
+              } catch (error) {
+                controller.error(error);
+              } finally {
+                streamController.current = null;
               }
-            }
-            processedEvents.push(enhancedEvent);
+            })();
+          }
+        });
+        const reader = mergedStream.getReader();
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+              break;
+            yield value;
           }
-          yield event;
+        } finally {
+          reader.releaseLock();
         }
       }
     };
@@ -7900,20 +7896,101 @@ ${context}`;
       userId,
       finalConversationId
     );
-    const subAgentEventsQueue = [];
-    const streamEventForwarder = /* @__PURE__ */ __name(async (event) => {
-      subAgentEventsQueue.push({
-        type: "subagent-event",
-        event,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    const subAgentStatus = /* @__PURE__ */ new Map();
+    const streamController = {
+      current: null
+    };
+    const streamEventForwarder2 = /* @__PURE__ */ __name(async (event) => {
+      dev_logger_default.info("[Real-time Stream] Received SubAgent event:", {
+        eventType: event.type,
+        subAgentId: event.subAgentId,
+        subAgentName: event.subAgentName
       });
+      if (!subAgentStatus.has(event.subAgentId)) {
+        subAgentStatus.set(event.subAgentId, { isActive: true, isCompleted: false });
+      }
+      if (event.type === "finish" || event.type === "error" || event.type === "text-delta" && event.data?.textDelta?.includes(".")) {
+        dev_logger_default.info(
+          `[Real-time Stream] Potential completion event from ${event.subAgentId}:`,
+          event.type
+        );
+      }
+      let streamEvent = {
+        type: event.type,
+        subAgentId: event.subAgentId,
+        subAgentName: event.subAgentName,
+        timestamp: event.timestamp
+      };
+      switch (event.type) {
+        case "tool-call":
+          if (event?.toolCall) {
+            streamEvent = {
+              ...streamEvent,
+              toolCallId: event.toolCall.toolCallId,
+              toolName: event.toolCall.toolName,
+              args: event.toolCall.args
+            };
+          }
+          break;
+        case "tool-result":
+          if (event?.toolResult) {
+            streamEvent = {
+              ...streamEvent,
+              toolCallId: event.toolResult.toolCallId,
+              toolName: event.toolResult.toolName,
+              result: event.toolResult.result
+            };
+          }
+          break;
+        case "text-delta":
+          if (event?.textDelta) {
+            streamEvent = {
+              ...streamEvent,
+              textDelta: event.data.textDelta
+            };
+          }
+          break;
+        case "reasoning":
+          if (event?.reasoning) {
+            streamEvent = {
+              ...streamEvent,
+              reasoning: event.reasoning
+            };
+          }
+          break;
+        case "source":
+          if (event?.source) {
+            streamEvent = {
+              ...streamEvent,
+              source: event.source
+            };
+          }
+          break;
+        default:
+          streamEvent = {
+            ...streamEvent,
+            ...event || {}
+          };
+          break;
+      }
+      if (streamController.current) {
+        try {
+          streamController.current.enqueue(streamEvent);
+          dev_logger_default.info("[Real-time Stream] Event injected into stream:", {
+            eventType: event.type,
+            subAgentId: event.subAgentId
+          });
+        } catch (error) {
+          dev_logger_default.error("[Real-time Stream] Failed to inject event:", error);
+        }
+      }
     }, "streamEventForwarder");
     const { tools, maxSteps } = this.prepareTextOptions({
       ...internalOptions,
       conversationId: finalConversationId,
       historyEntryId: operationContext.historyEntry.id,
       operationContext,
-      internalStreamForwarder: streamEventForwarder
+      internalStreamForwarder: streamEventForwarder2
       // Pass the internal forwarder to tools
     });
     const response = await this.llm.streamText({
@@ -8256,7 +8333,7 @@ ${context}`;
     });
     const wrappedResponse = {
       ...response,
-      fullStream: response.fullStream ? this.createEnhancedFullStream(response.fullStream, subAgentEventsQueue) : void 0
+      fullStream: response.fullStream ? this.createEnhancedFullStream(response.fullStream, streamController, subAgentStatus) : void 0
     };
     return wrappedResponse;
   }
@@ -10256,11 +10333,11 @@ if (typeof require !== "undefined" && typeof module !== "undefined" && require.m
   checkForUpdates,
   createAsyncIterableStream,
   createHooks,
-  createMergedStream,
   createNodeId,
   createPrompt,
   createReasoningTools,
   createRetrieverTool,
+  createStreamEventForwarder,
   createTool,
   createToolkit,
   getNodeTypeFromNodeId,
@@ -10268,6 +10345,7 @@ if (typeof require !== "undefined" && typeof module !== "undefined" && require.m
   registerCustomEndpoints,
   safeJsonParse,
   serializeValueForDebug,
+  streamEventForwarder,
   tool,
   updateAllPackages,
   updateSinglePackage,