ai 3.3.20 → 3.3.22

package/dist/index.js

@@ -73,17 +73,15 @@ __export(streams_exports, {
   experimental_createProviderRegistry: () => experimental_createProviderRegistry,
   experimental_customProvider: () => experimental_customProvider,
   experimental_generateObject: () => experimental_generateObject,
-  experimental_generateText: () => experimental_generateText,
   experimental_streamObject: () => experimental_streamObject,
-  experimental_streamText: () => experimental_streamText,
   formatStreamPart: () => import_ui_utils10.formatStreamPart,
   generateId: () => generateId2,
   generateObject: () => generateObject,
   generateText: () => generateText,
   jsonSchema: () => import_ui_utils6.jsonSchema,
   nanoid: () => nanoid,
-  parseComplexResponse: () => import_ui_utils10.parseComplexResponse,
   parseStreamPart: () => import_ui_utils10.parseStreamPart,
+  processDataProtocolResponse: () => import_ui_utils10.processDataProtocolResponse,
   readDataStream: () => import_ui_utils10.readDataStream,
   readableFromAsyncIterable: () => readableFromAsyncIterable,
   streamObject: () => streamObject,
@@ -2551,6 +2549,31 @@ function prepareToolsAndToolChoice({
   };
 }
 
+// core/generate-text/to-response-messages.ts
+function toResponseMessages({
+  text = "",
+  toolCalls,
+  toolResults
+}) {
+  const responseMessages = [];
+  responseMessages.push({
+    role: "assistant",
+    content: [{ type: "text", text }, ...toolCalls]
+  });
+  if (toolResults.length > 0) {
+    responseMessages.push({
+      role: "tool",
+      content: toolResults.map((result) => ({
+        type: "tool-result",
+        toolCallId: result.toolCallId,
+        toolName: result.toolName,
+        result: result.result
+      }))
+    });
+  }
+  return responseMessages;
+}
+
 // core/generate-text/tool-call.ts
 var import_provider_utils7 = require("@ai-sdk/provider-utils");
 var import_ui_utils4 = require("@ai-sdk/ui-utils");
@@ -2719,7 +2742,7 @@ async function generateText({
     }),
     tracer,
     fn: async (span) => {
-      var _a12, _b, _c, _d;
+      var _a12, _b, _c;
       const retry = retryWithExponentialBackoff({ maxRetries });
       const validatedPrompt = validatePrompt({
         system,
@@ -2830,7 +2853,7 @@ async function generateText({
           logprobs: currentModelResponse.logprobs
         });
         const newResponseMessages = toResponseMessages({
-          text: (_c = currentModelResponse.text) != null ? _c : "",
+          text: currentModelResponse.text,
           toolCalls: currentToolCalls,
           toolResults: currentToolResults
         });
@@ -2866,7 +2889,7 @@ async function generateText({
         // 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: (_d = currentModelResponse.text) != null ? _d : "",
+        text: (_c = currentModelResponse.text) != null ? _c : "",
         toolCalls: currentToolCalls,
         toolResults: currentToolResults,
         finishReason: currentModelResponse.finishReason,
@@ -2955,30 +2978,68 @@ var DefaultGenerateTextResult = class {
     this.experimental_providerMetadata = options.providerMetadata;
   }
 };
-function toResponseMessages({
-  text,
-  toolCalls,
-  toolResults
-}) {
-  const responseMessages = [];
-  responseMessages.push({
-    role: "assistant",
-    content: [{ type: "text", text }, ...toolCalls]
-  });
-  if (toolResults.length > 0) {
-    responseMessages.push({
-      role: "tool",
-      content: toolResults.map((result) => ({
-        type: "tool-result",
-        toolCallId: result.toolCallId,
-        toolName: result.toolName,
-        result: result.result
-      }))
-    });
-  }
-  return responseMessages;
+
+// core/util/create-stitchable-stream.ts
+function createStitchableStream() {
+  let innerStreamReaders = [];
+  let controller = null;
+  let isClosed = false;
+  const processPull = async () => {
+    if (isClosed && innerStreamReaders.length === 0) {
+      controller == null ? void 0 : controller.close();
+      return;
+    }
+    if (innerStreamReaders.length === 0) {
+      return;
+    }
+    try {
+      const { value, done } = await innerStreamReaders[0].read();
+      if (done) {
+        innerStreamReaders.shift();
+        if (innerStreamReaders.length > 0) {
+          await processPull();
+        } else if (isClosed) {
+          controller == null ? void 0 : controller.close();
+        }
+      } else {
+        controller == null ? void 0 : controller.enqueue(value);
+      }
+    } catch (error) {
+      controller == null ? void 0 : controller.error(error);
+      innerStreamReaders.shift();
+      if (isClosed && innerStreamReaders.length === 0) {
+        controller == null ? void 0 : controller.close();
+      }
+    }
+  };
+  return {
+    stream: new ReadableStream({
+      start(controllerParam) {
+        controller = controllerParam;
+      },
+      pull: processPull,
+      async cancel() {
+        for (const reader of innerStreamReaders) {
+          await reader.cancel();
+        }
+        innerStreamReaders = [];
+        isClosed = true;
+      }
+    }),
+    addStream: (innerStream) => {
+      if (isClosed) {
+        throw new Error("Cannot add inner stream: outer stream is closed");
+      }
+      innerStreamReaders.push(innerStream.getReader());
+    },
+    close: () => {
+      isClosed = true;
+      if (innerStreamReaders.length === 0) {
+        controller == null ? void 0 : controller.close();
+      }
+    }
+  };
 }
-var experimental_generateText = generateText;
 
 // core/util/merge-streams.ts
 function mergeStreams(stream1, stream2) {
@@ -3267,6 +3328,7 @@ async function streamText({
   maxRetries,
   abortSignal,
   headers,
+  maxToolRoundtrips = 0,
   experimental_telemetry: telemetry,
   experimental_toolCallStreaming: toolCallStreaming = false,
   onChunk,
@@ -3298,68 +3360,89 @@ async function streamText({
     endWhenDone: false,
     fn: async (rootSpan) => {
       const retry = retryWithExponentialBackoff({ maxRetries });
-      const validatedPrompt = validatePrompt({ system, prompt, messages });
+      const startRoundtrip = async ({
+        promptMessages: promptMessages2,
+        promptType
+      }) => {
+        const {
+          result: { stream: stream2, warnings: warnings2, rawResponse: rawResponse2 },
+          doStreamSpan: doStreamSpan2,
+          startTimestamp: startTimestamp2
+        } = await retry(
+          () => recordSpan({
+            name: "ai.streamText.doStream",
+            attributes: selectTelemetryAttributes({
+              telemetry,
+              attributes: {
+                ...assembleOperationName({
+                  operationId: "ai.streamText.doStream",
+                  telemetry
+                }),
+                ...baseTelemetryAttributes,
+                "ai.prompt.format": {
+                  input: () => promptType
+                },
+                "ai.prompt.messages": {
+                  input: () => JSON.stringify(promptMessages2)
+                },
+                // standardized gen-ai llm span attributes:
+                "gen_ai.request.model": model.modelId,
+                "gen_ai.system": model.provider,
+                "gen_ai.request.max_tokens": settings.maxTokens,
+                "gen_ai.request.temperature": settings.temperature,
+                "gen_ai.request.top_p": settings.topP
+              }
+            }),
+            tracer,
+            endWhenDone: false,
+            fn: async (doStreamSpan3) => ({
+              startTimestamp: performance.now(),
+              // get before the call
+              doStreamSpan: doStreamSpan3,
+              result: await model.doStream({
+                mode: {
+                  type: "regular",
+                  ...prepareToolsAndToolChoice({ tools, toolChoice })
+                },
+                ...prepareCallSettings(settings),
+                inputFormat: promptType,
+                prompt: promptMessages2,
+                abortSignal,
+                headers
+              })
+            })
+          })
+        );
+        return {
+          result: {
+            stream: runToolsTransformation({
+              tools,
+              generatorStream: stream2,
+              toolCallStreaming,
+              tracer,
+              telemetry
+            }),
+            warnings: warnings2,
+            rawResponse: rawResponse2
+          },
+          doStreamSpan: doStreamSpan2,
+          startTimestamp: startTimestamp2
+        };
+      };
       const promptMessages = await convertToLanguageModelPrompt({
-        prompt: validatedPrompt,
+        prompt: validatePrompt({ system, prompt, messages }),
         modelSupportsImageUrls: model.supportsImageUrls
       });
       const {
         result: { stream, warnings, rawResponse },
         doStreamSpan,
         startTimestamp
-      } = await retry(
-        () => recordSpan({
-          name: "ai.streamText.doStream",
-          attributes: selectTelemetryAttributes({
-            telemetry,
-            attributes: {
-              ...assembleOperationName({
-                operationId: "ai.streamText.doStream",
-                telemetry
-              }),
-              ...baseTelemetryAttributes,
-              "ai.prompt.format": {
-                input: () => validatedPrompt.type
-              },
-              "ai.prompt.messages": {
-                input: () => JSON.stringify(promptMessages)
-              },
-              // standardized gen-ai llm span attributes:
-              "gen_ai.request.model": model.modelId,
-              "gen_ai.system": model.provider,
-              "gen_ai.request.max_tokens": settings.maxTokens,
-              "gen_ai.request.temperature": settings.temperature,
-              "gen_ai.request.top_p": settings.topP
-            }
-          }),
-          tracer,
-          endWhenDone: false,
-          fn: async (doStreamSpan2) => ({
-            startTimestamp: performance.now(),
-            // get before the call
-            doStreamSpan: doStreamSpan2,
-            result: await model.doStream({
-              mode: {
-                type: "regular",
-                ...prepareToolsAndToolChoice({ tools, toolChoice })
-              },
-              ...prepareCallSettings(settings),
-              inputFormat: validatedPrompt.type,
-              prompt: promptMessages,
-              abortSignal,
-              headers
-            })
-          })
-        })
-      );
+      } = await startRoundtrip({
+        promptType: validatePrompt({ system, prompt, messages }).type,
+        promptMessages
+      });
       return new DefaultStreamTextResult({
-        stream: runToolsTransformation({
-          tools,
-          generatorStream: stream,
-          toolCallStreaming,
-          tracer,
-          telemetry
-        }),
+        stream,
         warnings,
         rawResponse,
         onChunk,
@@ -3367,7 +3450,10 @@ async function streamText({
         rootSpan,
         doStreamSpan,
         telemetry,
-        startTimestamp
+        startTimestamp,
+        maxToolRoundtrips,
+        startRoundtrip,
+        promptMessages
       });
     }
   });
@@ -3382,7 +3468,10 @@ var DefaultStreamTextResult = class {
     rootSpan,
     doStreamSpan,
     telemetry,
-    startTimestamp
+    startTimestamp,
+    maxToolRoundtrips,
+    startRoundtrip,
+    promptMessages
   }) {
     this.warnings = warnings;
     this.rawResponse = rawResponse;
@@ -3401,129 +3490,223 @@ var DefaultStreamTextResult = class {
       promise: providerMetadataPromise
     } = createResolvablePromise();
     this.experimental_providerMetadata = providerMetadataPromise;
-    let finishReason;
-    let usage;
-    let providerMetadata;
-    let text = "";
-    const toolCalls = [];
-    const toolResults = [];
-    let firstChunk = true;
-    this.originalStream = stream.pipeThrough(
-      new TransformStream({
-        async transform(chunk, controller) {
-          if (firstChunk) {
-            const msToFirstChunk = performance.now() - startTimestamp;
-            firstChunk = false;
-            doStreamSpan.addEvent("ai.stream.firstChunk", {
-              "ai.stream.msToFirstChunk": msToFirstChunk
-            });
-            doStreamSpan.setAttributes({
-              "ai.stream.msToFirstChunk": msToFirstChunk
-            });
-          }
-          if (chunk.type === "text-delta" && chunk.textDelta.length === 0) {
-            return;
-          }
-          controller.enqueue(chunk);
-          const chunkType = chunk.type;
-          switch (chunkType) {
-            case "text-delta":
-              text += chunk.textDelta;
-              await (onChunk == null ? void 0 : onChunk({ chunk }));
-              break;
-            case "tool-call":
-              toolCalls.push(chunk);
-              await (onChunk == null ? void 0 : onChunk({ chunk }));
-              break;
-            case "tool-result":
-              toolResults.push(chunk);
-              await (onChunk == null ? void 0 : onChunk({ chunk }));
-              break;
-            case "finish":
-              usage = chunk.usage;
-              finishReason = chunk.finishReason;
-              providerMetadata = chunk.experimental_providerMetadata;
-              resolveUsage(usage);
-              resolveFinishReason(finishReason);
-              resolveText(text);
-              resolveToolCalls(toolCalls);
-              resolveProviderMetadata(providerMetadata);
-              break;
-            case "tool-call-streaming-start":
-            case "tool-call-delta": {
-              await (onChunk == null ? void 0 : onChunk({ chunk }));
-              break;
-            }
-            case "error":
-              break;
-            default: {
-              const exhaustiveCheck = chunkType;
-              throw new Error(`Unknown chunk type: ${exhaustiveCheck}`);
-            }
-          }
-        },
-        // invoke onFinish callback and resolve toolResults promise when the stream is about to close:
-        async flush(controller) {
-          try {
-            const finalUsage = usage != null ? usage : {
-              promptTokens: NaN,
-              completionTokens: NaN,
-              totalTokens: NaN
-            };
-            const finalFinishReason = finishReason != null ? finishReason : "unknown";
-            const telemetryToolCalls = toolCalls.length > 0 ? JSON.stringify(toolCalls) : void 0;
-            doStreamSpan.setAttributes(
-              selectTelemetryAttributes({
-                telemetry,
-                attributes: {
-                  "ai.finishReason": finalFinishReason,
-                  "ai.usage.promptTokens": finalUsage.promptTokens,
-                  "ai.usage.completionTokens": finalUsage.completionTokens,
-                  "ai.result.text": { output: () => text },
-                  "ai.result.toolCalls": { output: () => telemetryToolCalls },
-                  // standardized gen-ai llm span attributes:
-                  "gen_ai.response.finish_reasons": [finalFinishReason],
-                  "gen_ai.usage.prompt_tokens": finalUsage.promptTokens,
-                  "gen_ai.usage.completion_tokens": finalUsage.completionTokens
+    const {
+      stream: stitchableStream,
+      addStream,
+      close: closeStitchableStream
+    } = createStitchableStream();
+    this.originalStream = stitchableStream;
+    const self = this;
+    function addRoundtripStream({
+      stream: stream2,
+      startTimestamp: startTimestamp2,
+      doStreamSpan: doStreamSpan2,
+      currentToolRoundtrip,
+      promptMessages: promptMessages2,
+      usage = {
+        promptTokens: 0,
+        completionTokens: 0,
+        totalTokens: 0
+      }
+    }) {
+      const roundtripToolCalls = [];
+      const roundtripToolResults = [];
+      let roundtripFinishReason = "unknown";
+      let roundtripUsage = {
+        promptTokens: 0,
+        completionTokens: 0,
+        totalTokens: 0
+      };
+      let roundtripProviderMetadata;
+      let roundtripFirstChunk = true;
+      let roundtripText = "";
+      let roundtripLogProbs;
+      addStream(
+        stream2.pipeThrough(
+          new TransformStream({
+            async transform(chunk, controller) {
+              if (roundtripFirstChunk) {
+                const msToFirstChunk = performance.now() - startTimestamp2;
+                roundtripFirstChunk = false;
+                doStreamSpan2.addEvent("ai.stream.firstChunk", {
+                  "ai.stream.msToFirstChunk": msToFirstChunk
+                });
+                doStreamSpan2.setAttributes({
+                  "ai.stream.msToFirstChunk": msToFirstChunk
+                });
+              }
+              if (chunk.type === "text-delta" && chunk.textDelta.length === 0) {
+                return;
+              }
+              const chunkType = chunk.type;
+              switch (chunkType) {
+                case "text-delta":
+                  controller.enqueue(chunk);
+                  roundtripText += chunk.textDelta;
+                  await (onChunk == null ? void 0 : onChunk({ chunk }));
+                  break;
+                case "tool-call":
+                  controller.enqueue(chunk);
+                  roundtripToolCalls.push(chunk);
+                  await (onChunk == null ? void 0 : onChunk({ chunk }));
+                  break;
+                case "tool-result":
+                  controller.enqueue(chunk);
+                  roundtripToolResults.push(chunk);
+                  await (onChunk == null ? void 0 : onChunk({ chunk }));
+                  break;
+                case "finish":
+                  roundtripUsage = chunk.usage;
+                  roundtripFinishReason = chunk.finishReason;
+                  roundtripProviderMetadata = chunk.experimental_providerMetadata;
+                  roundtripLogProbs = chunk.logprobs;
+                  break;
+                case "tool-call-streaming-start":
+                case "tool-call-delta": {
+                  controller.enqueue(chunk);
+                  await (onChunk == null ? void 0 : onChunk({ chunk }));
+                  break;
                 }
-              })
-            );
-            doStreamSpan.end();
-            rootSpan.setAttributes(
-              selectTelemetryAttributes({
-                telemetry,
-                attributes: {
-                  "ai.finishReason": finalFinishReason,
-                  "ai.usage.promptTokens": finalUsage.promptTokens,
-                  "ai.usage.completionTokens": finalUsage.completionTokens,
-                  "ai.result.text": { output: () => text },
-                  "ai.result.toolCalls": { output: () => telemetryToolCalls }
+                case "error":
+                  controller.enqueue(chunk);
+                  roundtripFinishReason = "error";
+                  break;
+                default: {
+                  const exhaustiveCheck = chunkType;
+                  throw new Error(`Unknown chunk type: ${exhaustiveCheck}`);
                 }
-              })
-            );
-            resolveToolResults(toolResults);
-            await (onFinish == null ? void 0 : onFinish({
-              finishReason: finalFinishReason,
-              usage: finalUsage,
-              text,
-              toolCalls,
-              // The tool results are inferred as a never[] type, because they are
-              // optional and the execute method with an inferred result type is
-              // optional as well. Therefore we need to cast the toolResults to any.
-              // The type exposed to the users will be correctly inferred.
-              toolResults,
-              rawResponse,
-              warnings,
-              experimental_providerMetadata: providerMetadata
-            }));
-          } catch (error) {
-            controller.error(error);
-          } finally {
-            rootSpan.end();
-          }
-        }
-      })
-    );
+              }
+            },
+            // invoke onFinish callback and resolve toolResults promise when the stream is about to close:
+            async flush(controller) {
+              controller.enqueue({
+                type: "roundtrip-finish",
+                finishReason: roundtripFinishReason,
+                usage: roundtripUsage,
+                experimental_providerMetadata: roundtripProviderMetadata,
+                logprobs: roundtripLogProbs
+              });
+              const telemetryToolCalls = roundtripToolCalls.length > 0 ? JSON.stringify(roundtripToolCalls) : void 0;
+              try {
+                doStreamSpan2.setAttributes(
+                  selectTelemetryAttributes({
+                    telemetry,
+                    attributes: {
+                      "ai.finishReason": roundtripFinishReason,
+                      "ai.usage.promptTokens": roundtripUsage.promptTokens,
+                      "ai.usage.completionTokens": roundtripUsage.completionTokens,
+                      "ai.result.text": { output: () => roundtripText },
+                      "ai.result.toolCalls": {
+                        output: () => telemetryToolCalls
+                      },
+                      // standardized gen-ai llm span attributes:
+                      "gen_ai.response.finish_reasons": [roundtripFinishReason],
+                      "gen_ai.usage.prompt_tokens": roundtripUsage.promptTokens,
+                      "gen_ai.usage.completion_tokens": roundtripUsage.completionTokens
+                    }
+                  })
+                );
+              } catch (error) {
+              } finally {
+                doStreamSpan2.end();
+              }
+              const combinedUsage = {
+                promptTokens: usage.promptTokens + roundtripUsage.promptTokens,
+                completionTokens: usage.completionTokens + roundtripUsage.completionTokens,
+                totalTokens: usage.totalTokens + roundtripUsage.totalTokens
+              };
+              if (
+                // there are tool calls:
+                roundtripToolCalls.length > 0 && // all current tool calls have results:
+                roundtripToolResults.length === roundtripToolCalls.length && // the number of roundtrips is less than the maximum:
+                currentToolRoundtrip < maxToolRoundtrips
+              ) {
+                promptMessages2.push(
+                  ...toResponseMessages({
+                    text: roundtripText,
+                    toolCalls: roundtripToolCalls,
+                    toolResults: roundtripToolResults
+                  }).map(
+                    (message) => convertToLanguageModelMessage(message, null)
+                  )
+                );
+                const { result, doStreamSpan: doStreamSpan3, startTimestamp: startTimestamp3 } = await startRoundtrip({
+                  promptType: "messages",
+                  promptMessages: promptMessages2
+                });
+                self.warnings = result.warnings;
+                self.rawResponse = result.rawResponse;
+                addRoundtripStream({
+                  stream: result.stream,
+                  startTimestamp: startTimestamp3,
+                  doStreamSpan: doStreamSpan3,
+                  currentToolRoundtrip: currentToolRoundtrip + 1,
+                  promptMessages: promptMessages2,
+                  usage: combinedUsage
+                });
+                return;
+              }
+              try {
+                controller.enqueue({
+                  type: "finish",
+                  finishReason: roundtripFinishReason,
+                  usage: combinedUsage,
+                  experimental_providerMetadata: roundtripProviderMetadata,
+                  logprobs: roundtripLogProbs
+                });
+                closeStitchableStream();
+                rootSpan.setAttributes(
+                  selectTelemetryAttributes({
+                    telemetry,
+                    attributes: {
+                      "ai.finishReason": roundtripFinishReason,
+                      "ai.usage.promptTokens": combinedUsage.promptTokens,
+                      "ai.usage.completionTokens": combinedUsage.completionTokens,
+                      "ai.result.text": { output: () => roundtripText },
+                      "ai.result.toolCalls": {
+                        output: () => telemetryToolCalls
+                      }
+                    }
+                  })
+                );
+                resolveUsage(combinedUsage);
+                resolveFinishReason(roundtripFinishReason);
+                resolveText(roundtripText);
+                resolveToolCalls(roundtripToolCalls);
+                resolveProviderMetadata(roundtripProviderMetadata);
+                resolveToolResults(roundtripToolResults);
+                await (onFinish == null ? void 0 : onFinish({
+                  finishReason: roundtripFinishReason,
+                  usage: combinedUsage,
+                  text: roundtripText,
+                  toolCalls: roundtripToolCalls,
+                  // The tool results are inferred as a never[] type, because they are
+                  // optional and the execute method with an inferred result type is
+                  // optional as well. Therefore we need to cast the toolResults to any.
+                  // The type exposed to the users will be correctly inferred.
+                  toolResults: roundtripToolResults,
+                  rawResponse,
+                  warnings,
+                  experimental_providerMetadata: roundtripProviderMetadata
+                }));
+              } catch (error) {
+                controller.error(error);
+              } finally {
+                rootSpan.end();
+              }
+            }
+          })
+        )
+      );
+    }
+    addRoundtripStream({
+      stream,
+      startTimestamp,
+      doStreamSpan,
+      currentToolRoundtrip: 0,
+      promptMessages,
+      usage: void 0
+    });
   }
   /**
   Split out a new stream from the original stream.
@@ -3633,6 +3816,17 @@ var DefaultStreamTextResult = class {
               (0, import_ui_utils10.formatStreamPart)("error", getErrorMessage4(chunk.error))
             );
             break;
+          case "roundtrip-finish":
+            controller.enqueue(
+              (0, import_ui_utils10.formatStreamPart)("finish_roundtrip", {
+                finishReason: chunk.finishReason,
+                usage: {
+                  promptTokens: chunk.usage.promptTokens,
+                  completionTokens: chunk.usage.completionTokens
+                }
+              })
+            );
+            break;
           case "finish":
             controller.enqueue(
               (0, import_ui_utils10.formatStreamPart)("finish_message", {
@@ -3734,7 +3928,6 @@ var DefaultStreamTextResult = class {
     });
   }
 };
-var experimental_streamText = streamText;
 
 // core/prompt/attachments-to-parts.ts
 function attachmentsToParts(attachments) {
@@ -5164,17 +5357,15 @@ var nanoid = import_provider_utils8.generateId;
   experimental_createProviderRegistry,
   experimental_customProvider,
   experimental_generateObject,
-  experimental_generateText,
   experimental_streamObject,
-  experimental_streamText,
   formatStreamPart,
   generateId,
   generateObject,
   generateText,
   jsonSchema,
   nanoid,
-  parseComplexResponse,
   parseStreamPart,
+  processDataProtocolResponse,
   readDataStream,
   readableFromAsyncIterable,
   streamObject,