@sprucelabs/sprucebot-llm 11.1.16 → 11.1.18

package/build/bots/SprucebotLlmBotImpl.d.ts

@@ -1,25 +1,23 @@
 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';
+import { BotOptions, 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 adapter;
     private youAre;
     private stateSchema?;
     protected state?: Partial<State>;
     private isDone;
     protected messages: LlmMessage[];
     protected skill?: SprucebotLLmSkill;
+    private activeTurn?;
     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/bots/SprucebotLlmBotImpl.js

@@ -6,7 +6,7 @@ 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"));
+const TurnRequest_1 = __importDefault(require("./TurnRequest"));
 class SprucebotLlmBotImpl extends mercury_event_emitter_1.AbstractEventEmitter {
     constructor(options) {
         const { adapter, youAre, stateSchema, state, skill } = options;
@@ -56,59 +56,16 @@ class SprucebotLlmBotImpl extends mercury_event_emitter_1.AbstractEventEmitter {
             llmMessage.message = message.imageDescription;
             llmMessage.imageBase64 = message.imageBase64;
         }
-        return this._sendMessageInternal(llmMessage, cb);
-    }
-    async _sendMessageInternal(llmMessage, cb) {
-        this.trackMessage(llmMessage);
-        const { model, callbacks } = this.skill?.serialize() ?? {};
-        const llmResponse = await this.sendMessageToAdapter(model);
-        let parsedMessage;
-        let isDone;
-        let state;
-        let callbackResults;
-        try {
-            const parsed = await 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 (err.options?.code === 'INVALID_CALLBACK' ||
-                err.options?.code === 'CALLBACK_ERROR') {
-                return this._sendMessageInternal({ from: 'Api', message: `Error: ${err.message}` }, cb);
-            }
-            throw err;
-        }
-        this.isDone = isDone;
-        await this.optionallyUpdateState(state);
-        this.trackMessage({
-            from: 'You',
-            message: llmResponse,
+        this.activeTurn?.cancel();
+        this.activeTurn = new TurnRequest_1.default({
+            adapter: this.adapter,
+            bot: this,
+            optionallyUpdateState: this.optionallyUpdateState.bind(this),
+            setDone: (isDone) => (this.isDone = isDone),
+            skill: this.skill,
+            trackMessage: this.trackMessage.bind(this),
         });
-        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}`,
-                };
-            }
-            await this._sendMessageInternal(message, cb);
-        }
-        return parsedMessage;
+        return this.activeTurn.sendMessage(llmMessage, cb);
     }
     async optionallyUpdateState(state) {
         if (this.stateSchema && state) {
@@ -118,16 +75,6 @@ class SprucebotLlmBotImpl extends mercury_event_emitter_1.AbstractEventEmitter {
             await this.skill?.updateState(state);
         }
     }
-    async parseResponse(response, callbacks) {
-        const parser = ResponseParser_1.default.getInstance();
-        const parsed = await parser.parse(response, callbacks);
-        return parsed;
-    }
-    async sendMessageToAdapter(model) {
-        return await this.adapter.sendMessage(this, {
-            model,
-        });
-    }
     trackMessage(m) {
         if (this.messages.length === SprucebotLlmBotImpl.messageMemoryLimit) {
             this.messages.shift();

package/build/bots/TurnRequest.d.ts

@@ -0,0 +1,22 @@
+import { LlmAdapter, LlmMessage, MessageResponseCallback, SprucebotLlmBot, SprucebotLLmSkill } from '../llm.types';
+export default class TurnRequest {
+    private trackMessage;
+    private skill?;
+    private adapter;
+    private setDone;
+    private optionallyUpdateState;
+    private bot;
+    private isCancelled;
+    constructor(options: {
+        trackMessage: (message: LlmMessage) => void;
+        setDone: (isDone: boolean) => void;
+        bot: SprucebotLlmBot;
+        skill?: SprucebotLLmSkill;
+        adapter: LlmAdapter;
+        optionallyUpdateState: (state?: Record<string, any>) => Promise<void>;
+    });
+    cancel(): void;
+    sendMessage(llmMessage: LlmMessage, cb?: MessageResponseCallback): Promise<string>;
+    private sendMessageToAdapter;
+    private parseResponse;
+}

package/build/bots/TurnRequest.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ResponseParser_1 = __importDefault(require("../parsingResponses/ResponseParser"));
+class TurnRequest {
+    constructor(options) {
+        this.isCancelled = false;
+        const { trackMessage, skill, bot, adapter, setDone, optionallyUpdateState, } = options;
+        this.trackMessage = trackMessage;
+        this.skill = skill;
+        this.adapter = adapter;
+        this.setDone = setDone;
+        this.bot = bot;
+        this.optionallyUpdateState = optionallyUpdateState;
+    }
+    cancel() {
+        this.isCancelled = true;
+    }
+    async sendMessage(llmMessage, cb) {
+        this.trackMessage(llmMessage);
+        const { model, callbacks } = this.skill?.serialize() ?? {};
+        const llmResponse = await this.sendMessageToAdapter(model);
+        if (this.isCancelled) {
+            return '';
+        }
+        let parsedMessage;
+        let isDone;
+        let state;
+        let callbackResults;
+        try {
+            const parsed = await 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 (err.options?.code === 'INVALID_CALLBACK' ||
+                err.options?.code === 'CALLBACK_ERROR') {
+                return this.sendMessage({ from: 'Api', message: `Error: ${err.message}` }, cb);
+            }
+            throw err;
+        }
+        this.setDone(isDone);
+        await this.optionallyUpdateState(state);
+        this.trackMessage({
+            from: 'You',
+            message: llmResponse,
+        });
+        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}`,
+                };
+            }
+            await this.sendMessage(message, cb);
+        }
+        return parsedMessage;
+    }
+    async sendMessageToAdapter(model) {
+        return await this.adapter.sendMessage(this.bot, {
+            model,
+        });
+    }
+    async parseResponse(response, callbacks) {
+        const parser = ResponseParser_1.default.getInstance();
+        const parsed = await parser.parse(response, callbacks);
+        return parsed;
+    }
+}
+exports.default = TurnRequest;

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

@@ -1,25 +1,23 @@
 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';
+import { BotOptions, 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 adapter;
     private youAre;
     private stateSchema?;
     protected state?: Partial<State>;
     private isDone;
     protected messages: LlmMessage[];
     protected skill?: SprucebotLLmSkill;
+    private activeTurn?;
     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

@@ -10,7 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 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';
+import TurnRequest from './TurnRequest.js';
 class SprucebotLlmBotImpl extends AbstractEventEmitter {
     constructor(options) {
         const { adapter, youAre, stateSchema, state, skill } = options;
@@ -47,6 +47,7 @@ class SprucebotLlmBotImpl extends AbstractEventEmitter {
     }
     sendMessage(message, cb) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             assertOptions({ message }, ['message']);
             const llmMessage = {
                 from: 'Me',
@@ -59,62 +60,16 @@ class SprucebotLlmBotImpl extends AbstractEventEmitter {
                 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,
+            (_a = this.activeTurn) === null || _a === void 0 ? void 0 : _a.cancel();
+            this.activeTurn = new TurnRequest({
+                adapter: this.adapter,
+                bot: this,
+                optionallyUpdateState: this.optionallyUpdateState.bind(this),
+                setDone: (isDone) => (this.isDone = isDone),
+                skill: this.skill,
+                trackMessage: this.trackMessage.bind(this),
             });
-            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;
+            return this.activeTurn.sendMessage(llmMessage, cb);
         });
     }
     optionallyUpdateState(state) {
@@ -128,20 +83,6 @@ class SprucebotLlmBotImpl extends AbstractEventEmitter {
             }
         });
     }
-    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();

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

@@ -0,0 +1,22 @@
+import { LlmAdapter, LlmMessage, MessageResponseCallback, SprucebotLlmBot, SprucebotLLmSkill } from '../llm.types';
+export default class TurnRequest {
+    private trackMessage;
+    private skill?;
+    private adapter;
+    private setDone;
+    private optionallyUpdateState;
+    private bot;
+    private isCancelled;
+    constructor(options: {
+        trackMessage: (message: LlmMessage) => void;
+        setDone: (isDone: boolean) => void;
+        bot: SprucebotLlmBot;
+        skill?: SprucebotLLmSkill;
+        adapter: LlmAdapter;
+        optionallyUpdateState: (state?: Record<string, any>) => Promise<void>;
+    });
+    cancel(): void;
+    sendMessage(llmMessage: LlmMessage, cb?: MessageResponseCallback): Promise<string>;
+    private sendMessageToAdapter;
+    private parseResponse;
+}

package/build/esm/bots/TurnRequest.js

@@ -0,0 +1,97 @@
+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 ResponseParser from '../parsingResponses/ResponseParser.js';
+export default class TurnRequest {
+    constructor(options) {
+        this.isCancelled = false;
+        const { trackMessage, skill, bot, adapter, setDone, optionallyUpdateState, } = options;
+        this.trackMessage = trackMessage;
+        this.skill = skill;
+        this.adapter = adapter;
+        this.setDone = setDone;
+        this.bot = bot;
+        this.optionallyUpdateState = optionallyUpdateState;
+    }
+    cancel() {
+        this.isCancelled = true;
+    }
+    sendMessage(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);
+            if (this.isCancelled) {
+                return '';
+            }
+            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.sendMessage({ from: 'Api', message: `Error: ${err.message}` }, cb);
+                }
+                throw err;
+            }
+            this.setDone(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.sendMessage(message, cb);
+            }
+            return parsedMessage;
+        });
+    }
+    sendMessageToAdapter(model) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.adapter.sendMessage(this.bot, {
+                model,
+            });
+        });
+    }
+    parseResponse(response, callbacks) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const parser = ResponseParser.getInstance();
+            const parsed = yield parser.parse(response, callbacks);
+            return parsed;
+        });
+    }
+}

package/package.json

@@ -8,7 +8,7 @@
       "eta"
     ]
   },
-  "version": "11.1.16",
+  "version": "11.1.18",
   "files": [
     "build"
   ],