ai 7.0.82 → 7.0.83

package/dist/index.js

@@ -1179,7 +1179,7 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "7.0.82" : "0.0.0-test";
+var VERSION = true ? "7.0.83" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({
@@ -7533,7 +7533,8 @@ function handleUIMessageStreamFinish({
   onEnd,
   onFinish,
   onError,
-  stream
+  stream,
+  getOutcome
 }) {
   let lastMessage = originalMessages == null ? void 0 : originalMessages[originalMessages.length - 1];
   if ((lastMessage == null ? void 0 : lastMessage.role) !== "assistant") {
@@ -7542,19 +7543,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);
       }
     })
   );
@@ -7569,19 +7585,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 callOnEnd = async () => {
+    var _a24;
     if (finishCalled || !resolvedOnEnd) {
       return;
     }
     finishCalled = true;
     const isContinuation = state.message.id === (lastMessage == null ? void 0 : lastMessage.id);
+    const declaredOutcome = (_a24 = getOutcome == null ? void 0 : getOutcome()) != null ? _a24 : { status: "unknown" };
+    const outcome = hasProcessingFailure ? { status: "failed", error: processingError } : declaredOutcome.status === "unknown" && isAborted ? { status: "aborted" } : declaredOutcome;
     await resolvedOnEnd({
-      isAborted,
+      isAborted: isAborted || outcome.status === "aborted",
       isContinuation,
+      outcome,
       responseMessage: state.message,
       messages: [
         ...isContinuation ? originalMessages.slice(0, -1) : originalMessages,
@@ -7902,32 +7927,96 @@ function toUIMessageStream({
   onEnd,
   onFinish
 }) {
+  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
   }) : void 0;
-  const uiMessageChunkStream = stream.pipeThrough(
+  const sourceReader = stream.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 uiMessageChunkStream = sourceStream.pipeThrough(
     new TransformStream({
       transform: async (part, controller) => {
-        const messageMetadataValue = messageMetadata == null ? void 0 : messageMetadata({ part });
-        const uiMessageChunk = toUIMessageChunk(part, {
-          tools,
-          sendReasoning,
-          sendSources,
-          sendStart,
-          sendFinish,
-          onError,
-          messageMetadata: messageMetadataValue,
-          responseMessageId
-        });
-        if (uiMessageChunk != null) {
-          controller.enqueue(uiMessageChunk);
-        }
-        if (messageMetadataValue != null && part.type !== "start" && part.type !== "finish") {
-          controller.enqueue({
-            type: "message-metadata",
-            messageMetadata: messageMetadataValue
+        try {
+          const messageMetadataValue = messageMetadata == null ? void 0 : messageMetadata({ part });
+          const uiMessageChunk = toUIMessageChunk(part, {
+            tools,
+            sendReasoning,
+            sendSources,
+            sendStart,
+            sendFinish,
+            onError,
+            messageMetadata: messageMetadataValue,
+            responseMessageId
           });
+          if (uiMessageChunk != null) {
+            controller.enqueue(uiMessageChunk);
+          }
+          if (messageMetadataValue != null && part.type !== "start" && part.type !== "finish") {
+            controller.enqueue({
+              type: "message-metadata",
+              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 });
+          }
+        } catch (error) {
+          failOutcome(error);
+          throw error;
         }
       }
     })
@@ -7937,7 +8026,8 @@ function toUIMessageStream({
     messageId: responseMessageId != null ? responseMessageId : generateMessageId == null ? void 0 : generateMessageId(),
     originalMessages,
     onEnd: onEnd != null ? onEnd : onFinish,
-    onError
+    onError,
+    getOutcome: () => outcome
   });
 }
 
@@ -8062,8 +8152,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 }) => {
@@ -8075,6 +8169,9 @@ function createStitchableStream() {
   };
   const processPull = async () => {
     var _a24;
+    if (isCancelled) {
+      return;
+    }
     if (isClosed && innerStreams.length === 0) {
       controller == null ? void 0 : controller.close();
       return;
@@ -8087,6 +8184,9 @@ function createStitchableStream() {
     const currentStream = innerStreams[0];
     try {
       const { value, done } = await currentStream.reader.read();
+      if (isCancelled) {
+        return;
+      }
       if (done) {
         innerStreams.shift();
         if (innerStreams.length === 0 && isClosed) {
@@ -8098,6 +8198,9 @@ function createStitchableStream() {
         controller == null ? void 0 : controller.enqueue(value);
       }
     } catch (error) {
+      if (isCancelled) {
+        return;
+      }
       (_a24 = currentStream.onError) == null ? void 0 : _a24.call(currentStream, error);
       controller == null ? void 0 : controller.error(error);
       innerStreams.shift();
@@ -8111,15 +8214,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 _a24;
+      if (isCancelled) {
+        (_a24 = callbacks == null ? void 0 : callbacks.onCancel) == null ? void 0 : _a24.call(callbacks);
+        void innerStream.cancel().catch(() => {
+        });
+        return;
+      }
       if (isClosed) {
         throw new Error("Cannot add inner stream: outer stream is closed");
       }
@@ -8134,6 +8246,9 @@ function createStitchableStream() {
      * finish processing and then close the outer stream.
      */
     close: () => {
+      if (isCancelled) {
+        return;
+      }
       isClosed = true;
       waitForNewStream.resolve();
       if (innerStreams.length === 0) {
@@ -10889,6 +11004,7 @@ function createUIMessageStream({
 }) {
   let controller;
   const ongoingStreamPromises = [];
+  let outcome = { status: "unknown" };
   const stream = new ReadableStream({
     start(controllerArg) {
       controller = controllerArg;
@@ -10900,6 +11016,35 @@ function createUIMessageStream({
     } catch (e) {
     }
   }
+  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: {
@@ -10917,38 +11062,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 (resolve3) => {
+  const waitForStreams = (async () => {
     while (ongoingStreamPromises.length > 0) {
       await ongoingStreamPromises.shift();
     }
-    resolve3();
-  });
+  })();
   waitForStreams.finally(() => {
     try {
       controller.close();
@@ -10961,7 +11097,8 @@ function createUIMessageStream({
     originalMessages,
     onStepEnd: onStepEnd != null ? onStepEnd : onStepFinish,
     onEnd: onEnd != null ? onEnd : onFinish,
-    onError
+    onError,
+    getOutcome: () => outcome
   });
 }
 
@@ -11310,6 +11447,7 @@ async function convertToModelMessages(messages, options) {
 import { TypeValidationError as TypeValidationError3 } from "@ai-sdk/provider";
 import {
   lazySchema as lazySchema2,
+  safeValidateTypes as safeValidateTypes5,
   validateTypes as validateTypes4,
   zodSchema as zodSchema2
 } from "@ai-sdk/provider-utils";
@@ -11318,6 +11456,17 @@ var toolMetadataSchema2 = z.record(
   jsonValueSchema.optional()
 );
 var providerReferenceSchema2 = z.record(z.string(), z.string());
+function isEmptyObject(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0;
+}
+function asDynamicToolPart(toolPart) {
+  const { type, ...part } = toolPart;
+  return {
+    ...part,
+    type: "dynamic-tool",
+    toolName: type.slice(5)
+  };
+}
 var uiMessagesSchema = lazySchema2(
   () => zodSchema2(
     z.array(
@@ -11653,11 +11802,13 @@ var uiMessagesSchema = lazySchema2(
     ).nonempty("Messages array must not be empty")
   )
 );
-async function safeValidateUIMessages({
+async function safeValidateUIMessagesInternal({
   messages,
   metadataSchema,
   dataSchemas,
   tools
+}, {
+  convertMissingTerminalToolsToDynamic
 }) {
   try {
     if (messages == null) {
@@ -11686,7 +11837,8 @@ async function safeValidateUIMessages({
         });
       }
     }
-    if (dataSchemas || tools) {
+    const shouldValidateToolParts = tools != null || convertMissingTerminalToolsToDynamic;
+    if (dataSchemas || shouldValidateToolParts) {
       for (const [msgIdx, message] of validatedMessages.entries()) {
         for (const [partIdx, part] of message.parts.entries()) {
           if (dataSchemas && part.type.startsWith("data-")) {
@@ -11717,11 +11869,17 @@ async function safeValidateUIMessages({
               }
             });
           }
-          if (tools && part.type.startsWith("tool-")) {
+          if (shouldValidateToolParts && part.type.startsWith("tool-")) {
             const toolPart = part;
             const toolName = toolPart.type.slice(5);
-            const tool2 = getOwn(tools, toolName);
-            if (!tool2 && (toolPart.state === "output-available" || toolPart.state === "output-error" || toolPart.state === "output-denied")) {
+            const tool2 = tools == null ? void 0 : getOwn(tools, toolName);
+            const isTerminal = toolPart.state === "output-available" || toolPart.state === "output-error" || toolPart.state === "output-denied";
+            if (!tool2 && isTerminal) {
+              if (tools != null || convertMissingTerminalToolsToDynamic) {
+                message.parts[partIdx] = asDynamicToolPart(
+                  toolPart
+                );
+              }
               continue;
             }
             if (!tool2) {
@@ -11738,15 +11896,39 @@ async function safeValidateUIMessages({
                 })
               };
             }
-            if (toolPart.state === "input-available") {
-              await validateTypes4({
+            const inputValidationContext = {
+              field: `messages[${msgIdx}].parts[${partIdx}].input`,
+              entityName: toolName,
+              entityId: toolPart.toolCallId
+            };
+            let convertToDynamic = false;
+            if (toolPart.state === "output-error") {
+              if (toolPart.input !== void 0) {
+                const result = await safeValidateTypes5({
+                  value: toolPart.input,
+                  schema: tool2.inputSchema,
+                  context: inputValidationContext
+                });
+                convertToDynamic = !result.success;
+              }
+            } else if (toolPart.state === "output-available") {
+              const result = await safeValidateTypes5({
                 value: toolPart.input,
                 schema: tool2.inputSchema,
-                context: {
-                  field: `messages[${msgIdx}].parts[${partIdx}].input`,
-                  entityName: toolName,
-                  entityId: toolPart.toolCallId
+                context: inputValidationContext
+              });
+              if (!result.success) {
+                if (isEmptyObject(toolPart.input)) {
+                  convertToDynamic = true;
+                } else {
+                  throw result.error;
                 }
+              }
+            } else if (toolPart.state === "input-available" || toolPart.state === "approval-requested" || toolPart.state === "approval-responded" || toolPart.state === "output-denied") {
+              await validateTypes4({
+                value: toolPart.input,
+                schema: tool2.inputSchema,
+                context: inputValidationContext
               });
             }
             if (toolPart.state === "output-available" && tool2.outputSchema) {
@@ -11760,6 +11942,11 @@ async function safeValidateUIMessages({
                 }
               });
             }
+            if (convertToDynamic) {
+              message.parts[partIdx] = asDynamicToolPart(
+                toolPart
+              );
+            }
           }
         }
       }
@@ -11776,17 +11963,23 @@ async function safeValidateUIMessages({
     };
   }
 }
-async function validateUIMessages({
-  messages,
-  metadataSchema,
-  dataSchemas,
-  tools
-}) {
-  const response = await safeValidateUIMessages({
-    messages,
-    metadataSchema,
-    dataSchemas,
-    tools
+async function safeValidateUIMessages(options) {
+  return safeValidateUIMessagesInternal(options, {
+    convertMissingTerminalToolsToDynamic: false
+  });
+}
+async function validateUIMessages(options) {
+  const response = await safeValidateUIMessages(options);
+  if (!response.success)
+    throw response.error;
+  return response.data;
+}
+async function validateUIMessagesForAgent(options) {
+  const response = await safeValidateUIMessagesInternal(options, {
+    // Agent tool sets can include ephemeral tools (for example, tools from a
+    // disconnected MCP server), so terminal history is converted to dynamic
+    // tool parts when those tools are no longer registered.
+    convertMissingTerminalToolsToDynamic: true
   });
   if (!response.success)
     throw response.error;
@@ -11807,7 +12000,7 @@ async function createAgentUIStream({
   ...uiMessageStreamOptions
 }) {
   var _a24;
-  const validatedMessages = await validateUIMessages({
+  const validatedMessages = await validateUIMessagesForAgent({
     messages: uiMessages,
     // tools are compatible; the casting is required because the context param is
     // not available in ui messages
@@ -12851,7 +13044,7 @@ import {
 } from "@ai-sdk/provider";
 import {
   asSchema as asSchema5,
-  safeValidateTypes as safeValidateTypes5
+  safeValidateTypes as safeValidateTypes6
 } from "@ai-sdk/provider-utils";
 var noSchemaOutputStrategy = {
   type: "no-schema",
@@ -12891,7 +13084,7 @@ var objectOutputStrategy = (schema) => ({
     };
   },
   async validateFinalResult(value) {
-    return safeValidateTypes5({ value, schema });
+    return safeValidateTypes6({ value, schema });
   },
   createElementStream() {
     throw new UnsupportedFunctionalityError4({
@@ -12944,7 +13137,7 @@ var arrayOutputStrategy = (schema) => {
       const resultArray = [];
       for (let i = 0; i < inputArray.length; i++) {
         const element = inputArray[i];
-        const result = await safeValidateTypes5({ value: element, schema });
+        const result = await safeValidateTypes6({ value: element, schema });
         if (i === inputArray.length - 1 && !isFinalDelta) {
           continue;
         }
@@ -12986,7 +13179,7 @@ var arrayOutputStrategy = (schema) => {
       const inputArray = value.elements;
       const resultArray = [];
       for (const element of inputArray) {
-        const result = await safeValidateTypes5({ value: element, schema });
+        const result = await safeValidateTypes6({ value: element, schema });
         if (!result.success) {
           return result;
         }
@@ -18583,7 +18776,7 @@ var DirectChatTransport = class {
     messages,
     abortSignal
   }) {
-    const validatedMessages = await validateUIMessages({
+    const validatedMessages = await validateUIMessagesForAgent({
       messages,
       // tools are compatible; the casting is required because the context param is
       // not available in ui messages
@@ -18633,7 +18826,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"
     )
   );
 }