ai 6.0.266 → 6.0.270

package/dist/index.mjs

@@ -1193,7 +1193,7 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "6.0.266" : "0.0.0-test";
+var VERSION = true ? "6.0.270" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({
@@ -2908,6 +2908,7 @@ async function executeToolCall({
   onToolCallStart,
   onToolCallFinish
 }) {
+  var _a22;
   const { toolName, toolCallId, input } = toolCall;
   const tool2 = tools == null ? void 0 : tools[toolName];
   if ((tool2 == null ? void 0 : tool2.execute) == null) {
@@ -2932,6 +2933,12 @@ async function executeToolCall({
           operationId: "ai.toolCall",
           telemetry
         }),
+        ...Object.fromEntries(
+          Object.entries((_a22 = telemetry == null ? void 0 : telemetry.metadata) != null ? _a22 : {}).map(([key, value]) => [
+            `ai.telemetry.metadata.${key}`,
+            value
+          ])
+        ),
         "ai.toolCall.name": toolName,
         "ai.toolCall.id": toolCallId,
         "ai.toolCall.args": {
@@ -5121,7 +5128,7 @@ async function generateText({
           ]
         });
         let resolvedOutput;
-        if (lastStep.finishReason === "stop") {
+        if (lastStep.finishReason === "stop" || lastStep.finishReason !== "tool-calls" && lastStep.text.length > 0) {
           const outputSpecification = output != null ? output : text();
           resolvedOutput = await outputSpecification.parseCompleteOutput(
             { text: lastStep.text },
@@ -6599,8 +6606,12 @@ function createStitchableStream() {
   let innerStreams = [];
   let controller = null;
   let isClosed = false;
+  let isCancelled = false;
   let waitForNewStream = createResolvablePromise();
   const terminate = () => {
+    if (isCancelled) {
+      return;
+    }
     isClosed = true;
     waitForNewStream.resolve();
     innerStreams.forEach(({ reader, onCancel }) => {
@@ -6611,7 +6622,10 @@ function createStitchableStream() {
     controller == null ? void 0 : controller.close();
   };
   const processPull = async () => {
-    var _a22, _b;
+    var _a22;
+    if (isCancelled) {
+      return;
+    }
     if (isClosed && innerStreams.length === 0) {
       controller == null ? void 0 : controller.close();
       return;
@@ -6621,8 +6635,12 @@ function createStitchableStream() {
       await waitForNewStream.promise;
       return processPull();
     }
+    const currentStream = innerStreams[0];
     try {
-      const { value, done } = await innerStreams[0].reader.read();
+      const { value, done } = await currentStream.reader.read();
+      if (isCancelled) {
+        return;
+      }
       if (done) {
         innerStreams.shift();
         if (innerStreams.length === 0 && isClosed) {
@@ -6634,7 +6652,10 @@ function createStitchableStream() {
         controller == null ? void 0 : controller.enqueue(value);
       }
     } catch (error) {
-      (_b = (_a22 = innerStreams[0]).onError) == null ? void 0 : _b.call(_a22, error);
+      if (isCancelled) {
+        return;
+      }
+      (_a22 = currentStream.onError) == null ? void 0 : _a22.call(currentStream, error);
       controller == null ? void 0 : controller.error(error);
       innerStreams.shift();
       terminate();
@@ -6647,15 +6668,24 @@ function createStitchableStream() {
       },
       pull: processPull,
       async cancel() {
+        isCancelled = true;
+        isClosed = true;
+        waitForNewStream.resolve();
         for (const { reader, onCancel } of innerStreams) {
           onCancel == null ? void 0 : onCancel();
           await reader.cancel();
         }
         innerStreams = [];
-        isClosed = true;
       }
     }),
     addStream: (innerStream, callbacks) => {
+      var _a22;
+      if (isCancelled) {
+        (_a22 = callbacks == null ? void 0 : callbacks.onCancel) == null ? void 0 : _a22.call(callbacks);
+        void innerStream.cancel().catch(() => {
+        });
+        return;
+      }
       if (isClosed) {
         throw new Error("Cannot add inner stream: outer stream is closed");
       }
@@ -6670,6 +6700,9 @@ function createStitchableStream() {
      * finish processing and then close the outer stream.
      */
     close: () => {
+      if (isCancelled) {
+        return;
+      }
       isClosed = true;
       waitForNewStream.resolve();
       if (innerStreams.length === 0) {
@@ -10060,6 +10093,12 @@ import {
   withUserAgentSuffix as withUserAgentSuffix4
 } from "@ai-sdk/provider-utils";
 
+// src/model/get-embedding-model-max-input-bytes-per-call.ts
+import { EXPERIMENTAL_EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL } from "@ai-sdk/provider-utils";
+function getEmbeddingModelMaxInputBytesPerCall(model) {
+  return model[EXPERIMENTAL_EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL];
+}
+
 // src/util/split-array.ts
 function splitArray(array2, chunkSize) {
   if (chunkSize <= 0) {
@@ -10115,11 +10154,18 @@ async function embedMany({
     tracer,
     fn: async (span) => {
       var _a22;
-      const [maxEmbeddingsPerCall, supportsParallelCalls] = await Promise.all([
+      const [
+        maxEmbeddingsPerCall,
+        maxInputBytesPerCall,
+        supportsParallelCalls
+      ] = await Promise.all([
         model.maxEmbeddingsPerCall,
+        getEmbeddingModelMaxInputBytesPerCall(model),
         model.supportsParallelCalls
       ]);
-      if (maxEmbeddingsPerCall == null || maxEmbeddingsPerCall === Infinity) {
+      const hasEmbeddingLimit = maxEmbeddingsPerCall != null && maxEmbeddingsPerCall !== Infinity;
+      const hasInputByteLimit = maxInputBytesPerCall != null && maxInputBytesPerCall !== Infinity;
+      if (!hasEmbeddingLimit && !hasInputByteLimit) {
         const { embeddings: embeddings2, usage, warnings: warnings2, response, providerMetadata: providerMetadata2 } = await retry(() => {
           return recordSpan({
             name: "ai.embedMany.doEmbed",
@@ -10196,7 +10242,11 @@ async function embedMany({
           responses: [response]
         });
       }
-      const valueChunks = splitArray(values, maxEmbeddingsPerCall);
+      const valueChunks = splitByEmbeddingLimits({
+        values,
+        maxEmbeddingsPerCall: hasEmbeddingLimit ? maxEmbeddingsPerCall : Infinity,
+        maxInputBytesPerCall: hasInputByteLimit ? maxInputBytesPerCall : Infinity
+      });
       const embeddings = [];
       const warnings = [];
       const responses = [];
@@ -10310,6 +10360,37 @@ async function embedMany({
     }
   });
 }
+var textEncoder = new TextEncoder();
+function splitByEmbeddingLimits({
+  values,
+  maxEmbeddingsPerCall,
+  maxInputBytesPerCall
+}) {
+  if (maxEmbeddingsPerCall <= 0) {
+    throw new Error("maxEmbeddingsPerCall must be greater than 0");
+  }
+  if (maxInputBytesPerCall <= 0) {
+    throw new Error("maxInputBytesPerCall must be greater than 0");
+  }
+  if (values.length === 0) {
+    return [];
+  }
+  const chunks = [];
+  let currentChunk = [];
+  let currentInputBytes = 0;
+  for (const value of values) {
+    const inputBytes = textEncoder.encode(value).length;
+    if (currentChunk.length > 0 && (currentChunk.length >= maxEmbeddingsPerCall || currentInputBytes + inputBytes > maxInputBytesPerCall)) {
+      chunks.push(currentChunk);
+      currentChunk = [];
+      currentInputBytes = 0;
+    }
+    currentChunk.push(value);
+    currentInputBytes += inputBytes;
+  }
+  chunks.push(currentChunk);
+  return chunks;
+}
 var DefaultEmbedManyResult = class {
   constructor(options) {
     this.values = options.values;
@@ -13007,6 +13088,7 @@ var doWrap = ({
 };
 
 // src/middleware/wrap-embedding-model.ts
+import { EXPERIMENTAL_EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL as EXPERIMENTAL_EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL2 } from "@ai-sdk/provider-utils";
 var wrapEmbeddingModel = ({
   model,
   middleware: middlewareArg,
@@ -13041,6 +13123,7 @@ var doWrap2 = ({
     provider: (_a22 = providerId != null ? providerId : overrideProvider == null ? void 0 : overrideProvider({ model })) != null ? _a22 : model.provider,
     modelId: (_b = modelId != null ? modelId : overrideModelId == null ? void 0 : overrideModelId({ model })) != null ? _b : model.modelId,
     maxEmbeddingsPerCall: (_c = overrideMaxEmbeddingsPerCall == null ? void 0 : overrideMaxEmbeddingsPerCall({ model })) != null ? _c : model.maxEmbeddingsPerCall,
+    [EXPERIMENTAL_EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL2]: getEmbeddingModelMaxInputBytesPerCall(model),
     supportsParallelCalls: (_d = overrideSupportsParallelCalls == null ? void 0 : overrideSupportsParallelCalls({ model })) != null ? _d : model.supportsParallelCalls,
     async doEmbed(params) {
       const transformedParams = await doTransform({ params });
@@ -14430,7 +14513,7 @@ function lastAssistantMessageIsCompleteWithApprovalResponses({
     // has at least one tool approval response
     lastStepToolInvocations.filter((part) => part.state === "approval-responded").length > 0 && // all tool approvals must have a response
     lastStepToolInvocations.every(
-      (part) => part.state === "output-available" || part.state === "output-error" || part.state === "approval-responded"
+      (part) => part.state === "output-available" || part.state === "output-error" || part.state === "output-denied" || part.state === "approval-responded"
     )
   );
 }