ai 5.0.248 → 5.0.250

package/dist/index.mjs

@@ -727,7 +727,7 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "5.0.248" : "0.0.0-test";
+var VERSION = true ? "5.0.250" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({
@@ -1744,12 +1744,13 @@ function asArray(value) {
 
 // src/util/retry-with-exponential-backoff.ts
 import { APICallError as APICallError2 } from "@ai-sdk/provider";
+import { GatewayError } from "@ai-sdk/gateway";
 import { delay, getErrorMessage as getErrorMessage3, isAbortError } from "@ai-sdk/provider-utils";
 function getRetryDelayInMs({
   error,
   exponentialBackoffDelay
 }) {
-  const headers = error.responseHeaders;
+  const headers = APICallError2.isInstance(error) ? error.responseHeaders : APICallError2.isInstance(error.cause) ? error.cause.responseHeaders : void 0;
   if (!headers)
     return exponentialBackoffDelay;
   let ms;
@@ -1810,7 +1811,7 @@ async function _retryWithExponentialBackoff(f, {
         errors: newErrors
       });
     }
-    if (error instanceof Error && APICallError2.isInstance(error) && error.isRetryable === true && tryNumber <= maxRetries) {
+    if (error instanceof Error && (APICallError2.isInstance(error) && error.isRetryable === true || GatewayError.isInstance(error) && error.isRetryable === true) && tryNumber <= maxRetries) {
       await delay(
         getRetryDelayInMs({
           error,
@@ -4072,7 +4073,8 @@ function handleUIMessageStreamFinish({
   originalMessages = [],
   onFinish,
   onError,
-  stream
+  stream,
+  getOutcome
 }) {
   let lastMessage = originalMessages == null ? void 0 : originalMessages[originalMessages.length - 1];
   if ((lastMessage == null ? void 0 : lastMessage.role) !== "assistant") {
@@ -4081,19 +4083,34 @@ function handleUIMessageStreamFinish({
     messageId = lastMessage.id;
   }
   let isAborted = false;
+  let hasProcessingFailure = false;
+  let processingError;
+  const recordProcessingFailure = (error) => {
+    hasProcessingFailure = true;
+    processingError = error;
+  };
   const idInjectedStream = stream.pipeThrough(
     new TransformStream({
       transform(chunk, controller) {
-        if (chunk.type === "start") {
-          const startChunk = chunk;
-          if (startChunk.messageId == null && messageId != null) {
-            startChunk.messageId = messageId;
+        try {
+          let outputChunk = chunk;
+          if (chunk.type === "start") {
+            const startChunk = chunk;
+            if (startChunk.messageId == null && messageId != null) {
+              outputChunk = {
+                ...startChunk,
+                messageId
+              };
+            }
           }
+          if (chunk.type === "abort") {
+            isAborted = true;
+          }
+          controller.enqueue(outputChunk);
+        } catch (error) {
+          recordProcessingFailure(error);
+          throw error;
         }
-        if (chunk.type === "abort") {
-          isAborted = true;
-        }
-        controller.enqueue(chunk);
       }
     })
   );
@@ -4106,19 +4123,28 @@ function handleUIMessageStreamFinish({
     // will be overridden by the stream
   });
   const runUpdateMessageJob = async (job) => {
-    await job({ state, write: () => {
-    } });
+    try {
+      await job({ state, write: () => {
+      } });
+    } catch (error) {
+      recordProcessingFailure(error);
+      throw error;
+    }
   };
   let finishCalled = false;
   const callOnFinish = async () => {
+    var _a16;
     if (finishCalled || !onFinish) {
       return;
     }
     finishCalled = true;
     const isContinuation = state.message.id === (lastMessage == null ? void 0 : lastMessage.id);
+    const declaredOutcome = (_a16 = getOutcome == null ? void 0 : getOutcome()) != null ? _a16 : { status: "unknown" };
+    const outcome = hasProcessingFailure ? { status: "failed", error: processingError } : declaredOutcome.status === "unknown" && isAborted ? { status: "aborted" } : declaredOutcome;
     await onFinish({
-      isAborted,
+      isAborted: isAborted || outcome.status === "aborted",
       isContinuation,
+      outcome,
       responseMessage: state.message,
       messages: [
         ...isContinuation ? originalMessages.slice(0, -1) : originalMessages,
@@ -5715,6 +5741,17 @@ var DefaultStreamTextResult = class {
     onError = () => "An error occurred."
     // prevent leaking server error details to the client by default
   } = {}) {
+    let outcome = { status: "unknown" };
+    let hasFatalFailure = false;
+    const setSourceOutcome = (newOutcome) => {
+      if (!hasFatalFailure && outcome.status !== "completed" && outcome.status !== "aborted" && newOutcome.status !== "unknown" && (outcome.status === "unknown" || newOutcome.status !== "failed")) {
+        outcome = newOutcome;
+      }
+    };
+    const failOutcome = (error) => {
+      hasFatalFailure = true;
+      outcome = { status: "failed", error };
+    };
     const responseMessageId = generateMessageId != null ? getResponseUIMessageId({
       originalMessages,
       responseMessageId: generateMessageId
@@ -5726,7 +5763,48 @@ var DefaultStreamTextResult = class {
       const dynamic = ((_b = (_a16 = this.tools) == null ? void 0 : _a16[toolName]) == null ? void 0 : _b.type) === "dynamic";
       return dynamic ? true : void 0;
     };
-    const baseStream = this.fullStream.pipeThrough(
+    const sourceReader = this.fullStream.getReader();
+    let sourceReaderReleased = false;
+    let sourceStreamCancelled = false;
+    const releaseSourceReader = () => {
+      if (!sourceReaderReleased) {
+        sourceReader.releaseLock();
+        sourceReaderReleased = true;
+      }
+    };
+    const sourceStream = new ReadableStream({
+      async pull(controller) {
+        try {
+          const { done, value } = await sourceReader.read();
+          if (done) {
+            releaseSourceReader();
+            if (!sourceStreamCancelled) {
+              controller.close();
+            }
+          } else {
+            controller.enqueue(value);
+          }
+        } catch (error) {
+          releaseSourceReader();
+          if (!sourceStreamCancelled) {
+            failOutcome(error);
+            controller.error(error);
+          }
+        }
+      },
+      async cancel(reason) {
+        sourceStreamCancelled = true;
+        if (sourceReaderReleased) {
+          return;
+        }
+        try {
+          await sourceReader.cancel(reason);
+        } finally {
+          releaseSourceReader();
+        }
+      }
+    });
+    const baseStream = sourceStream.pipeThrough(
       new TransformStream({
         transform: async (part, controller) => {
           const messageMetadataValue = messageMetadata == null ? void 0 : messageMetadata({ part });
@@ -5940,16 +6018,65 @@ var DefaultStreamTextResult = class {
               messageMetadata: messageMetadataValue
             });
           }
+          if (part.type === "finish") {
+            setSourceOutcome({ status: "completed" });
+          } else if (part.type === "abort") {
+            setSourceOutcome({ status: "aborted" });
+          } else if (part.type === "error") {
+            setSourceOutcome({ status: "failed", error: part.error });
+          }
         }
       })
     );
+    const baseStreamReader = baseStream.getReader();
+    let baseStreamReaderReleased = false;
+    let baseStreamCancelled = false;
+    const releaseBaseStreamReader = () => {
+      if (!baseStreamReaderReleased) {
+        baseStreamReader.releaseLock();
+        baseStreamReaderReleased = true;
+      }
+    };
+    const trackedBaseStream = new ReadableStream({
+      async pull(controller) {
+        try {
+          const { done, value } = await baseStreamReader.read();
+          if (done) {
+            releaseBaseStreamReader();
+            if (!baseStreamCancelled) {
+              controller.close();
+            }
+          } else {
+            controller.enqueue(value);
+          }
+        } catch (error) {
+          releaseBaseStreamReader();
+          if (!baseStreamCancelled) {
+            failOutcome(error);
+            controller.error(error);
+          }
+        }
+      },
+      async cancel(reason) {
+        baseStreamCancelled = true;
+        if (baseStreamReaderReleased) {
+          return;
+        }
+        try {
+          await baseStreamReader.cancel(reason);
+        } finally {
+          releaseBaseStreamReader();
+        }
+      }
+    });
     return createAsyncIterableStream(
       handleUIMessageStreamFinish({
-        stream: baseStream,
+        stream: trackedBaseStream,
         messageId: responseMessageId != null ? responseMessageId : generateMessageId == null ? void 0 : generateMessageId(),
         originalMessages,
         onFinish,
-        onError
+        onError,
+        getOutcome: () => outcome
       })
     );
   }
@@ -9955,10 +10082,38 @@ var TextStreamChatTransport = class extends HttpChatTransport {
 import { TypeValidationError as TypeValidationError4 } from "@ai-sdk/provider";
 import {
   lazyValidator as lazyValidator2,
+  safeValidateTypes as safeValidateTypes5,
   validateTypes as validateTypes2,
   zodSchema as zodSchema2
 } from "@ai-sdk/provider-utils";
 import { z as z8 } from "zod/v4";
+function isEmptyObject(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0;
+}
+function asDynamicToolPart(toolPart) {
+  const common = {
+    type: "dynamic-tool",
+    toolName: toolPart.type.slice(5),
+    toolCallId: toolPart.toolCallId,
+    ...toolPart.providerExecuted === void 0 ? {} : { providerExecuted: toolPart.providerExecuted },
+    ...toolPart.callProviderMetadata === void 0 ? {} : { callProviderMetadata: toolPart.callProviderMetadata }
+  };
+  if (toolPart.state === "output-available") {
+    return {
+      ...common,
+      state: "output-available",
+      input: toolPart.input,
+      output: toolPart.output,
+      ...toolPart.preliminary === void 0 ? {} : { preliminary: toolPart.preliminary }
+    };
+  }
+  return {
+    ...common,
+    state: "output-error",
+    input: toolPart.input,
+    errorText: toolPart.errorText
+  };
+}
 var uiMessagesSchema = lazyValidator2(
   () => zodSchema2(
     z8.array(
@@ -10049,7 +10204,8 @@ var uiMessagesSchema = lazyValidator2(
               toolName: z8.string(),
               toolCallId: z8.string(),
               state: z8.literal("output-error"),
-              input: z8.unknown(),
+              input: z8.unknown().optional(),
+              rawInput: z8.unknown().optional(),
               providerExecuted: z8.boolean().optional(),
               output: z8.never().optional(),
               errorText: z8.string(),
@@ -10127,7 +10283,8 @@ var uiMessagesSchema = lazyValidator2(
               toolCallId: z8.string(),
               state: z8.literal("output-error"),
               providerExecuted: z8.boolean().optional(),
-              input: z8.unknown(),
+              input: z8.unknown().optional(),
+              rawInput: z8.unknown().optional(),
               output: z8.never().optional(),
               errorText: z8.string(),
               callProviderMetadata: providerMetadataSchema.optional(),
@@ -10191,6 +10348,17 @@ async function safeValidateUIMessages({
       value: messages,
       schema: uiMessagesSchema
     });
+    for (const message of validatedMessages) {
+      for (const part of message.parts) {
+        if (part.type !== "dynamic-tool" && !part.type.startsWith("tool-")) {
+          continue;
+        }
+        const toolPart = part;
+        if (toolPart.state === "output-error" && !("input" in toolPart)) {
+          toolPart.input = void 0;
+        }
+      }
+    }
     if (metadataSchema) {
       for (const message of validatedMessages) {
         await validateTypes2({
@@ -10225,12 +10393,17 @@ async function safeValidateUIMessages({
     }
     if (tools) {
       for (const message of validatedMessages) {
-        const toolParts = message.parts.filter(
-          (part) => part.type.startsWith("tool-")
-        );
-        for (const toolPart of toolParts) {
+        for (const [partIdx, part] of message.parts.entries()) {
+          if (!part.type.startsWith("tool-")) {
+            continue;
+          }
+          const toolPart = part;
           const toolName = toolPart.type.slice(5);
           const tool2 = tools[toolName];
+          if (!tool2 && (toolPart.state === "output-available" || toolPart.state === "output-error")) {
+            message.parts[partIdx] = asDynamicToolPart(toolPart);
+            continue;
+          }
           if (!tool2) {
             return {
               success: false,
@@ -10240,7 +10413,30 @@ async function safeValidateUIMessages({
               })
             };
           }
-          if (toolPart.state === "input-available") {
+          let dynamicToolPart;
+          if (toolPart.state === "output-error") {
+            if (toolPart.input !== void 0) {
+              const result = await safeValidateTypes5({
+                value: toolPart.input,
+                schema: tool2.inputSchema
+              });
+              if (!result.success) {
+                dynamicToolPart = asDynamicToolPart(toolPart);
+              }
+            }
+          } else if (toolPart.state === "output-available") {
+            const result = await safeValidateTypes5({
+              value: toolPart.input,
+              schema: tool2.inputSchema
+            });
+            if (!result.success) {
+              if (isEmptyObject(toolPart.input)) {
+                dynamicToolPart = asDynamicToolPart(toolPart);
+              } else {
+                throw result.error;
+              }
+            }
+          } else if (toolPart.state === "input-available") {
             await validateTypes2({
               value: toolPart.input,
               schema: tool2.inputSchema
@@ -10252,6 +10448,9 @@ async function safeValidateUIMessages({
               schema: tool2.outputSchema
             });
           }
+          if (dynamicToolPart) {
+            message.parts[partIdx] = dynamicToolPart;
+          }
         }
       }
     }
@@ -10267,18 +10466,8 @@ async function safeValidateUIMessages({
     };
   }
 }
-async function validateUIMessages({
-  messages,
-  metadataSchema,
-  dataSchemas,
-  tools
-}) {
-  const response = await safeValidateUIMessages({
-    messages,
-    metadataSchema,
-    dataSchemas,
-    tools
-  });
+async function validateUIMessages(options) {
+  const response = await safeValidateUIMessages(options);
   if (!response.success)
     throw response.error;
   return response.data;
@@ -10298,6 +10487,7 @@ function createUIMessageStream({
 }) {
   let controller;
   const ongoingStreamPromises = [];
+  let outcome = { status: "unknown" };
   const stream = new ReadableStream({
     start(controllerArg) {
       controller = controllerArg;
@@ -10309,6 +10499,35 @@ function createUIMessageStream({
     } catch (error) {
     }
   }
+  function setOutcome(newOutcome) {
+    if (outcome.status === "unknown" && newOutcome.status !== "unknown") {
+      outcome = newOutcome;
+    }
+  }
+  function failOutcome(error) {
+    outcome = { status: "failed", error };
+  }
+  function safeError(error) {
+    try {
+      controller.error(error);
+    } catch (e) {
+    }
+  }
+  function handleError(error) {
+    failOutcome(error);
+    let errorText;
+    try {
+      errorText = onError(error);
+    } catch (onErrorError) {
+      failOutcome(onErrorError);
+      safeError(onErrorError);
+      return;
+    }
+    safeEnqueue({
+      type: "error",
+      errorText
+    });
+  }
   try {
     const result = execute({
       writer: {
@@ -10326,38 +10545,29 @@ function createUIMessageStream({
                 safeEnqueue(value);
               }
             })().catch((error) => {
-              safeEnqueue({
-                type: "error",
-                errorText: onError(error)
-              });
+              handleError(error);
             })
           );
         },
+        setOutcome,
         onError
       }
     });
     if (result) {
       ongoingStreamPromises.push(
         result.catch((error) => {
-          safeEnqueue({
-            type: "error",
-            errorText: onError(error)
-          });
+          handleError(error);
         })
       );
     }
   } catch (error) {
-    safeEnqueue({
-      type: "error",
-      errorText: onError(error)
-    });
+    handleError(error);
   }
-  const waitForStreams = new Promise(async (resolve2) => {
+  const waitForStreams = (async () => {
     while (ongoingStreamPromises.length > 0) {
       await ongoingStreamPromises.shift();
     }
-    resolve2();
-  });
+  })();
   waitForStreams.finally(() => {
     try {
       controller.close();
@@ -10369,7 +10579,8 @@ function createUIMessageStream({
     messageId: generateId3(),
     originalMessages,
     onFinish,
-    onError
+    onError,
+    getOutcome: () => outcome
   });
 }