ai 4.1.19 → 4.1.21

package/dist/index.mjs

@@ -13,7 +13,8 @@ import {
   parseAssistantStreamPart,
   parseDataStreamPart,
   processDataStream,
-  processTextStream
+  processTextStream,
+  zodSchema
 } from "@ai-sdk/ui-utils";
 
 // core/data-stream/create-data-stream.ts
@@ -1522,13 +1523,13 @@ _a8 = symbol8;
 
 // core/prompt/convert-to-core-messages.ts
 function convertToCoreMessages(messages, options) {
-  var _a15;
+  var _a15, _b;
   const tools = (_a15 = options == null ? void 0 : options.tools) != null ? _a15 : {};
   const coreMessages = [];
   for (let i = 0; i < messages.length; i++) {
     const message = messages[i];
     const isLastMessage = i === messages.length - 1;
-    const { role, content, toolInvocations, experimental_attachments } = message;
+    const { role, content, experimental_attachments } = message;
     switch (role) {
       case "system": {
         coreMessages.push({
@@ -1548,6 +1549,92 @@ function convertToCoreMessages(messages, options) {
         break;
       }
       case "assistant": {
+        if (message.parts != null) {
+          let processBlock2 = function() {
+            coreMessages.push({
+              role: "assistant",
+              content: block.map((part) => {
+                switch (part.type) {
+                  case "text":
+                    return {
+                      type: "text",
+                      text: part.text
+                    };
+                  default:
+                    return {
+                      type: "tool-call",
+                      toolCallId: part.toolInvocation.toolCallId,
+                      toolName: part.toolInvocation.toolName,
+                      args: part.toolInvocation.args
+                    };
+                }
+              })
+            });
+            const stepInvocations = block.filter(
+              (part) => part.type === "tool-invocation"
+            ).map((part) => part.toolInvocation);
+            if (stepInvocations.length > 0) {
+              coreMessages.push({
+                role: "tool",
+                content: stepInvocations.map(
+                  (toolInvocation) => {
+                    if (!("result" in toolInvocation)) {
+                      throw new MessageConversionError({
+                        originalMessage: message,
+                        message: "ToolInvocation must have a result: " + JSON.stringify(toolInvocation)
+                      });
+                    }
+                    const { toolCallId, toolName, result } = toolInvocation;
+                    const tool2 = tools[toolName];
+                    return (tool2 == null ? void 0 : tool2.experimental_toToolResultContent) != null ? {
+                      type: "tool-result",
+                      toolCallId,
+                      toolName,
+                      result: tool2.experimental_toToolResultContent(result),
+                      experimental_content: tool2.experimental_toToolResultContent(result)
+                    } : {
+                      type: "tool-result",
+                      toolCallId,
+                      toolName,
+                      result
+                    };
+                  }
+                )
+              });
+            }
+            block = [];
+            blockHasToolInvocations = false;
+            currentStep++;
+          };
+          var processBlock = processBlock2;
+          let currentStep = 0;
+          let blockHasToolInvocations = false;
+          let block = [];
+          for (const part of message.parts) {
+            switch (part.type) {
+              case "reasoning":
+                break;
+              case "text": {
+                if (blockHasToolInvocations) {
+                  processBlock2();
+                }
+                block.push(part);
+                break;
+              }
+              case "tool-invocation": {
+                if (((_b = part.toolInvocation.step) != null ? _b : 0) !== currentStep) {
+                  processBlock2();
+                }
+                block.push(part);
+                blockHasToolInvocations = true;
+                break;
+              }
+            }
+          }
+          processBlock2();
+          break;
+        }
+        const toolInvocations = message.toolInvocations;
         if (toolInvocations == null || toolInvocations.length === 0) {
           coreMessages.push({ role: "assistant", content });
           break;
@@ -5769,16 +5856,17 @@ import {
 } from "@ai-sdk/ui-utils";
 function appendResponseMessages({
   messages,
-  responseMessages
+  responseMessages,
+  _internal: { currentDate = () => /* @__PURE__ */ new Date() } = {}
 }) {
-  var _a15, _b;
+  var _a15, _b, _c, _d;
   const clonedMessages = structuredClone(messages);
   for (const message of responseMessages) {
     const role = message.role;
     const lastMessage = clonedMessages[clonedMessages.length - 1];
     const isLastMessageAssistant = lastMessage.role === "assistant";
     switch (role) {
-      case "assistant": {
+      case "assistant":
         let getToolInvocations2 = function(step) {
           return (typeof message.content === "string" ? [] : message.content.filter((part) => part.type === "tool-call")).map((call) => ({
             state: "call",
@@ -5794,40 +5882,71 @@ function appendResponseMessages({
           const maxStep = extractMaxToolInvocationStep(
             lastMessage.toolInvocations
           );
+          (_a15 = lastMessage.parts) != null ? _a15 : lastMessage.parts = [];
           lastMessage.content = textContent;
+          if (textContent.length > 0) {
+            lastMessage.parts.push({
+              type: "text",
+              text: textContent
+            });
+          }
           lastMessage.toolInvocations = [
-            ...(_a15 = lastMessage.toolInvocations) != null ? _a15 : [],
+            ...(_b = lastMessage.toolInvocations) != null ? _b : [],
             ...getToolInvocations2(maxStep === void 0 ? 0 : maxStep + 1)
           ];
+          getToolInvocations2(maxStep === void 0 ? 0 : maxStep + 1).map((call) => ({
+            type: "tool-invocation",
+            toolInvocation: call
+          })).forEach((part) => {
+            lastMessage.parts.push(part);
+          });
         } else {
           clonedMessages.push({
             role: "assistant",
             id: message.id,
-            createdAt: /* @__PURE__ */ new Date(),
+            createdAt: currentDate(),
             // generate a createdAt date for the message, will be overridden by the client
             content: textContent,
-            toolInvocations: getToolInvocations2(0)
+            toolInvocations: getToolInvocations2(0),
+            parts: [
+              ...textContent.length > 0 ? [{ type: "text", text: textContent }] : [],
+              ...getToolInvocations2(0).map((call) => ({
+                type: "tool-invocation",
+                toolInvocation: call
+              }))
+            ]
           });
         }
         break;
-      }
       case "tool": {
-        (_b = lastMessage.toolInvocations) != null ? _b : lastMessage.toolInvocations = [];
+        (_c = lastMessage.toolInvocations) != null ? _c : lastMessage.toolInvocations = [];
         if (lastMessage.role !== "assistant") {
           throw new Error(
             `Tool result must follow an assistant message: ${lastMessage.role}`
           );
         }
-        for (const part of message.content) {
+        (_d = lastMessage.parts) != null ? _d : lastMessage.parts = [];
+        for (const contentPart of message.content) {
           const toolCall = lastMessage.toolInvocations.find(
-            (call) => call.toolCallId === part.toolCallId
+            (call) => call.toolCallId === contentPart.toolCallId
+          );
+          const toolCallPart = lastMessage.parts.find(
+            (part) => part.type === "tool-invocation" && part.toolInvocation.toolCallId === contentPart.toolCallId
           );
           if (!toolCall) {
             throw new Error("Tool call not found in previous message");
           }
           toolCall.state = "result";
           const toolResult = toolCall;
-          toolResult.result = part.result;
+          toolResult.result = contentPart.result;
+          if (toolCallPart) {
+            toolCallPart.toolInvocation = toolResult;
+          } else {
+            lastMessage.parts.push({
+              type: "tool-invocation",
+              toolInvocation: toolResult
+            });
+          }
         }
         break;
       }
@@ -6450,6 +6569,7 @@ export {
   streamObject,
   streamText,
   tool,
-  wrapLanguageModel
+  wrapLanguageModel,
+  zodSchema
 };
 //# sourceMappingURL=index.mjs.map