ai 1.1.0 → 2.0.1

package/dist/huggingface-stream.js

@@ -0,0 +1,121 @@
+"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/huggingface-stream.ts
+var huggingface_stream_exports = {};
+__export(huggingface_stream_exports, {
+  HuggingFaceStream: () => HuggingFaceStream
+});
+module.exports = __toCommonJS(huggingface_stream_exports);
+
+// streams/ai-stream.ts
+var import_eventsource_parser = require("eventsource-parser");
+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;
+  };
+}
+
+// streams/huggingface-stream.ts
+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|>") {
+          controller.close();
+        } else {
+          controller.enqueue(text);
+        }
+      });
+    }
+  });
+}
+function HuggingFaceStream(res, callbacks) {
+  return createParser2(res).pipeThrough(createCallbacksTransformer(callbacks));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HuggingFaceStream
+});

package/dist/huggingface-stream.mjs

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

package/dist/index.d.ts

@@ -0,0 +1,131 @@
+export { AIStream, AIStreamCallbacks, AIStreamParser, createCallbacksTransformer, createEventStreamTransformer, trimStartOfStreamHelper } from './ai-stream.js';
+export { OpenAIStream } from './openai-stream.js';
+export { StreamingTextResponse, streamToResponse } from './streaming-text-response.js';
+export { HuggingFaceStream } from './huggingface-stream.js';
+export { AnthropicStream } from './anthropic-stream.js';
+export { LangChainStream } from './langchain-stream.js';
+import 'node:http';
+
+/**
+ * Shared types between the API and UI packages.
+ */
+type Message = {
+    id: string;
+    createdAt?: Date;
+    content: string;
+    role: 'system' | 'user' | 'assistant';
+};
+type CreateMessage = {
+    id?: string;
+    createdAt?: Date;
+    content: string;
+    role: 'system' | 'user' | 'assistant';
+};
+type UseChatOptions = {
+    /**
+     * The API endpoint that accepts a `{ messages: Message[] }` object and returns
+     * a stream of tokens of the AI chat response. Defaults to `/api/chat`.
+     */
+    api?: string;
+    /**
+     * An unique identifier for the chat. If not provided, a random one will be
+     * generated. When provided, the `useChat` hook with the same `id` will
+     * have shared states across components.
+     */
+    id?: string;
+    /**
+     * Initial messages of the chat. Useful to load an existing chat history.
+     */
+    initialMessages?: Message[];
+    /**
+     * Initial input of the chat.
+     */
+    initialInput?: string;
+    /**
+     * Callback function to be called when the API response is received.
+     */
+    onResponse?: (response: Response) => void;
+    /**
+     * Callback function to be called when the chat is finished streaming.
+     */
+    onFinish?: (message: Message) => void;
+    /**
+     * Callback function to be called when an error is encountered.
+     */
+    onError?: (error: Error) => void;
+    /**
+     * HTTP headers to be sent with the API request.
+     */
+    headers?: Record<string, string> | Headers;
+    /**
+     * Extra body object to be sent with the API request.
+     * @example
+     * Send a `sessionId` to the API along with the messages.
+     * ```js
+     * useChat({
+     *   body: {
+     *     sessionId: '123',
+     *   }
+     * })
+     * ```
+     */
+    body?: object;
+    /**
+     * Whether to send extra message fields such as `message.id` and `message.createdAt` to the API.
+     * Defaults to `false`. When set to `true`, the API endpoint might need to
+     * handle the extra fields before forwarding the request to the AI service.
+     */
+    sendExtraMessageFields?: boolean;
+};
+type UseCompletionOptions = {
+    /**
+     * The API endpoint that accepts a `{ prompt: string }` object and returns
+     * a stream of tokens of the AI completion response. Defaults to `/api/completion`.
+     */
+    api?: string;
+    /**
+     * An unique identifier for the chat. If not provided, a random one will be
+     * generated. When provided, the `useChat` hook with the same `id` will
+     * have shared states across components.
+     */
+    id?: string;
+    /**
+     * Initial prompt input of the completion.
+     */
+    initialInput?: string;
+    /**
+     * Initial completion result. Useful to load an existing history.
+     */
+    initialCompletion?: string;
+    /**
+     * Callback function to be called when the API response is received.
+     */
+    onResponse?: (response: Response) => void;
+    /**
+     * Callback function to be called when the completion is finished streaming.
+     */
+    onFinish?: (prompt: string, completion: string) => void;
+    /**
+     * Callback function to be called when an error is encountered.
+     */
+    onError?: (error: Error) => void;
+    /**
+     * HTTP headers to be sent with the API request.
+     */
+    headers?: Record<string, string> | Headers;
+    /**
+     * Extra body object to be sent with the API request.
+     * @example
+     * Send a `sessionId` to the API along with the prompt.
+     * ```js
+     * useChat({
+     *   body: {
+     *     sessionId: '123',
+     *   }
+     * })
+     * ```
+     */
+    body?: object;
+};
+
+export { CreateMessage, Message, UseChatOptions, UseCompletionOptions };

package/dist/index.js

@@ -0,0 +1,278 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __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/index.ts
+var streams_exports = {};
+__export(streams_exports, {
+  AIStream: () => AIStream,
+  AnthropicStream: () => AnthropicStream,
+  HuggingFaceStream: () => HuggingFaceStream,
+  LangChainStream: () => LangChainStream,
+  OpenAIStream: () => OpenAIStream,
+  StreamingTextResponse: () => StreamingTextResponse,
+  createCallbacksTransformer: () => createCallbacksTransformer,
+  createEventStreamTransformer: () => createEventStreamTransformer,
+  streamToResponse: () => streamToResponse,
+  trimStartOfStreamHelper: () => trimStartOfStreamHelper
+});
+module.exports = __toCommonJS(streams_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 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));
+}
+
+// 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);
+}
+
+// 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();
+}
+
+// streams/huggingface-stream.ts
+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|>") {
+          controller.close();
+        } else {
+          controller.enqueue(text);
+        }
+      });
+    }
+  });
+}
+function HuggingFaceStream(res, callbacks) {
+  return createParser2(res).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);
+}
+
+// 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);
+      })
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AIStream,
+  AnthropicStream,
+  HuggingFaceStream,
+  LangChainStream,
+  OpenAIStream,
+  StreamingTextResponse,
+  createCallbacksTransformer,
+  createEventStreamTransformer,
+  streamToResponse,
+  trimStartOfStreamHelper
+});

package/dist/index.mjs

@@ -0,0 +1,35 @@
+import {
+  AnthropicStream
+} from "./chunk-JGDC3BXD.mjs";
+import {
+  HuggingFaceStream
+} from "./chunk-PEYAHBDF.mjs";
+import {
+  LangChainStream
+} from "./chunk-GT4HKF2X.mjs";
+import {
+  OpenAIStream
+} from "./chunk-TJMME6CL.mjs";
+import {
+  AIStream,
+  createCallbacksTransformer,
+  createEventStreamTransformer,
+  trimStartOfStreamHelper
+} from "./chunk-265FSSO4.mjs";
+import {
+  StreamingTextResponse,
+  streamToResponse
+} from "./chunk-NK2CVBLI.mjs";
+import "./chunk-2L3ZO4UM.mjs";
+export {
+  AIStream,
+  AnthropicStream,
+  HuggingFaceStream,
+  LangChainStream,
+  OpenAIStream,
+  StreamingTextResponse,
+  createCallbacksTransformer,
+  createEventStreamTransformer,
+  streamToResponse,
+  trimStartOfStreamHelper
+};

package/dist/index.test.d.ts

@@ -0,0 +1,2 @@
+
+export { }

package/dist/index.test.js

@@ -0,0 +1,12 @@
+"use strict";
+
+// streams/index.test.ts
+describe("ai", () => {
+  beforeEach(() => {
+  });
+  describe("not a real test", () => {
+    it("exports a default client", () => {
+      expect(true).toEqual(true);
+    });
+  });
+});

package/dist/index.test.mjs

@@ -0,0 +1,10 @@
+// streams/index.test.ts
+describe("ai", () => {
+  beforeEach(() => {
+  });
+  describe("not a real test", () => {
+    it("exports a default client", () => {
+      expect(true).toEqual(true);
+    });
+  });
+});

package/dist/langchain-stream.d.ts

@@ -0,0 +1,12 @@
+import { AIStreamCallbacks } from './ai-stream.js';
+
+declare function LangChainStream(callbacks?: AIStreamCallbacks): {
+    stream: ReadableStream<Uint8Array>;
+    handlers: {
+        handleLLMNewToken: (token: string) => Promise<void>;
+        handleChainEnd: () => Promise<void>;
+        handleLLMError: (e: any) => Promise<void>;
+    };
+};
+
+export { LangChainStream };