ai 1.1.0 → 2.0.1

package/dist/langchain-stream.js

@@ -0,0 +1,102 @@
+"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/langchain-stream.ts
+var langchain_stream_exports = {};
+__export(langchain_stream_exports, {
+  LangChainStream: () => LangChainStream
+});
+module.exports = __toCommonJS(langchain_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);
+      });
+    }
+  });
+}
+
+// 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 = {
+  LangChainStream
+});

package/dist/langchain-stream.mjs

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

package/dist/openai-stream.d.ts

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

package/dist/openai-stream.js

@@ -0,0 +1,144 @@
+"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/openai-stream.ts
+var openai_stream_exports = {};
+__export(openai_stream_exports, {
+  OpenAIStream: () => OpenAIStream
+});
+module.exports = __toCommonJS(openai_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 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);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OpenAIStream
+});

package/dist/openai-stream.mjs

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

package/dist/streaming-text-response.d.ts

@@ -0,0 +1,17 @@
+import { ServerResponse } from 'node:http';
+
+/**
+ * A utility class for streaming text responses.
+ */
+declare class StreamingTextResponse extends Response {
+    constructor(res: ReadableStream, init?: ResponseInit);
+}
+/**
+ * A utility function to stream a ReadableStream to a Node.js response-like object.
+ */
+declare function streamToResponse(res: ReadableStream, response: ServerResponse, init?: {
+    headers?: Record<string, string>;
+    status?: number;
+}): void;
+
+export { StreamingTextResponse, streamToResponse };

package/dist/streaming-text-response.js

@@ -0,0 +1,75 @@
+"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);
+
+// streams/streaming-text-response.ts
+var streaming_text_response_exports = {};
+__export(streaming_text_response_exports, {
+  StreamingTextResponse: () => StreamingTextResponse,
+  streamToResponse: () => streamToResponse
+});
+module.exports = __toCommonJS(streaming_text_response_exports);
+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();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StreamingTextResponse,
+  streamToResponse
+});

package/dist/streaming-text-response.mjs

@@ -0,0 +1,9 @@
+import {
+  StreamingTextResponse,
+  streamToResponse
+} from "./chunk-NK2CVBLI.mjs";
+import "./chunk-2L3ZO4UM.mjs";
+export {
+  StreamingTextResponse,
+  streamToResponse
+};

package/package.json

@@ -1,37 +1,86 @@
 {
   "name": "ai",
-  "version": "1.1.0",
-  "description": "I'm helping you finding abandoned issues in your project",
-  "main": "index.js",
-  "bin": "./bin/ai.js",
-  "preferGlobal": true,
+  "version": "2.0.1",
+  "license": "Apache-2.0",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/**/*",
+    "react/dist/**/*",
+    "svelte/dist/**/*"
+  ],
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "module": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./react": {
+      "types": "./react/dist/index.d.ts",
+      "import": "./react/dist/index.mjs",
+      "module": "./react/dist/index.mjs",
+      "require": "./react/dist/index.js"
+    },
+    "./svelte": {
+      "types": "./svelte/dist/index.d.ts",
+      "import": "./svelte/dist/index.mjs",
+      "module": "./svelte/dist/index.mjs",
+      "require": "./svelte/dist/index.js"
+    }
+  },
+  "jest": {
+    "preset": "ts-jest",
+    "testEnvironment": "node"
+  },
   "dependencies": {
-    "request": "~2.40.0"
+    "eventsource-parser": "1.0.0",
+    "nanoid": "^3.3.6",
+    "sswr": "^1.10.0",
+    "swr": "2.1.5"
   },
   "devDependencies": {
-    "hock": "~0.2.4",
-    "tap": "~0.4.8"
+    "@edge-runtime/jest-environment": "1.1.0-beta.31",
+    "@types/jest": "29.2.0",
+    "@types/node": "^17.0.12",
+    "@types/react": "^18.2.0",
+    "@types/react-dom": "^18.2.0",
+    "eslint": "^7.32.0",
+    "jest": "29.2.1",
+    "ts-jest": "29.0.3",
+    "tsup": "^6.7.0",
+    "typescript": "^4.5.3",
+    "@vercel/ai-tsconfig": "0.0.0",
+    "eslint-config-vercel-ai": "0.0.0"
+  },
+  "peerDependencies": {
+    "react": "^18.0.0",
+    "svelte": "^3.29.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "svelte": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=14.6"
+  },
+  "publishConfig": {
+    "access": "public"
   },
-  "bundleDependencies": [
-    "request"
-  ],
   "scripts": {
-    "test": "tap test/*.js"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/robertkowalski/ai.git"
-  },
-  "homepage": "https://github.com/robertkowalski/ai",
-  "keywords": [
-    "support,",
-    "github,",
-    "issues,",
-    "abandoned"
-  ],
-  "author": "Robert Kowalski <rok@kowalski.gd>",
-  "license": "BSD-2-Clause",
-  "bugs": {
-    "url": "https://github.com/robertkowalski/ai/issues"
+    "build": "tsup",
+    "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist && rm -rf react/dist && rm -rf svelte/dist",
+    "dev": "tsup --watch",
+    "lint": "eslint \"./**/*.ts*\"",
+    "type-check": "tsc --noEmit",
+    "prettier-check": "prettier --check \"./**/*.ts*\"",
+    "test": "jest --env @edge-runtime/jest-environment .test.ts && jest --env node .test.ts"
   }
-}
+}

package/react/dist/chunk-5PP6W52J.mjs

@@ -0,0 +1,202 @@
+'use client'
+import {
+  __async,
+  __spreadValues,
+  decodeAIStreamChunk,
+  nanoid
+} from "./chunk-6EH3SWMP.mjs";
+
+// react/use-chat.ts
+import { useCallback, useId, useRef, useEffect, useState } from "react";
+import useSWRMutation from "swr/mutation";
+import useSWR from "swr";
+function useChat({
+  api = "/api/chat",
+  id,
+  initialMessages = [],
+  initialInput = "",
+  sendExtraMessageFields,
+  onResponse,
+  onFinish,
+  onError,
+  headers,
+  body
+} = {}) {
+  const hookId = useId();
+  const chatId = id || hookId;
+  const { data, mutate } = useSWR([api, chatId], null, {
+    fallbackData: initialMessages
+  });
+  const messages = data;
+  const messagesRef = useRef(messages);
+  useEffect(() => {
+    messagesRef.current = messages;
+  }, [messages]);
+  const abortControllerRef = useRef(null);
+  const extraMetadataRef = useRef({
+    headers,
+    body
+  });
+  useEffect(() => {
+    extraMetadataRef.current = {
+      headers,
+      body
+    };
+  }, [headers, body]);
+  const { error, trigger, isMutating } = useSWRMutation(
+    [api, chatId],
+    (_0, _1) => __async(this, [_0, _1], function* (_, { arg: messagesSnapshot }) {
+      try {
+        const abortController = new AbortController();
+        abortControllerRef.current = abortController;
+        const previousMessages = messagesRef.current;
+        mutate(messagesSnapshot, false);
+        const res = yield fetch(api, {
+          method: "POST",
+          body: JSON.stringify(__spreadValues({
+            messages: sendExtraMessageFields ? messagesSnapshot : messagesSnapshot.map(({ role, content }) => ({
+              role,
+              content
+            }))
+          }, extraMetadataRef.current.body)),
+          headers: extraMetadataRef.current.headers || {},
+          signal: abortController.signal
+        }).catch((err) => {
+          mutate(previousMessages, false);
+          throw err;
+        });
+        if (onResponse) {
+          try {
+            yield onResponse(res);
+          } catch (err) {
+            throw err;
+          }
+        }
+        if (!res.ok) {
+          mutate(previousMessages, false);
+          throw new Error(
+            (yield res.text()) || "Failed to fetch the chat response."
+          );
+        }
+        if (!res.body) {
+          throw new Error("The response body is empty.");
+        }
+        let result = "";
+        const createdAt = /* @__PURE__ */ new Date();
+        const replyId = nanoid();
+        const reader = res.body.getReader();
+        while (true) {
+          const { done, value } = yield reader.read();
+          if (done) {
+            break;
+          }
+          result += decodeAIStreamChunk(value);
+          mutate(
+            [
+              ...messagesSnapshot,
+              {
+                id: replyId,
+                createdAt,
+                content: result,
+                role: "assistant"
+              }
+            ],
+            false
+          );
+          if (abortControllerRef.current === null) {
+            reader.cancel();
+            break;
+          }
+        }
+        if (onFinish) {
+          onFinish({
+            id: replyId,
+            createdAt,
+            content: result,
+            role: "assistant"
+          });
+        }
+        abortControllerRef.current = null;
+        return result;
+      } catch (err) {
+        if (err.name === "AbortError") {
+          abortControllerRef.current = null;
+          return null;
+        }
+        if (onError && err instanceof Error) {
+          onError(err);
+        }
+        throw err;
+      }
+    }),
+    {
+      populateCache: false,
+      revalidate: false
+    }
+  );
+  const append = useCallback(
+    (message) => __async(this, null, function* () {
+      if (!message.id) {
+        message.id = nanoid();
+      }
+      return trigger(messagesRef.current.concat(message));
+    }),
+    [trigger]
+  );
+  const reload = useCallback(() => __async(this, null, function* () {
+    if (messagesRef.current.length === 0)
+      return null;
+    const lastMessage = messagesRef.current[messagesRef.current.length - 1];
+    if (lastMessage.role === "assistant") {
+      return trigger(messagesRef.current.slice(0, -1));
+    }
+    return trigger(messagesRef.current);
+  }), [trigger]);
+  const stop = useCallback(() => {
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+      abortControllerRef.current = null;
+    }
+  }, []);
+  const setMessages = useCallback(
+    (messages2) => {
+      mutate(messages2, false);
+      messagesRef.current = messages2;
+    },
+    [mutate]
+  );
+  const [input, setInput] = useState(initialInput);
+  const handleSubmit = useCallback(
+    (e) => {
+      e.preventDefault();
+      if (!input)
+        return;
+      append({
+        content: input,
+        role: "user"
+      });
+      setInput("");
+    },
+    [input, append]
+  );
+  const handleInputChange = (e) => {
+    setInput(e.target.value);
+  };
+  return {
+    messages,
+    error,
+    append,
+    reload,
+    stop,
+    setMessages,
+    input,
+    setInput,
+    handleInputChange,
+    handleSubmit,
+    isLoading: isMutating
+  };
+}
+
+export {
+  useChat
+};