ai 1.1.0 → 2.0.1

package/LICENSE

@@ -1,27 +1,13 @@
-Copyright (c) Robert Kowalski ("Author")
-All rights reserved.
+Copyright 2023 Vercel, Inc.
 
-The BSD License
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
 
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions
-are met:
+    http://www.apache.org/licenses/LICENSE-2.0
 
-1. Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright
-   notice, this list of conditions and the following disclaimer in the
-   documentation and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS
-BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
-BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
-OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
-IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/dist/ai-stream.d.ts

@@ -0,0 +1,18 @@
+interface AIStreamCallbacks {
+    onStart?: () => Promise<void>;
+    onCompletion?: (completion: string) => Promise<void>;
+    onToken?: (token: string) => Promise<void>;
+}
+interface AIStreamParser {
+    (data: string): string | void;
+}
+declare function createEventStreamTransformer(customParser: AIStreamParser): TransformStream<Uint8Array, string>;
+/**
+ * This stream forks input stream, allowing us to use the result as a
+ * bytestream of the messages and pass the messages to our callback interface.
+ */
+declare function createCallbacksTransformer(callbacks: AIStreamCallbacks | undefined): TransformStream<string, Uint8Array>;
+declare function trimStartOfStreamHelper(): (text: string) => string;
+declare function AIStream(res: Response, customParser: AIStreamParser, callbacks?: AIStreamCallbacks): ReadableStream;
+
+export { AIStream, AIStreamCallbacks, AIStreamParser, createCallbacksTransformer, createEventStreamTransformer, trimStartOfStreamHelper };

package/dist/ai-stream.js

@@ -0,0 +1,132 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+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
+var ai_stream_exports = {};
+__export(ai_stream_exports, {
+  AIStream: () => AIStream,
+  createCallbacksTransformer: () => createCallbacksTransformer,
+  createEventStreamTransformer: () => createEventStreamTransformer,
+  trimStartOfStreamHelper: () => trimStartOfStreamHelper
+});
+module.exports = __toCommonJS(ai_stream_exports);
+var import_eventsource_parser = require("eventsource-parser");
+function createEventStreamTransformer(customParser) {
+  const decoder = new TextDecoder();
+  let parser;
+  return new TransformStream({
+    start(controller) {
+      return __async(this, null, function* () {
+        function onParse(event) {
+          if (event.type === "event") {
+            const data = event.data;
+            if (data === "[DONE]") {
+              controller.terminate();
+              return;
+            }
+            const message = customParser(data);
+            if (message)
+              controller.enqueue(message);
+          }
+        }
+        parser = (0, import_eventsource_parser.createParser)(onParse);
+      });
+    },
+    transform(chunk) {
+      parser.feed(decoder.decode(chunk));
+    }
+  });
+}
+function createCallbacksTransformer(callbacks) {
+  const encoder = new TextEncoder();
+  let fullResponse = "";
+  const { onStart, onToken, onCompletion } = callbacks || {};
+  return new TransformStream({
+    start() {
+      return __async(this, null, function* () {
+        if (onStart)
+          yield onStart();
+      });
+    },
+    transform(message, controller) {
+      return __async(this, null, function* () {
+        controller.enqueue(encoder.encode(message));
+        if (onToken)
+          yield onToken(message);
+        if (onCompletion)
+          fullResponse += message;
+      });
+    },
+    flush() {
+      return __async(this, null, function* () {
+        yield onCompletion == null ? void 0 : onCompletion(fullResponse);
+      });
+    }
+  });
+}
+function trimStartOfStreamHelper() {
+  let start = true;
+  return (text) => {
+    if (start)
+      text = text.trimStart();
+    if (text)
+      start = false;
+    return text;
+  };
+}
+function AIStream(res, customParser, callbacks) {
+  if (!res.ok) {
+    throw new Error(
+      `Failed to convert the response to stream. Received status code: ${res.status}.`
+    );
+  }
+  const stream = res.body || new ReadableStream({
+    start(controller) {
+      controller.close();
+    }
+  });
+  return stream.pipeThrough(createEventStreamTransformer(customParser)).pipeThrough(createCallbacksTransformer(callbacks));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AIStream,
+  createCallbacksTransformer,
+  createEventStreamTransformer,
+  trimStartOfStreamHelper
+});

package/dist/ai-stream.mjs

@@ -0,0 +1,13 @@
+import {
+  AIStream,
+  createCallbacksTransformer,
+  createEventStreamTransformer,
+  trimStartOfStreamHelper
+} from "./chunk-265FSSO4.mjs";
+import "./chunk-2L3ZO4UM.mjs";
+export {
+  AIStream,
+  createCallbacksTransformer,
+  createEventStreamTransformer,
+  trimStartOfStreamHelper
+};

package/dist/anthropic-stream.d.ts

@@ -0,0 +1,5 @@
+import { AIStreamCallbacks } from './ai-stream.js';
+
+declare function AnthropicStream(res: Response, cb?: AIStreamCallbacks): ReadableStream;
+
+export { AnthropicStream };

package/dist/anthropic-stream.js

@@ -0,0 +1,133 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+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/anthropic-stream.ts
+var anthropic_stream_exports = {};
+__export(anthropic_stream_exports, {
+  AnthropicStream: () => AnthropicStream
+});
+module.exports = __toCommonJS(anthropic_stream_exports);
+
+// streams/ai-stream.ts
+var import_eventsource_parser = require("eventsource-parser");
+function createEventStreamTransformer(customParser) {
+  const decoder = new TextDecoder();
+  let parser;
+  return new TransformStream({
+    start(controller) {
+      return __async(this, null, function* () {
+        function onParse(event) {
+          if (event.type === "event") {
+            const data = event.data;
+            if (data === "[DONE]") {
+              controller.terminate();
+              return;
+            }
+            const message = customParser(data);
+            if (message)
+              controller.enqueue(message);
+          }
+        }
+        parser = (0, import_eventsource_parser.createParser)(onParse);
+      });
+    },
+    transform(chunk) {
+      parser.feed(decoder.decode(chunk));
+    }
+  });
+}
+function createCallbacksTransformer(callbacks) {
+  const encoder = new TextEncoder();
+  let fullResponse = "";
+  const { onStart, onToken, onCompletion } = callbacks || {};
+  return new TransformStream({
+    start() {
+      return __async(this, null, function* () {
+        if (onStart)
+          yield onStart();
+      });
+    },
+    transform(message, controller) {
+      return __async(this, null, function* () {
+        controller.enqueue(encoder.encode(message));
+        if (onToken)
+          yield onToken(message);
+        if (onCompletion)
+          fullResponse += message;
+      });
+    },
+    flush() {
+      return __async(this, null, function* () {
+        yield onCompletion == null ? void 0 : onCompletion(fullResponse);
+      });
+    }
+  });
+}
+function AIStream(res, customParser, callbacks) {
+  if (!res.ok) {
+    throw new Error(
+      `Failed to convert the response to stream. Received status code: ${res.status}.`
+    );
+  }
+  const stream = res.body || new ReadableStream({
+    start(controller) {
+      controller.close();
+    }
+  });
+  return stream.pipeThrough(createEventStreamTransformer(customParser)).pipeThrough(createCallbacksTransformer(callbacks));
+}
+
+// streams/anthropic-stream.ts
+function parseAnthropicStream() {
+  let previous = "";
+  return (data) => {
+    const json = JSON.parse(data);
+    const text = json.completion;
+    const delta = text.slice(previous.length);
+    previous = text;
+    return delta;
+  };
+}
+function AnthropicStream(res, cb) {
+  return AIStream(res, parseAnthropicStream(), cb);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AnthropicStream
+});

package/dist/anthropic-stream.mjs

@@ -0,0 +1,8 @@
+import {
+  AnthropicStream
+} from "./chunk-JGDC3BXD.mjs";
+import "./chunk-265FSSO4.mjs";
+import "./chunk-2L3ZO4UM.mjs";
+export {
+  AnthropicStream
+};

package/dist/chunk-265FSSO4.mjs

@@ -0,0 +1,91 @@
+import {
+  __async
+} from "./chunk-2L3ZO4UM.mjs";
+
+// streams/ai-stream.ts
+import {
+  createParser
+} from "eventsource-parser";
+function createEventStreamTransformer(customParser) {
+  const decoder = new TextDecoder();
+  let parser;
+  return new TransformStream({
+    start(controller) {
+      return __async(this, null, function* () {
+        function onParse(event) {
+          if (event.type === "event") {
+            const data = event.data;
+            if (data === "[DONE]") {
+              controller.terminate();
+              return;
+            }
+            const message = customParser(data);
+            if (message)
+              controller.enqueue(message);
+          }
+        }
+        parser = createParser(onParse);
+      });
+    },
+    transform(chunk) {
+      parser.feed(decoder.decode(chunk));
+    }
+  });
+}
+function createCallbacksTransformer(callbacks) {
+  const encoder = new TextEncoder();
+  let fullResponse = "";
+  const { onStart, onToken, onCompletion } = callbacks || {};
+  return new TransformStream({
+    start() {
+      return __async(this, null, function* () {
+        if (onStart)
+          yield onStart();
+      });
+    },
+    transform(message, controller) {
+      return __async(this, null, function* () {
+        controller.enqueue(encoder.encode(message));
+        if (onToken)
+          yield onToken(message);
+        if (onCompletion)
+          fullResponse += message;
+      });
+    },
+    flush() {
+      return __async(this, null, function* () {
+        yield onCompletion == null ? void 0 : onCompletion(fullResponse);
+      });
+    }
+  });
+}
+function trimStartOfStreamHelper() {
+  let start = true;
+  return (text) => {
+    if (start)
+      text = text.trimStart();
+    if (text)
+      start = false;
+    return text;
+  };
+}
+function AIStream(res, customParser, callbacks) {
+  if (!res.ok) {
+    throw new Error(
+      `Failed to convert the response to stream. Received status code: ${res.status}.`
+    );
+  }
+  const stream = res.body || new ReadableStream({
+    start(controller) {
+      controller.close();
+    }
+  });
+  return stream.pipeThrough(createEventStreamTransformer(customParser)).pipeThrough(createCallbacksTransformer(callbacks));
+}
+
+export {
+  createEventStreamTransformer,
+  createCallbacksTransformer,
+  trimStartOfStreamHelper,
+  AIStream
+};

package/dist/chunk-2L3ZO4UM.mjs

@@ -0,0 +1,45 @@
+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());
+  });
+};
+
+export {
+  __spreadValues,
+  __spreadProps,
+  __async
+};

package/dist/chunk-GT4HKF2X.mjs

@@ -0,0 +1,33 @@
+import {
+  createCallbacksTransformer
+} from "./chunk-265FSSO4.mjs";
+import {
+  __async
+} from "./chunk-2L3ZO4UM.mjs";
+
+// streams/langchain-stream.ts
+function LangChainStream(callbacks) {
+  const stream = new TransformStream();
+  const writer = stream.writable.getWriter();
+  return {
+    stream: stream.readable.pipeThrough(createCallbacksTransformer(callbacks)),
+    handlers: {
+      handleLLMNewToken: (token) => __async(this, null, function* () {
+        yield writer.ready;
+        yield writer.write(token);
+      }),
+      handleChainEnd: () => __async(this, null, function* () {
+        yield writer.ready;
+        yield writer.close();
+      }),
+      handleLLMError: (e) => __async(this, null, function* () {
+        yield writer.ready;
+        yield writer.abort(e);
+      })
+    }
+  };
+}
+
+export {
+  LangChainStream
+};

package/dist/chunk-JGDC3BXD.mjs

@@ -0,0 +1,22 @@
+import {
+  AIStream
+} from "./chunk-265FSSO4.mjs";
+
+// streams/anthropic-stream.ts
+function parseAnthropicStream() {
+  let previous = "";
+  return (data) => {
+    const json = JSON.parse(data);
+    const text = json.completion;
+    const delta = text.slice(previous.length);
+    previous = text;
+    return delta;
+  };
+}
+function AnthropicStream(res, cb) {
+  return AIStream(res, parseAnthropicStream(), cb);
+}
+
+export {
+  AnthropicStream
+};

package/dist/chunk-NK2CVBLI.mjs

@@ -0,0 +1,38 @@
+import {
+  __spreadProps,
+  __spreadValues
+} from "./chunk-2L3ZO4UM.mjs";
+
+// streams/streaming-text-response.ts
+var StreamingTextResponse = class extends Response {
+  constructor(res, init) {
+    super(res, __spreadProps(__spreadValues({}, init), {
+      status: 200,
+      headers: __spreadValues({
+        "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));
+  const reader = res.getReader();
+  function read() {
+    reader.read().then(({ done, value }) => {
+      if (done) {
+        response.end();
+        return;
+      }
+      response.write(value);
+      read();
+    });
+  }
+  read();
+}
+
+export {
+  StreamingTextResponse,
+  streamToResponse
+};

package/dist/chunk-PEYAHBDF.mjs

@@ -0,0 +1,43 @@
+import {
+  createCallbacksTransformer,
+  trimStartOfStreamHelper
+} from "./chunk-265FSSO4.mjs";
+import {
+  __async
+} from "./chunk-2L3ZO4UM.mjs";
+
+// streams/huggingface-stream.ts
+function createParser(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|>") {
+          controller.close();
+        } else {
+          controller.enqueue(text);
+        }
+      });
+    }
+  });
+}
+function HuggingFaceStream(res, callbacks) {
+  return createParser(res).pipeThrough(createCallbacksTransformer(callbacks));
+}
+
+export {
+  HuggingFaceStream
+};

package/dist/chunk-TJMME6CL.mjs

@@ -0,0 +1,24 @@
+import {
+  AIStream,
+  trimStartOfStreamHelper
+} from "./chunk-265FSSO4.mjs";
+
+// streams/openai-stream.ts
+function parseOpenAIStream() {
+  const trimStartOfStream = trimStartOfStreamHelper();
+  return (data) => {
+    var _a, _b, _c, _d, _e;
+    const json = JSON.parse(data);
+    const text = trimStartOfStream(
+      (_e = (_d = (_b = (_a = json.choices[0]) == null ? void 0 : _a.delta) == null ? void 0 : _b.content) != null ? _d : (_c = json.choices[0]) == null ? void 0 : _c.text) != null ? _e : ""
+    );
+    return text;
+  };
+}
+function OpenAIStream(res, cb) {
+  return AIStream(res, parseOpenAIStream(), cb);
+}
+
+export {
+  OpenAIStream
+};

package/dist/huggingface-stream.d.ts

@@ -0,0 +1,5 @@
+import { AIStreamCallbacks } from './ai-stream.js';
+
+declare function HuggingFaceStream(res: AsyncGenerator<any>, callbacks?: AIStreamCallbacks): ReadableStream;
+
+export { HuggingFaceStream };