@voltagent/core 2.3.3 → 2.3.4

package/dist/index.d.mts

@@ -3316,6 +3316,10 @@ declare function createSubagent<TAgent extends Agent, TSchema extends z.ZodType>
  * @template TOOLS - The tool set type parameter from ai-sdk
  */
 type VoltAgentTextStreamPart<TOOLS extends Record<string, any> = Record<string, any>> = TextStreamPart<TOOLS> & {
+    /**
+     * Optional response message identifier (carried on start/step chunks).
+     */
+    messageId?: string;
     /**
      * Optional identifier for the subagent that generated this event
      */

package/dist/index.d.ts

@@ -3316,6 +3316,10 @@ declare function createSubagent<TAgent extends Agent, TSchema extends z.ZodType>
  * @template TOOLS - The tool set type parameter from ai-sdk
  */
 type VoltAgentTextStreamPart<TOOLS extends Record<string, any> = Record<string, any>> = TextStreamPart<TOOLS> & {
+    /**
+     * Optional response message identifier (carried on start/step chunks).
+     */
+    messageId?: string;
     /**
      * Optional identifier for the subagent that generated this event
      */

package/dist/index.js

@@ -9291,6 +9291,9 @@ var WorkflowStreamWriterImpl = class {
       if ("id" in part && part.id !== void 0) {
         metadata.partId = part.id;
       }
+      if ("messageId" in part && part.messageId !== void 0) {
+        metadata.messageId = part.messageId;
+      }
       if ("providerMetadata" in part && part.providerMetadata !== void 0) {
         metadata.providerMetadata = part.providerMetadata;
       }
@@ -18389,6 +18392,112 @@ function resolveEvalFeedbackClient(host) {
 }
 __name(resolveEvalFeedbackClient, "resolveEvalFeedbackClient");
 
+// src/agent/openai-reasoning-utils.ts
+var OPENAI_REASONING_ID_PREFIX = "rs_";
+var isObject = /* @__PURE__ */ __name((value) => typeof value === "object" && value !== null, "isObject");
+var isOpenAIReasoningId = /* @__PURE__ */ __name((value) => value.trim().startsWith(OPENAI_REASONING_ID_PREFIX), "isOpenAIReasoningId");
+var hasOpenAIItemId = /* @__PURE__ */ __name((metadata) => {
+  if (!isObject(metadata)) {
+    return false;
+  }
+  const openai = metadata.openai;
+  if (!isObject(openai)) {
+    return false;
+  }
+  const itemId = typeof openai.itemId === "string" ? openai.itemId.trim() : "";
+  return Boolean(itemId);
+}, "hasOpenAIItemId");
+var hasOpenAIItemIdForPart = /* @__PURE__ */ __name((part, accessors) => {
+  if (accessors.isToolPart?.(part)) {
+    const callProviderMetadata = accessors.getCallProviderMetadata?.(part);
+    if (callProviderMetadata !== void 0 && hasOpenAIItemId(callProviderMetadata)) {
+      return true;
+    }
+  }
+  return hasOpenAIItemId(accessors.getProviderMetadata(part));
+}, "hasOpenAIItemIdForPart");
+var stripDanglingOpenAIReasoningFromParts = /* @__PURE__ */ __name((parts, options) => {
+  const sanitized = [];
+  let changed = false;
+  for (let index = 0; index < parts.length; index += 1) {
+    const part = parts[index];
+    if (!options.isReasoningPart(part)) {
+      sanitized.push(part);
+      continue;
+    }
+    const next = options.getNextPart(parts, index);
+    if (!next) {
+      changed = true;
+      continue;
+    }
+    if (options.isReasoningPart(next)) {
+      changed = true;
+      continue;
+    }
+    if (!options.hasOpenAIItemIdForPart(next)) {
+      changed = true;
+      continue;
+    }
+    sanitized.push(part);
+  }
+  return { parts: sanitized, changed };
+}, "stripDanglingOpenAIReasoningFromParts");
+
+// src/agent/model-message-normalizer.ts
+var isOpenAIReasoningPart = /* @__PURE__ */ __name((part) => {
+  if (!isObject(part)) {
+    return false;
+  }
+  if (part.type !== "reasoning") {
+    return false;
+  }
+  const providerOptions = part.providerOptions;
+  if (hasOpenAIItemId(providerOptions)) {
+    const openai = providerOptions.openai;
+    const itemId = typeof openai?.itemId === "string" ? openai.itemId.trim() : "";
+    if (itemId && isOpenAIReasoningId(itemId)) {
+      return true;
+    }
+  }
+  const reasoningId = typeof part.id === "string" ? part.id.trim() : "";
+  return Boolean(reasoningId && isOpenAIReasoningId(reasoningId));
+}, "isOpenAIReasoningPart");
+var hasOpenAIItemIdForPart2 = /* @__PURE__ */ __name((part) => {
+  if (!isObject(part)) {
+    return false;
+  }
+  return hasOpenAIItemIdForPart(part, {
+    getProviderMetadata: /* @__PURE__ */ __name((value) => value.providerOptions, "getProviderMetadata")
+  });
+}, "hasOpenAIItemIdForPart");
+var stripDanglingOpenAIReasoningFromModelMessages = /* @__PURE__ */ __name((messages) => {
+  let changed = false;
+  const sanitized = messages.map((message) => {
+    if (message.role !== "assistant" || !Array.isArray(message.content)) {
+      return message;
+    }
+    const content = message.content;
+    const { parts, changed: partsChanged } = stripDanglingOpenAIReasoningFromParts(content, {
+      isReasoningPart: isOpenAIReasoningPart,
+      hasOpenAIItemIdForPart: hasOpenAIItemIdForPart2,
+      getNextPart: /* @__PURE__ */ __name((parts2, index) => parts2[index + 1], "getNextPart")
+    });
+    if (!partsChanged) {
+      return message;
+    }
+    changed = true;
+    if (parts.length === 0) {
+      return null;
+    }
+    const assistantMessage = message;
+    return {
+      ...assistantMessage,
+      content: parts
+    };
+  }).filter((message) => Boolean(message));
+  return changed ? sanitized : messages;
+}, "stripDanglingOpenAIReasoningFromModelMessages");
+
 // src/agent/open-telemetry/trace-context.ts
 var import_api12 = require("@opentelemetry/api");
 var import_internal8 = require("@voltagent/internal");
@@ -19766,14 +19875,12 @@ var MemoryPersistQueue = class {
 };
 
 // src/agent/message-normalizer.ts
+var import_internal9 = require("@voltagent/internal");
 var WORKING_MEMORY_TOOL_NAMES = /* @__PURE__ */ new Set([
   "update_working_memory",
   "get_working_memory",
   "clear_working_memory"
 ]);
-var OPENAI_REASONING_ID_PREFIX = "rs_";
-var isObject = /* @__PURE__ */ __name((value) => typeof value === "object" && value !== null, "isObject");
-var isOpenAIReasoningId = /* @__PURE__ */ __name((value) => value.trim().startsWith(OPENAI_REASONING_ID_PREFIX), "isOpenAIReasoningId");
 var safeClone = /* @__PURE__ */ __name((value) => {
   if (!isObject(value) && !Array.isArray(value)) {
     return value;
@@ -19783,7 +19890,7 @@ var safeClone = /* @__PURE__ */ __name((value) => {
     return structuredCloneImpl(value);
   }
   try {
-    return JSON.parse(JSON.stringify(value));
+    return JSON.parse((0, import_internal9.safeStringify)(value));
   } catch (_error) {
     if (Array.isArray(value)) {
       return value.slice();
@@ -19940,11 +20047,13 @@ var isToolLikePart = /* @__PURE__ */ __name((part) => {
 }, "isToolLikePart");
 var hasToolOutput = /* @__PURE__ */ __name((part) => {
   const state = typeof part.state === "string" ? part.state : void 0;
-  if (state === "output-available" || state === "output-error" || state === "output-denied") {
+  if (state === "output-available" || state === "output-error" || state === "output-denied" || state === "output-streaming") {
     return true;
   }
   return part.output !== void 0;
 }, "hasToolOutput");
+var isToolInputState = /* @__PURE__ */ __name((state) => state === "input-available" || state === "input-streaming" || state === "approval-requested" || state === "approval-responded", "isToolInputState");
+var isToolOutputState = /* @__PURE__ */ __name((state) => state === "output-available" || state === "output-error" || state === "output-denied" || state === "output-streaming", "isToolOutputState");
 var isApprovalResponded = /* @__PURE__ */ __name((part) => Boolean(part.approval && part.approval.approved != null), "isApprovalResponded");
 var isWorkingMemoryTool = /* @__PURE__ */ __name((part) => {
   const toolName = toolNameFromType(part.type);
@@ -20000,11 +20109,120 @@ var normalizeToolPart = /* @__PURE__ */ __name((part) => {
   }
   return normalized;
 }, "normalizeToolPart");
+var hasOpenAIReasoningInMessages = /* @__PURE__ */ __name((messages) => messages.some(
+  (message) => message.role === "assistant" && hasOpenAIReasoningContext(message.parts)
+), "hasOpenAIReasoningInMessages");
+var countToolLikeParts = /* @__PURE__ */ __name((messages) => messages.reduce(
+  (count, message) => count + message.parts.filter((part) => isToolLikePart(part)).length,
+  0
+), "countToolLikeParts");
+var isOpenAIReasoningPart2 = /* @__PURE__ */ __name((part) => {
+  if (part.type !== "reasoning") {
+    return false;
+  }
+  const reasoningId = typeof part.reasoningId === "string" ? part.reasoningId.trim() : "";
+  if (reasoningId && isOpenAIReasoningId(reasoningId)) {
+    return true;
+  }
+  const providerMetadata = part.providerMetadata;
+  if (isObject(providerMetadata)) {
+    const openai = providerMetadata.openai;
+    if (isObject(openai)) {
+      const itemId = typeof openai.itemId === "string" ? openai.itemId.trim() : "";
+      if (itemId && isOpenAIReasoningId(itemId)) {
+        return true;
+      }
+      if (typeof openai.reasoning_trace_id === "string" && openai.reasoning_trace_id.trim()) {
+        return true;
+      }
+      if (isObject(openai.reasoning)) {
+        const id = typeof openai.reasoning.id === "string" ? openai.reasoning.id.trim() : "";
+        if (id && isOpenAIReasoningId(id)) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}, "isOpenAIReasoningPart");
+var endsWithOpenAIReasoning = /* @__PURE__ */ __name((parts) => {
+  for (let index = parts.length - 1; index >= 0; index -= 1) {
+    const part = parts[index];
+    if (part.type === "step-start") {
+      continue;
+    }
+    return isOpenAIReasoningPart2(part);
+  }
+  return false;
+}, "endsWithOpenAIReasoning");
+var hasOpenAIItemIdForPart3 = /* @__PURE__ */ __name((part) => {
+  return hasOpenAIItemIdForPart(part, {
+    isToolPart: /* @__PURE__ */ __name((candidate) => typeof candidate.type === "string" && candidate.type.startsWith("tool-"), "isToolPart"),
+    getCallProviderMetadata: /* @__PURE__ */ __name((candidate) => candidate.callProviderMetadata, "getCallProviderMetadata"),
+    getProviderMetadata: /* @__PURE__ */ __name((candidate) => candidate.providerMetadata, "getProviderMetadata")
+  });
+}, "hasOpenAIItemIdForPart");
+var stripDanglingOpenAIReasoning = /* @__PURE__ */ __name((messages) => {
+  const result = [];
+  for (const message of messages) {
+    if (message.role !== "assistant") {
+      result.push(message);
+      continue;
+    }
+    const { parts } = stripDanglingOpenAIReasoningFromParts(message.parts, {
+      isReasoningPart: isOpenAIReasoningPart2,
+      hasOpenAIItemIdForPart: hasOpenAIItemIdForPart3,
+      getNextPart: /* @__PURE__ */ __name((parts2, index) => {
+        for (let nextIndex = index + 1; nextIndex < parts2.length; nextIndex += 1) {
+          const candidate = parts2[nextIndex];
+          if (candidate.type === "step-start") {
+            continue;
+          }
+          return candidate;
+        }
+        return void 0;
+      }, "getNextPart")
+    });
+    if (parts.length === 0) {
+      continue;
+    }
+    result.push({
+      ...message,
+      parts,
+      ...message.metadata ? { metadata: safeClone(message.metadata) } : {}
+    });
+  }
+  return result;
+}, "stripDanglingOpenAIReasoning");
+var mergeTrailingReasoningAssistantMessages = /* @__PURE__ */ __name((messages) => {
+  const merged = [];
+  for (const message of messages) {
+    const last = merged.at(-1);
+    if (last && last.role === "assistant" && message.role === "assistant" && endsWithOpenAIReasoning(last.parts)) {
+      last.parts = [...last.parts, ...message.parts];
+      continue;
+    }
+    merged.push({ ...message, parts: [...message.parts] });
+  }
+  return merged;
+}, "mergeTrailingReasoningAssistantMessages");
 var sanitizeMessagesForModel = /* @__PURE__ */ __name((messages, options = {}) => {
   const sanitized = messages.map((message) => sanitizeMessageForModel(message)).filter((message) => Boolean(message));
+  const merged = mergeTrailingReasoningAssistantMessages(sanitized);
   const shouldFilterIncomplete = options.filterIncompleteToolCalls !== false;
-  const filtered = shouldFilterIncomplete ? filterIncompleteToolCallsForModel(sanitized) : sanitized;
-  return addStepStartsBetweenToolRuns(filtered);
+  if (!shouldFilterIncomplete) {
+    return addStepStartsBetweenToolRuns(stripDanglingOpenAIReasoning(merged));
+  }
+  const filtered = filterIncompleteToolCallsForModel(merged);
+  const hasOpenAIReasoning = hasOpenAIReasoningInMessages(merged);
+  if (hasOpenAIReasoning) {
+    const sanitizedToolCount = countToolLikeParts(merged);
+    const filteredToolCount = countToolLikeParts(filtered);
+    if (filteredToolCount < sanitizedToolCount) {
+      return addStepStartsBetweenToolRuns(stripDanglingOpenAIReasoning(merged));
+    }
+  }
+  return addStepStartsBetweenToolRuns(stripDanglingOpenAIReasoning(filtered));
 }, "sanitizeMessagesForModel");
 var sanitizeMessageForModel = /* @__PURE__ */ __name((message) => {
   const sanitizedParts = [];
@@ -20144,8 +20362,9 @@ var pruneEmptyToolRuns = /* @__PURE__ */ __name((parts) => {
   const cleaned = [];
   for (const part of parts) {
     if (typeof part.type === "string" && part.type.startsWith("tool-")) {
-      const hasPendingState = part.state === "input-available";
-      const hasResult = part.state === "output-available" || part.output !== void 0;
+      const state = typeof part.state === "string" ? part.state : void 0;
+      const hasPendingState = isToolInputState(state);
+      const hasResult = isToolOutputState(state) || part.output !== void 0;
       if (!hasPendingState && !hasResult && part.input == null) {
         continue;
       }
@@ -23172,6 +23391,25 @@ var Agent = class {
             generateMessageId: /* @__PURE__ */ __name(() => responseMessageId, "generateMessageId")
           };
         }, "applyResponseMessageId");
+        const applyResponseMessageIdToStream = /* @__PURE__ */ __name((baseStream) => {
+          if (!responseMessageId) {
+            return baseStream;
+          }
+          return (async function* () {
+            for await (const part of baseStream) {
+              if (part.type !== "start" && part.type !== "start-step") {
+                yield part;
+                continue;
+              }
+              const currentMessageId = part.messageId;
+              if (currentMessageId === responseMessageId) {
+                yield part;
+                continue;
+              }
+              yield { ...part, messageId: responseMessageId };
+            }
+          })();
+        }, "applyResponseMessageIdToStream");
         const createBaseFullStream = /* @__PURE__ */ __name(() => {
           const wrapWithAbortHandling = /* @__PURE__ */ __name(async function* (baseStream) {
             const iterator = baseStream[Symbol.asyncIterator]();
@@ -23198,7 +23436,9 @@ var Agent = class {
             } finally {
             }
           }, "wrapWithAbortHandling");
-          const parentStream = normalizeFinishUsageStream(wrapWithAbortHandling(result.fullStream));
+          const parentStream = applyResponseMessageIdToStream(
+            normalizeFinishUsageStream(wrapWithAbortHandling(result.fullStream))
+          );
           if (agent.subAgentManager.hasSubAgents()) {
             const createMergedFullStream = /* @__PURE__ */ __name(async function* () {
               const { readable, writable } = new TransformStream();
@@ -24122,6 +24362,7 @@ Metadata: ${(0, import_utils28.safeStringify)(metadata)}`;
         messages = result.modelMessages;
       }
     }
+    messages = stripDanglingOpenAIReasoningFromModelMessages(messages);
     const maxSteps = options?.maxSteps ?? this.calculateMaxSteps();
     const modelName = this.getModelName();
     const dynamicToolList = await this.resolveValue(this.dynamicTools, oc) || [];
@@ -31436,7 +31677,7 @@ var createPrompt = /* @__PURE__ */ __name(({
 }, "createPrompt");
 
 // src/utils/serialization/index.ts
-var import_internal9 = require("@voltagent/internal");
+var import_internal10 = require("@voltagent/internal");
 function safeJsonParse(value) {
   if (!value) return void 0;
   try {
@@ -31478,7 +31719,7 @@ function serializeValueForDebug(value) {
     }
     try {
       if (Object.getPrototypeOf(value) === Object.prototype) {
-        return (0, import_internal9.deepClone)(value);
+        return (0, import_internal10.deepClone)(value);
       }
       return `[Object: ${value.constructor?.name || "UnknownClass"}]`;
     } catch (e) {
@@ -31490,7 +31731,7 @@ function serializeValueForDebug(value) {
 __name(serializeValueForDebug, "serializeValueForDebug");
 
 // src/retriever/tools/index.ts
-var import_internal10 = require("@voltagent/internal");
+var import_internal11 = require("@voltagent/internal");
 var import_zod9 = require("zod");
 var createRetrieverTool = /* @__PURE__ */ __name((retriever, options = {}) => {
   const toolName = options.name || "search_knowledge";
@@ -31512,7 +31753,7 @@ var createRetrieverTool = /* @__PURE__ */ __name((retriever, options = {}) => {
         if (Array.isArray(value) && value.every((item) => ["string", "number", "boolean"].includes(typeof item))) {
           return value;
         }
-        return (0, import_internal10.safeStringify)(value);
+        return (0, import_internal11.safeStringify)(value);
       }, "normalizeAttributeValue");
       const attachRetrieverAttributes = /* @__PURE__ */ __name(() => {
         if (!toolSpan?.setAttribute) return;
@@ -31627,7 +31868,7 @@ var BaseRetriever = class {
 };
 
 // src/retriever/voltagent-rag-retriever.ts
-var import_internal11 = require("@voltagent/internal");
+var import_internal12 = require("@voltagent/internal");
 
 // src/voltops/global-client.ts
 var getGlobalVoltOpsClient = /* @__PURE__ */ __name(() => AgentRegistry.getInstance().getGlobalVoltOpsClient(), "getGlobalVoltOpsClient");
@@ -31660,7 +31901,7 @@ async function searchWithVoltOpsClient(voltOpsClient, payload) {
     headers: {
       "Content-Type": "application/json"
     },
-    body: (0, import_internal11.safeStringify)(payload)
+    body: (0, import_internal12.safeStringify)(payload)
   });
   const hasJson = response.headers.get("content-type")?.includes("application/json");
   const data = hasJson ? await response.json() : void 0;