ai 3.4.33 → 4.0.0-canary.1

package/dist/index.mjs

@@ -5120,19 +5120,12 @@ function createCallbacksTransformer(cb) {
       }
     },
     async flush() {
-      const isOpenAICallbacks = isOfTypeOpenAIStreamCallbacks(callbacks);
       if (callbacks.onCompletion) {
         await callbacks.onCompletion(aggregatedResponse);
       }
-      if (callbacks.onFinal && !isOpenAICallbacks) {
-        await callbacks.onFinal(aggregatedResponse);
-      }
     }
   });
 }
-function isOfTypeOpenAIStreamCallbacks(callbacks) {
-  return "experimental_onFunctionCall" in callbacks;
-}
 function trimStartOfStreamHelper() {
   let isStreamStart = true;
   return (text) => {
@@ -5192,136 +5185,9 @@ function readableFromAsyncIterable(iterable) {
   });
 }
 
-// streams/stream-data.ts
-import { formatStreamPart as formatStreamPart2 } from "@ai-sdk/ui-utils";
-
-// util/constants.ts
-var HANGING_STREAM_WARNING_TIME_MS = 15 * 1e3;
-
-// streams/stream-data.ts
-var StreamData2 = 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(formatStreamPart2("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(formatStreamPart2("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(formatStreamPart2("text", message)));
-    }
-  });
-}
-var experimental_StreamData = class extends StreamData2 {
-};
-
-// streams/anthropic-stream.ts
-function parseAnthropicStream() {
-  let previous = "";
-  return (data) => {
-    const json = JSON.parse(data);
-    if ("error" in json) {
-      throw new Error(`${json.error.type}: ${json.error.message}`);
-    }
-    if (!("completion" in json)) {
-      return;
-    }
-    const text = json.completion;
-    if (!previous || text.length > previous.length && text.startsWith(previous)) {
-      const delta = text.slice(previous.length);
-      previous = text;
-      return delta;
-    }
-    return text;
-  };
-}
-async function* streamable(stream) {
-  for await (const chunk of stream) {
-    if ("completion" in chunk) {
-      const text = chunk.completion;
-      if (text)
-        yield text;
-    } else if ("delta" in chunk) {
-      const { delta } = chunk;
-      if ("text" in delta) {
-        const text = delta.text;
-        if (text)
-          yield text;
-      }
-    }
-  }
-}
-function AnthropicStream(res, cb) {
-  if (Symbol.asyncIterator in res) {
-    return readableFromAsyncIterable(streamable(res)).pipeThrough(createCallbacksTransformer(cb)).pipeThrough(createStreamDataTransformer());
-  } else {
-    return AIStream(res, parseAnthropicStream(), cb).pipeThrough(
-      createStreamDataTransformer()
-    );
-  }
-}
-
 // streams/assistant-response.ts
 import {
-  formatStreamPart as formatStreamPart3
+  formatStreamPart as formatStreamPart2
 } from "@ai-sdk/ui-utils";
 function AssistantResponse({ threadId, messageId }, process2) {
   const stream = new ReadableStream({
@@ -5330,17 +5196,17 @@ function AssistantResponse({ threadId, messageId }, process2) {
       const textEncoder = new TextEncoder();
       const sendMessage = (message) => {
         controller.enqueue(
-          textEncoder.encode(formatStreamPart3("assistant_message", message))
+          textEncoder.encode(formatStreamPart2("assistant_message", message))
         );
       };
       const sendDataMessage = (message) => {
         controller.enqueue(
-          textEncoder.encode(formatStreamPart3("data_message", message))
+          textEncoder.encode(formatStreamPart2("data_message", message))
         );
       };
       const sendError = (errorMessage) => {
         controller.enqueue(
-          textEncoder.encode(formatStreamPart3("error", errorMessage))
+          textEncoder.encode(formatStreamPart2("error", errorMessage))
         );
       };
       const forwardStream = async (stream2) => {
@@ -5351,7 +5217,7 @@ function AssistantResponse({ threadId, messageId }, process2) {
             case "thread.message.created": {
               controller.enqueue(
                 textEncoder.encode(
-                  formatStreamPart3("assistant_message", {
+                  formatStreamPart2("assistant_message", {
                     id: value.data.id,
                     role: "assistant",
                     content: [{ type: "text", text: { value: "" } }]
@@ -5365,7 +5231,7 @@ function AssistantResponse({ threadId, messageId }, process2) {
               if ((content == null ? void 0 : content.type) === "text" && ((_b = content.text) == null ? void 0 : _b.value) != null) {
                 controller.enqueue(
                   textEncoder.encode(
-                    formatStreamPart3("text", content.text.value)
+                    formatStreamPart2("text", content.text.value)
                   )
                 );
               }
@@ -5382,7 +5248,7 @@ function AssistantResponse({ threadId, messageId }, process2) {
       };
       controller.enqueue(
         textEncoder.encode(
-          formatStreamPart3("assistant_control_data", {
+          formatStreamPart2("assistant_control_data", {
             threadId,
             messageId
           })
@@ -5416,192 +5282,96 @@ function AssistantResponse({ threadId, messageId }, process2) {
 }
 var experimental_AssistantResponse = AssistantResponse;
 
-// streams/aws-bedrock-stream.ts
-async function* asDeltaIterable(response, extractTextDeltaFromChunk) {
-  var _a11, _b;
-  const decoder = new TextDecoder();
-  for await (const chunk of (_a11 = response.body) != null ? _a11 : []) {
-    const bytes = (_b = chunk.chunk) == null ? void 0 : _b.bytes;
-    if (bytes != null) {
-      const chunkText = decoder.decode(bytes);
-      const chunkJSON = JSON.parse(chunkText);
-      const delta = extractTextDeltaFromChunk(chunkJSON);
-      if (delta != null) {
-        yield delta;
+// streams/langchain-adapter.ts
+var langchain_adapter_exports = {};
+__export(langchain_adapter_exports, {
+  toAIStream: () => toAIStream,
+  toDataStream: () => toDataStream,
+  toDataStreamResponse: () => toDataStreamResponse
+});
+
+// streams/stream-data.ts
+import { formatStreamPart as formatStreamPart3 } from "@ai-sdk/ui-utils";
+
+// util/constants.ts
+var HANGING_STREAM_WARNING_TIME_MS = 15 * 1e3;
+
+// streams/stream-data.ts
+var StreamData2 = 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;
       }
-    }
+    });
   }
-}
-function AWSBedrockAnthropicMessagesStream(response, callbacks) {
-  return AWSBedrockStream(response, callbacks, (chunk) => {
-    var _a11;
-    return (_a11 = chunk.delta) == null ? void 0 : _a11.text;
-  });
-}
-function AWSBedrockAnthropicStream(response, callbacks) {
-  return AWSBedrockStream(response, callbacks, (chunk) => chunk.completion);
-}
-function AWSBedrockCohereStream(response, callbacks) {
-  return AWSBedrockStream(response, callbacks, (chunk) => chunk == null ? void 0 : chunk.text);
-}
-function AWSBedrockLlama2Stream(response, callbacks) {
-  return AWSBedrockStream(response, callbacks, (chunk) => chunk.generation);
-}
-function AWSBedrockStream(response, callbacks, extractTextDeltaFromChunk) {
-  return readableFromAsyncIterable(
-    asDeltaIterable(response, extractTextDeltaFromChunk)
-  ).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(createStreamDataTransformer());
-}
-
-// streams/cohere-stream.ts
-var utf8Decoder = new TextDecoder("utf-8");
-async function processLines(lines, controller) {
-  for (const line of lines) {
-    const { text, is_finished } = JSON.parse(line);
-    if (!is_finished) {
-      controller.enqueue(text);
+  async close() {
+    if (this.isClosed) {
+      throw new Error("Data Stream has already been closed.");
     }
-  }
-}
-async function readAndProcessLines(reader, controller) {
-  let segment = "";
-  while (true) {
-    const { value: chunk, done } = await reader.read();
-    if (done) {
-      break;
+    if (!this.controller) {
+      throw new Error("Stream controller is not initialized.");
+    }
+    this.controller.close();
+    this.isClosed = true;
+    if (this.warningTimeout) {
+      clearTimeout(this.warningTimeout);
     }
-    segment += utf8Decoder.decode(chunk, { stream: true });
-    const linesArray = segment.split(/\r\n|\n|\r/g);
-    segment = linesArray.pop() || "";
-    await processLines(linesArray, controller);
-  }
-  if (segment) {
-    const linesArray = [segment];
-    await processLines(linesArray, controller);
   }
-  controller.close();
-}
-function createParser2(res) {
-  var _a11;
-  const reader = (_a11 = res.body) == null ? void 0 : _a11.getReader();
-  return new ReadableStream({
-    async start(controller) {
-      if (!reader) {
-        controller.close();
-        return;
-      }
-      await readAndProcessLines(reader, controller);
+  append(value) {
+    if (this.isClosed) {
+      throw new Error("Data Stream has already been closed.");
     }
-  });
-}
-async function* streamable2(stream) {
-  for await (const chunk of stream) {
-    if (chunk.eventType === "text-generation") {
-      const text = chunk.text;
-      if (text)
-        yield text;
+    if (!this.controller) {
+      throw new Error("Stream controller is not initialized.");
     }
+    this.controller.enqueue(
+      this.encoder.encode(formatStreamPart3("data", [value]))
+    );
   }
-}
-function CohereStream(reader, callbacks) {
-  if (Symbol.asyncIterator in reader) {
-    return readableFromAsyncIterable(streamable2(reader)).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(createStreamDataTransformer());
-  } else {
-    return createParser2(reader).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(createStreamDataTransformer());
-  }
-}
-
-// streams/google-generative-ai-stream.ts
-async function* streamable3(response) {
-  var _a11, _b, _c;
-  for await (const chunk of response.stream) {
-    const parts = (_c = (_b = (_a11 = chunk.candidates) == null ? void 0 : _a11[0]) == null ? void 0 : _b.content) == null ? void 0 : _c.parts;
-    if (parts === void 0) {
-      continue;
+  appendMessageAnnotation(value) {
+    if (this.isClosed) {
+      throw new Error("Data Stream has already been closed.");
     }
-    const firstPart = parts[0];
-    if (typeof firstPart.text === "string") {
-      yield firstPart.text;
+    if (!this.controller) {
+      throw new Error("Stream controller is not initialized.");
     }
+    this.controller.enqueue(
+      this.encoder.encode(formatStreamPart3("message_annotations", [value]))
+    );
   }
-}
-function GoogleGenerativeAIStream(response, cb) {
-  return readableFromAsyncIterable(streamable3(response)).pipeThrough(createCallbacksTransformer(cb)).pipeThrough(createStreamDataTransformer());
-}
-
-// streams/huggingface-stream.ts
-function createParser3(res) {
-  const trimStartOfStream = trimStartOfStreamHelper();
-  return new ReadableStream({
-    async pull(controller) {
-      var _a11, _b;
-      const { value, done } = await res.next();
-      if (done) {
-        controller.close();
-        return;
-      }
-      const text = trimStartOfStream((_b = (_a11 = value.token) == null ? void 0 : _a11.text) != null ? _b : "");
-      if (!text)
-        return;
-      if (value.generated_text != null && value.generated_text.length > 0) {
-        return;
-      }
-      if (text === "</s>" || text === "<|endoftext|>" || text === "<|end|>") {
-        return;
-      }
-      controller.enqueue(text);
+};
+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(formatStreamPart3("text", message)));
     }
   });
 }
-function HuggingFaceStream(res, callbacks) {
-  return createParser3(res).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(createStreamDataTransformer());
-}
-
-// streams/inkeep-stream.ts
-function InkeepStream(res, callbacks) {
-  if (!res.body) {
-    throw new Error("Response body is null");
-  }
-  let chat_session_id = "";
-  let records_cited;
-  const inkeepEventParser = (data, options) => {
-    var _a11, _b;
-    const { event } = options;
-    if (event === "records_cited") {
-      records_cited = JSON.parse(data);
-      (_a11 = callbacks == null ? void 0 : callbacks.onRecordsCited) == null ? void 0 : _a11.call(callbacks, records_cited);
-    }
-    if (event === "message_chunk") {
-      const inkeepMessageChunk = JSON.parse(data);
-      chat_session_id = (_b = inkeepMessageChunk.chat_session_id) != null ? _b : chat_session_id;
-      return inkeepMessageChunk.content_chunk;
-    }
-    return;
-  };
-  let { onRecordsCited, ...passThroughCallbacks } = callbacks || {};
-  passThroughCallbacks = {
-    ...passThroughCallbacks,
-    onFinal: (completion) => {
-      var _a11;
-      const inkeepOnFinalMetadata = {
-        chat_session_id,
-        records_cited
-      };
-      (_a11 = callbacks == null ? void 0 : callbacks.onFinal) == null ? void 0 : _a11.call(callbacks, completion, inkeepOnFinalMetadata);
-    }
-  };
-  return AIStream(res, inkeepEventParser, passThroughCallbacks).pipeThrough(
-    createStreamDataTransformer()
-  );
-}
+var experimental_StreamData = class extends StreamData2 {
+};
 
 // streams/langchain-adapter.ts
-var langchain_adapter_exports = {};
-__export(langchain_adapter_exports, {
-  toAIStream: () => toAIStream,
-  toDataStream: () => toDataStream,
-  toDataStreamResponse: () => toDataStreamResponse
-});
 function toAIStream(stream, callbacks) {
   return toDataStream(stream, callbacks);
 }
@@ -5698,425 +5468,6 @@ function toReadableStream(res) {
   });
 }
 
-// streams/langchain-stream.ts
-function LangChainStream(callbacks) {
-  const stream = new TransformStream();
-  const writer = stream.writable.getWriter();
-  const runs = /* @__PURE__ */ new Set();
-  const handleError = async (e, runId) => {
-    runs.delete(runId);
-    await writer.ready;
-    await writer.abort(e);
-  };
-  const handleStart = async (runId) => {
-    runs.add(runId);
-  };
-  const handleEnd = async (runId) => {
-    runs.delete(runId);
-    if (runs.size === 0) {
-      await writer.ready;
-      await writer.close();
-    }
-  };
-  return {
-    stream: stream.readable.pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(createStreamDataTransformer()),
-    writer,
-    handlers: {
-      handleLLMNewToken: async (token) => {
-        await writer.ready;
-        await writer.write(token);
-      },
-      handleLLMStart: async (_llm, _prompts, runId) => {
-        handleStart(runId);
-      },
-      handleLLMEnd: async (_output, runId) => {
-        await handleEnd(runId);
-      },
-      handleLLMError: async (e, runId) => {
-        await handleError(e, runId);
-      },
-      handleChainStart: async (_chain, _inputs, runId) => {
-        handleStart(runId);
-      },
-      handleChainEnd: async (_outputs, runId) => {
-        await handleEnd(runId);
-      },
-      handleChainError: async (e, runId) => {
-        await handleError(e, runId);
-      },
-      handleToolStart: async (_tool, _input, runId) => {
-        handleStart(runId);
-      },
-      handleToolEnd: async (_output, runId) => {
-        await handleEnd(runId);
-      },
-      handleToolError: async (e, runId) => {
-        await handleError(e, runId);
-      }
-    }
-  };
-}
-
-// streams/mistral-stream.ts
-async function* streamable4(stream) {
-  var _a11, _b;
-  for await (const chunk of stream) {
-    const content = (_b = (_a11 = chunk.choices[0]) == null ? void 0 : _a11.delta) == null ? void 0 : _b.content;
-    if (content === void 0 || content === "") {
-      continue;
-    }
-    yield content;
-  }
-}
-function MistralStream(response, callbacks) {
-  const stream = readableFromAsyncIterable(streamable4(response));
-  return stream.pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(createStreamDataTransformer());
-}
-
-// streams/openai-stream.ts
-import {
-  createChunkDecoder,
-  formatStreamPart as formatStreamPart4
-} from "@ai-sdk/ui-utils";
-function parseOpenAIStream() {
-  const extract = chunkToText();
-  return (data) => extract(JSON.parse(data));
-}
-async function* streamable5(stream) {
-  const extract = chunkToText();
-  for await (let chunk of stream) {
-    if ("promptFilterResults" in chunk) {
-      chunk = {
-        id: chunk.id,
-        created: chunk.created.getDate(),
-        object: chunk.object,
-        // not exposed by Azure API
-        model: chunk.model,
-        // not exposed by Azure API
-        choices: chunk.choices.map((choice) => {
-          var _a11, _b, _c, _d, _e, _f, _g;
-          return {
-            delta: {
-              content: (_a11 = choice.delta) == null ? void 0 : _a11.content,
-              function_call: (_b = choice.delta) == null ? void 0 : _b.functionCall,
-              role: (_c = choice.delta) == null ? void 0 : _c.role,
-              tool_calls: ((_e = (_d = choice.delta) == null ? void 0 : _d.toolCalls) == null ? void 0 : _e.length) ? (_g = (_f = choice.delta) == null ? void 0 : _f.toolCalls) == null ? void 0 : _g.map((toolCall, index) => ({
-                index,
-                id: toolCall.id,
-                function: toolCall.function,
-                type: toolCall.type
-              })) : void 0
-            },
-            finish_reason: choice.finishReason,
-            index: choice.index
-          };
-        })
-      };
-    }
-    const text = extract(chunk);
-    if (text)
-      yield text;
-  }
-}
-function chunkToText() {
-  const trimStartOfStream = trimStartOfStreamHelper();
-  let isFunctionStreamingIn;
-  return (json) => {
-    var _a11, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r;
-    if (isChatCompletionChunk(json)) {
-      const delta = (_a11 = json.choices[0]) == null ? void 0 : _a11.delta;
-      if ((_b = delta.function_call) == null ? void 0 : _b.name) {
-        isFunctionStreamingIn = true;
-        return {
-          isText: false,
-          content: `{"function_call": {"name": "${delta.function_call.name}", "arguments": "`
-        };
-      } else if ((_e = (_d = (_c = delta.tool_calls) == null ? void 0 : _c[0]) == null ? void 0 : _d.function) == null ? void 0 : _e.name) {
-        isFunctionStreamingIn = true;
-        const toolCall = delta.tool_calls[0];
-        if (toolCall.index === 0) {
-          return {
-            isText: false,
-            content: `{"tool_calls":[ {"id": "${toolCall.id}", "type": "function", "function": {"name": "${(_f = toolCall.function) == null ? void 0 : _f.name}", "arguments": "`
-          };
-        } else {
-          return {
-            isText: false,
-            content: `"}}, {"id": "${toolCall.id}", "type": "function", "function": {"name": "${(_g = toolCall.function) == null ? void 0 : _g.name}", "arguments": "`
-          };
-        }
-      } else if ((_h = delta.function_call) == null ? void 0 : _h.arguments) {
-        return {
-          isText: false,
-          content: cleanupArguments((_i = delta.function_call) == null ? void 0 : _i.arguments)
-        };
-      } else if ((_l = (_k = (_j = delta.tool_calls) == null ? void 0 : _j[0]) == null ? void 0 : _k.function) == null ? void 0 : _l.arguments) {
-        return {
-          isText: false,
-          content: cleanupArguments((_o = (_n = (_m = delta.tool_calls) == null ? void 0 : _m[0]) == null ? void 0 : _n.function) == null ? void 0 : _o.arguments)
-        };
-      } else if (isFunctionStreamingIn && (((_p = json.choices[0]) == null ? void 0 : _p.finish_reason) === "function_call" || ((_q = json.choices[0]) == null ? void 0 : _q.finish_reason) === "stop")) {
-        isFunctionStreamingIn = false;
-        return {
-          isText: false,
-          content: '"}}'
-        };
-      } else if (isFunctionStreamingIn && ((_r = json.choices[0]) == null ? void 0 : _r.finish_reason) === "tool_calls") {
-        isFunctionStreamingIn = false;
-        return {
-          isText: false,
-          content: '"}}]}'
-        };
-      }
-    }
-    const text = trimStartOfStream(
-      isChatCompletionChunk(json) && json.choices[0].delta.content ? json.choices[0].delta.content : isCompletion(json) ? json.choices[0].text : ""
-    );
-    return text;
-  };
-  function cleanupArguments(argumentChunk) {
-    let escapedPartialJson = argumentChunk.replace(/\\/g, "\\\\").replace(/\//g, "\\/").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t").replace(/\f/g, "\\f");
-    return `${escapedPartialJson}`;
-  }
-}
-var __internal__OpenAIFnMessagesSymbol = Symbol(
-  "internal_openai_fn_messages"
-);
-function isChatCompletionChunk(data) {
-  return "choices" in data && data.choices && data.choices[0] && "delta" in data.choices[0];
-}
-function isCompletion(data) {
-  return "choices" in data && data.choices && data.choices[0] && "text" in data.choices[0];
-}
-function OpenAIStream(res, callbacks) {
-  const cb = callbacks;
-  let stream;
-  if (Symbol.asyncIterator in res) {
-    stream = readableFromAsyncIterable(streamable5(res)).pipeThrough(
-      createCallbacksTransformer(
-        (cb == null ? void 0 : cb.experimental_onFunctionCall) || (cb == null ? void 0 : cb.experimental_onToolCall) ? {
-          ...cb,
-          onFinal: void 0
-        } : {
-          ...cb
-        }
-      )
-    );
-  } else {
-    stream = AIStream(
-      res,
-      parseOpenAIStream(),
-      (cb == null ? void 0 : cb.experimental_onFunctionCall) || (cb == null ? void 0 : cb.experimental_onToolCall) ? {
-        ...cb,
-        onFinal: void 0
-      } : {
-        ...cb
-      }
-    );
-  }
-  if (cb && (cb.experimental_onFunctionCall || cb.experimental_onToolCall)) {
-    const functionCallTransformer = createFunctionCallTransformer(cb);
-    return stream.pipeThrough(functionCallTransformer);
-  } else {
-    return stream.pipeThrough(createStreamDataTransformer());
-  }
-}
-function createFunctionCallTransformer(callbacks) {
-  const textEncoder = new TextEncoder();
-  let isFirstChunk = true;
-  let aggregatedResponse = "";
-  let aggregatedFinalCompletionResponse = "";
-  let isFunctionStreamingIn = false;
-  let functionCallMessages = callbacks[__internal__OpenAIFnMessagesSymbol] || [];
-  const decode = createChunkDecoder();
-  return new TransformStream({
-    async transform(chunk, controller) {
-      const message = decode(chunk);
-      aggregatedFinalCompletionResponse += message;
-      const shouldHandleAsFunction = isFirstChunk && (message.startsWith('{"function_call":') || message.startsWith('{"tool_calls":'));
-      if (shouldHandleAsFunction) {
-        isFunctionStreamingIn = true;
-        aggregatedResponse += message;
-        isFirstChunk = false;
-        return;
-      }
-      if (!isFunctionStreamingIn) {
-        controller.enqueue(
-          textEncoder.encode(formatStreamPart4("text", message))
-        );
-        return;
-      } else {
-        aggregatedResponse += message;
-      }
-    },
-    async flush(controller) {
-      try {
-        if (!isFirstChunk && isFunctionStreamingIn && (callbacks.experimental_onFunctionCall || callbacks.experimental_onToolCall)) {
-          isFunctionStreamingIn = false;
-          const payload = JSON.parse(aggregatedResponse);
-          let newFunctionCallMessages = [
-            ...functionCallMessages
-          ];
-          let functionResponse = void 0;
-          if (callbacks.experimental_onFunctionCall) {
-            if (payload.function_call === void 0) {
-              console.warn(
-                "experimental_onFunctionCall should not be defined when using tools"
-              );
-            }
-            const argumentsPayload = JSON.parse(
-              payload.function_call.arguments
-            );
-            functionResponse = await callbacks.experimental_onFunctionCall(
-              {
-                name: payload.function_call.name,
-                arguments: argumentsPayload
-              },
-              (result) => {
-                newFunctionCallMessages = [
-                  ...functionCallMessages,
-                  {
-                    role: "assistant",
-                    content: "",
-                    function_call: payload.function_call
-                  },
-                  {
-                    role: "function",
-                    name: payload.function_call.name,
-                    content: JSON.stringify(result)
-                  }
-                ];
-                return newFunctionCallMessages;
-              }
-            );
-          }
-          if (callbacks.experimental_onToolCall) {
-            const toolCalls = {
-              tools: []
-            };
-            for (const tool2 of payload.tool_calls) {
-              toolCalls.tools.push({
-                id: tool2.id,
-                type: "function",
-                func: {
-                  name: tool2.function.name,
-                  arguments: JSON.parse(tool2.function.arguments)
-                }
-              });
-            }
-            let responseIndex = 0;
-            try {
-              functionResponse = await callbacks.experimental_onToolCall(
-                toolCalls,
-                (result) => {
-                  if (result) {
-                    const { tool_call_id, function_name, tool_call_result } = result;
-                    newFunctionCallMessages = [
-                      ...newFunctionCallMessages,
-                      // Only append the assistant message if it's the first response
-                      ...responseIndex === 0 ? [
-                        {
-                          role: "assistant",
-                          content: "",
-                          tool_calls: payload.tool_calls.map(
-                            (tc) => ({
-                              id: tc.id,
-                              type: "function",
-                              function: {
-                                name: tc.function.name,
-                                // we send the arguments an object to the user, but as the API expects a string, we need to stringify it
-                                arguments: JSON.stringify(
-                                  tc.function.arguments
-                                )
-                              }
-                            })
-                          )
-                        }
-                      ] : [],
-                      // Append the function call result message
-                      {
-                        role: "tool",
-                        tool_call_id,
-                        name: function_name,
-                        content: JSON.stringify(tool_call_result)
-                      }
-                    ];
-                    responseIndex++;
-                  }
-                  return newFunctionCallMessages;
-                }
-              );
-            } catch (e) {
-              console.error("Error calling experimental_onToolCall:", e);
-            }
-          }
-          if (!functionResponse) {
-            controller.enqueue(
-              textEncoder.encode(
-                formatStreamPart4(
-                  payload.function_call ? "function_call" : "tool_calls",
-                  // parse to prevent double-encoding:
-                  JSON.parse(aggregatedResponse)
-                )
-              )
-            );
-            return;
-          } else if (typeof functionResponse === "string") {
-            controller.enqueue(
-              textEncoder.encode(formatStreamPart4("text", functionResponse))
-            );
-            aggregatedFinalCompletionResponse = functionResponse;
-            return;
-          }
-          const filteredCallbacks = {
-            ...callbacks,
-            onStart: void 0
-          };
-          callbacks.onFinal = void 0;
-          const openAIStream = OpenAIStream(functionResponse, {
-            ...filteredCallbacks,
-            [__internal__OpenAIFnMessagesSymbol]: newFunctionCallMessages
-          });
-          const reader = openAIStream.getReader();
-          while (true) {
-            const { done, value } = await reader.read();
-            if (done) {
-              break;
-            }
-            controller.enqueue(value);
-          }
-        }
-      } finally {
-        if (callbacks.onFinal && aggregatedFinalCompletionResponse) {
-          await callbacks.onFinal(aggregatedFinalCompletionResponse);
-        }
-      }
-    }
-  });
-}
-
-// streams/replicate-stream.ts
-async function ReplicateStream(res, cb, options) {
-  var _a11;
-  const url = (_a11 = res.urls) == null ? void 0 : _a11.stream;
-  if (!url) {
-    if (res.error)
-      throw new Error(res.error);
-    else
-      throw new Error("Missing stream URL in Replicate response");
-  }
-  const eventStream = await fetch(url, {
-    method: "GET",
-    headers: {
-      Accept: "text/event-stream",
-      ...options == null ? void 0 : options.headers
-    }
-  });
-  return AIStream(eventStream, void 0, cb).pipeThrough(
-    createStreamDataTransformer()
-  );
-}
-
 // streams/stream-to-response.ts
 function streamToResponse(res, response, init, data) {
   var _a11;
@@ -6161,24 +5512,13 @@ var StreamingTextResponse = class extends Response {
 
 // streams/index.ts
 var generateId2 = generateIdImpl;
-var nanoid = generateIdImpl;
 export {
   AISDKError10 as AISDKError,
   AIStream,
   APICallError2 as APICallError,
-  AWSBedrockAnthropicMessagesStream,
-  AWSBedrockAnthropicStream,
-  AWSBedrockCohereStream,
-  AWSBedrockLlama2Stream,
-  AWSBedrockStream,
-  AnthropicStream,
   AssistantResponse,
-  CohereStream,
   DownloadError,
   EmptyResponseBodyError,
-  GoogleGenerativeAIStream,
-  HuggingFaceStream,
-  InkeepStream,
   InvalidArgumentError,
   InvalidDataContentError,
   InvalidMessageRoleError,
@@ -6187,18 +5527,14 @@ export {
   InvalidToolArgumentsError,
   JSONParseError,
   langchain_adapter_exports as LangChainAdapter,
-  LangChainStream,
   llamaindex_adapter_exports as LlamaIndexAdapter,
   LoadAPIKeyError,
   MessageConversionError,
-  MistralStream,
   NoContentGeneratedError,
   NoObjectGeneratedError,
   NoSuchModelError,
   NoSuchProviderError,
   NoSuchToolError,
-  OpenAIStream,
-  ReplicateStream,
   RetryError,
   StreamData2 as StreamData,
   StreamingTextResponse,
@@ -6226,7 +5562,6 @@ export {
   generateObject,
   generateText,
   jsonSchema,
-  nanoid,
   parseStreamPart,
   processDataProtocolResponse,
   readDataStream,