ai 2.2.23 → 2.2.25

package/dist/index.d.ts

@@ -204,6 +204,16 @@ type UseCompletionOptions = {
 type JSONValue = null | string | number | boolean | {
     [x: string]: JSONValue;
 } | Array<JSONValue>;
+type AssistantMessage = {
+    id: string;
+    role: 'assistant';
+    content: Array<{
+        type: 'text';
+        text: {
+            value: string;
+        };
+    }>;
+};
 
 type OpenAIStreamCallbacks = AIStreamCallbacksAndOptions & {
     /**
@@ -451,6 +461,18 @@ declare function AIStream(response: Response, customParser?: AIStreamParser, cal
  */
 declare function readableFromAsyncIterable<T>(iterable: AsyncIterable<T>): ReadableStream<T>;
 
+interface AWSBedrockResponse {
+    body?: AsyncIterable<{
+        chunk?: {
+            bytes?: Uint8Array;
+        };
+    }>;
+}
+declare function AWSBedrockAnthropicStream(response: AWSBedrockResponse, callbacks?: AIStreamCallbacksAndOptions): ReadableStream;
+declare function AWSBedrockCohereStream(response: AWSBedrockResponse, callbacks?: AIStreamCallbacksAndOptions): ReadableStream;
+declare function AWSBedrockLlama2Stream(response: AWSBedrockResponse, callbacks?: AIStreamCallbacksAndOptions): ReadableStream;
+declare function AWSBedrockStream(response: AWSBedrockResponse, callbacks: AIStreamCallbacksAndOptions | undefined, extractTextDeltaFromChunk: (chunk: any) => string): ReadableStream<any>;
+
 /**
  * A stream wrapper to send custom JSON-encoded data back to the client.
  */
@@ -580,18 +602,26 @@ declare function ReplicateStream(res: Prediction, cb?: AIStreamCallbacksAndOptio
     headers?: Record<string, string>;
 }): Promise<ReadableStream>;
 
-declare const nanoid: (size?: number | undefined) => string;
-declare function createChunkDecoder(): (chunk: Uint8Array | undefined) => string;
-declare function createChunkDecoder(complex: false): (chunk: Uint8Array | undefined) => string;
-declare function createChunkDecoder(complex: true): (chunk: Uint8Array | undefined) => {
-    type: keyof typeof StreamStringPrefixes;
-    value: string;
-}[];
-declare function createChunkDecoder(complex?: boolean): (chunk: Uint8Array | undefined) => {
-    type: keyof typeof StreamStringPrefixes;
-    value: string;
-}[] | string;
-
+interface StreamPart<CODE extends string, NAME extends string, TYPE> {
+    code: CODE;
+    name: NAME;
+    parse: (value: JSONValue) => {
+        type: NAME;
+        value: TYPE;
+    };
+}
+declare const textStreamPart: StreamPart<'0', 'text', string>;
+declare const functionCallStreamPart: StreamPart<'1', 'function_call', {
+    function_call: FunctionCall;
+}>;
+declare const dataStreamPart: StreamPart<'2', 'data', Array<JSONValue>>;
+declare const errorStreamPart: StreamPart<'3', 'error', string>;
+declare const assistantMessage: StreamPart<'4', 'assistant_message', AssistantMessage>;
+declare const assistantControlData: StreamPart<'5', 'assistant_control_data', {
+    threadId: string;
+    messageId: string;
+}>;
+type StreamPartType = ReturnType<typeof textStreamPart.parse> | ReturnType<typeof functionCallStreamPart.parse> | ReturnType<typeof dataStreamPart.parse> | ReturnType<typeof errorStreamPart.parse> | ReturnType<typeof assistantMessage.parse> | ReturnType<typeof assistantControlData.parse>;
 /**
  * The map of prefixes for data in the stream
  *
@@ -613,20 +643,22 @@ declare function createChunkDecoder(complex?: boolean): (chunk: Uint8Array | und
  *```
  */
 declare const StreamStringPrefixes: {
-    readonly text: 0;
-    readonly function_call: 1;
-    readonly data: 2;
+    readonly text: "0";
+    readonly function_call: "1";
+    readonly data: "2";
+    readonly error: "3";
+    readonly assistant_message: "4";
+    readonly assistant_control_data: "5";
 };
-declare const isStreamStringEqualToType: (type: keyof typeof StreamStringPrefixes, value: string) => value is `0:${string}\n` | `1:${string}\n` | `2:${string}\n`;
-/**
- * Prepends a string with a prefix from the `StreamChunkPrefixes`, JSON-ifies it, and appends a new line.
- */
-declare const getStreamString: (type: keyof typeof StreamStringPrefixes, value: JSONValue) => StreamString;
+
+declare const nanoid: (size?: number | undefined) => string;
+declare function createChunkDecoder(): (chunk: Uint8Array | undefined) => string;
+declare function createChunkDecoder(complex: false): (chunk: Uint8Array | undefined) => string;
+declare function createChunkDecoder(complex: true): (chunk: Uint8Array | undefined) => StreamPartType[];
+declare function createChunkDecoder(complex?: boolean): (chunk: Uint8Array | undefined) => StreamPartType[] | string;
+
+declare const isStreamStringEqualToType: (type: keyof typeof StreamStringPrefixes, value: string) => value is `0:${string}\n` | `1:${string}\n` | `2:${string}\n` | `3:${string}\n` | `4:${string}\n` | `5:${string}\n`;
 type StreamString = `${(typeof StreamStringPrefixes)[keyof typeof StreamStringPrefixes]}:${string}\n`;
-declare const getStreamStringTypeAndValue: (line: string) => {
-    type: keyof typeof StreamStringPrefixes;
-    value: JSONValue;
-};
 /**
  * A header sent to the client so it knows how to handle parsing the stream (as a deprecated text response or using the new prefixed protocol)
  */
@@ -663,4 +695,13 @@ declare class experimental_StreamingReactResponse {
     });
 }
 
-export { AIStream, AIStreamCallbacksAndOptions, AIStreamParser, AnthropicStream, COMPLEX_HEADER, ChatRequest, ChatRequestOptions, CohereStream, CompletionUsage, CreateMessage, FunctionCall, FunctionCallHandler, FunctionCallPayload, HuggingFaceStream, JSONValue, LangChainStream, Message, OpenAIStream, OpenAIStreamCallbacks, ReactResponseRow, ReplicateStream, RequestOptions, StreamString, StreamStringPrefixes, StreamingTextResponse, UseChatOptions, UseCompletionOptions, createCallbacksTransformer, createChunkDecoder, createEventStreamTransformer, createStreamDataTransformer, experimental_StreamData, experimental_StreamingReactResponse, getStreamString, getStreamStringTypeAndValue, isStreamStringEqualToType, nanoid, readableFromAsyncIterable, streamToResponse, trimStartOfStreamHelper };
+declare function experimental_AssistantResponse({ threadId, messageId }: {
+    threadId: string;
+    messageId: string;
+}, process: (stream: {
+    threadId: string;
+    messageId: string;
+    sendMessage: (message: AssistantMessage) => void;
+}) => Promise<void>): Response;
+
+export { AIStream, AIStreamCallbacksAndOptions, AIStreamParser, AWSBedrockAnthropicStream, AWSBedrockCohereStream, AWSBedrockLlama2Stream, AWSBedrockStream, AnthropicStream, AssistantMessage, COMPLEX_HEADER, ChatRequest, ChatRequestOptions, CohereStream, CompletionUsage, CreateMessage, FunctionCall, FunctionCallHandler, FunctionCallPayload, HuggingFaceStream, JSONValue, LangChainStream, Message, OpenAIStream, OpenAIStreamCallbacks, ReactResponseRow, ReplicateStream, RequestOptions, StreamString, StreamingTextResponse, UseChatOptions, UseCompletionOptions, createCallbacksTransformer, createChunkDecoder, createEventStreamTransformer, createStreamDataTransformer, experimental_AssistantResponse, experimental_StreamData, experimental_StreamingReactResponse, isStreamStringEqualToType, nanoid, readableFromAsyncIterable, streamToResponse, trimStartOfStreamHelper };

package/dist/index.js

@@ -21,6 +21,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var streams_exports = {};
 __export(streams_exports, {
   AIStream: () => AIStream,
+  AWSBedrockAnthropicStream: () => AWSBedrockAnthropicStream,
+  AWSBedrockCohereStream: () => AWSBedrockCohereStream,
+  AWSBedrockLlama2Stream: () => AWSBedrockLlama2Stream,
+  AWSBedrockStream: () => AWSBedrockStream,
   AnthropicStream: () => AnthropicStream,
   COMPLEX_HEADER: () => COMPLEX_HEADER,
   CohereStream: () => CohereStream,
@@ -28,16 +32,14 @@ __export(streams_exports, {
   LangChainStream: () => LangChainStream,
   OpenAIStream: () => OpenAIStream,
   ReplicateStream: () => ReplicateStream,
-  StreamStringPrefixes: () => StreamStringPrefixes,
   StreamingTextResponse: () => StreamingTextResponse,
   createCallbacksTransformer: () => createCallbacksTransformer,
   createChunkDecoder: () => createChunkDecoder,
   createEventStreamTransformer: () => createEventStreamTransformer,
   createStreamDataTransformer: () => createStreamDataTransformer,
+  experimental_AssistantResponse: () => experimental_AssistantResponse,
   experimental_StreamData: () => experimental_StreamData,
   experimental_StreamingReactResponse: () => experimental_StreamingReactResponse,
-  getStreamString: () => getStreamString,
-  getStreamStringTypeAndValue: () => getStreamStringTypeAndValue,
   isStreamStringEqualToType: () => isStreamStringEqualToType,
   nanoid: () => nanoid,
   readableFromAsyncIterable: () => readableFromAsyncIterable,
@@ -162,57 +164,134 @@ function readableFromAsyncIterable(iterable) {
   });
 }
 
-// shared/utils.ts
-var import_non_secure = require("nanoid/non-secure");
-var nanoid = (0, import_non_secure.customAlphabet)(
-  "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
-  7
-);
-function createChunkDecoder(complex) {
-  const decoder = new TextDecoder();
-  if (!complex) {
-    return function(chunk) {
-      if (!chunk)
-        return "";
-      return decoder.decode(chunk, { stream: true });
+// shared/stream-parts.ts
+var textStreamPart = {
+  code: "0",
+  name: "text",
+  parse: (value) => {
+    if (typeof value !== "string") {
+      throw new Error('"text" parts expect a string value.');
+    }
+    return { type: "text", value };
+  }
+};
+var functionCallStreamPart = {
+  code: "1",
+  name: "function_call",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("function_call" in value) || typeof value.function_call !== "object" || value.function_call == null || !("name" in value.function_call) || !("arguments" in value.function_call) || typeof value.function_call.name !== "string" || typeof value.function_call.arguments !== "string") {
+      throw new Error(
+        '"function_call" parts expect an object with a "function_call" property.'
+      );
+    }
+    return {
+      type: "function_call",
+      value
     };
   }
-  return function(chunk) {
-    const decoded = decoder.decode(chunk, { stream: true }).split("\n").filter((line) => line !== "");
-    return decoded.map(getStreamStringTypeAndValue).filter(Boolean);
-  };
-}
-var StreamStringPrefixes = {
-  text: 0,
-  function_call: 1,
-  data: 2
-  // user_err: 3?
 };
-var isStreamStringEqualToType = (type, value) => value.startsWith(`${StreamStringPrefixes[type]}:`) && value.endsWith("\n");
-var getStreamString = (type, value) => `${StreamStringPrefixes[type]}:${JSON.stringify(value)}
-`;
-var getStreamStringTypeAndValue = (line) => {
-  const firstSeperatorIndex = line.indexOf(":");
-  if (firstSeperatorIndex === -1) {
-    throw new Error("Failed to parse stream string");
+var dataStreamPart = {
+  code: "2",
+  name: "data",
+  parse: (value) => {
+    if (!Array.isArray(value)) {
+      throw new Error('"data" parts expect an array value.');
+    }
+    return { type: "data", value };
   }
-  const prefix = line.slice(0, firstSeperatorIndex);
-  const type = Object.keys(StreamStringPrefixes).find(
-    (key) => StreamStringPrefixes[key] === Number(prefix)
-  );
-  const val = line.slice(firstSeperatorIndex + 1);
-  let parsedVal = val;
-  if (!val) {
-    return { type, value: "" };
+};
+var errorStreamPart = {
+  code: "3",
+  name: "error",
+  parse: (value) => {
+    if (typeof value !== "string") {
+      throw new Error('"error" parts expect a string value.');
+    }
+    return { type: "error", value };
   }
-  try {
-    parsedVal = JSON.parse(val);
-  } catch (e) {
-    console.error("Failed to parse JSON value:", val);
+};
+var assistantMessage = {
+  code: "4",
+  name: "assistant_message",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("id" in value) || !("role" in value) || !("content" in value) || typeof value.id !== "string" || typeof value.role !== "string" || value.role !== "assistant" || !Array.isArray(value.content) || !value.content.every(
+      (item) => item != null && typeof item === "object" && "type" in item && item.type === "text" && "text" in item && item.text != null && typeof item.text === "object" && "value" in item.text && typeof item.text.value === "string"
+    )) {
+      throw new Error(
+        '"assistant_message" parts expect an object with an "id", "role", and "content" property.'
+      );
+    }
+    return {
+      type: "assistant_message",
+      value
+    };
   }
-  return { type, value: parsedVal };
 };
-var COMPLEX_HEADER = "X-Experimental-Stream-Data";
+var assistantControlData = {
+  code: "5",
+  name: "assistant_control_data",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("threadId" in value) || !("messageId" in value) || typeof value.threadId !== "string" || typeof value.messageId !== "string") {
+      throw new Error(
+        '"assistant_control_data" parts expect an object with a "threadId" and "messageId" property.'
+      );
+    }
+    return {
+      type: "assistant_control_data",
+      value: {
+        threadId: value.threadId,
+        messageId: value.messageId
+      }
+    };
+  }
+};
+var streamParts = [
+  textStreamPart,
+  functionCallStreamPart,
+  dataStreamPart,
+  errorStreamPart,
+  assistantMessage,
+  assistantControlData
+];
+var streamPartsByCode = {
+  [textStreamPart.code]: textStreamPart,
+  [functionCallStreamPart.code]: functionCallStreamPart,
+  [dataStreamPart.code]: dataStreamPart,
+  [errorStreamPart.code]: errorStreamPart,
+  [assistantMessage.code]: assistantMessage,
+  [assistantControlData.code]: assistantControlData
+};
+var StreamStringPrefixes = {
+  [textStreamPart.name]: textStreamPart.code,
+  [functionCallStreamPart.name]: functionCallStreamPart.code,
+  [dataStreamPart.name]: dataStreamPart.code,
+  [errorStreamPart.name]: errorStreamPart.code,
+  [assistantMessage.name]: assistantMessage.code,
+  [assistantControlData.name]: assistantControlData.code
+};
+var validCodes = streamParts.map((part) => part.code);
+var parseStreamPart = (line) => {
+  const firstSeparatorIndex = line.indexOf(":");
+  if (firstSeparatorIndex === -1) {
+    throw new Error("Failed to parse stream string. No separator found.");
+  }
+  const prefix = line.slice(0, firstSeparatorIndex);
+  if (!validCodes.includes(prefix)) {
+    throw new Error(`Failed to parse stream string. Invalid code ${prefix}.`);
+  }
+  const code = prefix;
+  const textValue = line.slice(firstSeparatorIndex + 1);
+  const jsonValue = JSON.parse(textValue);
+  return streamPartsByCode[code].parse(jsonValue);
+};
+function formatStreamPart(type, value) {
+  const streamPart = streamParts.find((part) => part.name === type);
+  if (!streamPart) {
+    throw new Error(`Invalid stream part type: ${type}`);
+  }
+  return `${streamPart.code}:${JSON.stringify(value)}
+`;
+}
 
 // streams/stream-data.ts
 var experimental_StreamData = class {
@@ -237,7 +316,7 @@ var experimental_StreamData = class {
       transform: async (chunk, controller) => {
         if (self.data.length > 0) {
           const encodedData = self.encoder.encode(
-            getStreamString("data", JSON.stringify(self.data))
+            formatStreamPart("data", self.data)
           );
           self.data = [];
           controller.enqueue(encodedData);
@@ -256,7 +335,7 @@ var experimental_StreamData = class {
         }
         if (self.data.length) {
           const encodedData = self.encoder.encode(
-            getStreamString("data", JSON.stringify(self.data))
+            formatStreamPart("data", self.data)
           );
           controller.enqueue(encodedData);
         }
@@ -294,11 +373,76 @@ function createStreamDataTransformer(experimental_streamData) {
   return new TransformStream({
     transform: async (chunk, controller) => {
       const message = decoder.decode(chunk);
-      controller.enqueue(encoder.encode(getStreamString("text", message)));
+      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
+);
+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();
@@ -402,7 +546,7 @@ function createFunctionCallTransformer(callbacks) {
       }
       if (!isFunctionStreamingIn) {
         controller.enqueue(
-          isComplexMode ? textEncoder.encode(getStreamString("text", message)) : chunk
+          isComplexMode ? textEncoder.encode(formatStreamPart("text", message)) : chunk
         );
         return;
       } else {
@@ -444,13 +588,17 @@ function createFunctionCallTransformer(callbacks) {
           if (!functionResponse) {
             controller.enqueue(
               textEncoder.encode(
-                isComplexMode ? getStreamString("function_call", aggregatedResponse) : aggregatedResponse
+                isComplexMode ? formatStreamPart(
+                  "function_call",
+                  // parse to prevent double-encoding:
+                  JSON.parse(aggregatedResponse)
+                ) : aggregatedResponse
               )
             );
             return;
           } else if (typeof functionResponse === "string") {
             controller.enqueue(
-              isComplexMode ? textEncoder.encode(getStreamString("text", functionResponse)) : textEncoder.encode(functionResponse)
+              isComplexMode ? textEncoder.encode(formatStreamPart("text", functionResponse)) : textEncoder.encode(functionResponse)
             );
             return;
           }
@@ -715,18 +863,22 @@ async function ReplicateStream(res, cb, options) {
   );
 }
 
-// react/parse-complex-response.ts
+// shared/parse-complex-response.ts
 async function parseComplexResponse({
   reader,
   abortControllerRef,
   update,
-  onFinish
+  onFinish,
+  generateId = nanoid,
+  getCurrentDate = () => /* @__PURE__ */ new Date()
 }) {
+  const createdAt = getCurrentDate();
   const decode = createChunkDecoder(true);
-  const createdAt = /* @__PURE__ */ new Date();
-  const prefixMap = {};
+  const prefixMap = {
+    data: []
+  };
   const NEWLINE = "\n".charCodeAt(0);
-  let chunks = [];
+  const chunks = [];
   let totalLength = 0;
   while (true) {
     const { value } = await reader.read();
@@ -763,7 +915,7 @@ async function parseComplexResponse({
           };
         } else {
           prefixMap["text"] = {
-            id: nanoid(),
+            id: generateId(),
             role: "assistant",
             content: value2,
             createdAt
@@ -772,37 +924,24 @@ async function parseComplexResponse({
       }
       let functionCallMessage = null;
       if (type === "function_call") {
-        prefixMap["function_call"] = value2;
-        let functionCall = prefixMap["function_call"];
-        if (functionCall && typeof functionCall === "string") {
-          const parsedFunctionCall = JSON.parse(
-            functionCall
-          ).function_call;
-          functionCallMessage = {
-            id: nanoid(),
-            role: "assistant",
-            content: "",
-            function_call: parsedFunctionCall,
-            name: parsedFunctionCall.name,
-            createdAt
-          };
-          prefixMap["function_call"] = functionCallMessage;
-        }
+        prefixMap["function_call"] = {
+          id: generateId(),
+          role: "assistant",
+          content: "",
+          function_call: value2.function_call,
+          name: value2.function_call.name,
+          createdAt
+        };
+        functionCallMessage = prefixMap["function_call"];
       }
       if (type === "data") {
-        const parsedValue = JSON.parse(value2);
-        if (prefixMap["data"]) {
-          prefixMap["data"] = [...prefixMap["data"], ...parsedValue];
-        } else {
-          prefixMap["data"] = parsedValue;
-        }
+        prefixMap["data"].push(...value2);
       }
-      const data = prefixMap["data"];
       const responseMessage = prefixMap["text"];
       const merged = [functionCallMessage, responseMessage].filter(
         Boolean
       );
-      update(merged, data);
+      update(merged, [...prefixMap["data"]]);
       if ((abortControllerRef == null ? void 0 : abortControllerRef.current) === null) {
         reader.cancel();
         break;
@@ -810,7 +949,12 @@ async function parseComplexResponse({
     }
   }
   onFinish == null ? void 0 : onFinish(prefixMap);
-  return prefixMap;
+  return {
+    messages: [prefixMap.text, prefixMap.function_call].filter(
+      Boolean
+    ),
+    data: prefixMap.data
+  };
 }
 
 // streams/streaming-react-response.ts
@@ -885,9 +1029,62 @@ var experimental_StreamingReactResponse = class {
     return next;
   }
 };
+
+// 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 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
+        });
+      } 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"
+    }
+  });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AIStream,
+  AWSBedrockAnthropicStream,
+  AWSBedrockCohereStream,
+  AWSBedrockLlama2Stream,
+  AWSBedrockStream,
   AnthropicStream,
   COMPLEX_HEADER,
   CohereStream,
@@ -895,16 +1092,14 @@ var experimental_StreamingReactResponse = class {
   LangChainStream,
   OpenAIStream,
   ReplicateStream,
-  StreamStringPrefixes,
   StreamingTextResponse,
   createCallbacksTransformer,
   createChunkDecoder,
   createEventStreamTransformer,
   createStreamDataTransformer,
+  experimental_AssistantResponse,
   experimental_StreamData,
   experimental_StreamingReactResponse,
-  getStreamString,
-  getStreamStringTypeAndValue,
   isStreamStringEqualToType,
   nanoid,
   readableFromAsyncIterable,