@voltagent/core 1.1.30 → 1.1.31

package/dist/index.js

@@ -12578,17 +12578,61 @@ var normalizeText = /* @__PURE__ */ __name((part) => {
   }
   return normalized;
 }, "normalizeText");
+var sanitizeReasoningProviderMetadata = /* @__PURE__ */ __name((providerMetadata) => {
+  if (!isObject(providerMetadata) || Array.isArray(providerMetadata)) {
+    return void 0;
+  }
+  const cloned = safeClone(providerMetadata);
+  if (Object.keys(cloned).length === 0) {
+    return void 0;
+  }
+  return cloned;
+}, "sanitizeReasoningProviderMetadata");
+var extractReasoningIdFromMetadata = /* @__PURE__ */ __name((metadata) => {
+  const visit = /* @__PURE__ */ __name((value, hasReasoningContext) => {
+    if (Array.isArray(value)) {
+      for (const element of value) {
+        const found = visit(element, hasReasoningContext);
+        if (found) return found;
+      }
+      return void 0;
+    }
+    if (!isObject(value)) {
+      return void 0;
+    }
+    for (const [key, child] of Object.entries(value)) {
+      const keyHasReasoningContext = hasReasoningContext || /reasoning/i.test(key);
+      if (typeof child === "string") {
+        const trimmed = child.trim();
+        if (trimmed && keyHasReasoningContext && (/(^|_)id$/i.test(key) || /trace/i.test(key) || /id$/i.test(key))) {
+          return trimmed;
+        }
+      } else {
+        const found = visit(child, keyHasReasoningContext);
+        if (found) {
+          return found;
+        }
+      }
+    }
+    return void 0;
+  }, "visit");
+  return visit(metadata, false);
+}, "extractReasoningIdFromMetadata");
 var normalizeReasoning = /* @__PURE__ */ __name((part) => {
   const text = typeof part.text === "string" ? part.text : "";
-  if (!text.trim()) {
+  const explicitReasoningId = typeof part.reasoningId === "string" ? part.reasoningId : "";
+  const providerMetadata = sanitizeReasoningProviderMetadata(part.providerMetadata);
+  const metadataReasoningId = providerMetadata && isObject(providerMetadata) ? extractReasoningIdFromMetadata(providerMetadata) : void 0;
+  const reasoningId = explicitReasoningId || metadataReasoningId || "";
+  if (!text.trim() && !reasoningId.trim()) {
     return null;
   }
   const normalized = {
     type: "reasoning",
     text
   };
-  if (part.reasoningId) {
-    normalized.reasoningId = part.reasoningId;
+  if (reasoningId) {
+    normalized.reasoningId = reasoningId;
   }
   if (part.reasoningConfidence !== void 0) {
     normalized.reasoningConfidence = part.reasoningConfidence;
@@ -12623,6 +12667,16 @@ var normalizeToolPart = /* @__PURE__ */ __name((part) => {
   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;
+  const callProviderMetadata = sanitizeReasoningProviderMetadata(
+    part.callProviderMetadata
+  );
+  if (callProviderMetadata) {
+    normalized.callProviderMetadata = callProviderMetadata;
+  }
+  const providerMetadata = sanitizeReasoningProviderMetadata(part.providerMetadata);
+  if (providerMetadata) {
+    normalized.providerMetadata = providerMetadata;
+  }
   return normalized;
 }, "normalizeToolPart");
 var sanitizeMessagesForModel = /* @__PURE__ */ __name((messages) => messages.map((message) => sanitizeMessageForModel(message)).filter((message) => Boolean(message)), "sanitizeMessagesForModel");
@@ -12636,12 +12690,16 @@ var sanitizeMessageForModel = /* @__PURE__ */ __name((message) => {
     sanitizedParts.push(normalized);
   }
   const pruned = collapseRedundantStepStarts(pruneEmptyToolRuns(sanitizedParts));
-  const effectiveParts = pruned.filter((part) => {
+  const withoutDanglingTools = removeProviderExecutedToolsWithoutReasoning(pruned);
+  const normalizedParts = stripReasoningLinkedProviderMetadata(withoutDanglingTools);
+  const effectiveParts = normalizedParts.filter((part) => {
     if (part.type === "text") {
       return typeof part.text === "string" && part.text.trim().length > 0;
     }
     if (part.type === "reasoning") {
-      return typeof part.text === "string" && part.text.trim().length > 0;
+      const text = typeof part.text === "string" ? part.text.trim() : "";
+      const reasoningId = typeof part.reasoningId === "string" ? part.reasoningId.trim() : "";
+      return text.length > 0 || reasoningId.length > 0;
     }
     if (typeof part.type === "string" && part.type.startsWith("tool-")) {
       return Boolean(part.toolCallId);
@@ -12696,6 +12754,70 @@ var pruneEmptyToolRuns = /* @__PURE__ */ __name((parts) => {
   }
   return cleaned;
 }, "pruneEmptyToolRuns");
+var removeProviderExecutedToolsWithoutReasoning = /* @__PURE__ */ __name((parts) => {
+  const hasReasoning = parts.some((part) => part.type === "reasoning");
+  if (hasReasoning) {
+    return parts;
+  }
+  const hasProviderExecutedTool = parts.some(
+    (part) => typeof part.type === "string" && part.type.startsWith("tool-") && part.providerExecuted === true
+  );
+  if (!hasProviderExecutedTool) {
+    return parts;
+  }
+  return parts.filter(
+    (part) => !(typeof part.type === "string" && part.type.startsWith("tool-") && part.providerExecuted === true)
+  );
+}, "removeProviderExecutedToolsWithoutReasoning");
+var stripReasoningLinkedProviderMetadata = /* @__PURE__ */ __name((parts) => {
+  const hasReasoning = parts.some((part) => part.type === "reasoning");
+  if (hasReasoning) {
+    return parts;
+  }
+  const stripMetadata = /* @__PURE__ */ __name((metadata) => {
+    if (!isObject(metadata)) {
+      return void 0;
+    }
+    const cloned = { ...metadata };
+    const openaiMetadata = cloned.openai;
+    if (!isObject(openaiMetadata) || !("itemId" in openaiMetadata || "reasoning_trace_id" in openaiMetadata || "reasoning" in openaiMetadata && isObject(openaiMetadata.reasoning))) {
+      return metadata;
+    }
+    cloned.openai = void 0;
+    return Object.keys(cloned).length > 0 ? cloned : void 0;
+  }, "stripMetadata");
+  let mutated = false;
+  const result = parts.map((part) => {
+    let updated = false;
+    const nextPart = { ...part };
+    const applyStrip = /* @__PURE__ */ __name((key) => {
+      const current = part[key];
+      const cleaned = stripMetadata(current);
+      if (cleaned === void 0 && current === void 0) {
+        return;
+      }
+      if (cleaned === current) {
+        return;
+      }
+      if (!updated) {
+        updated = true;
+      }
+      if (cleaned) {
+        nextPart[key] = cleaned;
+      } else {
+        delete nextPart[key];
+      }
+    }, "applyStrip");
+    applyStrip("providerMetadata");
+    applyStrip("callProviderMetadata");
+    if (!updated) {
+      return part;
+    }
+    mutated = true;
+    return nextPart;
+  });
+  return mutated ? result : parts;
+}, "stripReasoningLinkedProviderMetadata");
 var collapseRedundantStepStarts = /* @__PURE__ */ __name((parts) => {
   const result = [];
   for (const part of parts) {