@voltagent/core 1.2.1 → 1.2.2

package/dist/index.d.mts

@@ -4837,6 +4837,7 @@ declare class Agent {
      * Common preparation for all execution methods
      */
     private prepareExecution;
+    private collectToolDataFromResult;
     /**
      * Create execution context
      */

package/dist/index.d.ts

@@ -4837,6 +4837,7 @@ declare class Agent {
      * Common preparation for all execution methods
      */
     private prepareExecution;
+    private collectToolDataFromResult;
     /**
      * Create execution context
      */

package/dist/index.js

@@ -8485,14 +8485,60 @@ var bytesToBase64 = /* @__PURE__ */ __name((bytes) => {
 }, "bytesToBase64");
 
 // src/utils/message-converter.ts
+function findExistingToolPart(parts, toolCallId) {
+  for (let i = parts.length - 1; i >= 0; i--) {
+    const part = parts[i];
+    if (part && typeof part.type === "string" && part.type.startsWith("tool-") && part.toolCallId === toolCallId) {
+      return part;
+    }
+  }
+  return void 0;
+}
+__name(findExistingToolPart, "findExistingToolPart");
 function convertModelMessagesToUIMessages(messages) {
   const uiMessages = [];
+  const toolPartsById = /* @__PURE__ */ new Map();
+  const assignToolResult = /* @__PURE__ */ __name((toolCallId, output, providerExecuted, partsToSearch) => {
+    const existing = toolPartsById.get(toolCallId);
+    if (existing) {
+      existing.state = "output-available";
+      existing.output = output;
+      existing.providerExecuted = providerExecuted;
+      return true;
+    }
+    if (partsToSearch) {
+      const fallback = findExistingToolPart(partsToSearch, toolCallId);
+      if (fallback) {
+        fallback.state = "output-available";
+        fallback.output = output;
+        fallback.providerExecuted = providerExecuted;
+        toolPartsById.set(toolCallId, fallback);
+        return true;
+      }
+    }
+    const globalFallback = findExistingToolPart(
+      uiMessages.flatMap((msg) => msg.parts),
+      toolCallId
+    );
+    if (globalFallback) {
+      globalFallback.state = "output-available";
+      globalFallback.output = output;
+      globalFallback.providerExecuted = providerExecuted;
+      toolPartsById.set(toolCallId, globalFallback);
+      return true;
+    }
+    return false;
+  }, "assignToolResult");
   for (const message of messages) {
     if (message.role === "tool") {
       if (Array.isArray(message.content)) {
         for (const part of message.content) {
           if (part.type === "tool-result") {
-            uiMessages.push({
+            const merged = assignToolResult(part.toolCallId, part.output, false);
+            if (merged) {
+              continue;
+            }
+            const toolMessage = {
               id: randomUUID(),
               role: "assistant",
               parts: [
@@ -8505,7 +8551,9 @@ function convertModelMessagesToUIMessages(messages) {
                   providerExecuted: false
                 }
               ]
-            });
+            };
+            uiMessages.push(toolMessage);
+            toolPartsById.set(part.toolCallId, toolMessage.parts[0]);
           }
         }
       }
@@ -8552,26 +8600,37 @@ function convertModelMessagesToUIMessages(messages) {
           break;
         }
         case "tool-call": {
-          ui.parts.push({
+          const toolPart = {
             type: `tool-${contentPart.toolName}`,
             toolCallId: contentPart.toolCallId,
             state: "input-available",
             input: contentPart.input || {},
             ...contentPart.providerOptions ? { callProviderMetadata: contentPart.providerOptions } : {},
             ...contentPart.providerExecuted != null ? { providerExecuted: contentPart.providerExecuted } : {}
-          });
+          };
+          ui.parts.push(toolPart);
+          toolPartsById.set(contentPart.toolCallId, toolPart);
           break;
         }
         case "tool-result": {
-          ui.parts.push({
-            type: `tool-${contentPart.toolName}`,
-            toolCallId: contentPart.toolCallId,
-            state: "output-available",
-            input: {},
-            output: contentPart.output,
-            // tool-result in assistant message content indicates provider execution
-            providerExecuted: true
-          });
+          const merged = assignToolResult(
+            contentPart.toolCallId,
+            contentPart.output,
+            true,
+            ui.parts
+          );
+          if (!merged) {
+            const resultPart = {
+              type: `tool-${contentPart.toolName}`,
+              toolCallId: contentPart.toolCallId,
+              state: "output-available",
+              input: {},
+              output: contentPart.output,
+              providerExecuted: true
+            };
+            ui.parts.push(resultPart);
+            toolPartsById.set(contentPart.toolCallId, resultPart);
+          }
           break;
         }
         case "image": {
@@ -13278,6 +13337,8 @@ async function runOutputGuardrails({
 __name(runOutputGuardrails, "runOutputGuardrails");
 
 // src/agent/memory-persist-queue.ts
+var AGENT_METADATA_CONTEXT_KEY = Symbol("agentMetadata");
+var SUBAGENT_TOOL_CALL_METADATA_KEY = Symbol("subAgentToolCallMetadata");
 var MemoryPersistQueue = class {
   constructor(memoryManager, options = {}) {
     this.memoryManager = memoryManager;
@@ -13344,9 +13405,16 @@ var MemoryPersistQueue = class {
       ids: pending.map((msg) => msg.id)
     };
     this.logger?.debug?.("[MemoryPersistQueue] persisting", payload);
+    const agentMetadata = oc.systemContext.get(AGENT_METADATA_CONTEXT_KEY);
+    const shouldApplySubAgentMetadata = Boolean(agentMetadata && oc.parentAgentId);
+    const toolCallMetadata = oc.systemContext.get(SUBAGENT_TOOL_CALL_METADATA_KEY);
     for (const message of pending) {
       try {
-        await this.memoryManager.saveMessage(oc, message, oc.userId, oc.conversationId);
+        const messageWithMetadata = this.applySubAgentMetadata(message, {
+          defaultMetadata: shouldApplySubAgentMetadata ? agentMetadata : void 0,
+          toolCallMetadata
+        });
+        await this.memoryManager.saveMessage(oc, messageWithMetadata, oc.userId, oc.conversationId);
       } catch (error) {
         this.logger?.error?.("Failed to save message", {
           conversationId: oc.conversationId,
@@ -13384,6 +13452,53 @@ var MemoryPersistQueue = class {
   getKey(oc) {
     return `${oc.userId ?? "unknown"}:${oc.conversationId ?? "unknown"}`;
   }
+  applySubAgentMetadata(message, opts) {
+    let metadata = typeof message.metadata === "object" && message.metadata !== null ? { ...message.metadata } : void 0;
+    const attachMetadata = /* @__PURE__ */ __name((value) => {
+      if (!value) return;
+      if (!metadata) metadata = {};
+      if (!metadata.subAgentId) {
+        metadata.subAgentId = value.agentId;
+      }
+      if (!metadata.subAgentName) {
+        metadata.subAgentName = value.agentName;
+      }
+    }, "attachMetadata");
+    const partMetadata = opts.toolCallMetadata && this.getMetadataFromMessageParts(message, opts.toolCallMetadata);
+    if (partMetadata) {
+      attachMetadata(partMetadata);
+    }
+    if (!metadata?.subAgentId && opts.defaultMetadata) {
+      attachMetadata(opts.defaultMetadata);
+    }
+    if (!metadata) {
+      return message;
+    }
+    return {
+      ...message,
+      metadata
+    };
+  }
+  getMetadataFromMessageParts(message, toolCallMetadata) {
+    for (const part of message.parts) {
+      const type = part.type;
+      if (!type) continue;
+      if (type === "data-subagent-stream") {
+        const data = part.data;
+        if (data?.subAgentId && data?.subAgentName) {
+          return { agentId: data.subAgentId, agentName: data.subAgentName };
+        }
+        continue;
+      }
+      if (type.startsWith("tool-")) {
+        const toolCallId = part.toolCallId;
+        if (toolCallId && toolCallMetadata.has(toolCallId)) {
+          return toolCallMetadata.get(toolCallId);
+        }
+      }
+    }
+    return void 0;
+  }
 };
 
 // src/agent/message-normalizer.ts
@@ -13498,6 +13613,22 @@ var isWorkingMemoryTool = /* @__PURE__ */ __name((part) => {
   if (!toolName) return false;
   return WORKING_MEMORY_TOOL_NAMES.has(toolName);
 }, "isWorkingMemoryTool");
+var normalizeToolOutputPayload = /* @__PURE__ */ __name((output) => {
+  if (Array.isArray(output)) {
+    return output.map((item) => normalizeToolOutputPayload(item));
+  }
+  if (!isObject(output)) {
+    return output;
+  }
+  const candidate = output;
+  if ("value" in candidate) {
+    const type = candidate.type;
+    if (typeof type === "string" && type.toLowerCase().includes("json")) {
+      return normalizeToolOutputPayload(candidate.value);
+    }
+  }
+  return output;
+}, "normalizeToolOutputPayload");
 var normalizeToolPart = /* @__PURE__ */ __name((part) => {
   if (isWorkingMemoryTool(part)) {
     return null;
@@ -13512,7 +13643,9 @@ var normalizeToolPart = /* @__PURE__ */ __name((part) => {
   if (part.toolCallId) normalized.toolCallId = part.toolCallId;
   if (part.state) normalized.state = part.state;
   if (part.input !== void 0) normalized.input = safeClone(part.input);
-  if (part.output !== void 0) normalized.output = safeClone(part.output);
+  if (part.output !== void 0) {
+    normalized.output = safeClone(normalizeToolOutputPayload(part.output));
+  }
   if (part.providerExecuted !== void 0) normalized.providerExecuted = part.providerExecuted;
   if (part.isError !== void 0) normalized.isError = part.isError;
   if (part.errorText !== void 0) normalized.errorText = part.errorText;
@@ -14832,6 +14965,7 @@ Context: ${(0, import_utils16.safeStringify)(contextObj, { indentation: 2 })}`;
                   subAgentId: targetAgent.id,
                   subAgentName: targetAgent.name
                 };
+                this.registerToolCallMetadata(parentOperationContext, enrichedPart, targetAgent);
                 await fullStreamWriter.write(enrichedPart);
               }
             } catch (error) {
@@ -14889,6 +15023,7 @@ Context: ${(0, import_utils16.safeStringify)(contextObj, { indentation: 2 })}`;
                   subAgentId: targetAgent.id,
                   subAgentName: targetAgent.name
                 };
+                this.registerToolCallMetadata(parentOperationContext, enrichedPart, targetAgent);
                 await fullStreamWriter.write(enrichedPart);
               }
             } catch (error) {
@@ -15182,6 +15317,22 @@ Context: ${(0, import_utils16.safeStringify)(contextObj, { indentation: 2 })}`;
       return subAgentData;
     });
   }
+  registerToolCallMetadata(oc, part, agent) {
+    if (!oc || !part?.type || !part.type.startsWith("tool-") || !part.toolCallId) {
+      return;
+    }
+    let metadataMap = oc.systemContext.get(SUBAGENT_TOOL_CALL_METADATA_KEY);
+    if (!metadataMap) {
+      metadataMap = /* @__PURE__ */ new Map();
+      oc.systemContext.set(SUBAGENT_TOOL_CALL_METADATA_KEY, metadataMap);
+    }
+    if (!metadataMap.has(part.toolCallId)) {
+      metadataMap.set(part.toolCallId, {
+        agentId: agent.id,
+        agentName: agent.name
+      });
+    }
+  }
 };
 
 // src/agent/agent.ts
@@ -15432,6 +15583,7 @@ var Agent = class {
           usage: resolvedProviderUsage,
           finishReason: result.finishReason
         });
+        const { toolCalls: aggregatedToolCalls, toolResults: aggregatedToolResults } = this.collectToolDataFromResult(result);
         await persistQueue.flush(buffer, oc);
         const usageInfo = convertUsage(result.usage);
         const finalText = await runOutputGuardrails({
@@ -15473,7 +15625,7 @@ var Agent = class {
             duration: Date.now() - startTime,
             finishReason: result.finishReason,
             usage: result.usage,
-            toolCalls: result.toolCalls?.length || 0,
+            toolCalls: aggregatedToolCalls.length,
             text: finalText
           }
         );
@@ -15491,13 +15643,15 @@ var Agent = class {
           metadata: {
             finishReason: result.finishReason,
             usage: result.usage ? JSON.parse((0, import_utils17.safeStringify)(result.usage)) : void 0,
-            toolCalls: result.toolCalls
+            toolCalls: aggregatedToolCalls
           }
         });
         oc.traceContext.end("completed");
         return cloneGenerateTextResultWithContext(result, {
           text: finalText,
-          context: oc.context
+          context: oc.context,
+          toolCalls: aggregatedToolCalls,
+          toolResults: aggregatedToolResults
         });
       } catch (error) {
         if (isBailError(error)) {
@@ -16464,6 +16618,15 @@ var Agent = class {
       maxSteps
     };
   }
+  collectToolDataFromResult(result) {
+    const steps = result.steps ?? [];
+    const stepToolCalls = steps.flatMap((step) => step.toolCalls ?? []);
+    const stepToolResults = steps.flatMap((step) => step.toolResults ?? []);
+    return {
+      toolCalls: stepToolCalls.length > 0 ? stepToolCalls : result.toolCalls ?? [],
+      toolResults: stepToolResults.length > 0 ? stepToolResults : result.toolResults ?? []
+    };
+  }
   /**
    * Create execution context
    */
@@ -16534,6 +16697,10 @@ var Agent = class {
       QUEUE_CONTEXT_KEY,
       new MemoryPersistQueue(this.memoryManager, { debounceMs: 200, logger })
     );
+    systemContext.set(AGENT_METADATA_CONTEXT_KEY, {
+      agentId: this.id,
+      agentName: this.name
+    });
     const elicitationHandler = options?.elicitation ?? options?.parentOperationContext?.elicitation;
     return {
       operationId,