ai 4.0.18 → 4.0.19

package/dist/index.mjs

@@ -1744,6 +1744,13 @@ function calculateLanguageModelUsage({
     totalTokens: promptTokens + completionTokens
   };
 }
+function addLanguageModelUsage(usage1, usage2) {
+  return {
+    promptTokens: usage1.promptTokens + usage2.promptTokens,
+    completionTokens: usage1.completionTokens + usage2.completionTokens,
+    totalTokens: usage1.totalTokens + usage2.totalTokens
+  };
+}
 
 // core/generate-object/inject-json-instruction.ts
 var DEFAULT_SCHEMA_PREFIX = "JSON schema:";
@@ -3582,7 +3589,7 @@ async function generateText({
       const responseMessages = [];
       let text2 = "";
       const steps = [];
-      const usage = {
+      let usage = {
         completionTokens: 0,
         promptTokens: 0,
         totalTokens: 0
@@ -3709,9 +3716,7 @@ async function generateText({
         const currentUsage = calculateLanguageModelUsage(
           currentModelResponse.usage
         );
-        usage.completionTokens += currentUsage.completionTokens;
-        usage.promptTokens += currentUsage.promptTokens;
-        usage.totalTokens += currentUsage.totalTokens;
+        usage = addLanguageModelUsage(usage, currentUsage);
         let nextStepType = "done";
         if (++stepCount < maxSteps) {
           if (continueSteps && currentModelResponse.finishReason === "length" && // only use continue when there are no tool calls:
@@ -4369,10 +4374,168 @@ var DefaultStreamTextResult = class {
         message: "maxSteps must be at least 1"
       });
     }
+    let recordedStepText = "";
+    let recordedContinuationText = "";
+    let recordedFullText = "";
+    let recordedRequest = void 0;
+    const recordedResponse = {
+      id: generateId3(),
+      timestamp: currentDate(),
+      modelId: model.modelId,
+      messages: []
+    };
+    let recordedToolCalls = [];
+    let recordedToolResults = [];
+    let recordedFinishReason = void 0;
+    let recordedUsage = void 0;
+    let recordedProviderMetadata = void 0;
+    let stepType = "initial";
+    const recordedSteps = [];
+    let rootSpan;
+    const eventProcessor = new TransformStream({
+      async transform(chunk, controller) {
+        controller.enqueue(chunk);
+        if (chunk.type === "text-delta" || chunk.type === "tool-call" || chunk.type === "tool-result" || chunk.type === "tool-call-streaming-start" || chunk.type === "tool-call-delta") {
+          await (onChunk == null ? void 0 : onChunk({ chunk }));
+        }
+        if (chunk.type === "text-delta") {
+          recordedStepText += chunk.textDelta;
+          recordedContinuationText += chunk.textDelta;
+          recordedFullText += chunk.textDelta;
+        }
+        if (chunk.type === "tool-call") {
+          recordedToolCalls.push(chunk);
+        }
+        if (chunk.type === "tool-result") {
+          recordedToolResults.push(chunk);
+        }
+        if (chunk.type === "step-finish") {
+          const stepMessages = toResponseMessages({
+            text: recordedContinuationText,
+            tools: tools != null ? tools : {},
+            toolCalls: recordedToolCalls,
+            toolResults: recordedToolResults
+          });
+          const currentStep = recordedSteps.length;
+          let nextStepType = "done";
+          if (currentStep + 1 < maxSteps) {
+            if (continueSteps && chunk.finishReason === "length" && // only use continue when there are no tool calls:
+            recordedToolCalls.length === 0) {
+              nextStepType = "continue";
+            } else if (
+              // there are tool calls:
+              recordedToolCalls.length > 0 && // all current tool calls have results:
+              recordedToolResults.length === recordedToolCalls.length
+            ) {
+              nextStepType = "tool-result";
+            }
+          }
+          const currentStepResult = {
+            stepType,
+            text: recordedStepText,
+            toolCalls: recordedToolCalls,
+            toolResults: recordedToolResults,
+            finishReason: chunk.finishReason,
+            usage: chunk.usage,
+            warnings: chunk.warnings,
+            logprobs: chunk.logprobs,
+            request: chunk.request,
+            response: {
+              ...chunk.response,
+              messages: [...recordedResponse.messages, ...stepMessages]
+            },
+            experimental_providerMetadata: chunk.experimental_providerMetadata,
+            isContinued: chunk.isContinued
+          };
+          await (onStepFinish == null ? void 0 : onStepFinish(currentStepResult));
+          recordedSteps.push(currentStepResult);
+          recordedToolCalls = [];
+          recordedToolResults = [];
+          recordedStepText = "";
+          recordedRequest = chunk.request;
+          if (nextStepType !== "done") {
+            stepType = nextStepType;
+          }
+          if (nextStepType !== "continue") {
+            recordedResponse.messages.push(...stepMessages);
+            recordedContinuationText = "";
+          }
+        }
+        if (chunk.type === "finish") {
+          recordedResponse.id = chunk.response.id;
+          recordedResponse.timestamp = chunk.response.timestamp;
+          recordedResponse.modelId = chunk.response.modelId;
+          recordedResponse.headers = chunk.response.headers;
+          recordedUsage = chunk.usage;
+          recordedFinishReason = chunk.finishReason;
+          recordedProviderMetadata = chunk.experimental_providerMetadata;
+        }
+      },
+      async flush(controller) {
+        var _a13;
+        try {
+          const lastStep = recordedSteps[recordedSteps.length - 1];
+          if (lastStep) {
+            self.warningsPromise.resolve(lastStep.warnings);
+            self.requestPromise.resolve(lastStep.request);
+            self.responsePromise.resolve(lastStep.response);
+            self.toolCallsPromise.resolve(lastStep.toolCalls);
+            self.toolResultsPromise.resolve(lastStep.toolResults);
+            self.providerMetadataPromise.resolve(
+              lastStep.experimental_providerMetadata
+            );
+          }
+          const finishReason = recordedFinishReason != null ? recordedFinishReason : "unknown";
+          const usage = recordedUsage != null ? recordedUsage : {
+            completionTokens: NaN,
+            promptTokens: NaN,
+            totalTokens: NaN
+          };
+          self.finishReasonPromise.resolve(finishReason);
+          self.usagePromise.resolve(usage);
+          self.textPromise.resolve(recordedFullText);
+          self.stepsPromise.resolve(recordedSteps);
+          await (onFinish == null ? void 0 : onFinish({
+            finishReason,
+            logprobs: void 0,
+            usage,
+            text: recordedFullText,
+            toolCalls: lastStep.toolCalls,
+            toolResults: lastStep.toolResults,
+            request: (_a13 = lastStep.request) != null ? _a13 : {},
+            response: lastStep.response,
+            warnings: lastStep.warnings,
+            experimental_providerMetadata: lastStep.experimental_providerMetadata,
+            steps: recordedSteps
+          }));
+          rootSpan.setAttributes(
+            selectTelemetryAttributes({
+              telemetry,
+              attributes: {
+                "ai.response.finishReason": finishReason,
+                "ai.response.text": { output: () => recordedFullText },
+                "ai.response.toolCalls": {
+                  output: () => {
+                    var _a14;
+                    return ((_a14 = lastStep.toolCalls) == null ? void 0 : _a14.length) ? JSON.stringify(lastStep.toolCalls) : void 0;
+                  }
+                },
+                "ai.usage.promptTokens": usage.promptTokens,
+                "ai.usage.completionTokens": usage.completionTokens
+              }
+            })
+          );
+        } catch (error) {
+          controller.error(error);
+        } finally {
+          rootSpan.end();
+        }
+      }
+    });
     const stitchableStream = createStitchableStream();
     this.addStream = stitchableStream.addStream;
     this.closeStream = stitchableStream.close;
-    this.baseStream = transform ? stitchableStream.stream.pipeThrough(transform) : stitchableStream.stream;
+    this.baseStream = (transform ? stitchableStream.stream.pipeThrough(transform) : stitchableStream.stream).pipeThrough(eventProcessor);
     const { maxRetries, retry } = prepareRetries({
       maxRetries: maxRetriesArg
     });
@@ -4404,13 +4567,13 @@ var DefaultStreamTextResult = class {
       }),
       tracer,
       endWhenDone: false,
-      fn: async (rootSpan) => {
-        const stepResults = [];
+      fn: async (rootSpanArg) => {
+        rootSpan = rootSpanArg;
         async function streamStep({
           currentStep,
           responseMessages,
           usage,
-          stepType,
+          stepType: stepType2,
           previousStepText,
           hasLeadingWhitespace
         }) {
@@ -4516,7 +4679,7 @@ var DefaultStreamTextResult = class {
           let stepProviderMetadata;
           let stepFirstChunk = true;
           let stepText = "";
-          let fullStepText = stepType === "continue" ? previousStepText : "";
+          let fullStepText = stepType2 === "continue" ? previousStepText : "";
           let stepLogProbs;
           let stepResponse = {
             id: generateId3(),
@@ -4536,7 +4699,6 @@ var DefaultStreamTextResult = class {
             fullStepText += chunk.textDelta;
             chunkTextPublished = true;
             hasWhitespaceSuffix = chunk.textDelta.trimEnd() !== chunk.textDelta;
-            await (onChunk == null ? void 0 : onChunk({ chunk }));
           }
           self.addStream(
             transformedStream.pipeThrough(
@@ -4585,13 +4747,11 @@ var DefaultStreamTextResult = class {
                     case "tool-call": {
                       controller.enqueue(chunk);
                       stepToolCalls.push(chunk);
-                      await (onChunk == null ? void 0 : onChunk({ chunk }));
                       break;
                     }
                     case "tool-result": {
                       controller.enqueue(chunk);
                       stepToolResults.push(chunk);
-                      await (onChunk == null ? void 0 : onChunk({ chunk }));
                       break;
                     }
                     case "response-metadata": {
@@ -4618,7 +4778,6 @@ var DefaultStreamTextResult = class {
                     case "tool-call-streaming-start":
                     case "tool-call-delta": {
                       controller.enqueue(chunk);
-                      await (onChunk == null ? void 0 : onChunk({ chunk }));
                       break;
                     }
                     case "error": {
@@ -4649,7 +4808,7 @@ var DefaultStreamTextResult = class {
                     }
                   }
                   if (continueSteps && chunkBuffer.length > 0 && (nextStepType !== "continue" || // when the next step is a regular step, publish the buffer
-                  stepType === "continue" && !chunkTextPublished)) {
+                  stepType2 === "continue" && !chunkTextPublished)) {
                     await publishTextChunk({
                       controller,
                       chunk: {
@@ -4693,69 +4852,16 @@ var DefaultStreamTextResult = class {
                     usage: stepUsage,
                     experimental_providerMetadata: stepProviderMetadata,
                     logprobs: stepLogProbs,
-                    response: {
-                      ...stepResponse
-                    },
-                    isContinued: nextStepType === "continue"
-                  });
-                  if (stepType === "continue") {
-                    const lastMessage = responseMessages[responseMessages.length - 1];
-                    if (typeof lastMessage.content === "string") {
-                      lastMessage.content += stepText;
-                    } else {
-                      lastMessage.content.push({
-                        text: stepText,
-                        type: "text"
-                      });
-                    }
-                  } else {
-                    responseMessages.push(
-                      ...toResponseMessages({
-                        text: stepText,
-                        tools: tools != null ? tools : {},
-                        toolCalls: stepToolCalls,
-                        toolResults: stepToolResults
-                      })
-                    );
-                  }
-                  const currentStepResult = {
-                    stepType,
-                    text: stepText,
-                    toolCalls: stepToolCalls,
-                    toolResults: stepToolResults,
-                    finishReason: stepFinishReason,
-                    usage: stepUsage,
-                    warnings,
-                    logprobs: stepLogProbs,
                     request: stepRequest,
                     response: {
                       ...stepResponse,
-                      headers: rawResponse == null ? void 0 : rawResponse.headers,
-                      // deep clone msgs to avoid mutating past messages in multi-step:
-                      messages: JSON.parse(JSON.stringify(responseMessages))
+                      headers: rawResponse == null ? void 0 : rawResponse.headers
                     },
-                    experimental_providerMetadata: stepProviderMetadata,
+                    warnings,
                     isContinued: nextStepType === "continue"
-                  };
-                  stepResults.push(currentStepResult);
-                  await (onStepFinish == null ? void 0 : onStepFinish(currentStepResult));
-                  const combinedUsage = {
-                    promptTokens: usage.promptTokens + stepUsage.promptTokens,
-                    completionTokens: usage.completionTokens + stepUsage.completionTokens,
-                    totalTokens: usage.totalTokens + stepUsage.totalTokens
-                  };
-                  if (nextStepType !== "done") {
-                    await streamStep({
-                      currentStep: currentStep + 1,
-                      responseMessages,
-                      usage: combinedUsage,
-                      stepType: nextStepType,
-                      previousStepText: fullStepText,
-                      hasLeadingWhitespace: hasWhitespaceSuffix
-                    });
-                    return;
-                  }
-                  try {
+                  });
+                  const combinedUsage = addLanguageModelUsage(usage, stepUsage);
+                  if (nextStepType === "done") {
                     controller.enqueue({
                       type: "finish",
                       finishReason: stepFinishReason,
@@ -4763,63 +4869,40 @@ var DefaultStreamTextResult = class {
                       experimental_providerMetadata: stepProviderMetadata,
                       logprobs: stepLogProbs,
                       response: {
-                        ...stepResponse
+                        ...stepResponse,
+                        headers: rawResponse == null ? void 0 : rawResponse.headers
                       }
                     });
                     self.closeStream();
-                    rootSpan.setAttributes(
-                      selectTelemetryAttributes({
-                        telemetry,
-                        attributes: {
-                          "ai.response.finishReason": stepFinishReason,
-                          "ai.response.text": { output: () => fullStepText },
-                          "ai.response.toolCalls": {
-                            output: () => stepToolCallsJson
-                          },
-                          "ai.usage.promptTokens": combinedUsage.promptTokens,
-                          "ai.usage.completionTokens": combinedUsage.completionTokens
-                        }
-                      })
-                    );
-                    self.usagePromise.resolve(combinedUsage);
-                    self.finishReasonPromise.resolve(stepFinishReason);
-                    self.textPromise.resolve(fullStepText);
-                    self.toolCallsPromise.resolve(stepToolCalls);
-                    self.providerMetadataPromise.resolve(stepProviderMetadata);
-                    self.toolResultsPromise.resolve(stepToolResults);
-                    self.requestPromise.resolve(stepRequest);
-                    self.responsePromise.resolve({
-                      ...stepResponse,
-                      headers: rawResponse == null ? void 0 : rawResponse.headers,
-                      messages: responseMessages
-                    });
-                    self.stepsPromise.resolve(stepResults);
-                    self.warningsPromise.resolve(warnings != null ? warnings : []);
-                    await (onFinish == null ? void 0 : onFinish({
-                      finishReason: stepFinishReason,
-                      logprobs: stepLogProbs,
+                  } else {
+                    if (stepType2 === "continue") {
+                      const lastMessage = responseMessages[responseMessages.length - 1];
+                      if (typeof lastMessage.content === "string") {
+                        lastMessage.content += stepText;
+                      } else {
+                        lastMessage.content.push({
+                          text: stepText,
+                          type: "text"
+                        });
+                      }
+                    } else {
+                      responseMessages.push(
+                        ...toResponseMessages({
+                          text: stepText,
+                          tools: tools != null ? tools : {},
+                          toolCalls: stepToolCalls,
+                          toolResults: stepToolResults
+                        })
+                      );
+                    }
+                    await streamStep({
+                      currentStep: currentStep + 1,
+                      responseMessages,
                       usage: combinedUsage,
-                      text: fullStepText,
-                      toolCalls: stepToolCalls,
-                      // 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: stepToolResults,
-                      request: stepRequest,
-                      response: {
-                        ...stepResponse,
-                        headers: rawResponse == null ? void 0 : rawResponse.headers,
-                        messages: responseMessages
-                      },
-                      warnings,
-                      experimental_providerMetadata: stepProviderMetadata,
-                      steps: stepResults
-                    }));
-                  } catch (error) {
-                    controller.error(error);
-                  } finally {
-                    rootSpan.end();
+                      stepType: nextStepType,
+                      previousStepText: fullStepText,
+                      hasLeadingWhitespace: hasWhitespaceSuffix
+                    });
                   }
                 }
               })