ai 2.2.34 → 2.2.35

package/dist/index.mjs

@@ -1,5 +1,122 @@
-// shared/utils.ts
-import { customAlphabet } from "nanoid/non-secure";
+// streams/ai-stream.ts
+import {
+  createParser
+} from "eventsource-parser";
+function createEventStreamTransformer(customParser) {
+  const textDecoder = new TextDecoder();
+  let eventSourceParser;
+  return new TransformStream({
+    async start(controller) {
+      eventSourceParser = 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: event.event
+            }) : 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/stream-parts.ts
 var textStreamPart = {
@@ -181,148 +298,6 @@ function formatStreamPart(type, value) {
 `;
 }
 
-// shared/utils.ts
-var nanoid = customAlphabet(
-  "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
-  7
-);
-function createChunkDecoder(complex) {
-  const decoder = new TextDecoder();
-  if (!complex) {
-    return function(chunk) {
-      if (!chunk)
-        return "";
-      return decoder.decode(chunk, { stream: true });
-    };
-  }
-  return function(chunk) {
-    const decoded = decoder.decode(chunk, { stream: true }).split("\n").filter((line) => line !== "");
-    return decoded.map(parseStreamPart).filter(Boolean);
-  };
-}
-var isStreamStringEqualToType = (type, value) => value.startsWith(`${StreamStringPrefixes[type]}:`) && value.endsWith("\n");
-var COMPLEX_HEADER = "X-Experimental-Stream-Data";
-
-// streams/ai-stream.ts
-import {
-  createParser
-} from "eventsource-parser";
-function createEventStreamTransformer(customParser) {
-  const textDecoder = new TextDecoder();
-  let eventSourceParser;
-  return new TransformStream({
-    async start(controller) {
-      eventSourceParser = 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: event.event
-            }) : 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));
-    }
-  });
-}
-
 // streams/stream-data.ts
 var experimental_StreamData = class {
   constructor() {
@@ -409,345 +384,96 @@ var experimental_StreamData = class {
     }
     this.messageAnnotations.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 AIStream(res, parseAnthropicStream(), cb).pipeThrough(
-      createStreamDataTransformer(cb == null ? void 0 : cb.experimental_streamData)
-    );
-  }
-}
-
-// 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/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)
-  );
-}
-
-// 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 function readAndProcessLines(reader, controller) {
-  let segment = "";
-  while (true) {
-    const { value: chunk, done } = await reader.read();
-    if (done) {
-      break;
-    }
-    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 _a;
-  const reader = (_a = res.body) == null ? void 0 : _a.getReader();
-  return new ReadableStream({
-    async start(controller) {
-      if (!reader) {
-        controller.close();
-        return;
-      }
-      await readAndProcessLines(reader, controller);
-    }
-  });
-}
-async function* streamable2(stream) {
-  for await (const chunk of stream) {
-    if (chunk.eventType === "text-generation") {
-      const text = chunk.text;
-      if (text)
-        yield text;
-    }
-  }
-}
-function CohereStream(reader, callbacks) {
-  if (Symbol.asyncIterator in reader) {
-    return readableFromAsyncIterable(streamable2(reader)).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(
-      createStreamDataTransformer(callbacks == null ? void 0 : callbacks.experimental_streamData)
-    );
-  } else {
-    return createParser2(reader).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(
-      createStreamDataTransformer(callbacks == null ? void 0 : callbacks.experimental_streamData)
-    );
-  }
+};
+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/google-generative-ai-stream.ts
-async function* streamable3(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;
-    }
-    const firstPart = parts[0];
-    if (typeof firstPart.text === "string") {
-      yield firstPart.text;
+// 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 GoogleGenerativeAIStream(response, cb) {
-  return readableFromAsyncIterable(streamable3(response)).pipeThrough(createCallbacksTransformer(cb)).pipeThrough(createStreamDataTransformer(cb == null ? void 0 : cb.experimental_streamData));
+function AWSBedrockAnthropicStream(response, callbacks) {
+  return AWSBedrockStream(response, callbacks, (chunk) => chunk.completion);
 }
-
-// streams/huggingface-stream.ts
-function createParser3(res) {
-  const trimStartOfStream = trimStartOfStreamHelper();
-  return new ReadableStream({
-    async pull(controller) {
+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 createParser3(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)
   );
 }
 
-// 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(callbacks == null ? void 0 : callbacks.experimental_streamData)
-    ),
-    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);
-      }
-    }
+// shared/utils.ts
+import { customAlphabet } from "nanoid/non-secure";
+var nanoid = customAlphabet(
+  "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+  7
+);
+function createChunkDecoder(complex) {
+  const decoder = new TextDecoder();
+  if (!complex) {
+    return function(chunk) {
+      if (!chunk)
+        return "";
+      return decoder.decode(chunk, { stream: true });
+    };
+  }
+  return function(chunk) {
+    const decoded = decoder.decode(chunk, { stream: true }).split("\n").filter((line) => line !== "");
+    return decoded.map(parseStreamPart).filter(Boolean);
   };
 }
+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) => extract(JSON.parse(data));
 }
-async function* streamable4(stream) {
+async function* streamable(stream) {
   const extract = chunkToText();
   for await (let chunk of stream) {
     if ("promptFilterResults" in chunk) {
@@ -836,7 +562,7 @@ function OpenAIStream(res, callbacks) {
   const cb = callbacks;
   let stream;
   if (Symbol.asyncIterator in res) {
-    stream = readableFromAsyncIterable(streamable4(res)).pipeThrough(
+    stream = readableFromAsyncIterable(streamable(res)).pipeThrough(
       createCallbacksTransformer(
         (cb == null ? void 0 : cb.experimental_onFunctionCall) || (cb == null ? void 0 : cb.experimental_onToolCall) ? {
           ...cb,
@@ -1041,6 +767,280 @@ function createFunctionCallTransformer(callbacks) {
   });
 }
 
+// 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();
+}
+
+// streams/huggingface-stream.ts
+function createParser2(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 createParser2(res).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(
+    createStreamDataTransformer(callbacks == null ? void 0 : callbacks.experimental_streamData)
+  );
+}
+
+// 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 function readAndProcessLines(reader, controller) {
+  let segment = "";
+  while (true) {
+    const { value: chunk, done } = await reader.read();
+    if (done) {
+      break;
+    }
+    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 createParser3(res) {
+  var _a;
+  const reader = (_a = res.body) == null ? void 0 : _a.getReader();
+  return new ReadableStream({
+    async start(controller) {
+      if (!reader) {
+        controller.close();
+        return;
+      }
+      await readAndProcessLines(reader, controller);
+    }
+  });
+}
+async function* streamable2(stream) {
+  for await (const chunk of stream) {
+    if (chunk.eventType === "text-generation") {
+      const text = chunk.text;
+      if (text)
+        yield text;
+    }
+  }
+}
+function CohereStream(reader, callbacks) {
+  if (Symbol.asyncIterator in reader) {
+    return readableFromAsyncIterable(streamable2(reader)).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(
+      createStreamDataTransformer(callbacks == null ? void 0 : callbacks.experimental_streamData)
+    );
+  } else {
+    return createParser3(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}`);
+    }
+    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* streamable3(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(streamable3(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)
+    );
+  }
+}
+
+// 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 _a, _b;
+    const { event } = options;
+    if (event === "records_cited") {
+      records_cited = JSON.parse(data);
+      (_a = callbacks == null ? void 0 : callbacks.onRecordsCited) == null ? void 0 : _a.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 _a;
+      const inkeepOnFinalMetadata = {
+        chat_session_id,
+        records_cited
+      };
+      (_a = callbacks == null ? void 0 : callbacks.onFinal) == null ? void 0 : _a.call(callbacks, completion, inkeepOnFinalMetadata);
+    }
+  };
+  return AIStream(res, inkeepEventParser, passThroughCallbacks).pipeThrough(
+    createStreamDataTransformer(passThroughCallbacks == null ? void 0 : passThroughCallbacks.experimental_streamData)
+  );
+}
+
+// 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(callbacks == null ? void 0 : callbacks.experimental_streamData)
+    ),
+    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/replicate-stream.ts
 async function ReplicateStream(res, cb, options) {
   var _a;
@@ -1063,6 +1063,79 @@ async function ReplicateStream(res, cb, options) {
   );
 }
 
+// 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/google-generative-ai-stream.ts
+async function* streamable4(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;
+    }
+    const firstPart = parts[0];
+    if (typeof firstPart.text === "string") {
+      yield firstPart.text;
+    }
+  }
+}
+function GoogleGenerativeAIStream(response, cb) {
+  return readableFromAsyncIterable(streamable4(response)).pipeThrough(createCallbacksTransformer(cb)).pipeThrough(createStreamDataTransformer(cb == null ? void 0 : cb.experimental_streamData));
+}
+
 // shared/read-data-stream.ts
 var NEWLINE = "\n".charCodeAt(0);
 function concatChunks(chunks, totalLength) {
@@ -1291,43 +1364,6 @@ var experimental_StreamingReactResponse = class {
     return next;
   }
 };
-
-// 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();
-}
 export {
   AIStream,
   AWSBedrockAnthropicStream,
@@ -1339,6 +1375,7 @@ export {
   CohereStream,
   GoogleGenerativeAIStream,
   HuggingFaceStream,
+  InkeepStream,
   LangChainStream,
   OpenAIStream,
   ReplicateStream,