@sprucelabs/sprucebot-llm 0.0.1

package/README.md

@@ -0,0 +1,148 @@
+# sprucebot-llm (WIP)
+A Typescript library for leveraging Large Langage Models (like GPT-3) to do... anything!
+
+* Has memory
+    * Remembers past messages to build context
+    * Configure how much of the conversation your bot should remember*
+* [Manages state](#adding-state-to-your-conversation)
+    * The state builds as the conversation continues
+    * Invoke callbacks whenever state changes
+* [Connect to 3rd party API's](pulling-from-3rd-party-apis)
+    * Pull in data in real time
+    * Have your bot respond generated responses
+* Unlimited use cases
+    * Skill architecture for extensibility
+    * Leverage Skills to get your bot to complete any task!
+* Adapter Interface to create your own adapters
+    * Only support GPT-3 for now (more adapters based on demand)
+* Fully typed
+
+
+*In progress
+## Getting started
+
+### Install the library
+
+```bash
+yarn add @sprucelabs/sprucebot-llm
+```
+
+### Building your first joke bot
+
+Create a file called `chat.ts` and add the following to get started:
+
+```ts
+import { stdin as input, stdout as output } from 'node:process'
+import * as readline from 'node:readline/promises'
+import dotenv from 'dotenv'
+import { OpenAi } from './bots/adapters/OpenAi'
+import SprucebotLlmFactory from './bots/SprucebotLlmFactory'
+
+dotenv.config()
+const rl = readline.createInterface({ input, output })
+
+;(async () => {
+	console.clear()
+
+	const adapter = new OpenAi(process.env.OPEN_AI_API_KEY!)
+	const bots = SprucebotLlmFactory.Factory()
+
+	const skill = bots.Skill({
+		yourJobIfYouChooseToAcceptItIs: 'to tell knock knock jokes!',
+		pleaseKeepInMindThat: [
+			'our audience is younger, so keep it PG!',
+			'you should never laugh when someone does not get the joke.',
+			"after each joke, you should tell me how many jokes you have left to tell before we're done.",
+			'you should acknowledge if someone laughs at your joke by saying "Thanks!" or "Glad you thought that was funny"!',
+		],
+		weAreDoneWhen: 'you have told 3 jokes!',
+	})
+
+	const bot = bots.Bot({
+		adapter,
+		skill,
+		youAre:
+			"a bot named Sprucebot that is in test mode. At the start of every conversation, you introduce yourself and announce that you are in test mode so I don't get confused! You are young, hip, and adorable. You say things like, 'Jeepers' and 'Golly' because you are so cute!",
+	})
+
+	do {
+		const input = await rl.question('Message > ')
+		const response = await bot.sendMessage(input)
+		console.log('>', response)
+	} while (!bot.getIsDone())
+
+	console.log('Signing off...')
+	rl.close()
+})()
+
+
+```
+
+### Adding state to your conversation
+This library depends on [`@sprucelabs/spruce-schema`](https://github.com/sprucelabsai/spruce-schema) to handle the structure and validation rules around your state.
+```ts
+const skill = bots.Skill({
+	yourJobIfYouChooseToAcceptItIs:
+		'to collect some information from me! You are a receptionist with 20 years experience and are very focused on getting answers needed to complete my profile',
+	stateSchema: buildSchema({
+		id: 'profile',
+		fields: {
+			firstName: {
+				type: 'text',
+				label: 'First name',
+			},
+			lastName: {
+				type: 'text',
+				label: 'Last name',
+			},
+			favoriteColor: {
+				type: 'select',
+				options: {
+					choices: [
+						{ label: 'Red', value: 'red' },
+						{ label: 'Blue', value: 'blue' },
+						{ label: 'Green', value: 'green' },
+					],
+				},
+			},
+		},
+	})
+
+```
+
+### Listening to state changes
+
+If you supply a `stateSchema` then your bot will work through it until the state is completely updated. While the conversation is taking place, if the state changes, the skill will emit `did-update-state`
+
+```ts
+await skill.on('did-update-state', () => {
+	console.log('we are making progress!')
+	console.log(JSON.stringify(this.skill.getState()))
+})
+
+```
+### Pulling from 3rd party api's
+
+The approach to integrating 3rd party api's (as well as dropping in other dynamic data into responses) is straight forward.
+
+```ts
+const skill = bots.Skill({
+	yourJobIfYouChooseToAcceptItIs:
+		"to be be the best appointment taker on the planet. You have a many years of experience. You are going to ask me only 2 questions for this practice run. First, you'll ask me to pick an available time. Then, you'll ask me to pick my favorite color!",
+	callbacks: {
+		availableTimes: {
+			cb: async () => {
+				return ['9am', '10am', '11am', '1pm', '4pm', '5pm', '12am.'].join(
+					'\n'
+				)
+			},
+			useThisWhenever: 'your are showing what times I can pick from.',
+		},
+		favoriteColor: {
+			cb: async () => {
+				return ['red', 'blue', 'green', 'purple'].join('\n')
+			},
+			useThisWhenever: 'your are showing what colors I can pick from.',
+		},
+	},
+})

package/build/.spruce/errors/errors.types.d.ts

@@ -0,0 +1,13 @@
+import { default as SchemaEntity } from '@sprucelabs/schema';
+import * as SpruceSchema from '@sprucelabs/schema';
+export declare namespace SpruceErrors.SprucebotLlm {
+    interface NoBotInstanceSet {
+    }
+    interface NoBotInstanceSetSchema extends SpruceSchema.Schema {
+        id: 'noBotInstanceSet';
+        namespace: 'SprucebotLlm';
+        name: 'No bot instance set';
+        fields: {};
+    }
+    type NoBotInstanceSetEntity = SchemaEntity<SpruceErrors.SprucebotLlm.NoBotInstanceSetSchema>;
+}

package/build/.spruce/errors/errors.types.js

@@ -0,0 +1,4 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable no-redeclare */
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/.spruce/errors/options.types.d.ts

@@ -0,0 +1,7 @@
+import { SpruceErrors } from "./errors.types";
+import { ErrorOptions as ISpruceErrorOptions } from "@sprucelabs/error";
+export interface NoBotInstanceSetErrorOptions extends SpruceErrors.SprucebotLlm.NoBotInstanceSet, ISpruceErrorOptions {
+    code: 'NO_BOT_INSTANCE_SET';
+}
+type ErrorOptions = NoBotInstanceSetErrorOptions;
+export default ErrorOptions;

package/build/.spruce/errors/options.types.js

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

package/build/.spruce/errors/sprucebotLlm/noBotInstanceSet.schema.d.ts

@@ -0,0 +1,3 @@
+import { SpruceErrors } from '../errors.types';
+declare const noBotInstanceSetSchema: SpruceErrors.SprucebotLlm.NoBotInstanceSetSchema;
+export default noBotInstanceSetSchema;

package/build/.spruce/errors/sprucebotLlm/noBotInstanceSet.schema.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require("@sprucelabs/schema");
+const noBotInstanceSetSchema = {
+    id: 'noBotInstanceSet',
+    namespace: 'SprucebotLlm',
+    name: 'No bot instance set',
+    fields: {}
+};
+schema_1.SchemaRegistry.getInstance().trackSchema(noBotInstanceSetSchema);
+exports.default = noBotInstanceSetSchema;

package/build/.spruce/schemas/fields/fieldClassMap.d.ts

@@ -0,0 +1,2 @@
+import { fieldClassMap } from '@sprucelabs/schema';
+export default fieldClassMap;

package/build/.spruce/schemas/fields/fieldClassMap.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require("@sprucelabs/schema");
+exports.default = schema_1.fieldClassMap;

package/build/.spruce/schemas/fields/fields.types.d.ts

@@ -0,0 +1 @@
+export { FieldDefinitions, FieldDefinitionMap, FieldValueTypeGeneratorMap, FieldMap } from '@sprucelabs/schema';

package/build/.spruce/schemas/fields/fields.types.js

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

package/build/.spruce/settings.json

@@ -0,0 +1,13 @@
+{
+  "scriptUpdater": {
+    "skipped": []
+  },
+  "skipped": [
+    "skill"
+  ],
+  "installed": [
+    "test",
+    "schema",
+    "error"
+  ]
+}

package/build/bots/PromptGenerator.d.ts

@@ -0,0 +1,15 @@
+import { LlmMessage, SprucebotLlmBot } from '../llm.types';
+export default class PromptGenerator {
+    private bot;
+    private eta;
+    constructor(bot: SprucebotLlmBot);
+    generate(): Promise<string>;
+    private stringifyState;
+}
+export declare function setUndefinedToNull(obj: Record<string, any>): void;
+export interface TemplateContext {
+    youAre: string;
+    messages: LlmMessage[];
+    stateSchemaJson?: string;
+    stateJson?: string;
+}

package/build/bots/PromptGenerator.js

@@ -0,0 +1,84 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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.setUndefinedToNull = void 0;
+const schema_1 = require("@sprucelabs/schema");
+const Eta = __importStar(require("eta"));
+const templates_1 = require("./templates");
+class PromptGenerator {
+    constructor(bot) {
+        this.eta = Eta;
+        (0, schema_1.assertOptions)({ bot }, ['bot']);
+        this.bot = bot;
+    }
+    async generate() {
+        const _a = this.bot.serialize(), { stateSchema, state } = _a, rest = __rest(_a, ["stateSchema", "state"]);
+        const { stateSchemaJson, stateJson } = this.stringifyState(stateSchema, state);
+        return await this.eta.render(templates_1.PROMPT_TEMPLATE, Object.assign({ stateSchemaJson,
+            stateJson }, rest), {
+            async: true,
+            autoEscape: false,
+        });
+    }
+    stringifyState(stateSchema, state) {
+        if (!stateSchema) {
+            return {
+                stateSchemaJson: null,
+                stateJson: null,
+            };
+        }
+        const normalizedState = (0, schema_1.normalizeSchemaValues)(stateSchema, state !== null && state !== void 0 ? state : {}, {});
+        setUndefinedToNull(normalizedState);
+        const stateSchemaJson = JSON.stringify(stateSchema);
+        const stateJson = JSON.stringify(normalizedState);
+        return { stateSchemaJson, stateJson };
+    }
+}
+exports.default = PromptGenerator;
+function setUndefinedToNull(obj) {
+    for (const key in obj) {
+        // eslint-disable-next-line no-prototype-builtins
+        if (obj.hasOwnProperty(key)) {
+            if (obj[key] === undefined) {
+                obj[key] = null;
+            }
+            else if (typeof obj[key] === 'object') {
+                setUndefinedToNull(obj[key]);
+            }
+        }
+    }
+}
+exports.setUndefinedToNull = setUndefinedToNull;

package/build/bots/SprucebotLlmBotImpl.d.ts

@@ -0,0 +1,18 @@
+import { AbstractEventEmitter } from '@sprucelabs/mercury-event-emitter';
+import { Schema, SchemaValues } from '@sprucelabs/schema';
+import { BotOptions, LlmEventContract, LlmMessage, SerializedBot, SprucebotLlmBot } from '../llm.types';
+export default class SprucebotLlmBotImpl<StateSchema extends Schema = Schema, State extends SchemaValues<StateSchema> = SchemaValues<StateSchema>> extends AbstractEventEmitter<LlmEventContract> implements SprucebotLlmBot<StateSchema, State> {
+    private adapter;
+    private youAre;
+    private stateSchema?;
+    protected state?: Partial<State>;
+    private isDone;
+    protected messages: LlmMessage[];
+    private skill?;
+    constructor(options: BotOptions<StateSchema, State>);
+    markAsDone(): void;
+    getIsDone(): boolean;
+    serialize(): SerializedBot<StateSchema, State>;
+    sendMessage(message: string): Promise<string>;
+    updateState(newState: Partial<State>): Promise<void>;
+}

package/build/bots/SprucebotLlmBotImpl.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mercury_event_emitter_1 = require("@sprucelabs/mercury-event-emitter");
+const schema_1 = require("@sprucelabs/schema");
+const llm_types_1 = require("../llm.types");
+const ResponseParser_1 = __importDefault(require("../parsingResponses/ResponseParser"));
+class SprucebotLlmBotImpl extends mercury_event_emitter_1.AbstractEventEmitter {
+    constructor(options) {
+        const { adapter, youAre, stateSchema, state, skill } = options;
+        super(llm_types_1.llmEventContract);
+        this.isDone = false;
+        this.messages = [];
+        this.adapter = adapter;
+        this.youAre = youAre;
+        this.stateSchema = stateSchema;
+        this.skill = skill;
+        this.state = stateSchema
+            ? Object.assign(Object.assign({}, (0, schema_1.defaultSchemaValues)(stateSchema)), state)
+            : undefined;
+    }
+    markAsDone() {
+        this.isDone = true;
+    }
+    getIsDone() {
+        return this.isDone;
+    }
+    serialize() {
+        var _a, _b, _c;
+        const skill = (_a = this.skill) === null || _a === void 0 ? void 0 : _a.serialize();
+        return {
+            youAre: this.youAre,
+            stateSchema: (_b = this.stateSchema) !== null && _b !== void 0 ? _b : skill === null || skill === void 0 ? void 0 : skill.stateSchema,
+            state: (_c = this.state) !== null && _c !== void 0 ? _c : skill === null || skill === void 0 ? void 0 : skill.state,
+            messages: this.messages,
+            skill,
+        };
+    }
+    async sendMessage(message) {
+        var _a, _b;
+        (0, schema_1.assertOptions)({ message }, ['message']);
+        this.messages.push({
+            from: 'Me',
+            message,
+        });
+        const response = await this.adapter.sendMessage(this);
+        const parser = ResponseParser_1.default.getInstance();
+        const { isDone, message: parsedResponse, state, } = await parser.parse(response, (_a = this.skill) === null || _a === void 0 ? void 0 : _a.serialize().callbacks);
+        this.isDone = isDone;
+        if (this.stateSchema && state) {
+            await this.updateState(state);
+        }
+        else if (state) {
+            await ((_b = this.skill) === null || _b === void 0 ? void 0 : _b.updateState(state));
+        }
+        this.messages.push({
+            from: 'You',
+            message: parsedResponse,
+        });
+        return parsedResponse;
+    }
+    async updateState(newState) {
+        this.state = Object.assign(Object.assign({}, this.state), newState);
+        await this.emit('did-update-state');
+    }
+}
+exports.default = SprucebotLlmBotImpl;

package/build/bots/SprucebotLlmFactory.d.ts

@@ -0,0 +1,9 @@
+import { BotOptions, SkillOptions, SprucebotLlmBot, SprucebotLLmSkill } from '../llm.types';
+export default class SprucebotLlmFactory {
+    private instance?;
+    Bot(options: BotOptions): SprucebotLlmBot;
+    Skill(options: SkillOptions): SprucebotLLmSkill;
+    getBotInstance(): SprucebotLlmBot<import("@sprucelabs/schema").Schema, import("@sprucelabs/schema").SchemaStaticValues<import("@sprucelabs/schema").Schema, false, never, import("@sprucelabs/schema").StaticSchemaAllValues<import("@sprucelabs/schema").Schema, false>>>;
+    setBotInstance(bot: SprucebotLlmBot): void;
+    static Factory(): SprucebotLlmFactory;
+}

package/build/bots/SprucebotLlmFactory.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require("@sprucelabs/schema");
+const SpruceError_1 = __importDefault(require("../errors/SpruceError"));
+const SprucebotLlmBotImpl_1 = __importDefault(require("./SprucebotLlmBotImpl"));
+const SprucebotLlmSkillImpl_1 = __importDefault(require("./SprucebotLlmSkillImpl"));
+class SprucebotLlmFactory {
+    Bot(options) {
+        (0, schema_1.assertOptions)(options, ['youAre', 'adapter']);
+        const { Class } = options;
+        return Class ? new Class(options) : new SprucebotLlmBotImpl_1.default(options);
+    }
+    Skill(options) {
+        (0, schema_1.assertOptions)(options, ['yourJobIfYouChooseToAcceptItIs']);
+        return new SprucebotLlmSkillImpl_1.default(options);
+    }
+    getBotInstance() {
+        if (!this.instance) {
+            throw new SpruceError_1.default({
+                code: 'NO_BOT_INSTANCE_SET',
+            });
+        }
+        return this.instance;
+    }
+    setBotInstance(bot) {
+        this.instance = bot;
+    }
+    static Factory() {
+        return new this();
+    }
+}
+exports.default = SprucebotLlmFactory;

package/build/bots/SprucebotLlmSkillImpl.d.ts

@@ -0,0 +1,12 @@
+import { AbstractEventEmitter } from '@sprucelabs/mercury-event-emitter';
+import { Schema, SchemaValues } from '@sprucelabs/schema';
+import { LlmEventContract, SerializedSkill, SkillOptions, SprucebotLLmSkill } from '../llm.types';
+export default class SprucebotLlmSkillImpl<StateSchema extends Schema = Schema, State extends SchemaValues<StateSchema> = SchemaValues<StateSchema>> extends AbstractEventEmitter<LlmEventContract> implements SprucebotLLmSkill<StateSchema, State> {
+    private options;
+    private state?;
+    private stateSchema?;
+    constructor(options: SkillOptions<StateSchema, State>);
+    updateState(updates: Partial<State>): Promise<void>;
+    getState(): Partial<State> | undefined;
+    serialize(): SerializedSkill<StateSchema, State>;
+}

package/build/bots/SprucebotLlmSkillImpl.js

@@ -0,0 +1,39 @@
+"use strict";
+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 });
+const mercury_event_emitter_1 = require("@sprucelabs/mercury-event-emitter");
+const schema_1 = require("@sprucelabs/schema");
+const llm_types_1 = require("../llm.types");
+class SprucebotLlmSkillImpl extends mercury_event_emitter_1.AbstractEventEmitter {
+    constructor(options) {
+        super(llm_types_1.llmEventContract);
+        this.state = {};
+        const { state, stateSchema } = options, rest = __rest(options, ["state", "stateSchema"]);
+        this.options = Object.assign(Object.assign({}, rest), { stateSchema });
+        this.stateSchema = stateSchema;
+        this.state = stateSchema
+            ? Object.assign(Object.assign({}, (0, schema_1.defaultSchemaValues)(stateSchema)), state)
+            : undefined;
+    }
+    async updateState(updates) {
+        await this.emit('did-update-state');
+        this.state = Object.assign(Object.assign({}, this.state), updates);
+    }
+    getState() {
+        return this.state;
+    }
+    serialize() {
+        return Object.assign(Object.assign({}, this.options), { stateSchema: this.stateSchema, state: this.state });
+    }
+}
+exports.default = SprucebotLlmSkillImpl;

package/build/bots/adapters/OpenAi.d.ts

@@ -0,0 +1,10 @@
+import { Configuration, OpenAIApi } from 'openai';
+import { LlmAdapter, SprucebotLlmBot } from '../../llm.types';
+export declare class OpenAi implements LlmAdapter {
+    static Configuration: typeof Configuration;
+    static OpenAIApi: typeof OpenAIApi;
+    private api;
+    constructor(apiKey: string);
+    sendMessage(bot: SprucebotLlmBot): Promise<string>;
+}
+export declare const MESSAGE_RESPONSE_ERROR_MESSAGE = "Oh no! Something went wrong and I can't talk right now!";

package/build/bots/adapters/OpenAi.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MESSAGE_RESPONSE_ERROR_MESSAGE = exports.OpenAi = void 0;
+const schema_1 = require("@sprucelabs/schema");
+const openai_1 = require("openai");
+const PromptGenerator_1 = __importDefault(require("../PromptGenerator"));
+class OpenAi {
+    constructor(apiKey) {
+        (0, schema_1.assertOptions)({ apiKey }, ['apiKey']);
+        const config = new OpenAi.Configuration({ apiKey });
+        this.api = new OpenAi.OpenAIApi(config);
+    }
+    async sendMessage(bot) {
+        var _a, _b, _c;
+        const generator = new PromptGenerator_1.default(bot);
+        const prompt = await generator.generate();
+        const response = await this.api.createCompletion({
+            prompt,
+            model: 'text-davinci-003',
+            max_tokens: 100,
+            stop: ['__Me__:'],
+        });
+        return ((_c = (_b = (_a = response.data.choices[0]) === null || _a === void 0 ? void 0 : _a.text) === null || _b === void 0 ? void 0 : _b.trim()) !== null && _c !== void 0 ? _c : exports.MESSAGE_RESPONSE_ERROR_MESSAGE);
+    }
+}
+exports.OpenAi = OpenAi;
+OpenAi.Configuration = openai_1.Configuration;
+OpenAi.OpenAIApi = openai_1.OpenAIApi;
+exports.MESSAGE_RESPONSE_ERROR_MESSAGE = "Oh no! Something went wrong and I can't talk right now!";

package/build/bots/adapters/SpyOpenAiApi.d.ts

@@ -0,0 +1,12 @@
+import { AxiosResponse } from 'axios';
+import { Configuration, CreateCompletionRequest, CreateCompletionRequestPrompt, CreateCompletionResponse, OpenAIApi } from 'openai';
+export default class SpyOpenAiApi extends OpenAIApi {
+    static config?: Configuration;
+    static lastMessage?: CreateCompletionRequestPrompt | null;
+    static lastModel?: string;
+    static responseMessage: string | false;
+    constructor(config: Configuration);
+    createCompletion(createCompletionRequest: CreateCompletionRequest): Promise<Response>;
+}
+type Response = AxiosResponse<CreateCompletionResponse, any>;
+export {};

package/build/bots/adapters/SpyOpenAiApi.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const openai_1 = require("openai");
+class SpyOpenAiApi extends openai_1.OpenAIApi {
+    constructor(config) {
+        super(config);
+        SpyOpenAiApi.config = config;
+    }
+    async createCompletion(createCompletionRequest) {
+        SpyOpenAiApi.lastMessage = createCompletionRequest.prompt;
+        SpyOpenAiApi.lastModel = createCompletionRequest.model;
+        const choices = [];
+        if (SpyOpenAiApi.responseMessage) {
+            choices.push({
+                text: SpyOpenAiApi.responseMessage,
+            });
+        }
+        return {
+            config: {},
+            headers: {},
+            status: 200,
+            statusText: 'OK',
+            data: {
+                id: 'cmpl-1',
+                model: 'text-davinci-003',
+                created: 0,
+                object: 'text_completion',
+                choices,
+            },
+        };
+    }
+}
+exports.default = SpyOpenAiApi;
+SpyOpenAiApi.responseMessage = 'hello!';

package/build/bots/templates.d.ts

@@ -0,0 +1,4 @@
+export declare const STATE_BOUNDARY = "*****";
+export declare const DONE_TOKEN = "____ DONE ____";
+export declare const CALLBACK_BOUNDARY = "xxxxx";
+export declare const PROMPT_TEMPLATE: string;