@sprucelabs/sprucebot-llm 0.0.1

package/build/bots/templates.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROMPT_TEMPLATE = exports.CALLBACK_BOUNDARY = exports.DONE_TOKEN = exports.STATE_BOUNDARY = void 0;
+const renderPlaceholder_1 = __importDefault(require("../parsingResponses/renderPlaceholder"));
+exports.STATE_BOUNDARY = '*****';
+exports.DONE_TOKEN = `____ DONE ____`;
+exports.CALLBACK_BOUNDARY = 'xxxxx';
+exports.PROMPT_TEMPLATE = `You are <%= it.youAre %>
+
+
+For this interaction, every message I send will start with "__Me__:" and I'll prompt you for your response by starting with "__You__:".
+
+__Me__: Do you understand?
+__You__: Yes
+
+<% if (it.stateSchemaJson) { %>
+
+Here is the schema that defines the state for this conversation:
+
+<%= it.stateSchemaJson %>
+
+
+Here is the current state, which is based on the schema above:
+
+<%= it.stateJson %>
+
+
+After each message, send the state in the form:
+
+${exports.STATE_BOUNDARY} <%= it.stateJson %> ${exports.STATE_BOUNDARY}
+
+__Me__: Sound good?
+__You__: Yup!
+
+${exports.STATE_BOUNDARY} <%= it.stateJson %> ${exports.STATE_BOUNDARY}
+
+When asking me about a "select" field, make sure I only pick a valid choice by showing me their labels!<% } %>
+
+<% if (it.skill) { %>
+	
+Your primary objective for this conversation is <%= it.skill.yourJobIfYouChooseToAcceptItIs %>
+<% if (it.skill.callbacks) { %>
+While we are talking, there are going to be things I don't want you to answer, but instead to respond with a placeholder in the form of ${(0, renderPlaceholder_1.default)('example')}.
+
+Here are the placeholders we will be using:
+
+<% Object.keys(it.skill.callbacks).forEach((key) => { %>
+Whenever <%= it.skill.callbacks[key].useThisWhenever %>, respond with ${exports.CALLBACK_BOUNDARY} <%= key %> ${exports.CALLBACK_BOUNDARY}
+
+<% }) %>
+<% } %>
+<% if (!it.stateSchemaJson && it.skill.weAreDoneWhen) { %>
+We are done when <%= it.skill.weAreDoneWhen %> At that point, send me the following message so I know we are done:
+
+${exports.DONE_TOKEN}
+<% } %>
+<% } %>
+<% if (it.stateSchemaJson) { %>
+
+Once you have asked about every field in the schema, send me the following message so I know we're done:
+
+${exports.DONE_TOKEN}
+<% } %>
+
+Let's get started:
+
+<% it.messages.forEach((message) => { %>
+__<%= message.from %>__: <%= message.message %>
+
+<% }) %>
+__You__:`;

package/build/chat.d.ts

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

package/build/chat.js

@@ -0,0 +1,60 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_process_1 = require("node:process");
+const readline = __importStar(require("node:readline/promises"));
+const dotenv_1 = __importDefault(require("dotenv"));
+const OpenAi_1 = require("./bots/adapters/OpenAi");
+const SprucebotLlmFactory_1 = __importDefault(require("./bots/SprucebotLlmFactory"));
+const buildCallbackSkill_1 = __importDefault(require("./examples/buildCallbackSkill"));
+const buildJokeSkill_1 = __importDefault(require("./examples/buildJokeSkill"));
+const buildProfileSkill_1 = __importDefault(require("./examples/buildProfileSkill"));
+dotenv_1.default.config();
+const rl = readline.createInterface({ input: node_process_1.stdin, output: node_process_1.stdout });
+(async () => {
+    console.clear();
+    const adapter = new OpenAi_1.OpenAi(process.env.OPEN_AI_API_KEY);
+    const bots = SprucebotLlmFactory_1.default.Factory();
+    const skills = {
+        jokes: (0, buildJokeSkill_1.default)(bots),
+        profile: (0, buildProfileSkill_1.default)(bots),
+        callbacks: (0, buildCallbackSkill_1.default)(bots),
+    };
+    const bot = bots.Bot({
+        adapter,
+        skill: skills.callbacks,
+        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 both hip and adorable. You say things like, 'Jeepers' and 'Golly' or even 'Jeezey peezy'!",
+    });
+    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();
+})();

package/build/errors/SpruceError.d.ts

@@ -0,0 +1,6 @@
+import BaseSpruceError from '@sprucelabs/error';
+import ErrorOptions from "./../.spruce/errors/options.types";
+export default class SpruceError extends BaseSpruceError<ErrorOptions> {
+    /** an easy to understand version of the errors */
+    friendlyMessage(): string;
+}

package/build/errors/SpruceError.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const error_1 = __importDefault(require("@sprucelabs/error"));
+class SpruceError extends error_1.default {
+    /** an easy to understand version of the errors */
+    friendlyMessage() {
+        const { options } = this;
+        let message;
+        switch (options === null || options === void 0 ? void 0 : options.code) {
+            case 'NO_BOT_INSTANCE_SET':
+                message = `You must create a bot and set it using 'SprucebotLlmFactory.setInstance(bot)' before you can get an instance of it.`;
+                break;
+            default:
+                message = super.friendlyMessage();
+        }
+        const fullMessage = options.friendlyMessage
+            ? options.friendlyMessage
+            : message;
+        return fullMessage;
+    }
+}
+exports.default = SpruceError;

package/build/errors/noBotInstanceSet.builder.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    id: string;
+    name: string;
+    fields: {};
+};
+export default _default;

package/build/errors/noBotInstanceSet.builder.js

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

package/build/esm/.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/esm/.spruce/errors/errors.types.js

@@ -0,0 +1,3 @@
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable no-redeclare */
+export {};

package/build/esm/.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/esm/.spruce/errors/options.types.js

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

package/build/esm/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/esm/bots/PromptGenerator.js

@@ -0,0 +1,67 @@
+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;
+};
+import { assertOptions, normalizeSchemaValues, } from '@sprucelabs/schema';
+import * as Eta from 'eta';
+import { PROMPT_TEMPLATE } from './templates.js';
+export default class PromptGenerator {
+    constructor(bot) {
+        this.eta = Eta;
+        assertOptions({ bot }, ['bot']);
+        this.bot = bot;
+    }
+    generate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _a = this.bot.serialize(), { stateSchema, state } = _a, rest = __rest(_a, ["stateSchema", "state"]);
+            const { stateSchemaJson, stateJson } = this.stringifyState(stateSchema, state);
+            return yield this.eta.render(PROMPT_TEMPLATE, Object.assign({ stateSchemaJson,
+                stateJson }, rest), {
+                async: true,
+                autoEscape: false,
+            });
+        });
+    }
+    stringifyState(stateSchema, state) {
+        if (!stateSchema) {
+            return {
+                stateSchemaJson: null,
+                stateJson: null,
+            };
+        }
+        const normalizedState = normalizeSchemaValues(stateSchema, state !== null && state !== void 0 ? state : {}, {});
+        setUndefinedToNull(normalizedState);
+        const stateSchemaJson = JSON.stringify(stateSchema);
+        const stateJson = JSON.stringify(normalizedState);
+        return { stateSchemaJson, stateJson };
+    }
+}
+export 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]);
+            }
+        }
+    }
+}

package/build/esm/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/esm/bots/SprucebotLlmBotImpl.js

@@ -0,0 +1,76 @@
+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());
+    });
+};
+import { AbstractEventEmitter } from '@sprucelabs/mercury-event-emitter';
+import { assertOptions, defaultSchemaValues, } from '@sprucelabs/schema';
+import { llmEventContract, } from '../llm.types.js';
+import ResponseParser from '../parsingResponses/ResponseParser.js';
+export default class SprucebotLlmBotImpl extends AbstractEventEmitter {
+    constructor(options) {
+        const { adapter, youAre, stateSchema, state, skill } = options;
+        super(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({}, 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,
+        };
+    }
+    sendMessage(message) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            assertOptions({ message }, ['message']);
+            this.messages.push({
+                from: 'Me',
+                message,
+            });
+            const response = yield this.adapter.sendMessage(this);
+            const parser = ResponseParser.getInstance();
+            const { isDone, message: parsedResponse, state, } = yield parser.parse(response, (_a = this.skill) === null || _a === void 0 ? void 0 : _a.serialize().callbacks);
+            this.isDone = isDone;
+            if (this.stateSchema && state) {
+                yield this.updateState(state);
+            }
+            else if (state) {
+                yield ((_b = this.skill) === null || _b === void 0 ? void 0 : _b.updateState(state));
+            }
+            this.messages.push({
+                from: 'You',
+                message: parsedResponse,
+            });
+            return parsedResponse;
+        });
+    }
+    updateState(newState) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.state = Object.assign(Object.assign({}, this.state), newState);
+            yield this.emit('did-update-state');
+        });
+    }
+}

package/build/esm/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/esm/bots/SprucebotLlmFactory.js

@@ -0,0 +1,29 @@
+import { assertOptions } from '@sprucelabs/schema';
+import SpruceError from '../errors/SpruceError.js';
+import SprucebotLlmBotImpl from './SprucebotLlmBotImpl.js';
+import SprucebotLlmSkillImpl from './SprucebotLlmSkillImpl.js';
+export default class SprucebotLlmFactory {
+    Bot(options) {
+        assertOptions(options, ['youAre', 'adapter']);
+        const { Class } = options;
+        return Class ? new Class(options) : new SprucebotLlmBotImpl(options);
+    }
+    Skill(options) {
+        assertOptions(options, ['yourJobIfYouChooseToAcceptItIs']);
+        return new SprucebotLlmSkillImpl(options);
+    }
+    getBotInstance() {
+        if (!this.instance) {
+            throw new SpruceError({
+                code: 'NO_BOT_INSTANCE_SET',
+            });
+        }
+        return this.instance;
+    }
+    setBotInstance(bot) {
+        this.instance = bot;
+    }
+    static Factory() {
+        return new this();
+    }
+}

package/build/esm/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/esm/bots/SprucebotLlmSkillImpl.js

@@ -0,0 +1,47 @@
+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;
+};
+import { AbstractEventEmitter } from '@sprucelabs/mercury-event-emitter';
+import { defaultSchemaValues } from '@sprucelabs/schema';
+import { llmEventContract, } from '../llm.types.js';
+export default class SprucebotLlmSkillImpl extends AbstractEventEmitter {
+    constructor(options) {
+        super(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({}, defaultSchemaValues(stateSchema)), state)
+            : undefined;
+    }
+    updateState(updates) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield 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 });
+    }
+}

package/build/esm/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/esm/bots/adapters/OpenAi.js

@@ -0,0 +1,36 @@
+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());
+    });
+};
+import { assertOptions } from '@sprucelabs/schema';
+import { Configuration, OpenAIApi } from 'openai';
+import PromptGenerator from '../PromptGenerator.js';
+export class OpenAi {
+    constructor(apiKey) {
+        assertOptions({ apiKey }, ['apiKey']);
+        const config = new OpenAi.Configuration({ apiKey });
+        this.api = new OpenAi.OpenAIApi(config);
+    }
+    sendMessage(bot) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            const generator = new PromptGenerator(bot);
+            const prompt = yield generator.generate();
+            const response = yield 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 : MESSAGE_RESPONSE_ERROR_MESSAGE);
+        });
+    }
+}
+OpenAi.Configuration = Configuration;
+OpenAi.OpenAIApi = OpenAIApi;
+export const MESSAGE_RESPONSE_ERROR_MESSAGE = "Oh no! Something went wrong and I can't talk right now!";

package/build/esm/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/esm/bots/adapters/SpyOpenAiApi.js

@@ -0,0 +1,42 @@
+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());
+    });
+};
+import { OpenAIApi, } from 'openai';
+export default class SpyOpenAiApi extends OpenAIApi {
+    constructor(config) {
+        super(config);
+        SpyOpenAiApi.config = config;
+    }
+    createCompletion(createCompletionRequest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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,
+                },
+            };
+        });
+    }
+}
+SpyOpenAiApi.responseMessage = 'hello!';

package/build/esm/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;