@voltagent/core 0.1.45 → 0.1.46

package/dist/index.d.ts

@@ -790,8 +790,8 @@ type InferStreamEventBase<TStreamPart extends StreamPart> = {
 type InferStreamEventData<TStreamPart extends StreamPart> = Simplify<Omit<TStreamPart, "type" | "subAgentId" | "subAgentName">>;
 
 interface StreamEventForwarderOptions {
-    forwarder?: (event: StreamEvent) => Promise<void>;
-    filterTypes?: LiteralUnion<StreamEventType, string>[];
+    forwarder: (event: StreamEvent) => Promise<void>;
+    types: Array<LiteralUnion<StreamEventType, string>> | ReadonlyArray<LiteralUnion<StreamEventType, string>>;
     addSubAgentPrefix?: boolean;
 }
 /**
@@ -799,13 +799,13 @@ interface StreamEventForwarderOptions {
  * @param event - The SubAgent event to forward
  * @param options - Configuration options for forwarding
  */
-declare function streamEventForwarder(event: StreamEvent, options?: StreamEventForwarderOptions): Promise<void>;
+declare function streamEventForwarder(event: StreamEvent, options: StreamEventForwarderOptions): Promise<void>;
 /**
  * Creates a configured streamEventForwarder function
  * @param options - Configuration options
  * @returns A configured forwarder function
  */
-declare function createStreamEventForwarder(options?: StreamEventForwarderOptions): (event: StreamEvent) => Promise<void>;
+declare function createStreamEventForwarder(options: StreamEventForwarderOptions): (event: StreamEvent) => Promise<void>;
 
 /**
  * Options object for dynamic value resolution

package/dist/index.js

@@ -3199,8 +3199,8 @@ __name(serializeValueForDebug, "serializeValueForDebug");
 
 // src/utils/streams/stream-event-forwarder.ts
 var import_dev5 = require("@voltagent/internal/dev");
-async function streamEventForwarder(event, options = {}) {
-  const { forwarder, filterTypes = ["text-delta", "reasoning", "source"] } = options;
+async function streamEventForwarder(event, options) {
+  const { forwarder, types } = options;
   try {
     if (!event || typeof event !== "object") {
       import_dev5.devLogger.warn("[StreamEventForwarder] Invalid event structure:", event);
@@ -3214,7 +3214,7 @@ async function streamEventForwarder(event, options = {}) {
       });
       return;
     }
-    if (filterTypes.includes(event.type)) {
+    if (!types.includes(event.type)) {
       import_dev5.devLogger.info(
         "[StreamEventForwarder] Filtered out",
         event.type,
@@ -3223,9 +3223,6 @@ async function streamEventForwarder(event, options = {}) {
       );
       return;
     }
-    if (!forwarder) {
-      return;
-    }
     await forwarder(formatEvent(event, options));
     import_dev5.devLogger.info(
       "[StreamEventForwarder] Forwarded",
@@ -3238,7 +3235,7 @@ async function streamEventForwarder(event, options = {}) {
   }
 }
 __name(streamEventForwarder, "streamEventForwarder");
-function createStreamEventForwarder(options = {}) {
+function createStreamEventForwarder(options) {
   return (event) => streamEventForwarder(event, options);
 }
 __name(createStreamEventForwarder, "createStreamEventForwarder");
@@ -7322,36 +7319,36 @@ var Agent = class {
   /**
    * Resolve dynamic instructions based on user context
    */
-  resolveInstructions = async (options) => {
+  async resolveInstructions(options) {
     if (!this.dynamicInstructions)
       return this.instructions;
     if (typeof this.dynamicInstructions === "function") {
       return await this.dynamicInstructions(options);
     }
     return this.dynamicInstructions;
-  };
+  }
   /**
    * Resolve dynamic model based on user context
    */
-  resolveModel = async (options) => {
+  async resolveModel(options) {
     if (!this.dynamicModel)
       return this.model;
     if (typeof this.dynamicModel === "function") {
       return await this.dynamicModel(options);
     }
     return this.dynamicModel;
-  };
+  }
   /**
    * Resolve dynamic tools based on user context
    */
-  resolveTools = async (options) => {
+  async resolveTools(options) {
     if (!this.dynamicTools)
       return [];
     if (typeof this.dynamicTools === "function") {
       return await this.dynamicTools(options);
     }
     return this.dynamicTools;
-  };
+  }
   /**
    * Get the system message for the agent
    */
@@ -7602,12 +7599,13 @@ ${context}`;
         import_dev14.devLogger.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
-        });
+        if (internalStreamForwarder) {
+          await streamEventForwarder(event, {
+            forwarder: internalStreamForwarder,
+            types: ["tool-call", "tool-result"],
+            addSubAgentPrefix: true
+          });
+        }
       }, "forwardEvent");
       const delegateTool = this.subAgentManager.createDelegateTool({
         sourceAgent: this,
@@ -7734,7 +7732,7 @@ ${context}`;
   /**
    * Fix delete operator usage for better performance
    */
-  addToolEvent = (context, toolName, status, data = {}) => {
+  addToolEvent(context, toolName, status, data = {}) {
     if (!context.toolSpans) {
       context.toolSpans = /* @__PURE__ */ new Map();
     }
@@ -7754,11 +7752,11 @@ ${context}`;
         context.toolSpans.set(toolCallId, toolSpan);
       }
     }
-  };
+  }
   /**
    * Agent event creator (update)
    */
-  addAgentEvent = (context, eventName, status, data = {}) => {
+  addAgentEvent(context, eventName, status, data = {}) {
     const otelSpan = context.otelSpan;
     if (otelSpan) {
       endOperationSpan({
@@ -7771,7 +7769,7 @@ ${context}`;
         `OpenTelemetry span not found in OperationContext for agent event ${eventName} (Operation ID: ${context.operationId})`
       );
     }
-  };
+  }
   /**
    * Helper method to enrich and end an OpenTelemetry span associated with a tool call.
    */