@mikugg/guidance 0.8.0

package/dist/lib/_trie.d.ts

@@ -0,0 +1,41 @@
+declare class TrieNode {
+    children: Map<number, TrieNode>;
+    isEndOfWord: boolean;
+    constructor();
+}
+/**
+ * Trie data structure for storing a list of numbers
+ */
+export default class Trie {
+    root: TrieNode;
+    constructor();
+    /**
+     * Add a prefix to the trie, a list of numbers
+     *
+     * @param prefix A list of numbers
+     */
+    addPrefix(prefix: number[]): void;
+    /**
+     * Get the next children of a prefix, a list of numbers
+     *
+     * @param prefix A list of numbers
+     * @returns
+     */
+    getNextChildren(prefix: number[]): number[];
+    /**
+     * Returns the word until it find multiple children or isEndOfWord
+     *
+     * @param prefix A list of numbers
+     * @returns
+     */
+    getNextPrefix(prefix: number[]): number[];
+    /**
+     * Returns the word until the end of the prefix, a list of numbers
+     *
+     * @param prefix A list of numbers
+     * @returns
+     */
+    getWord(prefix: number[]): number[];
+}
+export {};
+//# sourceMappingURL=_trie.d.ts.map

package/dist/lib/_trie.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_trie.d.ts","sourceRoot":"","sources":["../../src/lib/_trie.ts"],"names":[],"mappings":"AAAA,cAAM,QAAQ;IACZ,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IAChC,WAAW,EAAE,OAAO,CAAC;;CAMtB;AAED;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,IAAI;IACvB,IAAI,EAAE,QAAQ,CAAC;;IAMf;;;;OAIG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI;IAWjC;;;;;OAKG;IACH,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE;IAY3C;;;;;OAKG;IACH,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE;IAoBzC;;;;;OAKG;IACH,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE;CAmBpC"}

package/dist/lib/_trie.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class TrieNode {
+    constructor() {
+        this.children = new Map();
+        this.isEndOfWord = false;
+    }
+}
+/**
+ * Trie data structure for storing a list of numbers
+ */
+class Trie {
+    constructor() {
+        this.root = new TrieNode();
+    }
+    /**
+     * Add a prefix to the trie, a list of numbers
+     *
+     * @param prefix A list of numbers
+     */
+    addPrefix(prefix) {
+        let node = this.root;
+        prefix.forEach(num => {
+            if (!node.children.has(num)) {
+                node.children.set(num, new TrieNode());
+            }
+            node = node.children.get(num);
+        });
+        node.isEndOfWord = true;
+    }
+    /**
+     * Get the next children of a prefix, a list of numbers
+     *
+     * @param prefix A list of numbers
+     * @returns
+     */
+    getNextChildren(prefix) {
+        let node = this.root;
+        for (const num of prefix) {
+            if (node.children.has(num)) {
+                node = node.children.get(num);
+            }
+            else {
+                return []; // prefix not found
+            }
+        }
+        return Array.from(node.children.keys());
+    }
+    /**
+     * Returns the word until it find multiple children or isEndOfWord
+     *
+     * @param prefix A list of numbers
+     * @returns
+     */
+    getNextPrefix(prefix) {
+        let node = this.root;
+        const nextPrefix = [];
+        for (const num of prefix) {
+            if (node.children.has(num)) {
+                nextPrefix.push(num);
+                node = node.children.get(num);
+            }
+            else {
+                return []; // prefix not found
+            }
+        }
+        // continue until children > 1 or isEndOfWord
+        while (node.children.size === 1 && !node.isEndOfWord) {
+            const nextChild = Array.from(node.children.keys())[0];
+            nextPrefix.push(nextChild);
+            node = node.children.get(nextChild);
+        }
+        return nextPrefix;
+    }
+    /**
+     * Returns the word until the end of the prefix, a list of numbers
+     *
+     * @param prefix A list of numbers
+     * @returns
+     */
+    getWord(prefix) {
+        let node = this.root;
+        const word = [];
+        for (const num of prefix) {
+            if (node.children.has(num)) {
+                word.push(num);
+                node = node.children.get(num);
+            }
+            else {
+                return []; // prefix not found
+            }
+        }
+        // cotinue to get the first child until the end of the word
+        while (!node.isEndOfWord && node.children.size > 0) {
+            const nextChild = Array.from(node.children.keys())[0];
+            word.push(nextChild);
+            node = node.children.get(nextChild);
+        }
+        return word;
+    }
+}
+exports.default = Trie;

package/dist/lib/template.d.ts

@@ -0,0 +1,16 @@
+import { AbstractTokenizer } from './tokenizer';
+import { AbstractTokenGenerator } from './token-generator';
+export declare enum TEMPLATE_METHODS {
+    SEL = "SEL",
+    GEN = "GEN"
+}
+export declare class TemplateProcessor {
+    private tokenizer;
+    private generator;
+    constructor(tokenizer: AbstractTokenizer, generator: AbstractTokenGenerator);
+    setTokenizer(tokenizer: AbstractTokenizer): void;
+    setGenerator(generator: AbstractTokenGenerator): void;
+    processTemplate(template: string, variables: Map<string, string | string[]>): Promise<Map<string, string>>;
+    private findAllIndexes;
+}
+//# sourceMappingURL=template.d.ts.map

package/dist/lib/template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template.d.ts","sourceRoot":"","sources":["../../src/lib/template.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAE3D,oBAAY,gBAAgB;IAC1B,GAAG,QAAQ;IACX,GAAG,QAAQ;CACZ;AAED,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,SAAS,CAAoB;IACrC,OAAO,CAAC,SAAS,CAAyB;gBAE9B,SAAS,EAAE,iBAAiB,EAAE,SAAS,EAAE,sBAAsB;IAKpE,YAAY,CAAC,SAAS,EAAE,iBAAiB;IAIzC,YAAY,CAAC,SAAS,EAAE,sBAAsB;IAIxC,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,GAAC,MAAM,EAAE,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAkFrH,OAAO,CAAC,cAAc;CAQvB"}

package/dist/lib/template.js

@@ -0,0 +1,117 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateProcessor = exports.TEMPLATE_METHODS = void 0;
+const _trie_1 = __importDefault(require("./_trie"));
+var TEMPLATE_METHODS;
+(function (TEMPLATE_METHODS) {
+    TEMPLATE_METHODS["SEL"] = "SEL";
+    TEMPLATE_METHODS["GEN"] = "GEN";
+})(TEMPLATE_METHODS || (exports.TEMPLATE_METHODS = TEMPLATE_METHODS = {}));
+class TemplateProcessor {
+    constructor(tokenizer, generator) {
+        this.tokenizer = tokenizer;
+        this.generator = generator;
+    }
+    setTokenizer(tokenizer) {
+        this.tokenizer = tokenizer;
+    }
+    setGenerator(generator) {
+        this.generator = generator;
+    }
+    processTemplate(template, variables) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = new Map();
+            // Replace {{val}} in template with variables[val]
+            variables.forEach((value, key) => {
+                template = template.replace(new RegExp(`{{${key}}}`, 'g'), value.toString());
+            });
+            // Replace {{method variableName methodArg1=methodArg1Value methodArg2=methodArg2Value}} in template
+            const indexes = this.findAllIndexes(template, '{{');
+            let nextTemplateIndexForPrompt = 0;
+            let prompt = '';
+            for (let i = 0; i < indexes.length; i++) {
+                prompt += template.substring(nextTemplateIndexForPrompt, indexes[i]);
+                const start = indexes[i] + 2;
+                const end = template.substring(start).indexOf('}}') + start;
+                const content = template.substring(start, end);
+                const args = content.split(' ');
+                const method = args[0];
+                const variableName = args[1];
+                const methodArgs = args.slice(2).reduce((acc, arg) => {
+                    const [key, value] = arg.split('=');
+                    acc[key] = value;
+                    return acc;
+                }, {});
+                let completion = '';
+                switch (method) {
+                    case TEMPLATE_METHODS.GEN:
+                        completion = yield this.generator.generateString(prompt, methodArgs);
+                        // Remove string after stop
+                        if (methodArgs['stop']) {
+                            if (completion.indexOf(methodArgs['stop']) >= 0) {
+                                completion = completion.substring(0, completion.indexOf(methodArgs['stop']));
+                            }
+                        }
+                        result.set(variableName, completion);
+                        break;
+                    case TEMPLATE_METHODS.SEL:
+                        const trie = new _trie_1.default();
+                        // Get options from variables
+                        const options = variables.get(methodArgs['options']);
+                        if (!options) {
+                            throw new Error(`${methodArgs['options']} variable not found`);
+                        }
+                        // Add all options to trie
+                        options.forEach(option => trie.addPrefix(this.tokenizer.encodeString(prompt + option + this.tokenizer.getEOS())));
+                        let currentPrefixPrompt = prompt;
+                        do {
+                            const currentPrefix = trie.getNextPrefix(this.tokenizer.encodeString(currentPrefixPrompt));
+                            currentPrefixPrompt = this.tokenizer.decodeString(currentPrefix);
+                            const nextChildren = trie.getNextChildren(currentPrefix);
+                            if (nextChildren.length < 2) {
+                                // If there is only one child, we complete
+                                completion = this.tokenizer.decodeString(trie.getWord(currentPrefix)).substring(prompt.length).replace(this.tokenizer.getEOS(), '');
+                                break;
+                            }
+                            else {
+                                // If there is more than one child, we generate the next token
+                                const nextToken = yield this.generator.generateToken(prompt, nextChildren.reduce((acc, child) => {
+                                    acc[child.toString()] = 100;
+                                    return acc;
+                                }, {}));
+                                currentPrefixPrompt = currentPrefixPrompt + nextToken;
+                            }
+                        } while (!completion);
+                        result.set(variableName, completion);
+                        break;
+                    default:
+                        throw new Error(`Invalid method ${method} in template`);
+                }
+                prompt += completion;
+                nextTemplateIndexForPrompt = end + 2;
+            }
+            return result;
+        });
+    }
+    findAllIndexes(str, substr) {
+        const indexes = [];
+        let i = -1;
+        while ((i = str.indexOf(substr, i + 1)) >= 0) {
+            indexes.push(i);
+        }
+        return indexes;
+    }
+}
+exports.TemplateProcessor = TemplateProcessor;

package/dist/lib/token-generator.d.ts

@@ -0,0 +1,21 @@
+import { ClientOptions } from 'openai';
+export declare abstract class AbstractTokenGenerator {
+    abstract generateToken(prompt: string, logit_bias: Record<string, number>): Promise<string>;
+    abstract generateString(prompt: string, options: Record<string, string>): Promise<string>;
+}
+/**
+ * OpenAI Token Generator
+ *
+ */
+export declare class OpenAITokenGenerator extends AbstractTokenGenerator {
+    private openai;
+    private model;
+    constructor(params: {
+        apiKey: string;
+        model: string;
+        baseURL?: string;
+    }, options?: ClientOptions);
+    generateToken(prompt: string, logit_bias: Record<string, number>): Promise<string>;
+    generateString(prompt: string, options: Record<string, string>): Promise<string>;
+}
+//# sourceMappingURL=token-generator.d.ts.map

package/dist/lib/token-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-generator.d.ts","sourceRoot":"","sources":["../../src/lib/token-generator.ts"],"names":[],"mappings":"AAAA,OAAe,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAA;AAE9C,8BAAsB,sBAAsB;IAC1C,QAAQ,CAAC,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAC3F,QAAQ,CAAC,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;CAC1F;AACD;;;GAGG;AACH,qBAAa,oBAAqB,SAAQ,sBAAsB;IAC9D,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,KAAK,CAAS;gBAEV,MAAM,EAAE;QAClB,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,EAAE,MAAM,CAAC;QACd,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,EAAE,OAAO,CAAC,EAAE,aAAa;IAUX,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAoClF,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;CAShG"}

package/dist/lib/token-generator.js

@@ -0,0 +1,72 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAITokenGenerator = exports.AbstractTokenGenerator = void 0;
+const openai_1 = __importDefault(require("openai"));
+class AbstractTokenGenerator {
+}
+exports.AbstractTokenGenerator = AbstractTokenGenerator;
+/**
+ * OpenAI Token Generator
+ *
+ */
+class OpenAITokenGenerator extends AbstractTokenGenerator {
+    constructor(params, options) {
+        super();
+        this.model = params.model;
+        this.openai = new openai_1.default(Object.assign({ apiKey: params.apiKey, baseURL: params.baseURL }, options));
+    }
+    generateToken(prompt, logit_bias) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.openai.completions.create({
+                model: this.model,
+                prompt,
+                logit_bias,
+                logprobs: 10,
+                max_tokens: 1,
+            });
+            const logprobsResult = ((_a = result.choices[0].logprobs) === null || _a === void 0 ? void 0 : _a.top_logprobs) || [];
+            const top_logprobs = logprobsResult ? logprobsResult[0] : { '2': 0 };
+            // get max top_logpobs that is in logit_bias
+            let max = -Infinity;
+            let max_key = '';
+            for (const key in top_logprobs) {
+                if (top_logprobs[key] > max && key in logit_bias) {
+                    max = top_logprobs[key];
+                    max_key = key;
+                }
+            }
+            // if no key in logit_bias, get max top_logprobs
+            if (max_key === '') {
+                // no key in logit_bias
+                max = -Infinity;
+                for (const key in top_logprobs) {
+                    if (top_logprobs[key] > max) {
+                        max = top_logprobs[key];
+                        max_key = key;
+                    }
+                }
+            }
+            return max_key;
+        });
+    }
+    generateString(prompt, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.openai.completions.create(Object.assign({ model: this.model, prompt }, options));
+            return result.choices[0].text;
+        });
+    }
+}
+exports.OpenAITokenGenerator = OpenAITokenGenerator;

package/dist/lib/tokenizer.d.ts

@@ -0,0 +1,16 @@
+export declare abstract class AbstractTokenizer {
+    abstract encodeString(str: string): number[];
+    abstract decodeString(arr: number[]): string;
+    abstract getEOS(): string;
+}
+export declare class LLaMATokenizer extends AbstractTokenizer {
+    encodeString(str: string, add_bos_token?: boolean, add_preceding_space?: boolean, log_performance?: boolean): number[];
+    decodeString(arr: number[], add_bos_token?: boolean, add_preceding_space?: boolean): string;
+    getEOS(): string;
+}
+export declare class GTPTokenizer extends AbstractTokenizer {
+    encodeString(str: string): number[];
+    decodeString(arr: number[]): string;
+    getEOS(): string;
+}
+//# sourceMappingURL=tokenizer.d.ts.map

package/dist/lib/tokenizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenizer.d.ts","sourceRoot":"","sources":["../../src/lib/tokenizer.ts"],"names":[],"mappings":"AAGA,8BAAsB,iBAAiB;IACrC,QAAQ,CAAC,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE;IAC5C,QAAQ,CAAC,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,MAAM;IAC5C,QAAQ,CAAC,MAAM,IAAI,MAAM;CAC1B;AAED,qBAAa,cAAe,SAAQ,iBAAiB;IAC1C,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,OAAO,EAAE,mBAAmB,CAAC,EAAE,OAAO,EAAE,eAAe,CAAC,EAAE,OAAO,GAAG,MAAM,EAAE;IAWtH,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,aAAa,CAAC,EAAE,OAAO,EAAE,mBAAmB,CAAC,EAAE,OAAO,GAAG,MAAM;IAQ3F,MAAM,IAAI,MAAM;CAG1B;AAED,qBAAa,YAAa,SAAQ,iBAAiB;IACxC,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE;IAMnC,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,MAAM;IAInC,MAAM,IAAI,MAAM;CAG1B"}

package/dist/lib/tokenizer.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GTPTokenizer = exports.LLaMATokenizer = exports.AbstractTokenizer = void 0;
+const _llama_tokenizer_1 = __importDefault(require("./_llama-tokenizer"));
+const gpt_tokenizer_1 = require("gpt-tokenizer");
+class AbstractTokenizer {
+}
+exports.AbstractTokenizer = AbstractTokenizer;
+class LLaMATokenizer extends AbstractTokenizer {
+    encodeString(str, add_bos_token, add_preceding_space, log_performance) {
+        if (str.endsWith(this.getEOS())) {
+            str = str.substring(0, str.length - this.getEOS().length);
+            return [
+                ..._llama_tokenizer_1.default.encode(str, add_bos_token, add_preceding_space, log_performance),
+                2 // EOS
+            ];
+        }
+        return _llama_tokenizer_1.default.encode(str, add_bos_token, add_preceding_space, log_performance);
+    }
+    decodeString(arr, add_bos_token, add_preceding_space) {
+        if (arr[arr.length - 1] === 2) {
+            arr = arr.slice(0, arr.length - 1);
+            return _llama_tokenizer_1.default.decode(arr, add_bos_token, add_preceding_space) + this.getEOS();
+        }
+        return _llama_tokenizer_1.default.decode(arr, add_bos_token, add_preceding_space);
+    }
+    getEOS() {
+        return '</s>';
+    }
+}
+exports.LLaMATokenizer = LLaMATokenizer;
+class GTPTokenizer extends AbstractTokenizer {
+    encodeString(str) {
+        return (0, gpt_tokenizer_1.encode)(str, {
+            allowedSpecial: new Set([this.getEOS()])
+        });
+    }
+    decodeString(arr) {
+        return (0, gpt_tokenizer_1.decode)(arr);
+    }
+    getEOS() {
+        return '<|endoftext|>';
+    }
+}
+exports.GTPTokenizer = GTPTokenizer;

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@mikugg/guidance",
+  "version": "0.8.0",
+  "description": "",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/**/*"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "demo": "ts-node demo/index.ts",
+    "lint": "eslint . --ext .ts",
+    "prepare": "npm run build",
+    "test": "jest"
+  },
+  "author": "mikudev",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/miku-gg/miku.git",
+    "directory": "packages/guidance"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "gpt-tokenizer": "^2.1.2",
+    "openai": "^4.19.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.8",
+    "@typescript-eslint/eslint-plugin": "^6.11.0",
+    "@typescript-eslint/parser": "^6.11.0",
+    "eslint": "^8.54.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.1",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.2.2"
+  },
+  "gitHead": "e0e2c0cc7fbde0c7d477a6907658a76a18e4fd0b"
+}