ai 2.2.29 → 2.2.30

package/dist/index.js

@@ -28,6 +28,7 @@ __export(streams_exports, {
   AnthropicStream: () => AnthropicStream,
   COMPLEX_HEADER: () => COMPLEX_HEADER,
   CohereStream: () => CohereStream,
+  GoogleGenerativeAIStream: () => GoogleGenerativeAIStream,
   HuggingFaceStream: () => HuggingFaceStream,
   LangChainStream: () => LangChainStream,
   OpenAIStream: () => OpenAIStream,
@@ -48,121 +49,8 @@ __export(streams_exports, {
 });
 module.exports = __toCommonJS(streams_exports);
 
-// streams/ai-stream.ts
-var import_eventsource_parser = require("eventsource-parser");
-function createEventStreamTransformer(customParser) {
-  const textDecoder = new TextDecoder();
-  let eventSourceParser;
-  return new TransformStream({
-    async start(controller) {
-      eventSourceParser = (0, import_eventsource_parser.createParser)(
-        (event) => {
-          if ("data" in event && event.type === "event" && event.data === "[DONE]" || // Replicate doesn't send [DONE] but does send a 'done' event
-          // @see https://replicate.com/docs/streaming
-          event.event === "done") {
-            controller.terminate();
-            return;
-          }
-          if ("data" in event) {
-            const parsedMessage = customParser ? customParser(event.data) : event.data;
-            if (parsedMessage)
-              controller.enqueue(parsedMessage);
-          }
-        }
-      );
-    },
-    transform(chunk) {
-      eventSourceParser.feed(textDecoder.decode(chunk));
-    }
-  });
-}
-function createCallbacksTransformer(cb) {
-  const textEncoder = new TextEncoder();
-  let aggregatedResponse = "";
-  const callbacks = cb || {};
-  return new TransformStream({
-    async start() {
-      if (callbacks.onStart)
-        await callbacks.onStart();
-    },
-    async transform(message, controller) {
-      controller.enqueue(textEncoder.encode(message));
-      aggregatedResponse += message;
-      if (callbacks.onToken)
-        await callbacks.onToken(message);
-    },
-    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) => {
-    if (isStreamStart) {
-      text = text.trimStart();
-      if (text)
-        isStreamStart = false;
-    }
-    return text;
-  };
-}
-function AIStream(response, customParser, callbacks) {
-  if (!response.ok) {
-    if (response.body) {
-      const reader = response.body.getReader();
-      return new ReadableStream({
-        async start(controller) {
-          const { done, value } = await reader.read();
-          if (!done) {
-            const errorText = new TextDecoder().decode(value);
-            controller.error(new Error(`Response error: ${errorText}`));
-          }
-        }
-      });
-    } else {
-      return new ReadableStream({
-        start(controller) {
-          controller.error(new Error("Response error: No response body"));
-        }
-      });
-    }
-  }
-  const responseBodyStream = response.body || createEmptyReadableStream();
-  return responseBodyStream.pipeThrough(createEventStreamTransformer(customParser)).pipeThrough(createCallbacksTransformer(callbacks));
-}
-function createEmptyReadableStream() {
-  return new ReadableStream({
-    start(controller) {
-      controller.close();
-    }
-  });
-}
-function readableFromAsyncIterable(iterable) {
-  let it = iterable[Symbol.asyncIterator]();
-  return new ReadableStream({
-    async pull(controller) {
-      const { done, value } = await it.next();
-      if (done)
-        controller.close();
-      else
-        controller.enqueue(value);
-    },
-    async cancel(reason) {
-      var _a;
-      await ((_a = it.return) == null ? void 0 : _a.call(it, reason));
-    }
-  });
-}
+// shared/utils.ts
+var import_non_secure = require("nanoid/non-secure");
 
 // shared/stream-parts.ts
 var textStreamPart = {
@@ -260,6 +148,23 @@ var dataMessageStreamPart = {
     };
   }
 };
+var toolCallStreamPart = {
+  code: "7",
+  name: "tool_calls",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("tool_calls" in value) || typeof value.tool_calls !== "object" || value.tool_calls == null || !Array.isArray(value.tool_calls) || value.tool_calls.some((tc) => {
+      tc == null || typeof tc !== "object" || !("id" in tc) || typeof tc.id !== "string" || !("type" in tc) || typeof tc.type !== "string" || !("function" in tc) || tc.function == null || typeof tc.function !== "object" || !("arguments" in tc.function) || typeof tc.function.name !== "string" || typeof tc.function.arguments !== "string";
+    })) {
+      throw new Error(
+        '"tool_calls" parts expect an object with a ToolCallPayload.'
+      );
+    }
+    return {
+      type: "tool_calls",
+      value
+    };
+  }
+};
 var streamParts = [
   textStreamPart,
   functionCallStreamPart,
@@ -267,7 +172,8 @@ var streamParts = [
   errorStreamPart,
   assistantMessageStreamPart,
   assistantControlDataStreamPart,
-  dataMessageStreamPart
+  dataMessageStreamPart,
+  toolCallStreamPart
 ];
 var streamPartsByCode = {
   [textStreamPart.code]: textStreamPart,
@@ -276,7 +182,8 @@ var streamPartsByCode = {
   [errorStreamPart.code]: errorStreamPart,
   [assistantMessageStreamPart.code]: assistantMessageStreamPart,
   [assistantControlDataStreamPart.code]: assistantControlDataStreamPart,
-  [dataMessageStreamPart.code]: dataMessageStreamPart
+  [dataMessageStreamPart.code]: dataMessageStreamPart,
+  [toolCallStreamPart.code]: toolCallStreamPart
 };
 var StreamStringPrefixes = {
   [textStreamPart.name]: textStreamPart.code,
@@ -285,7 +192,8 @@ var StreamStringPrefixes = {
   [errorStreamPart.name]: errorStreamPart.code,
   [assistantMessageStreamPart.name]: assistantMessageStreamPart.code,
   [assistantControlDataStreamPart.name]: assistantControlDataStreamPart.code,
-  [dataMessageStreamPart.name]: dataMessageStreamPart.code
+  [dataMessageStreamPart.name]: dataMessageStreamPart.code,
+  [toolCallStreamPart.name]: toolCallStreamPart.code
 };
 var validCodes = streamParts.map((part) => part.code);
 var parseStreamPart = (line) => {
@@ -311,135 +219,7 @@ function formatStreamPart(type, value) {
 `;
 }
 
-// streams/stream-data.ts
-var experimental_StreamData = class {
-  constructor() {
-    this.encoder = new TextEncoder();
-    this.controller = null;
-    // closing the stream is synchronous, but we want to return a promise
-    // in case we're doing async work
-    this.isClosedPromise = null;
-    this.isClosedPromiseResolver = void 0;
-    this.isClosed = false;
-    // array to store appended data
-    this.data = [];
-    this.isClosedPromise = new Promise((resolve) => {
-      this.isClosedPromiseResolver = resolve;
-    });
-    const self = this;
-    this.stream = new TransformStream({
-      start: async (controller) => {
-        self.controller = controller;
-      },
-      transform: async (chunk, controller) => {
-        if (self.data.length > 0) {
-          const encodedData = self.encoder.encode(
-            formatStreamPart("data", self.data)
-          );
-          self.data = [];
-          controller.enqueue(encodedData);
-        }
-        controller.enqueue(chunk);
-      },
-      async flush(controller) {
-        const warningTimeout = process.env.NODE_ENV === "development" ? setTimeout(() => {
-          console.warn(
-            "The data stream is hanging. Did you forget to close it with `data.close()`?"
-          );
-        }, 3e3) : null;
-        await self.isClosedPromise;
-        if (warningTimeout !== null) {
-          clearTimeout(warningTimeout);
-        }
-        if (self.data.length) {
-          const encodedData = self.encoder.encode(
-            formatStreamPart("data", self.data)
-          );
-          controller.enqueue(encodedData);
-        }
-      }
-    });
-  }
-  async close() {
-    var _a;
-    if (this.isClosed) {
-      throw new Error("Data Stream has already been closed.");
-    }
-    if (!this.controller) {
-      throw new Error("Stream controller is not initialized.");
-    }
-    (_a = this.isClosedPromiseResolver) == null ? void 0 : _a.call(this);
-    this.isClosed = true;
-  }
-  append(value) {
-    if (this.isClosed) {
-      throw new Error("Data Stream has already been closed.");
-    }
-    this.data.push(value);
-  }
-};
-function createStreamDataTransformer(experimental_streamData) {
-  if (!experimental_streamData) {
-    return new TransformStream({
-      transform: async (chunk, controller) => {
-        controller.enqueue(chunk);
-      }
-    });
-  }
-  const encoder = new TextEncoder();
-  const decoder = new TextDecoder();
-  return new TransformStream({
-    transform: async (chunk, controller) => {
-      const message = decoder.decode(chunk);
-      controller.enqueue(encoder.encode(formatStreamPart("text", message)));
-    }
-  });
-}
-
-// streams/aws-bedrock-stream.ts
-async function* asDeltaIterable(response, extractTextDeltaFromChunk) {
-  var _a, _b;
-  const decoder = new TextDecoder();
-  for await (const chunk of (_a = response.body) != null ? _a : []) {
-    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;
-      }
-    }
-  }
-}
-function AWSBedrockAnthropicStream(response, callbacks) {
-  return AWSBedrockStream(response, callbacks, (chunk) => chunk.completion);
-}
-function AWSBedrockCohereStream(response, callbacks) {
-  return AWSBedrockStream(
-    response,
-    callbacks,
-    // As of 2023-11-17, Bedrock does not support streaming for Cohere,
-    // so we take the full generation:
-    (chunk) => {
-      var _a, _b;
-      return (_b = (_a = chunk.generations) == null ? void 0 : _a[0]) == null ? void 0 : _b.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(callbacks == null ? void 0 : callbacks.experimental_streamData)
-  );
-}
-
 // shared/utils.ts
-var import_non_secure = require("nanoid/non-secure");
 var nanoid = (0, import_non_secure.customAlphabet)(
   "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
   7
@@ -461,255 +241,346 @@ function createChunkDecoder(complex) {
 var isStreamStringEqualToType = (type, value) => value.startsWith(`${StreamStringPrefixes[type]}:`) && value.endsWith("\n");
 var COMPLEX_HEADER = "X-Experimental-Stream-Data";
 
-// streams/openai-stream.ts
-function parseOpenAIStream() {
-  const extract = chunkToText();
-  return (data) => {
-    return extract(JSON.parse(data));
-  };
+// streams/ai-stream.ts
+var import_eventsource_parser = require("eventsource-parser");
+function createEventStreamTransformer(customParser) {
+  const textDecoder = new TextDecoder();
+  let eventSourceParser;
+  return new TransformStream({
+    async start(controller) {
+      eventSourceParser = (0, import_eventsource_parser.createParser)(
+        (event) => {
+          if ("data" in event && event.type === "event" && event.data === "[DONE]" || // Replicate doesn't send [DONE] but does send a 'done' event
+          // @see https://replicate.com/docs/streaming
+          event.event === "done") {
+            controller.terminate();
+            return;
+          }
+          if ("data" in event) {
+            const parsedMessage = customParser ? customParser(event.data) : event.data;
+            if (parsedMessage)
+              controller.enqueue(parsedMessage);
+          }
+        }
+      );
+    },
+    transform(chunk) {
+      eventSourceParser.feed(textDecoder.decode(chunk));
+    }
+  });
 }
-async function* streamable(stream) {
-  const extract = chunkToText();
-  for await (const chunk of stream) {
-    const text = extract(chunk);
-    if (text)
-      yield text;
-  }
+function createCallbacksTransformer(cb) {
+  const textEncoder = new TextEncoder();
+  let aggregatedResponse = "";
+  const callbacks = cb || {};
+  return new TransformStream({
+    async start() {
+      if (callbacks.onStart)
+        await callbacks.onStart();
+    },
+    async transform(message, controller) {
+      controller.enqueue(textEncoder.encode(message));
+      aggregatedResponse += message;
+      if (callbacks.onToken)
+        await callbacks.onToken(message);
+    },
+    async flush() {
+      const isOpenAICallbacks = isOfTypeOpenAIStreamCallbacks(callbacks);
+      if (callbacks.onCompletion) {
+        await callbacks.onCompletion(aggregatedResponse);
+      }
+      if (callbacks.onFinal && !isOpenAICallbacks) {
+        await callbacks.onFinal(aggregatedResponse);
+      }
+    }
+  });
 }
-function chunkToText() {
-  const trimStartOfStream = trimStartOfStreamHelper();
-  let isFunctionStreamingIn;
-  return (json) => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
-    if (isChatCompletionChunk(json) && ((_c = (_b = (_a = json.choices[0]) == null ? void 0 : _a.delta) == null ? void 0 : _b.function_call) == null ? void 0 : _c.name)) {
-      isFunctionStreamingIn = true;
-      return `{"function_call": {"name": "${(_e = (_d = json.choices[0]) == null ? void 0 : _d.delta) == null ? void 0 : _e.function_call.name}", "arguments": "`;
-    } else if (isChatCompletionChunk(json) && ((_h = (_g = (_f = json.choices[0]) == null ? void 0 : _f.delta) == null ? void 0 : _g.function_call) == null ? void 0 : _h.arguments)) {
-      const argumentChunk = json.choices[0].delta.function_call.arguments;
-      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}`;
-    } else if (isFunctionStreamingIn && (((_i = json.choices[0]) == null ? void 0 : _i.finish_reason) === "function_call" || ((_j = json.choices[0]) == null ? void 0 : _j.finish_reason) === "stop")) {
-      isFunctionStreamingIn = false;
-      return '"}}';
+function isOfTypeOpenAIStreamCallbacks(callbacks) {
+  return "experimental_onFunctionCall" in callbacks;
+}
+function trimStartOfStreamHelper() {
+  let isStreamStart = true;
+  return (text) => {
+    if (isStreamStart) {
+      text = text.trimStart();
+      if (text)
+        isStreamStart = false;
     }
-    const text = trimStartOfStream(
-      isChatCompletionChunk(json) && json.choices[0].delta.content ? json.choices[0].delta.content : isCompletion(json) ? json.choices[0].text : ""
-    );
     return text;
   };
 }
-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 AIStream(response, customParser, callbacks) {
+  if (!response.ok) {
+    if (response.body) {
+      const reader = response.body.getReader();
+      return new ReadableStream({
+        async start(controller) {
+          const { done, value } = await reader.read();
+          if (!done) {
+            const errorText = new TextDecoder().decode(value);
+            controller.error(new Error(`Response error: ${errorText}`));
+          }
+        }
+      });
+    } else {
+      return new ReadableStream({
+        start(controller) {
+          controller.error(new Error("Response error: No response body"));
+        }
+      });
+    }
+  }
+  const responseBodyStream = response.body || createEmptyReadableStream();
+  return responseBodyStream.pipeThrough(createEventStreamTransformer(customParser)).pipeThrough(createCallbacksTransformer(callbacks));
 }
-function isCompletion(data) {
-  return "choices" in data && data.choices && data.choices[0] && "text" in data.choices[0];
+function createEmptyReadableStream() {
+  return new ReadableStream({
+    start(controller) {
+      controller.close();
+    }
+  });
 }
-function OpenAIStream(res, callbacks) {
-  const cb = callbacks;
-  let stream;
-  if (Symbol.asyncIterator in res) {
-    stream = readableFromAsyncIterable(streamable(res)).pipeThrough(
-      createCallbacksTransformer(
-        (cb == null ? void 0 : cb.experimental_onFunctionCall) ? {
-          ...cb,
-          onFinal: void 0
-        } : {
-          ...cb
+function readableFromAsyncIterable(iterable) {
+  let it = iterable[Symbol.asyncIterator]();
+  return new ReadableStream({
+    async pull(controller) {
+      const { done, value } = await it.next();
+      if (done)
+        controller.close();
+      else
+        controller.enqueue(value);
+    },
+    async cancel(reason) {
+      var _a;
+      await ((_a = it.return) == null ? void 0 : _a.call(it, reason));
+    }
+  });
+}
+
+// streams/stream-data.ts
+var experimental_StreamData = class {
+  constructor() {
+    this.encoder = new TextEncoder();
+    this.controller = null;
+    // closing the stream is synchronous, but we want to return a promise
+    // in case we're doing async work
+    this.isClosedPromise = null;
+    this.isClosedPromiseResolver = void 0;
+    this.isClosed = false;
+    // array to store appended data
+    this.data = [];
+    this.isClosedPromise = new Promise((resolve) => {
+      this.isClosedPromiseResolver = resolve;
+    });
+    const self = this;
+    this.stream = new TransformStream({
+      start: async (controller) => {
+        self.controller = controller;
+      },
+      transform: async (chunk, controller) => {
+        if (self.data.length > 0) {
+          const encodedData = self.encoder.encode(
+            formatStreamPart("data", self.data)
+          );
+          self.data = [];
+          controller.enqueue(encodedData);
+        }
+        controller.enqueue(chunk);
+      },
+      async flush(controller) {
+        const warningTimeout = process.env.NODE_ENV === "development" ? setTimeout(() => {
+          console.warn(
+            "The data stream is hanging. Did you forget to close it with `data.close()`?"
+          );
+        }, 3e3) : null;
+        await self.isClosedPromise;
+        if (warningTimeout !== null) {
+          clearTimeout(warningTimeout);
+        }
+        if (self.data.length) {
+          const encodedData = self.encoder.encode(
+            formatStreamPart("data", self.data)
+          );
+          controller.enqueue(encodedData);
         }
-      )
-    );
-  } else {
-    stream = AIStream(
-      res,
-      parseOpenAIStream(),
-      (cb == null ? void 0 : cb.experimental_onFunctionCall) ? {
-        ...cb,
-        onFinal: void 0
-      } : {
-        ...cb
       }
-    );
+    });
   }
-  if (cb && cb.experimental_onFunctionCall) {
-    const functionCallTransformer = createFunctionCallTransformer(cb);
-    return stream.pipeThrough(functionCallTransformer);
+  async close() {
+    var _a;
+    if (this.isClosed) {
+      throw new Error("Data Stream has already been closed.");
+    }
+    if (!this.controller) {
+      throw new Error("Stream controller is not initialized.");
+    }
+    (_a = this.isClosedPromiseResolver) == null ? void 0 : _a.call(this);
+    this.isClosed = true;
+  }
+  append(value) {
+    if (this.isClosed) {
+      throw new Error("Data Stream has already been closed.");
+    }
+    this.data.push(value);
+  }
+};
+function createStreamDataTransformer(experimental_streamData) {
+  if (!experimental_streamData) {
+    return new TransformStream({
+      transform: async (chunk, controller) => {
+        controller.enqueue(chunk);
+      }
+    });
+  }
+  const encoder = new TextEncoder();
+  const decoder = new TextDecoder();
+  return new TransformStream({
+    transform: async (chunk, controller) => {
+      const message = decoder.decode(chunk);
+      controller.enqueue(encoder.encode(formatStreamPart("text", message)));
+    }
+  });
+}
+
+// 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(cb == null ? void 0 : cb.experimental_streamData));
   } else {
-    return stream.pipeThrough(
+    return AIStream(res, parseAnthropicStream(), cb).pipeThrough(
       createStreamDataTransformer(cb == null ? void 0 : cb.experimental_streamData)
     );
   }
 }
-function createFunctionCallTransformer(callbacks) {
-  const textEncoder = new TextEncoder();
-  let isFirstChunk = true;
-  let aggregatedResponse = "";
-  let aggregatedFinalCompletionResponse = "";
-  let isFunctionStreamingIn = false;
-  let functionCallMessages = callbacks[__internal__OpenAIFnMessagesSymbol] || [];
-  const isComplexMode = callbacks == null ? void 0 : callbacks.experimental_streamData;
-  const decode = createChunkDecoder();
-  return new TransformStream({
-    async transform(chunk, controller) {
-      const message = decode(chunk);
-      aggregatedFinalCompletionResponse += message;
-      const shouldHandleAsFunction = isFirstChunk && message.startsWith('{"function_call":');
-      if (shouldHandleAsFunction) {
-        isFunctionStreamingIn = true;
-        aggregatedResponse += message;
-        isFirstChunk = false;
-        return;
-      }
-      if (!isFunctionStreamingIn) {
+
+// streams/assistant-response.ts
+function experimental_AssistantResponse({ threadId, messageId }, process2) {
+  const stream = new ReadableStream({
+    async start(controller) {
+      var _a;
+      const textEncoder = new TextEncoder();
+      const sendMessage = (message) => {
         controller.enqueue(
-          isComplexMode ? textEncoder.encode(formatStreamPart("text", message)) : chunk
+          textEncoder.encode(formatStreamPart("assistant_message", message))
         );
-        return;
-      } else {
-        aggregatedResponse += message;
-      }
-    },
-    async flush(controller) {
+      };
+      const sendDataMessage = (message) => {
+        controller.enqueue(
+          textEncoder.encode(formatStreamPart("data_message", message))
+        );
+      };
+      const sendError = (errorMessage) => {
+        controller.enqueue(
+          textEncoder.encode(formatStreamPart("error", errorMessage))
+        );
+      };
+      controller.enqueue(
+        textEncoder.encode(
+          formatStreamPart("assistant_control_data", {
+            threadId,
+            messageId
+          })
+        )
+      );
       try {
-        const isEndOfFunction = !isFirstChunk && callbacks.experimental_onFunctionCall && isFunctionStreamingIn;
-        if (isEndOfFunction && callbacks.experimental_onFunctionCall) {
-          isFunctionStreamingIn = false;
-          const payload = JSON.parse(aggregatedResponse);
-          const argumentsPayload = JSON.parse(payload.function_call.arguments);
-          let newFunctionCallMessages = [
-            ...functionCallMessages
-          ];
-          const 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 (!functionResponse) {
-            controller.enqueue(
-              textEncoder.encode(
-                isComplexMode ? formatStreamPart(
-                  "function_call",
-                  // parse to prevent double-encoding:
-                  JSON.parse(aggregatedResponse)
-                ) : aggregatedResponse
-              )
-            );
-            return;
-          } else if (typeof functionResponse === "string") {
-            controller.enqueue(
-              isComplexMode ? textEncoder.encode(formatStreamPart("text", functionResponse)) : textEncoder.encode(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);
-          }
-        }
+        await process2({
+          threadId,
+          messageId,
+          sendMessage,
+          sendDataMessage
+        });
+      } catch (error) {
+        sendError((_a = error.message) != null ? _a : `${error}`);
       } finally {
-        if (callbacks.onFinal && aggregatedFinalCompletionResponse) {
-          await callbacks.onFinal(aggregatedFinalCompletionResponse);
-        }
+        controller.close();
       }
+    },
+    pull(controller) {
+    },
+    cancel() {
     }
   });
-}
-
-// streams/streaming-text-response.ts
-var StreamingTextResponse = class extends Response {
-  constructor(res, init, data) {
-    let processedStream = res;
-    if (data) {
-      processedStream = res.pipeThrough(data.stream);
+  return new Response(stream, {
+    status: 200,
+    headers: {
+      "Content-Type": "text/plain; charset=utf-8"
     }
-    super(processedStream, {
-      ...init,
-      status: 200,
-      headers: {
-        "Content-Type": "text/plain; charset=utf-8",
-        [COMPLEX_HEADER]: data ? "true" : "false",
-        ...init == null ? void 0 : init.headers
-      }
-    });
-  }
-};
-function streamToResponse(res, response, init) {
-  response.writeHead((init == null ? void 0 : init.status) || 200, {
-    "Content-Type": "text/plain; charset=utf-8",
-    ...init == null ? void 0 : init.headers
   });
-  const reader = res.getReader();
-  function read() {
-    reader.read().then(({ done, value }) => {
-      if (done) {
-        response.end();
-        return;
+}
+
+// streams/aws-bedrock-stream.ts
+async function* asDeltaIterable(response, extractTextDeltaFromChunk) {
+  var _a, _b;
+  const decoder = new TextDecoder();
+  for await (const chunk of (_a = response.body) != null ? _a : []) {
+    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;
       }
-      response.write(value);
-      read();
-    });
+    }
   }
-  read();
 }
-
-// streams/huggingface-stream.ts
-function createParser2(res) {
-  const trimStartOfStream = trimStartOfStreamHelper();
-  return new ReadableStream({
-    async pull(controller) {
+function AWSBedrockAnthropicStream(response, callbacks) {
+  return AWSBedrockStream(response, callbacks, (chunk) => chunk.completion);
+}
+function AWSBedrockCohereStream(response, callbacks) {
+  return AWSBedrockStream(
+    response,
+    callbacks,
+    // As of 2023-11-17, Bedrock does not support streaming for Cohere,
+    // so we take the full generation:
+    (chunk) => {
       var _a, _b;
-      const { value, done } = await res.next();
-      if (done) {
-        controller.close();
-        return;
-      }
-      const text = trimStartOfStream((_b = (_a = value.token) == null ? void 0 : _a.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);
+      return (_b = (_a = chunk.generations) == null ? void 0 : _a[0]) == null ? void 0 : _b.text;
     }
-  });
+  );
 }
-function HuggingFaceStream(res, callbacks) {
-  return createParser2(res).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(
+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(callbacks == null ? void 0 : callbacks.experimental_streamData)
   );
 }
@@ -742,7 +613,7 @@ async function readAndProcessLines(reader, controller) {
   }
   controller.close();
 }
-function createParser3(res) {
+function createParser2(res) {
   var _a;
   const reader = (_a = res.body) == null ? void 0 : _a.getReader();
   return new ReadableStream({
@@ -756,46 +627,57 @@ function createParser3(res) {
   });
 }
 function CohereStream(reader, callbacks) {
-  return createParser3(reader).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(
+  return createParser2(reader).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(
     createStreamDataTransformer(callbacks == null ? void 0 : callbacks.experimental_streamData)
   );
 }
 
-// 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}`);
+// streams/google-generative-ai-stream.ts
+async function* streamable2(response) {
+  var _a, _b, _c;
+  for await (const chunk of response.stream) {
+    const parts = (_c = (_b = (_a = chunk.candidates) == null ? void 0 : _a[0]) == null ? void 0 : _b.content) == null ? void 0 : _c.parts;
+    if (parts === void 0) {
+      continue;
     }
-    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;
+    const firstPart = parts[0];
+    if (typeof firstPart.text === "string") {
+      yield firstPart.text;
     }
-    return text;
-  };
-}
-async function* streamable2(stream) {
-  for await (const chunk of stream) {
-    const text = chunk.completion;
-    if (text)
-      yield text;
   }
 }
-function AnthropicStream(res, cb) {
-  if (Symbol.asyncIterator in res) {
-    return readableFromAsyncIterable(streamable2(res)).pipeThrough(createCallbacksTransformer(cb)).pipeThrough(createStreamDataTransformer(cb == null ? void 0 : cb.experimental_streamData));
-  } else {
-    return AIStream(res, parseAnthropicStream(), cb).pipeThrough(
-      createStreamDataTransformer(cb == null ? void 0 : cb.experimental_streamData)
-    );
-  }
+function GoogleGenerativeAIStream(response, cb) {
+  return readableFromAsyncIterable(streamable2(response)).pipeThrough(createCallbacksTransformer(cb)).pipeThrough(createStreamDataTransformer(cb == null ? void 0 : cb.experimental_streamData));
+}
+
+// streams/huggingface-stream.ts
+function createParser3(res) {
+  const trimStartOfStream = trimStartOfStreamHelper();
+  return new ReadableStream({
+    async pull(controller) {
+      var _a, _b;
+      const { value, done } = await res.next();
+      if (done) {
+        controller.close();
+        return;
+      }
+      const text = trimStartOfStream((_b = (_a = value.token) == null ? void 0 : _a.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 HuggingFaceStream(res, callbacks) {
+  return createParser3(res).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(
+    createStreamDataTransformer(callbacks == null ? void 0 : callbacks.experimental_streamData)
+  );
 }
 
 // streams/langchain-stream.ts
@@ -859,6 +741,277 @@ function LangChainStream(callbacks) {
   };
 }
 
+// streams/openai-stream.ts
+function parseOpenAIStream() {
+  const extract = chunkToText();
+  return (data) => extract(JSON.parse(data));
+}
+async function* streamable3(stream) {
+  const extract = chunkToText();
+  for await (const chunk of stream) {
+    const text = extract(chunk);
+    if (text)
+      yield text;
+  }
+}
+function chunkToText() {
+  const trimStartOfStream = trimStartOfStreamHelper();
+  let isFunctionStreamingIn;
+  return (json) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q;
+    if (isChatCompletionChunk(json)) {
+      const delta = (_a = json.choices[0]) == null ? void 0 : _a.delta;
+      if ((_b = delta.function_call) == null ? void 0 : _b.name) {
+        isFunctionStreamingIn = true;
+        return `{"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 `{"tool_calls":[ {"id": "${toolCall.id}", "type": "function", "function": {"name": "${(_f = toolCall.function) == null ? void 0 : _f.name}", "arguments": "`;
+        } else {
+          return `"}}, {"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 cleanupArguments((_i = delta.function_call) == null ? void 0 : _i.arguments);
+      } else if ((_k = (_j = delta.tool_calls) == null ? void 0 : _j[0].function) == null ? void 0 : _k.arguments) {
+        return cleanupArguments((_n = (_m = (_l = delta.tool_calls) == null ? void 0 : _l[0]) == null ? void 0 : _m.function) == null ? void 0 : _n.arguments);
+      } else if (isFunctionStreamingIn && (((_o = json.choices[0]) == null ? void 0 : _o.finish_reason) === "function_call" || ((_p = json.choices[0]) == null ? void 0 : _p.finish_reason) === "stop")) {
+        isFunctionStreamingIn = false;
+        return '"}}';
+      } else if (isFunctionStreamingIn && ((_q = json.choices[0]) == null ? void 0 : _q.finish_reason) === "tool_calls") {
+        isFunctionStreamingIn = false;
+        return '"}}]}';
+      }
+    }
+    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(streamable3(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(cb == null ? void 0 : cb.experimental_streamData)
+    );
+  }
+}
+function createFunctionCallTransformer(callbacks) {
+  const textEncoder = new TextEncoder();
+  let isFirstChunk = true;
+  let aggregatedResponse = "";
+  let aggregatedFinalCompletionResponse = "";
+  let isFunctionStreamingIn = false;
+  let functionCallMessages = callbacks[__internal__OpenAIFnMessagesSymbol] || [];
+  const isComplexMode = callbacks == null ? void 0 : callbacks.experimental_streamData;
+  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(
+          isComplexMode ? textEncoder.encode(formatStreamPart("text", message)) : chunk
+        );
+        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 tool of payload.tool_calls) {
+              toolCalls.tools.push({
+                id: tool.id,
+                type: "function",
+                func: {
+                  name: tool.function.name,
+                  arguments: tool.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(
+                isComplexMode ? formatStreamPart(
+                  payload.function_call ? "function_call" : "tool_calls",
+                  // parse to prevent double-encoding:
+                  JSON.parse(aggregatedResponse)
+                ) : aggregatedResponse
+              )
+            );
+            return;
+          } else if (typeof functionResponse === "string") {
+            controller.enqueue(
+              isComplexMode ? textEncoder.encode(formatStreamPart("text", functionResponse)) : textEncoder.encode(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 _a;
@@ -967,20 +1120,35 @@ async function parseComplexResponse({
       };
       functionCallMessage = prefixMap["function_call"];
     }
+    let toolCallMessage = null;
+    if (type === "tool_calls") {
+      prefixMap["tool_calls"] = {
+        id: generateId(),
+        role: "assistant",
+        content: "",
+        tool_calls: value.tool_calls,
+        createdAt
+      };
+      toolCallMessage = prefixMap["tool_calls"];
+    }
     if (type === "data") {
       prefixMap["data"].push(...value);
     }
     const responseMessage = prefixMap["text"];
-    const merged = [functionCallMessage, responseMessage].filter(
-      Boolean
-    );
+    const merged = [
+      functionCallMessage,
+      toolCallMessage,
+      responseMessage
+    ].filter(Boolean);
     update(merged, [...prefixMap["data"]]);
   }
   onFinish == null ? void 0 : onFinish(prefixMap);
   return {
-    messages: [prefixMap.text, prefixMap.function_call].filter(
-      Boolean
-    ),
+    messages: [
+      prefixMap.text,
+      prefixMap.function_call,
+      prefixMap.tool_calls
+    ].filter(Boolean),
     data: prefixMap.data
   };
 }
@@ -1060,59 +1228,41 @@ var experimental_StreamingReactResponse = class {
   }
 };
 
-// streams/assistant-response.ts
-function experimental_AssistantResponse({ threadId, messageId }, process2) {
-  const stream = new ReadableStream({
-    async start(controller) {
-      var _a;
-      const textEncoder = new TextEncoder();
-      const sendMessage = (message) => {
-        controller.enqueue(
-          textEncoder.encode(formatStreamPart("assistant_message", message))
-        );
-      };
-      const sendDataMessage = (message) => {
-        controller.enqueue(
-          textEncoder.encode(formatStreamPart("data_message", message))
-        );
-      };
-      const sendError = (errorMessage) => {
-        controller.enqueue(
-          textEncoder.encode(formatStreamPart("error", errorMessage))
-        );
-      };
-      controller.enqueue(
-        textEncoder.encode(
-          formatStreamPart("assistant_control_data", {
-            threadId,
-            messageId
-          })
-        )
-      );
-      try {
-        await process2({
-          threadId,
-          messageId,
-          sendMessage,
-          sendDataMessage
-        });
-      } catch (error) {
-        sendError((_a = error.message) != null ? _a : `${error}`);
-      } finally {
-        controller.close();
-      }
-    },
-    pull(controller) {
-    },
-    cancel() {
-    }
-  });
-  return new Response(stream, {
-    status: 200,
-    headers: {
-      "Content-Type": "text/plain; charset=utf-8"
+// streams/streaming-text-response.ts
+var StreamingTextResponse = class extends Response {
+  constructor(res, init, data) {
+    let processedStream = res;
+    if (data) {
+      processedStream = res.pipeThrough(data.stream);
     }
+    super(processedStream, {
+      ...init,
+      status: 200,
+      headers: {
+        "Content-Type": "text/plain; charset=utf-8",
+        [COMPLEX_HEADER]: data ? "true" : "false",
+        ...init == null ? void 0 : init.headers
+      }
+    });
+  }
+};
+function streamToResponse(res, response, init) {
+  response.writeHead((init == null ? void 0 : init.status) || 200, {
+    "Content-Type": "text/plain; charset=utf-8",
+    ...init == null ? void 0 : init.headers
   });
+  const reader = res.getReader();
+  function read() {
+    reader.read().then(({ done, value }) => {
+      if (done) {
+        response.end();
+        return;
+      }
+      response.write(value);
+      read();
+    });
+  }
+  read();
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -1124,6 +1274,7 @@ function experimental_AssistantResponse({ threadId, messageId }, process2) {
   AnthropicStream,
   COMPLEX_HEADER,
   CohereStream,
+  GoogleGenerativeAIStream,
   HuggingFaceStream,
   LangChainStream,
   OpenAIStream,