ai 2.1.26 → 2.1.27

package/dist/index.mjs

@@ -1,43 +1,3 @@
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
-
 // streams/ai-stream.ts
 import {
   createParser
@@ -46,22 +6,20 @@ function createEventStreamTransformer(customParser) {
   const textDecoder = new TextDecoder();
   let eventSourceParser;
   return new TransformStream({
-    start(controller) {
-      return __async(this, null, function* () {
-        eventSourceParser = createParser(
-          (event) => {
-            if ("data" in event && event.type === "event" && event.data === "[DONE]") {
-              controller.terminate();
-              return;
-            }
-            if ("data" in event) {
-              const parsedMessage = customParser(event.data);
-              if (parsedMessage)
-                controller.enqueue(parsedMessage);
-            }
+    async start(controller) {
+      eventSourceParser = createParser(
+        (event) => {
+          if ("data" in event && event.type === "event" && event.data === "[DONE]") {
+            controller.terminate();
+            return;
           }
-        );
-      });
+          if ("data" in event) {
+            const parsedMessage = customParser(event.data);
+            if (parsedMessage)
+              controller.enqueue(parsedMessage);
+          }
+        }
+      );
     },
     transform(chunk) {
       eventSourceParser.feed(textDecoder.decode(chunk));
@@ -73,26 +31,20 @@ function createCallbacksTransformer(callbacks) {
   let aggregatedResponse = "";
   const { onStart, onToken, onCompletion } = callbacks || {};
   return new TransformStream({
-    start() {
-      return __async(this, null, function* () {
-        if (onStart)
-          yield onStart();
-      });
+    async start() {
+      if (onStart)
+        await onStart();
     },
-    transform(message, controller) {
-      return __async(this, null, function* () {
-        controller.enqueue(textEncoder.encode(message));
-        if (onToken)
-          yield onToken(message);
-        if (onCompletion)
-          aggregatedResponse += message;
-      });
+    async transform(message, controller) {
+      controller.enqueue(textEncoder.encode(message));
+      if (onToken)
+        await onToken(message);
+      if (onCompletion)
+        aggregatedResponse += message;
     },
-    flush() {
-      return __async(this, null, function* () {
-        if (onCompletion)
-          yield onCompletion(aggregatedResponse);
-      });
+    async flush() {
+      if (onCompletion)
+        await onCompletion(aggregatedResponse);
     }
   });
 }
@@ -110,17 +62,14 @@ function trimStartOfStreamHelper() {
 function AIStream(response, customParser, callbacks) {
   if (!response.ok) {
     if (response.body) {
-      let _a;
       const reader = response.body.getReader();
       return new ReadableStream({
-        start(controller) {
-          return __async(this, null, function* () {
-            const { done, value } = yield reader.read();
-            if (!done) {
-              const errorText = new TextDecoder().decode(value);
-              controller.error(new Error(`Response error: ${errorText}`));
-            }
-          });
+        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 {
@@ -141,14 +90,43 @@ function createEmptyReadableStream() {
     }
   });
 }
+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/openai-stream.ts
 function parseOpenAIStream() {
+  const extract = chunkToText();
+  return (data) => {
+    return extract(JSON.parse(data));
+  };
+}
+async function* streamable(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 (data) => {
+  return (json) => {
     var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o;
-    const json = JSON.parse(data);
     if ((_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": "`;
@@ -156,7 +134,7 @@ function parseOpenAIStream() {
       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 ((((_i = json.choices[0]) == null ? void 0 : _i.finish_reason) === "function_call" || ((_j = json.choices[0]) == null ? void 0 : _j.finish_reason) === "stop") && isFunctionStreamingIn) {
+    } 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 '"}}';
     }
@@ -169,7 +147,14 @@ function parseOpenAIStream() {
 var __internal__OpenAIFnMessagesSymbol = Symbol("internal_openai_fn_messages");
 function OpenAIStream(res, callbacks) {
   const cb = callbacks;
-  const stream = AIStream(res, parseOpenAIStream(), cb);
+  let stream;
+  if (Symbol.asyncIterator in res) {
+    stream = readableFromAsyncIterable(streamable(res)).pipeThrough(
+      createCallbacksTransformer(cb)
+    );
+  } else {
+    stream = AIStream(res, parseOpenAIStream(), cb);
+  }
   if (cb && cb.experimental_onFunctionCall) {
     const functionCallTransformer = createFunctionCallTransformer(cb);
     return stream.pipeThrough(functionCallTransformer);
@@ -184,78 +169,76 @@ function createFunctionCallTransformer(callbacks) {
   let isFunctionStreamingIn = false;
   let functionCallMessages = callbacks[__internal__OpenAIFnMessagesSymbol] || [];
   return new TransformStream({
-    transform(chunk, controller) {
-      return __async(this, null, function* () {
-        const message = new TextDecoder().decode(chunk);
-        const shouldHandleAsFunction = isFirstChunk && message.startsWith('{"function_call":');
-        if (shouldHandleAsFunction) {
-          isFunctionStreamingIn = true;
-          aggregatedResponse += message;
-          isFirstChunk = false;
+    async transform(chunk, controller) {
+      const message = new TextDecoder().decode(chunk);
+      const shouldHandleAsFunction = isFirstChunk && message.startsWith('{"function_call":');
+      if (shouldHandleAsFunction) {
+        isFunctionStreamingIn = true;
+        aggregatedResponse += message;
+        isFirstChunk = false;
+        return;
+      }
+      if (!isFunctionStreamingIn) {
+        controller.enqueue(chunk);
+        return;
+      } else {
+        aggregatedResponse += message;
+      }
+    },
+    async flush(controller) {
+      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(aggregatedResponse));
           return;
-        }
-        if (!isFunctionStreamingIn) {
-          controller.enqueue(chunk);
+        } else if (typeof functionResponse === "string") {
+          controller.enqueue(textEncoder.encode(functionResponse));
           return;
-        } else {
-          aggregatedResponse += message;
         }
-      });
-    },
-    flush(controller) {
-      return __async(this, null, function* () {
-        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 = yield 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(aggregatedResponse));
-            return;
-          } else if (typeof functionResponse === "string") {
-            controller.enqueue(textEncoder.encode(functionResponse));
-            return;
-          }
-          const filteredCallbacks = __spreadProps(__spreadValues({}, callbacks), {
-            onStart: void 0,
-            onCompletion: void 0
-          });
-          const openAIStream = OpenAIStream(functionResponse, __spreadProps(__spreadValues({}, filteredCallbacks), {
-            [__internal__OpenAIFnMessagesSymbol]: newFunctionCallMessages
-          }));
-          const reader = openAIStream.getReader();
-          while (true) {
-            const { done, value } = yield reader.read();
-            if (done) {
-              break;
-            }
-            controller.enqueue(value);
+        const filteredCallbacks = {
+          ...callbacks,
+          onStart: void 0,
+          onCompletion: 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);
         }
-      });
+      }
     }
   });
 }
@@ -263,18 +246,21 @@ function createFunctionCallTransformer(callbacks) {
 // streams/streaming-text-response.ts
 var StreamingTextResponse = class extends Response {
   constructor(res, init) {
-    super(res, __spreadProps(__spreadValues({}, init), {
+    super(res, {
+      ...init,
       status: 200,
-      headers: __spreadValues({
-        "Content-Type": "text/plain; charset=utf-8"
-      }, init == null ? void 0 : init.headers)
-    }));
+      headers: {
+        "Content-Type": "text/plain; charset=utf-8",
+        ...init == null ? void 0 : init.headers
+      }
+    });
   }
 };
 function streamToResponse(res, response, init) {
-  response.writeHead((init == null ? void 0 : init.status) || 200, __spreadValues({
-    "Content-Type": "text/plain; charset=utf-8"
-  }, init == null ? void 0 : init.headers));
+  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 }) => {
@@ -293,27 +279,25 @@ function streamToResponse(res, response, init) {
 function createParser2(res) {
   const trimStartOfStream = trimStartOfStreamHelper();
   return new ReadableStream({
-    pull(controller) {
-      return __async(this, null, function* () {
-        var _a2, _b;
-        const { value, done } = yield res.next();
-        if (done) {
-          controller.close();
-          return;
-        }
-        const text = trimStartOfStream((_b = (_a2 = value.token) == null ? void 0 : _a2.text) != null ? _b : "");
-        if (!text)
-          return;
-        if (value.generated_text != null && value.generated_text.length > 0) {
-          controller.close();
-          return;
-        }
-        if (text === "</s>" || text === "<|endoftext|>" || text === "<|end|>") {
-          controller.close();
-        } else {
-          controller.enqueue(text);
-        }
-      });
+    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) {
+        controller.close();
+        return;
+      }
+      if (text === "</s>" || text === "<|endoftext|>" || text === "<|end|>") {
+        controller.close();
+      } else {
+        controller.enqueue(text);
+      }
     }
   });
 }
@@ -323,50 +307,44 @@ function HuggingFaceStream(res, callbacks) {
 
 // streams/cohere-stream.ts
 var utf8Decoder = new TextDecoder("utf-8");
-function processLines(lines, controller) {
-  return __async(this, null, function* () {
-    for (const line of lines) {
-      const { text, is_finished } = JSON.parse(line);
-      if (is_finished === true) {
-        controller.close();
-      } else {
-        controller.enqueue(text);
-      }
+async function processLines(lines, controller) {
+  for (const line of lines) {
+    const { text, is_finished } = JSON.parse(line);
+    if (is_finished === true) {
+      controller.close();
+    } else {
+      controller.enqueue(text);
     }
-  });
+  }
 }
-function readAndProcessLines(reader, controller) {
-  return __async(this, null, function* () {
-    let segment = "";
-    while (true) {
-      const { value: chunk, done } = yield reader.read();
-      if (done) {
-        break;
-      }
-      segment += utf8Decoder.decode(chunk, { stream: true });
-      const linesArray = segment.split(/\r\n|\n|\r/g);
-      segment = linesArray.pop() || "";
-      yield processLines(linesArray, controller);
+async function readAndProcessLines(reader, controller) {
+  let segment = "";
+  while (true) {
+    const { value: chunk, done } = await reader.read();
+    if (done) {
+      break;
     }
-    if (segment) {
-      const linesArray = [segment];
-      yield processLines(linesArray, controller);
-    }
-    controller.close();
-  });
+    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({
-    start(controller) {
-      return __async(this, null, function* () {
-        if (!reader) {
-          controller.close();
-          return;
-        }
-        yield readAndProcessLines(reader, controller);
-      });
+    async start(controller) {
+      if (!reader) {
+        controller.close();
+        return;
+      }
+      await readAndProcessLines(reader, controller);
     }
   });
 }
@@ -394,55 +372,55 @@ function LangChainStream(callbacks) {
   const stream = new TransformStream();
   const writer = stream.writable.getWriter();
   const runs = /* @__PURE__ */ new Set();
-  const handleError = (e, runId) => __async(this, null, function* () {
+  const handleError = async (e, runId) => {
     runs.delete(runId);
-    yield writer.ready;
-    yield writer.abort(e);
-  });
-  const handleStart = (runId) => __async(this, null, function* () {
+    await writer.ready;
+    await writer.abort(e);
+  };
+  const handleStart = async (runId) => {
     runs.add(runId);
-  });
-  const handleEnd = (runId) => __async(this, null, function* () {
+  };
+  const handleEnd = async (runId) => {
     runs.delete(runId);
     if (runs.size === 0) {
-      yield writer.ready;
-      yield writer.close();
+      await writer.ready;
+      await writer.close();
     }
-  });
+  };
   return {
     stream: stream.readable.pipeThrough(createCallbacksTransformer(callbacks)),
     handlers: {
-      handleLLMNewToken: (token) => __async(this, null, function* () {
-        yield writer.ready;
-        yield writer.write(token);
-      }),
-      handleLLMStart: (_llm, _prompts, runId) => __async(this, null, function* () {
+      handleLLMNewToken: async (token) => {
+        await writer.ready;
+        await writer.write(token);
+      },
+      handleLLMStart: async (_llm, _prompts, runId) => {
         handleStart(runId);
-      }),
-      handleLLMEnd: (_output, runId) => __async(this, null, function* () {
-        yield handleEnd(runId);
-      }),
-      handleLLMError: (e, runId) => __async(this, null, function* () {
-        yield handleError(e, runId);
-      }),
-      handleChainStart: (_chain, _inputs, runId) => __async(this, null, function* () {
+      },
+      handleLLMEnd: async (_output, runId) => {
+        await handleEnd(runId);
+      },
+      handleLLMError: async (e, runId) => {
+        await handleError(e, runId);
+      },
+      handleChainStart: async (_chain, _inputs, runId) => {
         handleStart(runId);
-      }),
-      handleChainEnd: (_outputs, runId) => __async(this, null, function* () {
-        yield handleEnd(runId);
-      }),
-      handleChainError: (e, runId) => __async(this, null, function* () {
-        yield handleError(e, runId);
-      }),
-      handleToolStart: (_tool, _input, runId) => __async(this, null, function* () {
+      },
+      handleChainEnd: async (_outputs, runId) => {
+        await handleEnd(runId);
+      },
+      handleChainError: async (e, runId) => {
+        await handleError(e, runId);
+      },
+      handleToolStart: async (_tool, _input, runId) => {
         handleStart(runId);
-      }),
-      handleToolEnd: (_output, runId) => __async(this, null, function* () {
-        yield handleEnd(runId);
-      }),
-      handleToolError: (e, runId) => __async(this, null, function* () {
-        yield handleError(e, runId);
-      })
+      },
+      handleToolEnd: async (_output, runId) => {
+        await handleEnd(runId);
+      },
+      handleToolError: async (e, runId) => {
+        await handleError(e, runId);
+      }
     }
   };
 }
@@ -473,6 +451,7 @@ export {
   createChunkDecoder,
   createEventStreamTransformer,
   nanoid,
+  readableFromAsyncIterable,
   streamToResponse,
   trimStartOfStreamHelper
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "2.1.26",
+  "version": "2.1.27",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -79,8 +79,8 @@
     "ts-jest": "29.0.3",
     "tsup": "^6.7.0",
     "typescript": "5.1.3",
-    "eslint-config-vercel-ai": "0.0.0",
-    "@vercel/ai-tsconfig": "0.0.0"
+    "@vercel/ai-tsconfig": "0.0.0",
+    "eslint-config-vercel-ai": "0.0.0"
   },
   "peerDependencies": {
     "react": "^18.2.0",