ai-functions 0.2.10 → 0.2.13

package/dist/cjs/functions/ai.d.ts

@@ -0,0 +1,18 @@
+import { ClientOptions, OpenAI } from 'openai';
+import { ChatCompletionCreateParamsBase } from 'openai/resources/chat/completions';
+export type AIConfig = ClientOptions & {
+    openai?: OpenAI;
+    system?: string;
+    model?: ChatCompletionCreateParamsBase['model'];
+};
+export type FunctionCallOptions = Omit<ChatCompletionCreateParamsBase, 'messages' | 'stream'> & {
+    system?: string;
+    meta?: boolean;
+    description?: string;
+};
+type AIFunctions<T = Record<string, string>> = Record<string, (returnSchema: T, options?: Partial<FunctionCallOptions>) => (args: string | object, callOptions?: Partial<FunctionCallOptions>) => Promise<T>>;
+export declare const AI: (config?: AIConfig) => {
+    ai: AIFunctions<Record<string, string>>;
+    openai: OpenAI;
+};
+export {};

package/dist/cjs/functions/ai.js

@@ -0,0 +1,99 @@
+"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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AI = void 0;
+const openai_1 = require("openai");
+// import { AIDB, AIDBConfig } from '../db/mongo'
+const js_yaml_1 = require("js-yaml");
+const schema_1 = require("../utils/schema");
+const AI = (config = {}) => {
+    var _a;
+    const { model = 'gpt-4-1106-preview', system } = config, rest = __rest(config, ["model", "system"]);
+    const openai = (_a = config.openai) !== null && _a !== void 0 ? _a : new openai_1.OpenAI(rest);
+    // const { client, db, cache, events, queue } = config.db ? AIDB(config.db) : {}
+    // const prompt = {
+    //   model,
+    //   messages: [{ role: 'user', content: user }],
+    // }
+    // if (system) prompt.messages.unshift({ role: 'system', content: system })
+    // const messages = system ? [{ role: 'system', content: system }] : []  
+    // const completion = openai.chat.completions.create({
+    //   model,
+    //   messages: [{ role: 'user', content: 'hello' }],
+    // })
+    const ai = new Proxy({}, {
+        get: (target, functionName, receiver) => {
+            target[functionName] = (returnSchema, options) => (args, callOptions) => __awaiter(void 0, void 0, void 0, function* () {
+                var _a;
+                console.log((0, schema_1.generateSchema)(returnSchema));
+                const _b = Object.assign(Object.assign({}, options), callOptions), { system, description, model = 'gpt-3.5-turbo', meta = false } = _b, rest = __rest(_b, ["system", "description", "model", "meta"]);
+                const prompt = Object.assign({ model, messages: [
+                        {
+                            role: 'user',
+                            content: `Call ${functionName} given the context:\n${(0, js_yaml_1.dump)(args)}`,
+                        }, // \nThere is no additional information, so make assumptions/guesses as necessary` },
+                    ], tools: [
+                        {
+                            type: 'function',
+                            function: {
+                                name: functionName,
+                                description,
+                                parameters: (0, schema_1.generateSchema)(returnSchema),
+                            }
+                        }
+                    ], tool_choice: {
+                        type: 'function',
+                        function: { name: functionName }
+                    } }, rest);
+                if (system)
+                    prompt.messages.unshift({ role: 'system', content: system });
+                const completion = yield openai.chat.completions.create(prompt);
+                const schema = (0, schema_1.generateSchema)(returnSchema);
+                let data;
+                let error;
+                const { message } = (_a = completion.choices) === null || _a === void 0 ? void 0 : _a[0];
+                console.log({ message });
+                prompt.messages.push(message);
+                const { content, tool_calls } = message;
+                if (tool_calls) {
+                    try {
+                        data = JSON.parse(tool_calls[0].function.arguments);
+                    }
+                    catch (err) {
+                        error = err.message;
+                    }
+                }
+                const gpt4 = model.includes('gpt-4');
+                const cost = completion.usage ?
+                    Math.round((gpt4
+                        ? completion.usage.prompt_tokens * 0.003 + completion.usage.completion_tokens * 0.006
+                        : completion.usage.prompt_tokens * 0.00015 + completion.usage.completion_tokens * 0.0002) * 100000) / 100000 : undefined;
+                // completion.usage = camelcaseKeys(completion.usage)
+                console.log({ data, content, error, cost, usage: completion.usage });
+                return meta ? Object.assign({ prompt, content, data, error, cost }, completion) : data !== null && data !== void 0 ? data : content;
+            });
+            return target[functionName];
+        },
+    });
+    return { ai, openai }; //, client, db, cache, events, queue }
+};
+exports.AI = AI;

package/dist/cjs/functions/ai.test.d.ts

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

package/dist/cjs/functions/ai.test.js

@@ -0,0 +1,40 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const ai_1 = require("./ai");
+(0, vitest_1.describe)('AI Functions', () => __awaiter(void 0, void 0, void 0, function* () {
+    const { ai } = (0, ai_1.AI)();
+    (0, vitest_1.it)('should be initialized', () => {
+        (0, vitest_1.expect)(ai).toBeDefined();
+    });
+    const categorizeWord = ai.categorizeWord({
+        type: 'Noun | Verb | Adjective | Adverb | Pronoun | Preposition | Conjunction | Interjection | Other',
+        example: 'use the word in a sentence',
+        // partOfSpeech: 'Part of speech'
+    }, { seed: 1, model: 'gpt-3.5-turbo' });
+    (0, vitest_1.it)('should be a function', () => {
+        (0, vitest_1.expect)(typeof categorizeWord).toBe('function');
+    });
+    (0, vitest_1.it)('Destroy should be a verb', () => __awaiter(void 0, void 0, void 0, function* () {
+        (0, vitest_1.expect)(yield categorizeWord('destroy')).toMatchObject({ type: 'Verb', example: 'I will destroy the old building.' });
+    }));
+    (0, vitest_1.it)('Dog should be a Noun', () => __awaiter(void 0, void 0, void 0, function* () {
+        const dog = yield categorizeWord({ word: 'dog' });
+        (0, vitest_1.expect)(dog).toMatchObject({ type: 'Noun', example: 'I have a dog.' });
+    }));
+    (0, vitest_1.it)('Large should be an Adjective', () => __awaiter(void 0, void 0, void 0, function* () {
+        (0, vitest_1.expect)(yield categorizeWord({ word: 'large' })).toMatchObject({ type: 'Adjective', example: 'She has a large collection of books.' });
+    }));
+    (0, vitest_1.it)('To should be an Preposition', () => __awaiter(void 0, void 0, void 0, function* () {
+        (0, vitest_1.expect)(yield categorizeWord('to')).toMatchObject({ type: 'Preposition', example: "I'm going to the park." });
+    }));
+}));

package/dist/cjs/functions/gpt.d.ts

@@ -0,0 +1,4 @@
+import { GPTConfig } from '../types';
+export declare const GPT: (config: GPTConfig) => {
+    gpt: (strings: string[], ...values: string[]) => Promise<string | null>;
+};

package/dist/cjs/functions/gpt.js

@@ -0,0 +1,24 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GPT = void 0;
+const completion_1 = require("../utils/completion");
+const GPT = (config) => {
+    const gpt = (strings, ...values) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        const user = values.map((value, i) => strings[i] + value).join('') + strings[strings.length - 1];
+        const completion = yield (0, completion_1.chatCompletion)(Object.assign({ user }, config));
+        const content = (_a = completion.choices) === null || _a === void 0 ? void 0 : _a[0].message.content;
+        return content;
+    });
+    return { gpt };
+};
+exports.GPT = GPT;

package/dist/cjs/functions/list.d.ts

@@ -0,0 +1,7 @@
+import { GPTConfig } from '../types';
+export declare const List: (config: GPTConfig) => {
+    list: (strings: string[], ...values: string[]) => Promise<string[]>;
+};
+export declare const StreamingList: (config: GPTConfig) => {
+    list: (strings: string[], ...values: string[]) => AsyncGenerator<string | undefined, void, unknown>;
+};

package/dist/cjs/functions/list.js

@@ -0,0 +1,134 @@
+"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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamingList = exports.List = void 0;
+const openai_1 = require("openai");
+const completion_1 = require("../utils/completion");
+const List = (config) => {
+    const list = (strings, ...values) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        const user = values.map((value, i) => strings[i] + value).join('') + strings[strings.length - 1];
+        const completion = yield (0, completion_1.chatCompletion)(Object.assign({ user }, config));
+        const content = (_a = completion.choices) === null || _a === void 0 ? void 0 : _a[0].message.content;
+        return content ? parseList(content) : [];
+    });
+    return { list };
+};
+exports.List = List;
+function parseList(listStr) {
+    // Define a regex pattern to match lines with '1. value', '1) value', '- value', or ' - value'
+    const listItemRegex = /^\s*\d+\.\s*(.+)|^\s*\d+\)\s*(.+)|^\s*-\s*(.+)$/gm;
+    let match;
+    const result = [];
+    // Loop over the list string, finding matches with the regex pattern
+    while ((match = listItemRegex.exec(listStr)) !== null) {
+        // The actual value is in one of the capturing groups (1, 2 or 3)
+        const value = match[1] || match[2] || match[3];
+        if (value) {
+            result.push(value.trim());
+        }
+    }
+    return result;
+}
+const StreamingList = (config) => {
+    function list(strings, ...values) {
+        var _a, _b, _c;
+        return __asyncGenerator(this, arguments, function* list_1() {
+            var _d, e_1, _e, _f;
+            const user = values.map((value, i) => strings[i] + value).join('') + strings[strings.length - 1];
+            const { system, model, db, queue } = config, rest = __rest(config, ["system", "model", "db", "queue"]);
+            const openai = (_a = config.openai) !== null && _a !== void 0 ? _a : new openai_1.OpenAI(rest);
+            const prompt = {
+                model,
+                messages: [{ role: 'user', content: user }],
+                stream: true,
+            };
+            if (system)
+                prompt.messages.unshift({ role: 'system', content: system });
+            const completion = yield __await(openai.chat.completions.create(prompt));
+            const stream = yield __await(openai.chat.completions.create(prompt));
+            let content = '';
+            let seperator;
+            let numberedList;
+            try {
+                for (var _g = true, stream_1 = __asyncValues(stream), stream_1_1; stream_1_1 = yield __await(stream_1.next()), _d = stream_1_1.done, !_d; _g = true) {
+                    _f = stream_1_1.value;
+                    _g = false;
+                    const part = _f;
+                    const { delta, finish_reason } = part.choices[0];
+                    content += (delta === null || delta === void 0 ? void 0 : delta.content) || '';
+                    if (seperator === undefined && content.length > 4) {
+                        numberedList = content.match(/(\d+\.\s)/g);
+                        seperator = numberedList ? '\n' : ', ';
+                    }
+                    const numberedRegex = /\d+\.\s(?:")?([^"]+)(?:")?/;
+                    if (seperator && content.includes(seperator)) {
+                        // get the string before the newline, and modify `content` to be the string after the newline
+                        // then yield the string before the newline
+                        const items = content.split(seperator);
+                        while (items.length > 1) {
+                            const item = items.shift();
+                            yield yield __await(numberedList ? (_b = item === null || item === void 0 ? void 0 : item.match(numberedRegex)) === null || _b === void 0 ? void 0 : _b[1] : item);
+                        }
+                        content = items[0];
+                    }
+                    if (finish_reason) {
+                        // TODO: Figure out DB saving strategy for streaming
+                        // if (db) {
+                        //   db.log(prompt, completion as ChatCompletion)
+                        // }
+                        yield yield __await(numberedList ? (_c = content.match(numberedRegex)) === null || _c === void 0 ? void 0 : _c[1] : content);
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_g && !_d && (_e = stream_1.return)) yield __await(_e.call(stream_1));
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        });
+    }
+    return { list };
+};
+exports.StreamingList = StreamingList;

package/dist/cjs/index.d.ts

@@ -0,0 +1,3 @@
+export * from './functions/ai';
+export * from './functions/gpt';
+export * from './functions/list';

package/dist/cjs/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./functions/ai"), exports);
+__exportStar(require("./functions/gpt"), exports);
+__exportStar(require("./functions/list"), exports);

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "commonjs"
+}

package/dist/cjs/queue/kafka.js

@@ -0,0 +1 @@
+"use strict";

package/dist/cjs/queue/memory.js

@@ -0,0 +1 @@
+"use strict";

package/dist/cjs/queue/mongo.d.ts

@@ -0,0 +1,30 @@
+import { AIDB } from '../db/mongo';
+import { CompletionInput } from '../utils/completion';
+import { BSON, ObjectId } from 'mongodb';
+export type QueueConfig = AIDB & {
+    batchSize?: number;
+    concurrency?: number;
+    lockExpiration?: number;
+};
+export type QueueInputMerge = {
+    into: string;
+    on?: BSON.Document;
+    let?: BSON.Document;
+    contentAs?: string;
+    itemsAs?: string;
+    functionDataAs?: string;
+    forEachItem?: boolean;
+};
+export type QueueInput = (CompletionInput | ({
+    list: string;
+} & Partial<CompletionInput>)) & {
+    _id?: ObjectId;
+    metadata?: object;
+    merge?: string | QueueInputMerge;
+    target?: string;
+};
+export type QueueDocument = QueueInput & {
+    lockedAt: Date;
+    lockedBy: string;
+};
+export declare const startQueue: (config: QueueConfig) => Promise<void>;

package/dist/cjs/queue/mongo.js

@@ -0,0 +1,69 @@
+"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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startQueue = void 0;
+const p_queue_1 = __importDefault(require("p-queue"));
+const completion_1 = require("../utils/completion");
+let localQueue;
+const startQueue = (config) => __awaiter(void 0, void 0, void 0, function* () {
+    const { concurrency = 10, batchSize = 100, lockExpiration = 3600 } = config, db = __rest(config, ["concurrency", "batchSize", "lockExpiration"]);
+    const instance = Math.random().toString(36).substring(2, 6);
+    const queue = new p_queue_1.default({ concurrency });
+    const clearExpiredLocks = () => db.queue.updateMany({ lockedAt: { $lt: new Date(Date.now() - lockExpiration * 1000) } }, { $unset: { lockedAt: '', lockedBy: '' } });
+    const lockBatch = () => db.queue.aggregate([
+        { $match: { lockedAt: { $exists: false } } },
+        { $limit: batchSize },
+        { $set: { lockedAt: new Date(), lockedBy: instance } },
+        { $merge: { into: 'queue', on: '_id', whenMatched: 'replace' } }, // TODO: Change the `into` to the name of the `queue` collection
+    ]).toArray();
+    db.queue.watch([
+        { $match: { lockedBy: instance } },
+    ]).on('change', (change) => __awaiter(void 0, void 0, void 0, function* () {
+        const _a = change.fullDocument, { _id, metadata, merge, target } = _a, input = __rest(_a, ["_id", "metadata", "merge", "target"]); // TODO: Move input to child object not catchall spread
+        const completion = yield queue.add(() => (0, completion_1.chatCompletion)(input));
+        if (merge) {
+            const coll = typeof merge === 'string' ? merge : merge.into;
+            const match = typeof merge === 'string' ? undefined : merge.on;
+            // TODO: Add support to make completion optional, and specify field names for content, items, and functionData
+            const mergeResult = match
+                ? yield db.db.collection(coll).updateOne(match, { $set: Object.assign({ completion }, metadata !== null && metadata !== void 0 ? metadata : {}) })
+                : yield db.db.collection(coll).insertOne(Object.assign({ completion }, metadata !== null && metadata !== void 0 ? metadata : {}));
+            if (mergeResult.acknowledged && (mergeResult.modifiedCount ||
+                mergeResult.insertedId)) {
+                // TODO: We may want to store the merge result in the Events collection to link the queue input to the merge result
+                yield db.queue.deleteOne({ _id });
+            }
+        }
+    }));
+    queue.on('idle', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield clearExpiredLocks();
+        yield lockBatch();
+    }));
+    queue.start();
+    // TODO: Add Find() and Watch() for Actors collection
+    // TODO: For each actor, create a state machine and start it
+    // TODO: Figure out how to create new queued jobs from the results of the state machine
+});
+exports.startQueue = startQueue;

package/dist/cjs/streams/kafka.js

@@ -0,0 +1 @@
+"use strict";

package/dist/cjs/streams/memory.js

@@ -0,0 +1 @@
+"use strict";

package/dist/cjs/streams/mongo.js

@@ -0,0 +1 @@
+"use strict";

package/dist/cjs/streams/types.js

@@ -0,0 +1 @@
+"use strict";

package/dist/cjs/types.d.ts

@@ -0,0 +1,11 @@
+import type { OpenAI, ClientOptions } from 'openai';
+import type { ChatCompletionCreateParamsNonStreaming } from 'openai/resources';
+import type { AIDB } from './db/mongo';
+import type PQueue from 'p-queue';
+export type GPTConfig = {
+    openai?: OpenAI;
+    system?: string;
+    model?: ChatCompletionCreateParamsNonStreaming['model'] | 'gpt-4-1106-preview' | 'gpt-3.5-turbo-1106';
+    db?: AIDB;
+    queue?: PQueue;
+} & ClientOptions;

package/dist/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/utils/completion.d.ts

@@ -0,0 +1,9 @@
+import { OpenAI } from 'openai';
+import type { ChatCompletionCreateParamsNonStreaming } from 'openai/resources';
+import { GPTConfig } from '../types';
+export type CompletionInput = GPTConfig & ((({
+    user: string;
+} | {
+    list: string;
+}) & Partial<ChatCompletionCreateParamsNonStreaming>) | ChatCompletionCreateParamsNonStreaming);
+export declare const chatCompletion: (config: CompletionInput) => Promise<OpenAI.Chat.Completions.ChatCompletion>;

package/dist/cjs/utils/completion.js

@@ -0,0 +1,45 @@
+"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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chatCompletion = void 0;
+const openai_1 = require("openai");
+// TODO: add support for list input and parsing
+// TODO: add support for caching w/ seed generation for unit tests
+const chatCompletion = (config) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const { user, system, model, db, queue } = config, rest = __rest(config, ["user", "system", "model", "db", "queue"]);
+    const openai = (_a = config.openai) !== null && _a !== void 0 ? _a : new openai_1.OpenAI(rest);
+    const prompt = {
+        model,
+        messages: [{ role: 'user', content: user }],
+    };
+    if (system)
+        prompt.messages.unshift({ role: 'system', content: system });
+    const completion = queue
+        ? yield queue.add(() => openai.chat.completions.create(prompt))
+        : yield openai.chat.completions.create(prompt);
+    if (db) {
+        db.log(prompt, completion);
+    }
+    return completion;
+});
+exports.chatCompletion = chatCompletion;

package/dist/cjs/utils/schema.d.ts

@@ -0,0 +1,10 @@
+import { JSONSchema } from 'json-schema-to-ts';
+export declare const parseStringDescription: (description: string) => JSONSchema;
+/**
+ * Given a property description object, generate a JSON schema.
+ *
+ * @param propDescriptions - A record object with keys as property names
+ * and values as descriptions or nested property description objects.
+ * @returns A JSON schema object based on the provided descriptions.
+ */
+export declare const generateSchema: (propDescriptions: Record<string, string | Record<string, any>>) => JSONSchema;