ai 3.1.19 → 3.1.21

package/dist/index.mjs

@@ -212,7 +212,8 @@ function convertToLanguageModelPrompt(prompt) {
   if (prompt.system != null) {
     languageModelMessages.push({ role: "system", content: prompt.system });
   }
-  switch (prompt.type) {
+  const promptType = prompt.type;
+  switch (promptType) {
     case "prompt": {
       languageModelMessages.push({
         role: "user",
@@ -222,72 +223,75 @@ function convertToLanguageModelPrompt(prompt) {
     }
     case "messages": {
       languageModelMessages.push(
-        ...prompt.messages.map((message) => {
-          switch (message.role) {
-            case "system": {
-              return { role: "system", content: message.content };
-            }
-            case "user": {
-              if (typeof message.content === "string") {
-                return {
-                  role: "user",
-                  content: [{ type: "text", text: message.content }]
-                };
+        ...prompt.messages.map(convertToLanguageModelMessage)
+      );
+      break;
+    }
+    default: {
+      const _exhaustiveCheck = promptType;
+      throw new Error(`Unsupported prompt type: ${_exhaustiveCheck}`);
+    }
+  }
+  return languageModelMessages;
+}
+function convertToLanguageModelMessage(message) {
+  switch (message.role) {
+    case "system": {
+      return { role: "system", content: message.content };
+    }
+    case "user": {
+      if (typeof message.content === "string") {
+        return {
+          role: "user",
+          content: [{ type: "text", text: message.content }]
+        };
+      }
+      return {
+        role: "user",
+        content: message.content.map(
+          (part) => {
+            var _a;
+            switch (part.type) {
+              case "text": {
+                return part;
               }
-              return {
-                role: "user",
-                content: message.content.map(
-                  (part) => {
-                    var _a;
-                    switch (part.type) {
-                      case "text": {
-                        return part;
-                      }
-                      case "image": {
-                        if (part.image instanceof URL) {
-                          return {
-                            type: "image",
-                            image: part.image,
-                            mimeType: part.mimeType
-                          };
-                        }
-                        const imageUint8 = convertDataContentToUint8Array(
-                          part.image
-                        );
-                        return {
-                          type: "image",
-                          image: imageUint8,
-                          mimeType: (_a = part.mimeType) != null ? _a : detectImageMimeType(imageUint8)
-                        };
-                      }
-                    }
-                  }
-                )
-              };
-            }
-            case "assistant": {
-              if (typeof message.content === "string") {
+              case "image": {
+                if (part.image instanceof URL) {
+                  return {
+                    type: "image",
+                    image: part.image,
+                    mimeType: part.mimeType
+                  };
+                }
+                const imageUint8 = convertDataContentToUint8Array(part.image);
                 return {
-                  role: "assistant",
-                  content: [{ type: "text", text: message.content }]
+                  type: "image",
+                  image: imageUint8,
+                  mimeType: (_a = part.mimeType) != null ? _a : detectImageMimeType(imageUint8)
                 };
               }
-              return { role: "assistant", content: message.content };
-            }
-            case "tool": {
-              return message;
             }
           }
-        })
-      );
-      break;
+        )
+      };
+    }
+    case "assistant": {
+      if (typeof message.content === "string") {
+        return {
+          role: "assistant",
+          content: [{ type: "text", text: message.content }]
+        };
+      }
+      return { role: "assistant", content: message.content };
+    }
+    case "tool": {
+      return message;
     }
     default: {
-      const _exhaustiveCheck = prompt;
-      throw new Error(`Unsupported prompt type: ${_exhaustiveCheck}`);
+      const _exhaustiveCheck = message;
+      throw new Error(`Unsupported message role: ${_exhaustiveCheck}`);
     }
   }
-  return languageModelMessages;
 }
 
 // core/prompt/get-validated-prompt.ts
@@ -1245,40 +1249,66 @@ async function generateText({
   messages,
   maxRetries,
   abortSignal,
+  maxAutomaticRoundtrips = 0,
   ...settings
 }) {
-  var _a, _b;
+  var _a, _b, _c;
   const retry = retryWithExponentialBackoff({ maxRetries });
   const validatedPrompt = getValidatedPrompt({ system, prompt, messages });
-  const modelResponse = await retry(() => {
-    return model.doGenerate({
-      mode: {
-        type: "regular",
-        ...prepareToolsAndToolChoice({ tools, toolChoice })
-      },
-      ...prepareCallSettings(settings),
-      inputFormat: validatedPrompt.type,
-      prompt: convertToLanguageModelPrompt(validatedPrompt),
-      abortSignal
+  const mode = {
+    type: "regular",
+    ...prepareToolsAndToolChoice({ tools, toolChoice })
+  };
+  const callSettings = prepareCallSettings(settings);
+  const promptMessages = convertToLanguageModelPrompt(validatedPrompt);
+  let currentModelResponse;
+  let currentToolCalls = [];
+  let currentToolResults = [];
+  let roundtrips = 0;
+  const responseMessages = [];
+  do {
+    currentModelResponse = await retry(() => {
+      return model.doGenerate({
+        mode,
+        ...callSettings,
+        // once we have a roundtrip, we need to switch to messages format:
+        inputFormat: roundtrips === 0 ? validatedPrompt.type : "messages",
+        prompt: promptMessages,
+        abortSignal
+      });
     });
-  });
-  const toolCalls = [];
-  for (const modelToolCall of (_a = modelResponse.toolCalls) != null ? _a : []) {
-    toolCalls.push(parseToolCall({ toolCall: modelToolCall, tools }));
-  }
-  const toolResults = tools == null ? [] : await executeTools({ toolCalls, tools });
+    currentToolCalls = ((_a = currentModelResponse.toolCalls) != null ? _a : []).map(
+      (modelToolCall) => parseToolCall({ toolCall: modelToolCall, tools })
+    );
+    currentToolResults = tools == null ? [] : await executeTools({ toolCalls: currentToolCalls, tools });
+    const newResponseMessages = toResponseMessages({
+      text: (_b = currentModelResponse.text) != null ? _b : "",
+      toolCalls: currentToolCalls,
+      toolResults: currentToolResults
+    });
+    responseMessages.push(...newResponseMessages);
+    promptMessages.push(
+      ...newResponseMessages.map(convertToLanguageModelMessage)
+    );
+  } while (
+    // there are tool calls:
+    currentToolCalls.length > 0 && // all current tool calls have results:
+    currentToolResults.length === currentToolCalls.length && // the number of roundtrips is less than the maximum:
+    roundtrips++ < maxAutomaticRoundtrips
+  );
   return new GenerateTextResult({
     // Always return a string so that the caller doesn't have to check for undefined.
     // If they need to check if the model did not return any text,
     // they can check the length of the string:
-    text: (_b = modelResponse.text) != null ? _b : "",
-    toolCalls,
-    toolResults,
-    finishReason: modelResponse.finishReason,
-    usage: calculateTokenUsage(modelResponse.usage),
-    warnings: modelResponse.warnings,
-    rawResponse: modelResponse.rawResponse,
-    logprobs: modelResponse.logprobs
+    text: (_c = currentModelResponse.text) != null ? _c : "",
+    toolCalls: currentToolCalls,
+    toolResults: currentToolResults,
+    finishReason: currentModelResponse.finishReason,
+    usage: calculateTokenUsage(currentModelResponse.usage),
+    warnings: currentModelResponse.warnings,
+    rawResponse: currentModelResponse.rawResponse,
+    logprobs: currentModelResponse.logprobs,
+    responseMessages
   });
 }
 async function executeTools({
@@ -1314,7 +1344,7 @@ var GenerateTextResult = class {
     this.warnings = options.warnings;
     this.rawResponse = options.rawResponse;
     this.logprobs = options.logprobs;
-    this.responseMessages = toResponseMessages(options);
+    this.responseMessages = options.responseMessages;
   }
 };
 function toResponseMessages({
@@ -1342,6 +1372,16 @@ function toResponseMessages({
 }
 var experimental_generateText = generateText;
 
+// core/util/prepare-response-headers.ts
+function prepareResponseHeaders(init, { contentType }) {
+  var _a;
+  const headers = new Headers((_a = init == null ? void 0 : init.headers) != null ? _a : {});
+  if (!headers.has("Content-Type")) {
+    headers.set("Content-Type", contentType);
+  }
+  return headers;
+}
+
 // core/generate-text/run-tools-transformation.ts
 import { NoSuchToolError as NoSuchToolError2 } from "@ai-sdk/provider";
 
@@ -1814,10 +1854,9 @@ var StreamTextResult = class {
     var _a;
     return new Response(this.textStream.pipeThrough(new TextEncoderStream()), {
       status: (_a = init == null ? void 0 : init.status) != null ? _a : 200,
-      headers: {
-        "Content-Type": "text/plain; charset=utf-8",
-        ...init == null ? void 0 : init.headers
-      }
+      headers: prepareResponseHeaders(init, {
+        contentType: "text/plain; charset=utf-8"
+      })
     });
   }
 };
@@ -3447,10 +3486,9 @@ var StreamingTextResponse = class extends Response {
     super(processedStream, {
       ...init,
       status: 200,
-      headers: {
-        "Content-Type": "text/plain; charset=utf-8",
-        ...init == null ? void 0 : init.headers
-      }
+      headers: prepareResponseHeaders(init, {
+        contentType: "text/plain; charset=utf-8"
+      })
     });
   }
 };