@sprucelabs/sprucebot-llm 11.1.14 → 11.1.16

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

@@ -1,3 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=errors.types.js.map

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

@@ -1,3 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=options.types.js.map

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

@@ -9,4 +9,3 @@ const callbackErrorSchema = {
 };
 schema_1.SchemaRegistry.getInstance().trackSchema(callbackErrorSchema);
 exports.default = callbackErrorSchema;
-//# sourceMappingURL=callbackError.schema.js.map

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

@@ -24,4 +24,3 @@ const invalidCallbackSchema = {
 };
 schema_1.SchemaRegistry.getInstance().trackSchema(invalidCallbackSchema);
 exports.default = invalidCallbackSchema;
-//# sourceMappingURL=invalidCallback.schema.js.map

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

@@ -9,4 +9,3 @@ const noBotInstanceSetSchema = {
 };
 schema_1.SchemaRegistry.getInstance().trackSchema(noBotInstanceSetSchema);
 exports.default = noBotInstanceSetSchema;
-//# sourceMappingURL=noBotInstanceSet.schema.js.map

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

@@ -2,4 +2,3 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const schema_1 = require("@sprucelabs/schema");
 exports.default = schema_1.fieldClassMap;
-//# sourceMappingURL=fieldClassMap.js.map

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

@@ -1,3 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=fields.types.js.map

package/build/bots/PromptGenerator.js

@@ -55,4 +55,3 @@ function setUndefinedToNull(obj) {
         }
     }
 }
-//# sourceMappingURL=PromptGenerator.js.map

package/build/bots/SprucebotLlmBotImpl.js

@@ -145,4 +145,3 @@ class SprucebotLlmBotImpl extends mercury_event_emitter_1.AbstractEventEmitter {
 }
 SprucebotLlmBotImpl.messageMemoryLimit = 10;
 exports.default = SprucebotLlmBotImpl;
-//# sourceMappingURL=SprucebotLlmBotImpl.js.map

package/build/bots/SprucebotLlmFactory.js

@@ -46,4 +46,3 @@ class SprucebotLlmFactory {
     }
 }
 exports.default = SprucebotLlmFactory;
-//# sourceMappingURL=SprucebotLlmFactory.js.map

package/build/bots/SprucebotLlmSkillImpl.js

@@ -33,4 +33,3 @@ class SprucebotLlmSkillImpl extends mercury_event_emitter_1.AbstractEventEmitter
     }
 }
 exports.default = SprucebotLlmSkillImpl;
-//# sourceMappingURL=SprucebotLlmSkillImpl.js.map

package/build/bots/adapters/OpenAi.js

@@ -39,4 +39,3 @@ class OpenAiAdapter {
 OpenAiAdapter.OpenAI = openai_1.default;
 exports.default = OpenAiAdapter;
 exports.MESSAGE_RESPONSE_ERROR_MESSAGE = "Oh no! Something went wrong and I can't talk right now!";
-//# sourceMappingURL=OpenAi.js.map

package/build/bots/adapters/OpenAiMessageBuilder.js

@@ -153,4 +153,3 @@ class OpenAiMessageBuilder {
     }
 }
 exports.default = OpenAiMessageBuilder;
-//# sourceMappingURL=OpenAiMessageBuilder.js.map

package/build/bots/adapters/SpyOpenAiApi.js

@@ -41,4 +41,3 @@ class SpyOpenAiApi extends openai_1.default {
 }
 SpyOpenAiApi.responseMessage = 'hello!';
 exports.default = SpyOpenAiApi;
-//# sourceMappingURL=SpyOpenAiApi.js.map

package/build/bots/templates.js

@@ -72,4 +72,3 @@ __<%= message.from %>__: <%= message.message %>
 
 <% }) %>
 __You__:`;
-//# sourceMappingURL=templates.js.map

package/build/chat.js

@@ -80,4 +80,3 @@ void (async () => {
     console.log('Signing off...');
     rl.close();
 })();
-//# sourceMappingURL=chat.js.map

package/build/chatWithImages.js

@@ -40,4 +40,3 @@ void (async () => {
         imageDescription: 'The first image',
     }, (message) => console.log('>', message));
 })();
-//# sourceMappingURL=chatWithImages.js.map

package/build/errors/SpruceError.js

@@ -29,4 +29,3 @@ class SpruceError extends error_1.default {
     }
 }
 exports.default = SpruceError;
-//# sourceMappingURL=SpruceError.js.map

package/build/errors/callbackError.builder.js

@@ -6,4 +6,3 @@ exports.default = (0, schema_1.buildErrorSchema)({
     name: 'Callback error',
     fields: {},
 });
-//# sourceMappingURL=callbackError.builder.js.map

package/build/errors/invalidCallback.builder.js

@@ -17,4 +17,3 @@ exports.default = (0, schema_1.buildErrorSchema)({
         },
     },
 });
-//# sourceMappingURL=invalidCallback.builder.js.map

package/build/errors/noBotInstanceSet.builder.js

@@ -6,4 +6,3 @@ exports.default = (0, schema_1.buildErrorSchema)({
     name: 'No bot instance set',
     fields: {},
 });
-//# sourceMappingURL=noBotInstanceSet.builder.js.map

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

@@ -0,0 +1,52 @@
+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>;
+}
+export declare namespace SpruceErrors.SprucebotLlm {
+    interface InvalidCallback {
+        'validCallbacks': string[];
+        'matchedCallback': string;
+    }
+    interface InvalidCallbackSchema extends SpruceSchema.Schema {
+        id: 'invalidCallback';
+        namespace: 'SprucebotLlm';
+        name: 'Invalid callback';
+        fields: {
+            /** . */
+            'validCallbacks': {
+                type: 'text';
+                isRequired: true;
+                isArray: true;
+                minArrayLength: 0;
+                options: undefined;
+            };
+            /** . */
+            'matchedCallback': {
+                type: 'text';
+                isRequired: true;
+                options: undefined;
+            };
+        };
+    }
+    type InvalidCallbackEntity = SchemaEntity<SpruceErrors.SprucebotLlm.InvalidCallbackSchema>;
+}
+export declare namespace SpruceErrors.SprucebotLlm {
+    interface CallbackError {
+    }
+    interface CallbackErrorSchema extends SpruceSchema.Schema {
+        id: 'callbackError';
+        namespace: 'SprucebotLlm';
+        name: 'Callback error';
+        fields: {};
+    }
+    type CallbackErrorEntity = SchemaEntity<SpruceErrors.SprucebotLlm.CallbackErrorSchema>;
+}

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

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

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

@@ -0,0 +1,13 @@
+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';
+}
+export interface InvalidCallbackErrorOptions extends SpruceErrors.SprucebotLlm.InvalidCallback, ISpruceErrorOptions {
+    code: 'INVALID_CALLBACK';
+}
+export interface CallbackErrorErrorOptions extends SpruceErrors.SprucebotLlm.CallbackError, ISpruceErrorOptions {
+    code: 'CALLBACK_ERROR';
+}
+type ErrorOptions = NoBotInstanceSetErrorOptions | InvalidCallbackErrorOptions | CallbackErrorErrorOptions;
+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,22 @@
+import { LlmMessage, SprucebotLlmBot } from '../llm.types';
+export default class PromptGenerator {
+    private bot;
+    private eta;
+    private log;
+    static Class?: typeof PromptGenerator;
+    private promptTemplate;
+    protected constructor(bot: SprucebotLlmBot, options?: PromptGeneratorOptions);
+    static Generator(bot: SprucebotLlmBot, options?: PromptGeneratorOptions): PromptGenerator;
+    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;
+}
+export interface PromptGeneratorOptions {
+    promptTemplate?: string;
+}

package/build/esm/bots/PromptGenerator.js

@@ -0,0 +1,74 @@
+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 { Eta } from 'eta';
+import { PROMPT_TEMPLATE } from './templates.js';
+export default class PromptGenerator {
+    constructor(bot, options) {
+        var _a;
+        this.eta = new Eta();
+        this.log = process.env.SHOULD_LOG_GENERATED_PROMPTS === 'true'
+            ? console.info
+            : () => { };
+        assertOptions({ bot }, ['bot']);
+        this.bot = bot;
+        this.promptTemplate = (_a = options === null || options === void 0 ? void 0 : options.promptTemplate) !== null && _a !== void 0 ? _a : PROMPT_TEMPLATE;
+    }
+    static Generator(bot, options) {
+        var _a;
+        return new ((_a = this.Class) !== null && _a !== void 0 ? _a : PromptGenerator)(bot, options);
+    }
+    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);
+            const rendered = yield this.eta.renderStringAsync(this.promptTemplate, Object.assign({ stateSchemaJson,
+                stateJson }, rest));
+            this.log('Generated prompt:', rendered);
+            return rendered;
+        });
+    }
+    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) {
+        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,26 @@
+import { AbstractEventEmitter } from '@sprucelabs/mercury-event-emitter';
+import { Schema, SchemaValues } from '@sprucelabs/schema';
+import { BotOptions, LlmAdapter, LlmEventContract, LlmMessage, MessageResponseCallback, SendMessage, SerializedBot, SprucebotLlmBot, SprucebotLLmSkill } from '../llm.types';
+export default class SprucebotLlmBotImpl<StateSchema extends Schema = Schema, State extends SchemaValues<StateSchema> = SchemaValues<StateSchema>> extends AbstractEventEmitter<LlmEventContract> implements SprucebotLlmBot<StateSchema, State> {
+    static messageMemoryLimit: number;
+    protected adapter: LlmAdapter;
+    private youAre;
+    private stateSchema?;
+    protected state?: Partial<State>;
+    private isDone;
+    protected messages: LlmMessage[];
+    protected skill?: SprucebotLLmSkill;
+    constructor(options: BotOptions<StateSchema, State>);
+    clearMessageHistory(): void;
+    markAsDone(): void;
+    getIsDone(): boolean;
+    serialize(): SerializedBot<StateSchema, State>;
+    sendMessage(message: SendMessage, cb?: MessageResponseCallback): Promise<string>;
+    private _sendMessageInternal;
+    private optionallyUpdateState;
+    private parseResponse;
+    private sendMessageToAdapter;
+    private trackMessage;
+    updateState(newState: Partial<State>): Promise<void>;
+    setSkill(skill: SprucebotLLmSkill<any>): void;
+}

package/build/esm/bots/SprucebotLlmBotImpl.js

@@ -0,0 +1,163 @@
+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';
+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;
+    }
+    clearMessageHistory() {
+        this.messages = [];
+    }
+    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, cb) {
+        return __awaiter(this, void 0, void 0, function* () {
+            assertOptions({ message }, ['message']);
+            const llmMessage = {
+                from: 'Me',
+                message: '',
+            };
+            if (typeof message === 'string') {
+                llmMessage.message = message;
+            }
+            else {
+                llmMessage.message = message.imageDescription;
+                llmMessage.imageBase64 = message.imageBase64;
+            }
+            return this._sendMessageInternal(llmMessage, cb);
+        });
+    }
+    _sendMessageInternal(llmMessage, cb) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            this.trackMessage(llmMessage);
+            const { model, callbacks } = (_b = (_a = this.skill) === null || _a === void 0 ? void 0 : _a.serialize()) !== null && _b !== void 0 ? _b : {};
+            const llmResponse = yield this.sendMessageToAdapter(model);
+            let parsedMessage;
+            let isDone;
+            let state;
+            let callbackResults;
+            try {
+                const parsed = yield this.parseResponse(llmResponse, callbacks);
+                parsedMessage = parsed.message;
+                isDone = parsed.isDone;
+                state = parsed.state;
+                callbackResults = parsed.callbackResults;
+            }
+            catch (err) {
+                this.trackMessage({
+                    from: 'You',
+                    message: llmResponse,
+                });
+                if (((_c = err.options) === null || _c === void 0 ? void 0 : _c.code) === 'INVALID_CALLBACK' ||
+                    ((_d = err.options) === null || _d === void 0 ? void 0 : _d.code) === 'CALLBACK_ERROR') {
+                    return this._sendMessageInternal({ from: 'Api', message: `Error: ${err.message}` }, cb);
+                }
+                throw err;
+            }
+            this.isDone = isDone;
+            yield this.optionallyUpdateState(state);
+            this.trackMessage({
+                from: 'You',
+                message: llmResponse,
+            });
+            cb === null || cb === void 0 ? void 0 : cb(parsedMessage);
+            if (callbackResults) {
+                let message;
+                if (typeof callbackResults === 'string') {
+                    message = {
+                        from: 'Api',
+                        message: `API Results: ${callbackResults}`,
+                    };
+                }
+                else {
+                    message = {
+                        from: 'Api',
+                        imageBase64: callbackResults.imageBase64,
+                        message: `API Results: ${callbackResults.imageDescription}`,
+                    };
+                }
+                yield this._sendMessageInternal(message, cb);
+            }
+            return parsedMessage;
+        });
+    }
+    optionallyUpdateState(state) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (this.stateSchema && state) {
+                yield this.updateState(state);
+            }
+            else if (state) {
+                yield ((_a = this.skill) === null || _a === void 0 ? void 0 : _a.updateState(state));
+            }
+        });
+    }
+    parseResponse(response, callbacks) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const parser = ResponseParser.getInstance();
+            const parsed = yield parser.parse(response, callbacks);
+            return parsed;
+        });
+    }
+    sendMessageToAdapter(model) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.adapter.sendMessage(this, {
+                model,
+            });
+        });
+    }
+    trackMessage(m) {
+        if (this.messages.length === SprucebotLlmBotImpl.messageMemoryLimit) {
+            this.messages.shift();
+        }
+        this.messages.push(m);
+    }
+    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');
+        });
+    }
+    setSkill(skill) {
+        this.skill = skill;
+        this.isDone = false;
+    }
+}
+SprucebotLlmBotImpl.messageMemoryLimit = 10;
+export default SprucebotLlmBotImpl;

package/build/esm/bots/SprucebotLlmFactory.d.ts

@@ -0,0 +1,15 @@
+import { BotOptions, LlmAdapter, SkillOptions, SprucebotLlmBot, SprucebotLLmSkill } from '../llm.types';
+export default class SprucebotLlmFactory {
+    protected adapter: LlmAdapter;
+    private instance?;
+    static FactoryClass?: typeof SprucebotLlmFactory;
+    static BotClass?: new (options: any) => SprucebotLlmBot;
+    static SkillClass?: new (options: any) => SprucebotLLmSkill;
+    protected constructor(adapter: LlmAdapter);
+    Bot(options: Omit<BotOptions, 'adapter'>): SprucebotLlmBot;
+    Skill(options: SkillOptions): SprucebotLLmSkill;
+    getBotInstance(): SprucebotLlmBot<import("@sprucelabs/schema").Schema, Pick<import("@sprucelabs/schema").SchemaStaticValues<import("@sprucelabs/schema").Schema, false, never, import("@sprucelabs/schema").StaticSchemaAllValues<import("@sprucelabs/schema").Schema, false>>, never>>;
+    setBotInstance(bot: SprucebotLlmBot): void;
+    static Factory(adapter: LlmAdapter): SprucebotLlmFactory;
+    static reset(): void;
+}

package/build/esm/bots/SprucebotLlmFactory.js

@@ -0,0 +1,41 @@
+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 {
+    constructor(adapter) {
+        this.adapter = adapter;
+    }
+    Bot(options) {
+        var _a;
+        assertOptions(options, ['youAre']);
+        const { Class } = options;
+        return new ((_a = Class !== null && Class !== void 0 ? Class : SprucebotLlmFactory.BotClass) !== null && _a !== void 0 ? _a : SprucebotLlmBotImpl)(Object.assign(Object.assign({}, options), { adapter: this.adapter }));
+    }
+    Skill(options) {
+        var _a;
+        assertOptions(options, ['yourJobIfYouChooseToAcceptItIs']);
+        return new ((_a = SprucebotLlmFactory.SkillClass) !== null && _a !== void 0 ? _a : SprucebotLlmSkillImpl)(Object.assign({}, options));
+    }
+    getBotInstance() {
+        if (!this.instance) {
+            throw new SpruceError({
+                code: 'NO_BOT_INSTANCE_SET',
+            });
+        }
+        return this.instance;
+    }
+    setBotInstance(bot) {
+        this.instance = bot;
+    }
+    static Factory(adapter) {
+        var _a;
+        assertOptions({ adapter }, ['adapter']);
+        return new ((_a = this.FactoryClass) !== null && _a !== void 0 ? _a : this)(adapter);
+    }
+    static reset() {
+        this.BotClass = undefined;
+        this.FactoryClass = undefined;
+        this.SkillClass = undefined;
+    }
+}

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> {
+    protected options: SkillOptions;
+    private state?;
+    protected stateSchema?: 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 _a = options !== null && options !== void 0 ? options : {}, { state, stateSchema } = _a, rest = __rest(_a, ["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,11 @@
+import OpenAI from 'openai';
+import { LlmAdapter, SendMessageOptions, SprucebotLlmBot } from '../../llm.types';
+export default class OpenAiAdapter implements LlmAdapter {
+    static OpenAI: typeof OpenAI;
+    private api;
+    private log;
+    protected constructor(apiKey: string);
+    static Adapter(apiKey: string): OpenAiAdapter;
+    sendMessage(bot: SprucebotLlmBot, options?: SendMessageOptions): Promise<string>;
+}
+export declare const MESSAGE_RESPONSE_ERROR_MESSAGE = "Oh no! Something went wrong and I can't talk right now!";