@sprucelabs/sprucebot-llm 13.1.9 → 13.2.0

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

@@ -0,0 +1,17 @@
+import { Schema } from '@sprucelabs/schema';
+import Anthropic from '@anthropic-ai/sdk';
+import { LlmAdapter, SprucebotLlmBot, SendMessageOptions, LllmReasoningEffort } from '../../llm.types';
+export default class AthropicAdapter implements LlmAdapter {
+    static Anthropic: typeof Anthropic;
+    private api;
+    private model;
+    private maxTokens;
+    private sender;
+    constructor(apiKey: string, options: {
+        maxTokens: number;
+    });
+    sendMessage(bot: SprucebotLlmBot<Schema>, options?: SendMessageOptions): Promise<string>;
+    private sendHandler;
+    setModel(model: string): void;
+    setReasoningEffort(_effort: LllmReasoningEffort): void;
+}

package/build/bots/adapters/AthropicAdapter.js

@@ -0,0 +1,50 @@
+"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 sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+const MessageSender_1 = __importDefault(require("./MessageSender"));
+class AthropicAdapter {
+    constructor(apiKey, options) {
+        this.model = 'claude-sonnet-4-5';
+        (0, schema_1.assertOptions)({ apiKey, maxTokens: options?.maxTokens }, [
+            'apiKey',
+            'maxTokens',
+        ]);
+        this.api = new AthropicAdapter.Anthropic({ apiKey });
+        this.maxTokens = options.maxTokens;
+        this.sender = MessageSender_1.default.Sender(this.sendHandler.bind(this));
+    }
+    async sendMessage(bot, options) {
+        const text = await this.sender.sendMessage(bot, {
+            model: this.model,
+            ...options,
+        });
+        return text;
+    }
+    async sendHandler(params, sendOptions) {
+        const { messages: openAiMessages, model } = params;
+        const messages = [];
+        for (const msg of openAiMessages) {
+            messages.push({
+                role: msg.role === 'assistant' ? 'assistant' : 'user',
+                content: msg.content,
+            });
+        }
+        const response = await this.api.messages.create({
+            max_tokens: this.maxTokens,
+            model,
+            messages,
+        }, sendOptions);
+        const text = response.content?.[0]?.text;
+        return text;
+    }
+    setModel(model) {
+        this.model = model;
+    }
+    setReasoningEffort(_effort) { }
+}
+AthropicAdapter.Anthropic = sdk_1.default;
+exports.default = AthropicAdapter;

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

@@ -0,0 +1,33 @@
+import { Log } from '@sprucelabs/spruce-skill-utils';
+import OpenAI from 'openai';
+import { RequestOptions } from 'openai/internal/request-options';
+import { ReasoningEffort, ChatCompletionCreateParamsNonStreaming } from 'openai/resources';
+import { SprucebotLlmBot, SendMessageOptions } from '../../llm.types';
+export default class MessageSenderImpl implements MessageSender {
+    static AbortController: {
+        new (): AbortController;
+        prototype: AbortController;
+    };
+    private log?;
+    private lastAbortController?;
+    private sendHandler;
+    private constructor();
+    static Sender(send: MessageSenderSendHandler, log?: Log): MessageSender;
+    sendMessage(bot: SprucebotLlmBot, options: MessageSenderSendMessageOptions): Promise<string>;
+    private send;
+}
+export type MessageSenderSendOptions = SendMessageOptions & {
+    messages: OpenAI.Chat.Completions.ChatCompletionMessageParam[];
+    reasoningEffort?: ReasoningEffort;
+    model: string;
+    abortController: AbortController;
+};
+export type MessageSenderSendHandler = (params: ChatCompletionCreateParamsNonStreaming, options: RequestOptions) => Promise<string | undefined>;
+export interface MessageSender {
+    sendMessage(bot: SprucebotLlmBot, options: MessageSenderSendMessageOptions): Promise<string>;
+}
+export type MessageSenderSendMessageOptions = SendMessageOptions & {
+    memoryLimit?: number;
+    reasoningEffort?: ReasoningEffort;
+    model: string;
+};

package/build/bots/adapters/MessageSender.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const openai_1 = require("openai");
+const OpenAiAdapter_1 = require("./OpenAiAdapter");
+const OpenAiMessageBuilder_1 = __importDefault(require("./OpenAiMessageBuilder"));
+class MessageSenderImpl {
+    constructor(send, log) {
+        this.log = log;
+        this.sendHandler = send;
+    }
+    static Sender(send, log) {
+        return new this(send, log);
+    }
+    async sendMessage(bot, options) {
+        const { memoryLimit, ...rest } = options;
+        const messageBuilder = OpenAiMessageBuilder_1.default.Builder(bot, {
+            memoryLimit,
+        });
+        const messages = messageBuilder.buildMessages();
+        this.log?.info('Sending message', JSON.stringify(messages, null, 2));
+        try {
+            this.lastAbortController?.abort('Interrupted by new message');
+            this.lastAbortController = new MessageSenderImpl.AbortController();
+            const response = await this.send({
+                messages,
+                ...rest,
+                abortController: this.lastAbortController,
+            });
+            delete this.lastAbortController;
+            const message = response ?? OpenAiAdapter_1.MESSAGE_RESPONSE_ERROR_MESSAGE;
+            this.log?.info('Received response', message);
+            return message;
+        }
+        catch (err) {
+            if (err instanceof openai_1.APIUserAbortError) {
+                this.log?.info('Request was aborted');
+                return '';
+            }
+            throw err;
+        }
+    }
+    async send(options) {
+        const { abortController, reasoningEffort, ...restOptions } = options;
+        const params = {
+            ...restOptions,
+        };
+        if (reasoningEffort) {
+            params.reasoning_effort = reasoningEffort;
+        }
+        const response = await this.sendHandler(params, {
+            signal: abortController.signal,
+        });
+        return response;
+    }
+}
+MessageSenderImpl.AbortController = AbortController;
+exports.default = MessageSenderImpl;

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

@@ -5,19 +5,15 @@ import { LlmAdapter, SendMessageOptions, SprucebotLlmBot } from '../../llm.types
 export default class OpenAiAdapter implements LlmAdapter {
     static Class: new (apiKey: string, options?: OpenAiAdapterOptions) => OpenAiAdapter;
     static OpenAI: typeof OpenAI;
-    static AbortController: {
-        new (): AbortController;
-        prototype: AbortController;
-    };
     private api;
-    private log?;
     private model;
     private memoryLimit?;
     private reasoningEffort?;
-    private lastAbortController?;
+    private sender;
     protected constructor(apiKey: string, options?: OpenAiAdapterOptions);
     static Adapter(apiKey: string, options?: OpenAiAdapterOptions): OpenAiAdapter;
     sendMessage(bot: SprucebotLlmBot, options?: SendMessageOptions): Promise<string>;
+    private sendHandler;
     private getReasoningEffort;
     setModel(model: string): void;
     setMessageMemoryLimit(limit: number): void;

package/build/bots/adapters/OpenAiAdapter.js

@@ -1,93 +1,38 @@
 "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 () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __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 });
 exports.MESSAGE_RESPONSE_ERROR_MESSAGE = void 0;
 const schema_1 = require("@sprucelabs/schema");
-const openai_1 = __importStar(require("openai"));
-const OpenAiMessageBuilder_1 = __importDefault(require("./OpenAiMessageBuilder"));
+const openai_1 = __importDefault(require("openai"));
+const MessageSender_1 = __importDefault(require("./MessageSender"));
 class OpenAiAdapter {
     constructor(apiKey, options) {
         this.model = 'gpt-4o';
         (0, schema_1.assertOptions)({ apiKey }, ['apiKey']);
         const { log, memoryLimit, model, reasoningEffort, baseUrl } = options || {};
         this.api = new OpenAiAdapter.OpenAI({ apiKey, baseURL: baseUrl });
-        this.log = log;
         this.memoryLimit = memoryLimit;
         this.model = model ?? this.model;
         this.reasoningEffort = reasoningEffort;
+        this.sender = MessageSender_1.default.Sender(this.sendHandler.bind(this), log);
     }
     static Adapter(apiKey, options) {
         return new (this.Class ?? this)(apiKey, options);
     }
     async sendMessage(bot, options) {
-        const messageBuilder = OpenAiMessageBuilder_1.default.Builder(bot, {
-            memoryLimit: this.memoryLimit,
-        });
-        const messages = messageBuilder.buildMessages();
-        this.log?.info('Sending message to OpenAI', JSON.stringify(messages, null, 2));
-        const params = {
-            messages,
+        return this.sender.sendMessage(bot, {
             model: this.model,
+            memoryLimit: this.memoryLimit,
+            reasoningEffort: this.getReasoningEffort(),
             ...options,
-        };
-        const reasoningEffort = this.getReasoningEffort();
-        if (reasoningEffort) {
-            params.reasoning_effort = reasoningEffort;
-        }
-        try {
-            this.lastAbortController?.abort('Interrupted by new message');
-            this.lastAbortController = new OpenAiAdapter.AbortController();
-            const response = await this.api.chat.completions.create(params, {
-                signal: this.lastAbortController.signal,
-            });
-            delete this.lastAbortController;
-            const message = response.choices?.[0]?.message?.content?.trim() ??
-                exports.MESSAGE_RESPONSE_ERROR_MESSAGE;
-            this.log?.info('Received response from OpenAI', message);
-            return message;
-        }
-        catch (err) {
-            if (err instanceof openai_1.APIUserAbortError) {
-                this.log?.info('OpenAI request was aborted');
-                return '';
-            }
-            throw err;
-        }
+        });
+    }
+    async sendHandler(params, sendOptions) {
+        const response = await this.api.chat.completions.create(params, sendOptions);
+        const responseMessage = response.choices?.[0]?.message?.content?.trim();
+        return responseMessage;
     }
     getReasoningEffort() {
         return (this.reasoningEffort ?? process.env.OPENAI_REASONING_EFFORT);
@@ -103,6 +48,5 @@ class OpenAiAdapter {
     }
 }
 OpenAiAdapter.OpenAI = openai_1.default;
-OpenAiAdapter.AbortController = AbortController;
 exports.default = OpenAiAdapter;
 exports.MESSAGE_RESPONSE_ERROR_MESSAGE = "Oh no! Something went wrong and I can't talk right now!";

package/build/errors/SpruceError.js

@@ -25,7 +25,7 @@ Next steps:
 
 1. Don't just takes stabs at it, review the syntax rules for callbacks and make sure your tags are properly formatted.
     1a. <<callbackName/>> for callbacks with no arguments.
-    1b. <<callbackName>>{{JSON arguments}}<</callbackName>> for callbacks with arguments.
+    1b. <<callbackName>>{"valid": "json"}<</callbackName>> for callbacks with arguments.
 2. Check the list of valid callbacks (below) below to ensure the callback you are trying to invoke actually exists.
 
 Valid callbacks:

package/build/esm/bots/adapters/AthropicAdapter.d.ts

@@ -0,0 +1,17 @@
+import { Schema } from '@sprucelabs/schema';
+import Anthropic from '@anthropic-ai/sdk';
+import { LlmAdapter, SprucebotLlmBot, SendMessageOptions, LllmReasoningEffort } from '../../llm.types';
+export default class AthropicAdapter implements LlmAdapter {
+    static Anthropic: typeof Anthropic;
+    private api;
+    private model;
+    private maxTokens;
+    private sender;
+    constructor(apiKey: string, options: {
+        maxTokens: number;
+    });
+    sendMessage(bot: SprucebotLlmBot<Schema>, options?: SendMessageOptions): Promise<string>;
+    private sendHandler;
+    setModel(model: string): void;
+    setReasoningEffort(_effort: LllmReasoningEffort): void;
+}

package/build/esm/bots/adapters/AthropicAdapter.js

@@ -0,0 +1,56 @@
+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 Anthropic from '@anthropic-ai/sdk';
+import MessageSenderImpl from './MessageSender.js';
+class AthropicAdapter {
+    constructor(apiKey, options) {
+        this.model = 'claude-sonnet-4-5';
+        assertOptions({ apiKey, maxTokens: options === null || options === void 0 ? void 0 : options.maxTokens }, [
+            'apiKey',
+            'maxTokens',
+        ]);
+        this.api = new AthropicAdapter.Anthropic({ apiKey });
+        this.maxTokens = options.maxTokens;
+        this.sender = MessageSenderImpl.Sender(this.sendHandler.bind(this));
+    }
+    sendMessage(bot, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const text = yield this.sender.sendMessage(bot, Object.assign({ model: this.model }, options));
+            return text;
+        });
+    }
+    sendHandler(params, sendOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const { messages: openAiMessages, model } = params;
+            const messages = [];
+            for (const msg of openAiMessages) {
+                messages.push({
+                    role: msg.role === 'assistant' ? 'assistant' : 'user',
+                    content: msg.content,
+                });
+            }
+            const response = yield this.api.messages.create({
+                max_tokens: this.maxTokens,
+                model,
+                messages,
+            }, sendOptions);
+            const text = (_b = (_a = response.content) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.text;
+            return text;
+        });
+    }
+    setModel(model) {
+        this.model = model;
+    }
+    setReasoningEffort(_effort) { }
+}
+AthropicAdapter.Anthropic = Anthropic;
+export default AthropicAdapter;

package/build/esm/bots/adapters/MessageSender.d.ts

@@ -0,0 +1,33 @@
+import { Log } from '@sprucelabs/spruce-skill-utils';
+import OpenAI from 'openai';
+import { RequestOptions } from 'openai/internal/request-options';
+import { ReasoningEffort, ChatCompletionCreateParamsNonStreaming } from 'openai/resources';
+import { SprucebotLlmBot, SendMessageOptions } from '../../llm.types';
+export default class MessageSenderImpl implements MessageSender {
+    static AbortController: {
+        new (): AbortController;
+        prototype: AbortController;
+    };
+    private log?;
+    private lastAbortController?;
+    private sendHandler;
+    private constructor();
+    static Sender(send: MessageSenderSendHandler, log?: Log): MessageSender;
+    sendMessage(bot: SprucebotLlmBot, options: MessageSenderSendMessageOptions): Promise<string>;
+    private send;
+}
+export type MessageSenderSendOptions = SendMessageOptions & {
+    messages: OpenAI.Chat.Completions.ChatCompletionMessageParam[];
+    reasoningEffort?: ReasoningEffort;
+    model: string;
+    abortController: AbortController;
+};
+export type MessageSenderSendHandler = (params: ChatCompletionCreateParamsNonStreaming, options: RequestOptions) => Promise<string | undefined>;
+export interface MessageSender {
+    sendMessage(bot: SprucebotLlmBot, options: MessageSenderSendMessageOptions): Promise<string>;
+}
+export type MessageSenderSendMessageOptions = SendMessageOptions & {
+    memoryLimit?: number;
+    reasoningEffort?: ReasoningEffort;
+    model: string;
+};

package/build/esm/bots/adapters/MessageSender.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 { APIUserAbortError } from 'openai';
+import { MESSAGE_RESPONSE_ERROR_MESSAGE } from './OpenAiAdapter.js';
+import OpenAiMessageBuilder from './OpenAiMessageBuilder.js';
+class MessageSenderImpl {
+    constructor(send, log) {
+        this.log = log;
+        this.sendHandler = send;
+    }
+    static Sender(send, log) {
+        return new this(send, log);
+    }
+    sendMessage(bot, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            const { memoryLimit } = options, rest = __rest(options, ["memoryLimit"]);
+            const messageBuilder = OpenAiMessageBuilder.Builder(bot, {
+                memoryLimit,
+            });
+            const messages = messageBuilder.buildMessages();
+            (_a = this.log) === null || _a === void 0 ? void 0 : _a.info('Sending message', JSON.stringify(messages, null, 2));
+            try {
+                (_b = this.lastAbortController) === null || _b === void 0 ? void 0 : _b.abort('Interrupted by new message');
+                this.lastAbortController = new MessageSenderImpl.AbortController();
+                const response = yield this.send(Object.assign(Object.assign({ messages }, rest), { abortController: this.lastAbortController }));
+                delete this.lastAbortController;
+                const message = response !== null && response !== void 0 ? response : MESSAGE_RESPONSE_ERROR_MESSAGE;
+                (_c = this.log) === null || _c === void 0 ? void 0 : _c.info('Received response', message);
+                return message;
+            }
+            catch (err) {
+                if (err instanceof APIUserAbortError) {
+                    (_d = this.log) === null || _d === void 0 ? void 0 : _d.info('Request was aborted');
+                    return '';
+                }
+                throw err;
+            }
+        });
+    }
+    send(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { abortController, reasoningEffort } = options, restOptions = __rest(options, ["abortController", "reasoningEffort"]);
+            const params = Object.assign({}, restOptions);
+            if (reasoningEffort) {
+                params.reasoning_effort = reasoningEffort;
+            }
+            const response = yield this.sendHandler(params, {
+                signal: abortController.signal,
+            });
+            return response;
+        });
+    }
+}
+MessageSenderImpl.AbortController = AbortController;
+export default MessageSenderImpl;

package/build/esm/bots/adapters/OpenAiAdapter.d.ts

@@ -5,19 +5,15 @@ import { LlmAdapter, SendMessageOptions, SprucebotLlmBot } from '../../llm.types
 export default class OpenAiAdapter implements LlmAdapter {
     static Class: new (apiKey: string, options?: OpenAiAdapterOptions) => OpenAiAdapter;
     static OpenAI: typeof OpenAI;
-    static AbortController: {
-        new (): AbortController;
-        prototype: AbortController;
-    };
     private api;
-    private log?;
     private model;
     private memoryLimit?;
     private reasoningEffort?;
-    private lastAbortController?;
+    private sender;
     protected constructor(apiKey: string, options?: OpenAiAdapterOptions);
     static Adapter(apiKey: string, options?: OpenAiAdapterOptions): OpenAiAdapter;
     sendMessage(bot: SprucebotLlmBot, options?: SendMessageOptions): Promise<string>;
+    private sendHandler;
     private getReasoningEffort;
     setModel(model: string): void;
     setMessageMemoryLimit(limit: number): void;

package/build/esm/bots/adapters/OpenAiAdapter.js

@@ -8,18 +8,18 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { assertOptions } from '@sprucelabs/schema';
-import OpenAI, { APIUserAbortError } from 'openai';
-import OpenAiMessageBuilder from './OpenAiMessageBuilder.js';
+import OpenAI from 'openai';
+import MessageSenderImpl from './MessageSender.js';
 class OpenAiAdapter {
     constructor(apiKey, options) {
         this.model = 'gpt-4o';
         assertOptions({ apiKey }, ['apiKey']);
         const { log, memoryLimit, model, reasoningEffort, baseUrl } = options || {};
         this.api = new OpenAiAdapter.OpenAI({ apiKey, baseURL: baseUrl });
-        this.log = log;
         this.memoryLimit = memoryLimit;
         this.model = model !== null && model !== void 0 ? model : this.model;
         this.reasoningEffort = reasoningEffort;
+        this.sender = MessageSenderImpl.Sender(this.sendHandler.bind(this), log);
     }
     static Adapter(apiKey, options) {
         var _a;
@@ -27,35 +27,15 @@ class OpenAiAdapter {
     }
     sendMessage(bot, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j;
-            const messageBuilder = OpenAiMessageBuilder.Builder(bot, {
-                memoryLimit: this.memoryLimit,
-            });
-            const messages = messageBuilder.buildMessages();
-            (_a = this.log) === null || _a === void 0 ? void 0 : _a.info('Sending message to OpenAI', JSON.stringify(messages, null, 2));
-            const params = Object.assign({ messages, model: this.model }, options);
-            const reasoningEffort = this.getReasoningEffort();
-            if (reasoningEffort) {
-                params.reasoning_effort = reasoningEffort;
-            }
-            try {
-                (_b = this.lastAbortController) === null || _b === void 0 ? void 0 : _b.abort('Interrupted by new message');
-                this.lastAbortController = new OpenAiAdapter.AbortController();
-                const response = yield this.api.chat.completions.create(params, {
-                    signal: this.lastAbortController.signal,
-                });
-                delete this.lastAbortController;
-                const message = (_g = (_f = (_e = (_d = (_c = response.choices) === null || _c === void 0 ? void 0 : _c[0]) === null || _d === void 0 ? void 0 : _d.message) === null || _e === void 0 ? void 0 : _e.content) === null || _f === void 0 ? void 0 : _f.trim()) !== null && _g !== void 0 ? _g : MESSAGE_RESPONSE_ERROR_MESSAGE;
-                (_h = this.log) === null || _h === void 0 ? void 0 : _h.info('Received response from OpenAI', message);
-                return message;
-            }
-            catch (err) {
-                if (err instanceof APIUserAbortError) {
-                    (_j = this.log) === null || _j === void 0 ? void 0 : _j.info('OpenAI request was aborted');
-                    return '';
-                }
-                throw err;
-            }
+            return this.sender.sendMessage(bot, Object.assign({ model: this.model, memoryLimit: this.memoryLimit, reasoningEffort: this.getReasoningEffort() }, options));
+        });
+    }
+    sendHandler(params, sendOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            const response = yield this.api.chat.completions.create(params, sendOptions);
+            const responseMessage = (_d = (_c = (_b = (_a = response.choices) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.message) === null || _c === void 0 ? void 0 : _c.content) === null || _d === void 0 ? void 0 : _d.trim();
+            return responseMessage;
         });
     }
     getReasoningEffort() {
@@ -73,6 +53,5 @@ class OpenAiAdapter {
     }
 }
 OpenAiAdapter.OpenAI = OpenAI;
-OpenAiAdapter.AbortController = AbortController;
 export default OpenAiAdapter;
 export const MESSAGE_RESPONSE_ERROR_MESSAGE = "Oh no! Something went wrong and I can't talk right now!";

package/build/esm/errors/SpruceError.js

@@ -20,7 +20,7 @@ Next steps:
 
 1. Don't just takes stabs at it, review the syntax rules for callbacks and make sure your tags are properly formatted.
     1a. <<callbackName/>> for callbacks with no arguments.
-    1b. <<callbackName>>{{JSON arguments}}<</callbackName>> for callbacks with arguments.
+    1b. <<callbackName>>{"valid": "json"}<</callbackName>> for callbacks with arguments.
 2. Check the list of valid callbacks (below) below to ensure the callback you are trying to invoke actually exists.
 
 Valid callbacks:

package/build/esm/index.d.ts

@@ -10,3 +10,5 @@ export { default as SpyLlmAdapter } from './tests/SpyAdapter';
 export { default as SpyOpenAiApi } from './bots/adapters/SpyOpenAiModule';
 export { default as OllamaAdapter } from './bots/adapters/OllamaAdapter';
 export * from './bots/adapters/OllamaAdapter';
+export { default as AthropicAdapter } from './bots/adapters/AthropicAdapter';
+export * from './bots/adapters/AthropicAdapter';

package/build/esm/index.js

@@ -10,3 +10,5 @@ export { default as SpyLlmAdapter } from './tests/SpyAdapter.js';
 export { default as SpyOpenAiApi } from './bots/adapters/SpyOpenAiModule.js';
 export { default as OllamaAdapter } from './bots/adapters/OllamaAdapter.js';
 export * from './bots/adapters/OllamaAdapter.js';
+export { default as AthropicAdapter } from './bots/adapters/AthropicAdapter.js';
+export * from './bots/adapters/AthropicAdapter.js';

package/build/index.d.ts

@@ -10,3 +10,5 @@ export { default as SpyLlmAdapter } from './tests/SpyAdapter';
 export { default as SpyOpenAiApi } from './bots/adapters/SpyOpenAiModule';
 export { default as OllamaAdapter } from './bots/adapters/OllamaAdapter';
 export * from './bots/adapters/OllamaAdapter';
+export { default as AthropicAdapter } from './bots/adapters/AthropicAdapter';
+export * from './bots/adapters/AthropicAdapter';

package/build/index.js

@@ -17,7 +17,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OllamaAdapter = exports.SpyOpenAiApi = exports.SpyLlmAdapter = exports.SpyLllmBot = exports.MockLlmSkill = exports.SprucebotLlmError = exports.OpenAiAdapter = exports.SprucebotLlmSkillImpl = exports.SprucebotLlmBotImpl = exports.SprucebotLlmFactory = void 0;
+exports.AthropicAdapter = exports.OllamaAdapter = exports.SpyOpenAiApi = exports.SpyLlmAdapter = exports.SpyLllmBot = exports.MockLlmSkill = exports.SprucebotLlmError = exports.OpenAiAdapter = exports.SprucebotLlmSkillImpl = exports.SprucebotLlmBotImpl = exports.SprucebotLlmFactory = void 0;
 var SprucebotLlmFactory_1 = require("./bots/SprucebotLlmFactory");
 Object.defineProperty(exports, "SprucebotLlmFactory", { enumerable: true, get: function () { return __importDefault(SprucebotLlmFactory_1).default; } });
 var SprucebotLlmBotImpl_1 = require("./bots/SprucebotLlmBotImpl");
@@ -40,3 +40,6 @@ Object.defineProperty(exports, "SpyOpenAiApi", { enumerable: true, get: function
 var OllamaAdapter_1 = require("./bots/adapters/OllamaAdapter");
 Object.defineProperty(exports, "OllamaAdapter", { enumerable: true, get: function () { return __importDefault(OllamaAdapter_1).default; } });
 __exportStar(require("./bots/adapters/OllamaAdapter"), exports);
+var AthropicAdapter_1 = require("./bots/adapters/AthropicAdapter");
+Object.defineProperty(exports, "AthropicAdapter", { enumerable: true, get: function () { return __importDefault(AthropicAdapter_1).default; } });
+__exportStar(require("./bots/adapters/AthropicAdapter"), exports);

package/package.json

@@ -8,7 +8,7 @@
       "eta"
     ]
   },
-  "version": "13.1.9",
+  "version": "13.2.0",
   "files": [
     "build"
   ],
@@ -65,6 +65,7 @@
     "chat.images": "node ./build/chatWithImages.js"
   },
   "dependencies": {
+    "@anthropic-ai/sdk": "^0.74.0",
     "@sprucelabs/error": "^8.1.4",
     "@sprucelabs/mercury-event-emitter": "^46.1.2",
     "@sprucelabs/mercury-types": "^49.1.5",