ai 4.0.7 → 4.0.9

package/dist/index.mjs

@@ -7,7 +7,7 @@ var __export = (target, all) => {
 // streams/index.ts
 import {
   formatAssistantStreamPart as formatAssistantStreamPart2,
-  formatDataStreamPart as formatDataStreamPart3,
+  formatDataStreamPart as formatDataStreamPart6,
   parseAssistantStreamPart,
   parseDataStreamPart,
   processDataStream,
@@ -18,6 +18,172 @@ import { generateId as generateId2 } from "@ai-sdk/provider-utils";
 // core/index.ts
 import { jsonSchema } from "@ai-sdk/ui-utils";
 
+// core/data-stream/create-data-stream.ts
+import { formatDataStreamPart } from "@ai-sdk/ui-utils";
+function createDataStream({
+  execute,
+  onError = () => "An error occurred."
+  // mask error messages for safety by default
+}) {
+  let controller;
+  const ongoingStreamPromises = [];
+  const stream = new ReadableStream({
+    start(controllerArg) {
+      controller = controllerArg;
+    }
+  });
+  try {
+    const result = execute({
+      writeData(data) {
+        controller.enqueue(formatDataStreamPart("data", [data]));
+      },
+      writeMessageAnnotation(annotation) {
+        controller.enqueue(
+          formatDataStreamPart("message_annotations", [annotation])
+        );
+      },
+      merge(streamArg) {
+        ongoingStreamPromises.push(
+          (async () => {
+            const reader = streamArg.getReader();
+            while (true) {
+              const { done, value } = await reader.read();
+              if (done)
+                break;
+              controller.enqueue(value);
+            }
+          })().catch((error) => {
+            controller.enqueue(formatDataStreamPart("error", onError(error)));
+          })
+        );
+      },
+      onError
+    });
+    if (result) {
+      result.catch((error) => {
+        controller.enqueue(formatDataStreamPart("error", onError(error)));
+      });
+    }
+  } catch (error) {
+    controller.enqueue(formatDataStreamPart("error", onError(error)));
+  }
+  const waitForStreams = new Promise(async (resolve) => {
+    while (ongoingStreamPromises.length > 0) {
+      await ongoingStreamPromises.shift();
+    }
+    resolve();
+  });
+  waitForStreams.finally(() => {
+    controller.close();
+  });
+  return stream;
+}
+
+// core/util/prepare-response-headers.ts
+function prepareResponseHeaders(headers, {
+  contentType,
+  dataStreamVersion
+}) {
+  const responseHeaders = new Headers(headers != null ? headers : {});
+  if (!responseHeaders.has("Content-Type")) {
+    responseHeaders.set("Content-Type", contentType);
+  }
+  if (dataStreamVersion !== void 0) {
+    responseHeaders.set("X-Vercel-AI-Data-Stream", dataStreamVersion);
+  }
+  return responseHeaders;
+}
+
+// core/data-stream/create-data-stream-response.ts
+function createDataStreamResponse({
+  status,
+  statusText,
+  headers,
+  execute,
+  onError
+}) {
+  return new Response(
+    createDataStream({ execute, onError }).pipeThrough(new TextEncoderStream()),
+    {
+      status,
+      statusText,
+      headers: prepareResponseHeaders(headers, {
+        contentType: "text/plain; charset=utf-8",
+        dataStreamVersion: "v1"
+      })
+    }
+  );
+}
+
+// core/util/prepare-outgoing-http-headers.ts
+function prepareOutgoingHttpHeaders(headers, {
+  contentType,
+  dataStreamVersion
+}) {
+  const outgoingHeaders = {};
+  if (headers != null) {
+    for (const [key, value] of Object.entries(headers)) {
+      outgoingHeaders[key] = value;
+    }
+  }
+  if (outgoingHeaders["Content-Type"] == null) {
+    outgoingHeaders["Content-Type"] = contentType;
+  }
+  if (dataStreamVersion !== void 0) {
+    outgoingHeaders["X-Vercel-AI-Data-Stream"] = dataStreamVersion;
+  }
+  return outgoingHeaders;
+}
+
+// core/util/write-to-server-response.ts
+function writeToServerResponse({
+  response,
+  status,
+  statusText,
+  headers,
+  stream
+}) {
+  response.writeHead(status != null ? status : 200, statusText, headers);
+  const reader = stream.getReader();
+  const read = async () => {
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        response.write(value);
+      }
+    } catch (error) {
+      throw error;
+    } finally {
+      response.end();
+    }
+  };
+  read();
+}
+
+// core/data-stream/pipe-data-stream-to-response.ts
+function pipeDataStreamToResponse(response, {
+  status,
+  statusText,
+  headers,
+  execute,
+  onError
+}) {
+  writeToServerResponse({
+    response,
+    status,
+    statusText,
+    headers: prepareOutgoingHttpHeaders(headers, {
+      contentType: "text/plain; charset=utf-8",
+      dataStreamVersion: "v1"
+    }),
+    stream: createDataStream({ execute, onError }).pipeThrough(
+      new TextEncoderStream()
+    )
+  });
+}
+
 // errors/invalid-argument-error.ts
 import { AISDKError } from "@ai-sdk/provider";
 var name = "AI_InvalidArgumentError";
@@ -1512,21 +1678,6 @@ function calculateLanguageModelUsage({
   };
 }
 
-// core/util/prepare-response-headers.ts
-function prepareResponseHeaders(headers, {
-  contentType,
-  dataStreamVersion
-}) {
-  const responseHeaders = new Headers(headers != null ? headers : {});
-  if (!responseHeaders.has("Content-Type")) {
-    responseHeaders.set("Content-Type", contentType);
-  }
-  if (dataStreamVersion !== void 0) {
-    responseHeaders.set("X-Vercel-AI-Data-Stream", dataStreamVersion);
-  }
-  return responseHeaders;
-}
-
 // core/generate-object/inject-json-instruction.ts
 var DEFAULT_SCHEMA_PREFIX = "JSON schema:";
 var DEFAULT_SCHEMA_SUFFIX = "You MUST answer with a JSON object that matches the JSON schema above.";
@@ -2430,53 +2581,6 @@ function now() {
   return (_b = (_a11 = globalThis == null ? void 0 : globalThis.performance) == null ? void 0 : _a11.now()) != null ? _b : Date.now();
 }
 
-// core/util/prepare-outgoing-http-headers.ts
-function prepareOutgoingHttpHeaders(headers, {
-  contentType,
-  dataStreamVersion
-}) {
-  const outgoingHeaders = {};
-  if (headers != null) {
-    for (const [key, value] of Object.entries(headers)) {
-      outgoingHeaders[key] = value;
-    }
-  }
-  if (outgoingHeaders["Content-Type"] == null) {
-    outgoingHeaders["Content-Type"] = contentType;
-  }
-  if (dataStreamVersion !== void 0) {
-    outgoingHeaders["X-Vercel-AI-Data-Stream"] = dataStreamVersion;
-  }
-  return outgoingHeaders;
-}
-
-// core/util/write-to-server-response.ts
-function writeToServerResponse({
-  response,
-  status,
-  statusText,
-  headers,
-  stream
-}) {
-  response.writeHead(status != null ? status : 200, statusText, headers);
-  const reader = stream.getReader();
-  const read = async () => {
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done)
-          break;
-        response.write(value);
-      }
-    } catch (error) {
-      throw error;
-    } finally {
-      response.end();
-    }
-  };
-  read();
-}
-
 // core/generate-object/stream-object.ts
 var originalGenerateId2 = createIdGenerator2({ prefix: "aiobj", size: 24 });
 function streamObject({
@@ -3530,8 +3634,8 @@ async function executeTools({
   abortSignal
 }) {
   const toolResults = await Promise.all(
-    toolCalls.map(async (toolCall) => {
-      const tool2 = tools[toolCall.toolName];
+    toolCalls.map(async ({ toolCallId, toolName, args }) => {
+      const tool2 = tools[toolName];
       if ((tool2 == null ? void 0 : tool2.execute) == null) {
         return void 0;
       }
@@ -3544,16 +3648,17 @@ async function executeTools({
               operationId: "ai.toolCall",
               telemetry
             }),
-            "ai.toolCall.name": toolCall.toolName,
-            "ai.toolCall.id": toolCall.toolCallId,
+            "ai.toolCall.name": toolName,
+            "ai.toolCall.id": toolCallId,
             "ai.toolCall.args": {
-              output: () => JSON.stringify(toolCall.args)
+              output: () => JSON.stringify(args)
             }
           }
         }),
         tracer,
         fn: async (span) => {
-          const result2 = await tool2.execute(toolCall.args, {
+          const result2 = await tool2.execute(args, {
+            toolCallId,
             messages,
             abortSignal
           });
@@ -3574,9 +3679,9 @@ async function executeTools({
         }
       });
       return {
-        toolCallId: toolCall.toolCallId,
-        toolName: toolCall.toolName,
-        args: toolCall.args,
+        toolCallId,
+        toolName,
+        args,
         result
       };
     })
@@ -3604,7 +3709,7 @@ var DefaultGenerateTextResult = class {
 
 // core/generate-text/stream-text.ts
 import { createIdGenerator as createIdGenerator4 } from "@ai-sdk/provider-utils";
-import { formatDataStreamPart } from "@ai-sdk/ui-utils";
+import { formatDataStreamPart as formatDataStreamPart2 } from "@ai-sdk/ui-utils";
 
 // core/util/merge-streams.ts
 function mergeStreams(stream1, stream2) {
@@ -3799,6 +3904,7 @@ function runToolsTransformation({
                 }),
                 tracer,
                 fn: async (span) => tool2.execute(toolCall.args, {
+                  toolCallId: toolCall.toolCallId,
                   messages,
                   abortSignal
                 }).then(
@@ -4542,12 +4648,12 @@ var DefaultStreamTextResult = class {
         const chunkType = chunk.type;
         switch (chunkType) {
           case "text-delta": {
-            controller.enqueue(formatDataStreamPart("text", chunk.textDelta));
+            controller.enqueue(formatDataStreamPart2("text", chunk.textDelta));
             break;
           }
           case "tool-call-streaming-start": {
             controller.enqueue(
-              formatDataStreamPart("tool_call_streaming_start", {
+              formatDataStreamPart2("tool_call_streaming_start", {
                 toolCallId: chunk.toolCallId,
                 toolName: chunk.toolName
               })
@@ -4556,7 +4662,7 @@ var DefaultStreamTextResult = class {
           }
           case "tool-call-delta": {
             controller.enqueue(
-              formatDataStreamPart("tool_call_delta", {
+              formatDataStreamPart2("tool_call_delta", {
                 toolCallId: chunk.toolCallId,
                 argsTextDelta: chunk.argsTextDelta
               })
@@ -4565,7 +4671,7 @@ var DefaultStreamTextResult = class {
           }
           case "tool-call": {
             controller.enqueue(
-              formatDataStreamPart("tool_call", {
+              formatDataStreamPart2("tool_call", {
                 toolCallId: chunk.toolCallId,
                 toolName: chunk.toolName,
                 args: chunk.args
@@ -4575,7 +4681,7 @@ var DefaultStreamTextResult = class {
           }
           case "tool-result": {
             controller.enqueue(
-              formatDataStreamPart("tool_result", {
+              formatDataStreamPart2("tool_result", {
                 toolCallId: chunk.toolCallId,
                 result: chunk.result
               })
@@ -4584,13 +4690,13 @@ var DefaultStreamTextResult = class {
           }
           case "error": {
             controller.enqueue(
-              formatDataStreamPart("error", getErrorMessage3(chunk.error))
+              formatDataStreamPart2("error", getErrorMessage3(chunk.error))
             );
             break;
           }
           case "step-finish": {
             controller.enqueue(
-              formatDataStreamPart("finish_step", {
+              formatDataStreamPart2("finish_step", {
                 finishReason: chunk.finishReason,
                 usage: sendUsage ? {
                   promptTokens: chunk.usage.promptTokens,
@@ -4603,7 +4709,7 @@ var DefaultStreamTextResult = class {
           }
           case "finish": {
             controller.enqueue(
-              formatDataStreamPart("finish_message", {
+              formatDataStreamPart2("finish_message", {
                 finishReason: chunk.finishReason,
                 usage: sendUsage ? {
                   promptTokens: chunk.usage.promptTokens,
@@ -4620,7 +4726,7 @@ var DefaultStreamTextResult = class {
         }
       }
     });
-    return this.fullStream.pipeThrough(callbackTransformer).pipeThrough(streamPartsTransformer).pipeThrough(new TextEncoderStream());
+    return this.fullStream.pipeThrough(callbackTransformer).pipeThrough(streamPartsTransformer);
   }
   pipeDataStreamToResponse(response, {
     status,
@@ -4652,13 +4758,21 @@ var DefaultStreamTextResult = class {
       stream: this.textStream.pipeThrough(new TextEncoderStream())
     });
   }
+  // TODO breaking change 5.0: remove pipeThrough(new TextEncoderStream())
   toDataStream(options) {
     const stream = this.toDataStreamInternal({
       getErrorMessage: options == null ? void 0 : options.getErrorMessage,
       sendUsage: options == null ? void 0 : options.sendUsage
-    });
+    }).pipeThrough(new TextEncoderStream());
     return (options == null ? void 0 : options.data) ? mergeStreams(options == null ? void 0 : options.data.stream, stream) : stream;
   }
+  mergeIntoDataStream(writer) {
+    writer.merge(
+      this.toDataStreamInternal({
+        getErrorMessage: writer.onError
+      })
+    );
+  }
   toDataStreamResponse({
     headers,
     status,
@@ -5012,9 +5126,11 @@ function AssistantResponse({ threadId, messageId }, process2) {
 // streams/langchain-adapter.ts
 var langchain_adapter_exports = {};
 __export(langchain_adapter_exports, {
+  mergeIntoDataStream: () => mergeIntoDataStream,
   toDataStream: () => toDataStream,
   toDataStreamResponse: () => toDataStreamResponse
 });
+import { formatDataStreamPart as formatDataStreamPart3 } from "@ai-sdk/ui-utils";
 
 // streams/stream-callbacks.ts
 function createCallbacksTransformer(callbacks = {}) {
@@ -5045,87 +5161,8 @@ function createCallbacksTransformer(callbacks = {}) {
   });
 }
 
-// streams/stream-data.ts
-import { formatDataStreamPart as formatDataStreamPart2 } from "@ai-sdk/ui-utils";
-
-// util/constants.ts
-var HANGING_STREAM_WARNING_TIME_MS = 15 * 1e3;
-
-// streams/stream-data.ts
-var StreamData = class {
-  constructor() {
-    this.encoder = new TextEncoder();
-    this.controller = null;
-    this.isClosed = false;
-    this.warningTimeout = null;
-    const self = this;
-    this.stream = new ReadableStream({
-      start: async (controller) => {
-        self.controller = controller;
-        if (process.env.NODE_ENV === "development") {
-          self.warningTimeout = setTimeout(() => {
-            console.warn(
-              "The data stream is hanging. Did you forget to close it with `data.close()`?"
-            );
-          }, HANGING_STREAM_WARNING_TIME_MS);
-        }
-      },
-      pull: (controller) => {
-      },
-      cancel: (reason) => {
-        this.isClosed = true;
-      }
-    });
-  }
-  async close() {
-    if (this.isClosed) {
-      throw new Error("Data Stream has already been closed.");
-    }
-    if (!this.controller) {
-      throw new Error("Stream controller is not initialized.");
-    }
-    this.controller.close();
-    this.isClosed = true;
-    if (this.warningTimeout) {
-      clearTimeout(this.warningTimeout);
-    }
-  }
-  append(value) {
-    if (this.isClosed) {
-      throw new Error("Data Stream has already been closed.");
-    }
-    if (!this.controller) {
-      throw new Error("Stream controller is not initialized.");
-    }
-    this.controller.enqueue(
-      this.encoder.encode(formatDataStreamPart2("data", [value]))
-    );
-  }
-  appendMessageAnnotation(value) {
-    if (this.isClosed) {
-      throw new Error("Data Stream has already been closed.");
-    }
-    if (!this.controller) {
-      throw new Error("Stream controller is not initialized.");
-    }
-    this.controller.enqueue(
-      this.encoder.encode(formatDataStreamPart2("message_annotations", [value]))
-    );
-  }
-};
-function createStreamDataTransformer() {
-  const encoder = new TextEncoder();
-  const decoder = new TextDecoder();
-  return new TransformStream({
-    transform: async (chunk, controller) => {
-      const message = decoder.decode(chunk);
-      controller.enqueue(encoder.encode(formatDataStreamPart2("text", message)));
-    }
-  });
-}
-
 // streams/langchain-adapter.ts
-function toDataStream(stream, callbacks) {
+function toDataStreamInternal(stream, callbacks) {
   return stream.pipeThrough(
     new TransformStream({
       transform: async (value, controller) => {
@@ -5146,11 +5183,25 @@ function toDataStream(stream, callbacks) {
         forwardAIMessageChunk(value, controller);
       }
     })
-  ).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(createStreamDataTransformer());
+  ).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(new TextDecoderStream()).pipeThrough(
+    new TransformStream({
+      transform: async (chunk, controller) => {
+        controller.enqueue(formatDataStreamPart3("text", chunk));
+      }
+    })
+  );
+}
+function toDataStream(stream, callbacks) {
+  return toDataStreamInternal(stream, callbacks).pipeThrough(
+    new TextEncoderStream()
+  );
 }
 function toDataStreamResponse(stream, options) {
   var _a11;
-  const dataStream = toDataStream(stream, options == null ? void 0 : options.callbacks);
+  const dataStream = toDataStreamInternal(
+    stream,
+    options == null ? void 0 : options.callbacks
+  ).pipeThrough(new TextEncoderStream());
   const data = options == null ? void 0 : options.data;
   const init = options == null ? void 0 : options.init;
   const responseStream = data ? mergeStreams(data.stream, dataStream) : dataStream;
@@ -5163,6 +5214,9 @@ function toDataStreamResponse(stream, options) {
     })
   });
 }
+function mergeIntoDataStream(stream, options) {
+  options.dataStream.merge(toDataStreamInternal(stream, options.callbacks));
+}
 function forwardAIMessageChunk(chunk, controller) {
   if (typeof chunk.content === "string") {
     controller.enqueue(chunk.content);
@@ -5179,11 +5233,13 @@ function forwardAIMessageChunk(chunk, controller) {
 // streams/llamaindex-adapter.ts
 var llamaindex_adapter_exports = {};
 __export(llamaindex_adapter_exports, {
+  mergeIntoDataStream: () => mergeIntoDataStream2,
   toDataStream: () => toDataStream2,
   toDataStreamResponse: () => toDataStreamResponse2
 });
 import { convertAsyncIteratorToReadableStream } from "@ai-sdk/provider-utils";
-function toDataStream2(stream, callbacks) {
+import { formatDataStreamPart as formatDataStreamPart4 } from "@ai-sdk/ui-utils";
+function toDataStreamInternal2(stream, callbacks) {
   const trimStart = trimStartOfStream();
   return convertAsyncIteratorToReadableStream(stream[Symbol.asyncIterator]()).pipeThrough(
     new TransformStream({
@@ -5191,12 +5247,25 @@ function toDataStream2(stream, callbacks) {
         controller.enqueue(trimStart(message.delta));
       }
     })
-  ).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(createStreamDataTransformer());
+  ).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(new TextDecoderStream()).pipeThrough(
+    new TransformStream({
+      transform: async (chunk, controller) => {
+        controller.enqueue(formatDataStreamPart4("text", chunk));
+      }
+    })
+  );
+}
+function toDataStream2(stream, callbacks) {
+  return toDataStreamInternal2(stream, callbacks).pipeThrough(
+    new TextEncoderStream()
+  );
 }
 function toDataStreamResponse2(stream, options = {}) {
   var _a11;
   const { init, data, callbacks } = options;
-  const dataStream = toDataStream2(stream, callbacks);
+  const dataStream = toDataStreamInternal2(stream, callbacks).pipeThrough(
+    new TextEncoderStream()
+  );
   const responseStream = data ? mergeStreams(data.stream, dataStream) : dataStream;
   return new Response(responseStream, {
     status: (_a11 = init == null ? void 0 : init.status) != null ? _a11 : 200,
@@ -5207,6 +5276,9 @@ function toDataStreamResponse2(stream, options = {}) {
     })
   });
 }
+function mergeIntoDataStream2(stream, options) {
+  options.dataStream.merge(toDataStreamInternal2(stream, options.callbacks));
+}
 function trimStartOfStream() {
   let isStreamStart = true;
   return (text2) => {
@@ -5218,6 +5290,75 @@ function trimStartOfStream() {
     return text2;
   };
 }
+
+// streams/stream-data.ts
+import { formatDataStreamPart as formatDataStreamPart5 } from "@ai-sdk/ui-utils";
+
+// util/constants.ts
+var HANGING_STREAM_WARNING_TIME_MS = 15 * 1e3;
+
+// streams/stream-data.ts
+var StreamData = class {
+  constructor() {
+    this.encoder = new TextEncoder();
+    this.controller = null;
+    this.isClosed = false;
+    this.warningTimeout = null;
+    const self = this;
+    this.stream = new ReadableStream({
+      start: async (controller) => {
+        self.controller = controller;
+        if (process.env.NODE_ENV === "development") {
+          self.warningTimeout = setTimeout(() => {
+            console.warn(
+              "The data stream is hanging. Did you forget to close it with `data.close()`?"
+            );
+          }, HANGING_STREAM_WARNING_TIME_MS);
+        }
+      },
+      pull: (controller) => {
+      },
+      cancel: (reason) => {
+        this.isClosed = true;
+      }
+    });
+  }
+  async close() {
+    if (this.isClosed) {
+      throw new Error("Data Stream has already been closed.");
+    }
+    if (!this.controller) {
+      throw new Error("Stream controller is not initialized.");
+    }
+    this.controller.close();
+    this.isClosed = true;
+    if (this.warningTimeout) {
+      clearTimeout(this.warningTimeout);
+    }
+  }
+  append(value) {
+    if (this.isClosed) {
+      throw new Error("Data Stream has already been closed.");
+    }
+    if (!this.controller) {
+      throw new Error("Stream controller is not initialized.");
+    }
+    this.controller.enqueue(
+      this.encoder.encode(formatDataStreamPart5("data", [value]))
+    );
+  }
+  appendMessageAnnotation(value) {
+    if (this.isClosed) {
+      throw new Error("Data Stream has already been closed.");
+    }
+    if (!this.controller) {
+      throw new Error("Stream controller is not initialized.");
+    }
+    this.controller.enqueue(
+      this.encoder.encode(formatDataStreamPart5("message_annotations", [value]))
+    );
+  }
+};
 export {
   AISDKError10 as AISDKError,
   APICallError2 as APICallError,
@@ -5247,20 +5388,22 @@ export {
   UnsupportedFunctionalityError2 as UnsupportedFunctionalityError,
   convertToCoreMessages,
   cosineSimilarity,
-  createStreamDataTransformer,
+  createDataStream,
+  createDataStreamResponse,
   embed,
   embedMany,
   experimental_createProviderRegistry,
   experimental_customProvider,
   experimental_wrapLanguageModel,
   formatAssistantStreamPart2 as formatAssistantStreamPart,
-  formatDataStreamPart3 as formatDataStreamPart,
+  formatDataStreamPart6 as formatDataStreamPart,
   generateId2 as generateId,
   generateObject,
   generateText,
   jsonSchema,
   parseAssistantStreamPart,
   parseDataStreamPart,
+  pipeDataStreamToResponse,
   processDataStream,
   processTextStream,
   streamObject,