@xsai/utils-reasoning 0.2.0-beta.6

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Moeru AI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,26 @@
+interface ExtractReasoningOptions {
+    /** @default `\n` */
+    separator?: string;
+    /** @default `false` */
+    startWithReasoning?: boolean;
+    /** @default `think` */
+    tagName: string;
+}
+interface ExtractReasoningResult {
+    reasoning?: string;
+    text: string;
+}
+declare const extractReasoning: (text: string, options?: ExtractReasoningOptions) => {
+    reasoning: string;
+    text: string;
+};
+
+interface ExtractReasoningStreamOptions extends ExtractReasoningOptions {
+}
+interface ExtractReasoningStreamResult {
+    reasoningStream: ReadableStream<string>;
+    textStream: ReadableStream<string>;
+}
+declare const extractReasoningStream: (stream: ReadableStream<string>, options?: ExtractReasoningStreamOptions) => ExtractReasoningStreamResult;
+
+export { type ExtractReasoningOptions, type ExtractReasoningResult, type ExtractReasoningStreamOptions, type ExtractReasoningStreamResult, extractReasoning, extractReasoningStream };

package/dist/index.js

@@ -0,0 +1,133 @@
+const extractReasoning = (text, options = {
+  tagName: "think"
+}) => {
+  const startTag = `<${options.tagName}>`;
+  const endTag = `</${options.tagName}>`;
+  const separator = options.separator ?? "\n";
+  const fullText = options.startWithReasoning ? startTag + text : text;
+  const regex = new RegExp(`${startTag}(.*?)${endTag}`, "gs");
+  const reasonMatches = [...fullText.matchAll(regex)];
+  if (reasonMatches.length === 0) {
+    return {
+      reasoning: void 0,
+      text
+    };
+  }
+  const reasoning = reasonMatches.map((match) => match[1]).join(separator);
+  let startIndex = 0;
+  const texts = reasonMatches.reduce((acc, match, idx) => {
+    if (startIndex < match.index) {
+      acc.push(fullText.slice(startIndex, match.index));
+    }
+    startIndex = match.index + match[0].length;
+    if (idx === reasonMatches.length - 1) {
+      acc.push(fullText.slice(startIndex));
+    }
+    return acc;
+  }, []).join(separator);
+  return {
+    reasoning,
+    text: texts
+  };
+};
+
+const getPartialMatchIndex = (text, matchText) => {
+  if (text.length === 0 || matchText.length === 0) {
+    return -1;
+  }
+  const matchIndex = text.indexOf(matchText);
+  if (matchIndex !== -1) {
+    return matchIndex;
+  }
+  for (let i = Math.max(text.length - matchText.length + 1, 0); i < text.length; i++) {
+    if (matchText.startsWith(text.slice(i))) {
+      return i;
+    }
+  }
+  return -1;
+};
+
+const extractReasoningStream = (stream, options = {
+  tagName: "think"
+}) => {
+  const startTag = `<${options.tagName}>`;
+  const endTag = `</${options.tagName}>`;
+  const separator = options.separator ?? "\n";
+  let reasoningStreamController;
+  let textStreamController;
+  const reasoningStream = new ReadableStream({
+    start(controller) {
+      reasoningStreamController = controller;
+    }
+  });
+  const textStream = new ReadableStream({
+    start(controller) {
+      textStreamController = controller;
+    }
+  });
+  let buffer = "";
+  let isFirstTextMode = true;
+  let isFirstReasoningMode = true;
+  let isReasoning = options.startWithReasoning;
+  let switchBlock = false;
+  const enqueueStream = (chunk) => {
+    if (chunk.length === 0) {
+      return;
+    }
+    const prefix = switchBlock && (isReasoning ? !isFirstReasoningMode : !isFirstTextMode) ? separator : "";
+    if (isReasoning) {
+      reasoningStreamController?.enqueue(prefix + chunk);
+      isFirstReasoningMode = false;
+    } else {
+      textStreamController?.enqueue(prefix + chunk);
+      isFirstTextMode = false;
+    }
+    switchBlock = false;
+  };
+  stream.pipeTo(
+    new WritableStream({
+      close() {
+        if (buffer.length > 0) {
+          if (isReasoning) {
+            reasoningStreamController?.enqueue(buffer);
+          } else {
+            textStreamController?.enqueue(buffer);
+          }
+        }
+        reasoningStreamController?.close();
+        textStreamController?.close();
+      },
+      write(chunk) {
+        buffer += chunk;
+        while (true) {
+          const checkTag = isReasoning ? endTag : startTag;
+          const idx = getPartialMatchIndex(buffer, checkTag);
+          if (idx === -1) {
+            enqueueStream(buffer);
+            buffer = "";
+            break;
+          }
+          enqueueStream(buffer.slice(0, idx));
+          const isFullMatch = idx + checkTag.length <= buffer.length;
+          if (isFullMatch) {
+            isReasoning = !isReasoning;
+            buffer = buffer.slice(idx + checkTag.length);
+            switchBlock = true;
+          } else {
+            buffer = buffer.slice(idx);
+            break;
+          }
+        }
+      }
+    })
+  ).catch((error) => {
+    reasoningStreamController?.error(error);
+    textStreamController?.error(error);
+  });
+  return {
+    reasoningStream,
+    textStream
+  };
+};
+
+export { extractReasoning, extractReasoningStream };

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@xsai/utils-reasoning",
+  "type": "module",
+  "version": "0.2.0-beta.6",
+  "description": "extra-small AI SDK for Browser, Node.js, Deno, Bun or Edge Runtime.",
+  "author": "Moeru AI",
+  "license": "MIT",
+  "homepage": "https://xsai.js.org",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/moeru-ai/xsai.git",
+    "directory": "packages/utils-reasoning"
+  },
+  "bugs": "https://github.com/moeru-ai/xsai/issues",
+  "keywords": [
+    "xsai",
+    "openai",
+    "ai"
+  ],
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@xsai/generate-text": "",
+    "@xsai/stream-text": ""
+  },
+  "scripts": {
+    "build": "pkgroll",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts"
+}