@sprucelabs/sprucebot-llm 11.1.12 → 11.1.14

package/build/__tests__/behavioral/adapters/OpenAi.test.js

@@ -0,0 +1,699 @@
+"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 __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+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 });
+const schema_1 = require("@sprucelabs/schema");
+const test_utils_1 = require("@sprucelabs/test-utils");
+const openai_1 = __importDefault(require("openai"));
+const OpenAi_1 = __importStar(require("../../../bots/adapters/OpenAi"));
+const SpyOpenAiApi_1 = __importDefault(require("../../../bots/adapters/SpyOpenAiApi"));
+const templates_1 = require("../../../bots/templates");
+const AbstractLlmTest_1 = __importDefault(require("../../support/AbstractLlmTest"));
+let OpenAiTest = class OpenAiTest extends AbstractLlmTest_1.default {
+    constructor() {
+        super(...arguments);
+        this.skillJob = (0, test_utils_1.generateId)();
+    }
+    static async beforeAll() {
+        await super.beforeAll();
+        test_utils_1.assert.isEqual(OpenAi_1.default.OpenAI, openai_1.default, 'OpenAI not set');
+    }
+    async beforeEach() {
+        await super.beforeEach();
+        this.setupSpys();
+        this.openAi = this.OpenAi();
+        this.bot = this.Bot();
+        delete process.env.OPENAI_CHAT_HISTORY_LIMIT;
+        delete process.env.OPENAI_REASONING_EFFORT;
+    }
+    async throwsWhenMissingKey() {
+        //@ts-ignore
+        const err = test_utils_1.assert.doesThrow(() => new OpenAi_1.default());
+        test_utils_1.errorAssert.assertError(err, 'MISSING_PARAMETERS', {
+            parameters: ['apiKey'],
+        });
+    }
+    async instantiatingOpenAiSetsKeyToConfig() {
+        const key = (0, test_utils_1.generateId)();
+        this.OpenAi(key);
+        test_utils_1.assert.isEqual(SpyOpenAiApi_1.default.config?.apiKey, key);
+    }
+    async canSendMessage() {
+        const message = (0, test_utils_1.generateId)();
+        await this.setAndSendMessage(message);
+        this.assertLastCompletionEquals([
+            {
+                role: 'user',
+                content: message,
+            },
+        ]);
+    }
+    async returnsResponseFromSendMessage() {
+        SpyOpenAiApi_1.default.responseMessage = (0, test_utils_1.generateId)();
+        await this.assertResponseEquals(SpyOpenAiApi_1.default.responseMessage);
+    }
+    async trimsResponseMessage() {
+        SpyOpenAiApi_1.default.responseMessage = ' hello world ';
+        await this.assertResponseEquals('hello world');
+    }
+    async noResponseReturnsDefaultErrorMesssage() {
+        SpyOpenAiApi_1.default.responseMessage = false;
+        await this.assertResponseEquals(OpenAi_1.MESSAGE_RESPONSE_ERROR_MESSAGE);
+    }
+    async sendMessageCanAcceptModel() {
+        const model = 'davinci:ft-personal:sprucebot-concierge-2023-04-28-04-42-19';
+        await this.setAndSendMessage((0, test_utils_1.generateId)(), {
+            model,
+        });
+        test_utils_1.assert.isEqual(SpyOpenAiApi_1.default.lastSentCompletion?.model, model);
+    }
+    async sendsAllMessagesToOpenAi() {
+        const message1 = (0, test_utils_1.generateId)();
+        const message2 = (0, test_utils_1.generateId)();
+        this.bot.setMessages([
+            {
+                from: 'Me',
+                message: message1,
+            },
+            {
+                from: 'You',
+                message: message2,
+            },
+        ]);
+        await this.sendMessage();
+        this.assertLastCompletionEquals([
+            {
+                role: 'user',
+                content: message1,
+            },
+            {
+                role: 'assistant',
+                content: message2,
+            },
+        ]);
+    }
+    async sendsExpectedMessageIfSkillIsPassedWithJustJustJob() {
+        await this.setSkillSendMessageAndAssertSystemMessagesEqual({}, []);
+    }
+    async sendsExpectedMessageIfSkillPassedWithWhenWeAreDone() {
+        const doneWhen = (0, test_utils_1.generateId)();
+        await this.setSkillSendMessageAndAssertSystemMessagesEqual({
+            weAreDoneWhen: doneWhen,
+        }, [
+            {
+                role: 'developer',
+                content: `Our conversation is done when ${doneWhen}. Once you determine we are done, send me the following message so I know we're done: ${templates_1.DONE_TOKEN}`,
+            },
+        ]);
+    }
+    async sendsExpectedWithOnePleaseKeepInMind() {
+        const pleaseKeepInMind = [(0, test_utils_1.generateId)()];
+        await this.setSkillSendMessageAndAssertSystemMessagesEqual({
+            pleaseKeepInMindThat: pleaseKeepInMind,
+        }, [this.buildPleaseKeepInMindMessage(pleaseKeepInMind)]);
+    }
+    async sendsExpectedWithMultiplePleaseKeepInMind() {
+        const pleaseKeepInMind = [(0, test_utils_1.generateId)(), (0, test_utils_1.generateId)()];
+        await this.setSkillSendMessageAndAssertSystemMessagesEqual({
+            pleaseKeepInMindThat: pleaseKeepInMind,
+        }, [
+            {
+                role: 'developer',
+                content: `During this conversation, please keep the following in mind:\n\n1. ${pleaseKeepInMind[0]}\n2. ${pleaseKeepInMind[1]}.`,
+            },
+        ]);
+    }
+    async sendsExpectedWithSchema() {
+        await this.setSkillSendMessageWithSchemaAndAssertSystemMessagesEqualExpected((0, schema_1.buildSchema)({
+            id: 'test',
+            fields: {
+                firstName: {
+                    type: 'text',
+                },
+            },
+        }));
+        await this.setSkillSendMessageWithSchemaAndAssertSystemMessagesEqualExpected((0, schema_1.buildSchema)({
+            id: 'another',
+            fields: {
+                lastName: {
+                    type: 'text',
+                },
+            },
+        }));
+    }
+    async sendsExpectedWithState() {
+        const schema = (0, schema_1.buildSchema)({
+            id: 'next',
+            fields: {
+                firstName: {
+                    type: 'text',
+                    isRequired: true,
+                },
+            },
+        });
+        const state = {
+            firstName: (0, test_utils_1.generateId)(),
+        };
+        await this.setSkillSendMessageAndAssertSystemMessagesEqual({
+            state,
+            stateSchema: schema,
+        }, [this.renderSchemaMessage(schema), this.renderStateMessage(state)]);
+    }
+    async sendsExpectedMessageWithSimpleCallback() {
+        await this.setSkillSendMessageWithCallbacksAndAssertSystemMessagesEqualExpected({
+            test: {
+                cb: async () => 'hello',
+                useThisWhenever: (0, test_utils_1.generateId)(),
+            },
+        });
+    }
+    async sendsExectedMessageWithDifferentSimpleCallback() {
+        await this.setSkillSendMessageWithCallbacksAndAssertSystemMessagesEqualExpected({
+            aDifferentCallback: {
+                cb: async () => 'hello',
+                useThisWhenever: (0, test_utils_1.generateId)(),
+            },
+        });
+    }
+    async sendsExpectedMessagesWithMultipleCallbacks() {
+        await this.setSkillSendMessageWithCallbacksAndAssertSystemMessagesEqualExpected({
+            a: {
+                cb: async () => 'hello',
+                useThisWhenever: (0, test_utils_1.generateId)(),
+            },
+            b: {
+                cb: async () => 'hello',
+                useThisWhenever: (0, test_utils_1.generateId)(),
+            },
+        });
+    }
+    async sendsExpectedWithCallbackWithParameters() {
+        await this.setSkillSendMessageWithCallbacksAndAssertSystemMessagesEqualExpected({
+            a: {
+                cb: async () => `hello`,
+                useThisWhenever: (0, test_utils_1.generateId)(),
+                parameters: [
+                    {
+                        name: (0, test_utils_1.generateId)(),
+                        type: (0, test_utils_1.generateId)(),
+                    },
+                ],
+            },
+        });
+    }
+    async sendsExpectedWithCallbackParameterWithDescription() {
+        await this.setSkillSendMessageWithCallbacksAndAssertSystemMessagesEqualExpected({
+            callbackOne: {
+                cb: async () => `hello`,
+                useThisWhenever: (0, test_utils_1.generateId)(),
+                parameters: [
+                    {
+                        name: (0, test_utils_1.generateId)(),
+                        description: (0, test_utils_1.generateId)(),
+                        type: (0, test_utils_1.generateId)(),
+                    },
+                ],
+            },
+        });
+    }
+    async sendsExpectedWithCallbackParmaterThatIsRequired() {
+        await this.setSkillSendMessageWithCallbacksAndAssertSystemMessagesEqualExpected({
+            callbackOne: {
+                cb: async () => `hello`,
+                useThisWhenever: (0, test_utils_1.generateId)(),
+                parameters: [
+                    {
+                        name: (0, test_utils_1.generateId)(),
+                        isRequired: true,
+                        type: (0, test_utils_1.generateId)(),
+                    },
+                ],
+            },
+        });
+    }
+    async sendsExpectedWithMultipleCallbackParameters() {
+        await this.setSkillSendMessageWithCallbacksAndAssertSystemMessagesEqualExpected({
+            callbackOne: {
+                cb: async () => `hello`,
+                useThisWhenever: (0, test_utils_1.generateId)(),
+                parameters: [
+                    {
+                        name: (0, test_utils_1.generateId)(),
+                        type: (0, test_utils_1.generateId)(),
+                    },
+                    {
+                        name: (0, test_utils_1.generateId)(),
+                        type: (0, test_utils_1.generateId)(),
+                    },
+                ],
+            },
+        });
+    }
+    async chatHistoryCanBeLimitedByEnvTo1() {
+        this.setMessageMemoryLimit('1');
+        this.bot.setMessages([
+            {
+                from: 'Me',
+                message: (0, test_utils_1.generateId)(),
+            },
+            {
+                from: 'You',
+                message: 'hello world',
+            },
+        ]);
+        await this.sendMessage();
+        this.assertLastCompletionEquals([
+            {
+                role: 'assistant',
+                content: 'hello world',
+            },
+        ]);
+    }
+    async chatHistoryCanBeLimitedByEnvTo2() {
+        this.setMessageMemoryLimit('2');
+        this.bot.setMessages([
+            {
+                from: 'Me',
+                message: 'hey there!',
+            },
+            {
+                from: 'You',
+                message: 'hello world',
+            },
+            {
+                from: 'Me',
+                message: 'another',
+            },
+        ]);
+        await this.sendMessage();
+        this.assertLastCompletionEquals([
+            {
+                role: 'assistant',
+                content: 'hello world',
+            },
+            {
+                role: 'user',
+                content: 'another',
+            },
+        ]);
+    }
+    async pleaseKeepInMindIsLast() {
+        const callbacks = {
+            test: {
+                cb: async () => 'hello',
+                useThisWhenever: 'here we go!',
+            },
+        };
+        await this.setSkillSendMessageAndAssertSystemMessagesEqual({
+            callbacks,
+            pleaseKeepInMindThat: ['this is important'],
+        }, [
+            this.buildCallbacksMessage(callbacks),
+            this.buildPleaseKeepInMindMessage(['this is important']),
+        ]);
+    }
+    async canSendImageAsBase64() {
+        const image = (0, test_utils_1.generateId)();
+        const message = (0, test_utils_1.generateId)();
+        this.bot.setMessages([
+            {
+                from: 'Me',
+                message,
+                imageBase64: image,
+            },
+        ]);
+        await this.sendMessage();
+        this.assertLastCompletionEquals([
+            {
+                role: 'user',
+                content: [
+                    {
+                        type: 'text',
+                        text: message,
+                    },
+                    {
+                        type: 'image_url',
+                        image_url: {
+                            url: `data:image/png;base64,${image}`,
+                        },
+                    },
+                ],
+            },
+        ]);
+    }
+    async rendersSelectOptionsAsExpected() {
+        const callbacks = {
+            test: {
+                cb: async () => 'hello',
+                useThisWhenever: 'here we go!',
+                parameters: [
+                    {
+                        name: 'option',
+                        type: 'select',
+                        options: {
+                            choices: [
+                                {
+                                    label: 'Option 1',
+                                    value: 'option_1',
+                                },
+                                {
+                                    label: 'Option 2',
+                                    value: 'option_2',
+                                },
+                            ],
+                        },
+                    },
+                ],
+            },
+        };
+        await this.setSkillSendMessageAndAssertSystemMessagesEqual({
+            callbacks,
+        }, [this.buildCallbacksMessage(callbacks)]);
+    }
+    async rendersDifferentSelectOptionsAsExpected() {
+        const callbacks = {
+            test: {
+                cb: async () => 'what the',
+                useThisWhenever: (0, test_utils_1.generateId)(),
+                parameters: [
+                    {
+                        name: (0, test_utils_1.generateId)(),
+                        type: 'boolean',
+                    },
+                    {
+                        name: (0, test_utils_1.generateId)(),
+                        type: 'select',
+                        options: {
+                            choices: [
+                                {
+                                    label: (0, test_utils_1.generateId)(),
+                                    value: (0, test_utils_1.generateId)(),
+                                },
+                                {
+                                    label: (0, test_utils_1.generateId)(),
+                                    value: (0, test_utils_1.generateId)(),
+                                },
+                                {
+                                    label: (0, test_utils_1.generateId)(),
+                                    value: (0, test_utils_1.generateId)(),
+                                },
+                            ],
+                        },
+                    },
+                ],
+            },
+        };
+        await this.setSkillSendMessageAndAssertSystemMessagesEqual({
+            callbacks,
+        }, [this.buildCallbacksMessage(callbacks)]);
+    }
+    async canSetReasoningEffortViaEnv() {
+        process.env.OPENAI_REASONING_EFFORT = (0, test_utils_1.generateId)();
+        const message = (0, test_utils_1.generateId)();
+        await this.setAndSendMessage(message);
+        this.assertLastCompletionEquals([
+            {
+                role: 'user',
+                content: message,
+            },
+        ]);
+    }
+    buildPleaseKeepInMindMessage(pleaseKeepInMind) {
+        return {
+            role: 'developer',
+            content: this.renderPleaseKeepInMind(pleaseKeepInMind),
+        };
+    }
+    renderPleaseKeepInMind(pleaseKeepInMind) {
+        return `During this conversation, please keep the following in mind:\n\n${pleaseKeepInMind.map((m, idx) => `${idx + 1}. ${m}`).join('\n')}.`;
+    }
+    setMessageMemoryLimit(limit) {
+        process.env.OPENAI_MESSAGE_MEMORY_LIMIT = limit;
+    }
+    async setSkillSendMessageWithCallbacksAndAssertSystemMessagesEqualExpected(callbacks) {
+        await this.setSkillSendMessageAndAssertSystemMessagesEqual({
+            callbacks,
+        }, [this.buildCallbacksMessage(callbacks)]);
+    }
+    buildCallbacksMessage(callbacks) {
+        const keys = Object.keys(callbacks);
+        const descriptions = [];
+        for (const key of keys) {
+            const callback = callbacks[key];
+            let desc = `
+<Function name="${key}">
+    <Description>For use when ${callback.useThisWhenever}</Description>`;
+            if (callback.parameters) {
+                desc += `<Parameters>`;
+                const parameters = [];
+                for (const parameter of callback.parameters) {
+                    let parameterChoices = '';
+                    if (parameter.type === 'select') {
+                        const choices = parameter
+                            .options.choices;
+                        parameterChoices = `<Choices>\n${choices
+                            .map((c) => `
+    <Choice>
+        <Label>${c.label}</Label>
+        <Value>${c.value}</Value>
+    </Choice>`)
+                            .join('\n')}\n</Choices>`;
+                    }
+                    const parameterDefinition = `
+        <Parameter${parameter.isRequired ? ' required="true"' : ''}>
+            <Name>${parameter.name}</Name>
+            <Type>${parameter.type}</Type>
+            ${parameter.description ? `<Description>${parameter.description}</Description>` : ''}${parameterChoices}
+        </Parameter>`;
+                    parameters.push(parameterDefinition);
+                }
+                desc += parameters.join('\n') + `</Parameters>`;
+            }
+            descriptions.push(desc +
+                `
+</Function>`);
+        }
+        const api = `<APIReference>\n\n${descriptions.join('\n\n')}</APIReference>`;
+        const message = `You have an API available to you to lookup answers. When you need the response of the function call to proceed, you can call a function using a custom markup we created that looks like this: <<FunctionName/>>. The API will respond with the results and then you can continue the conversation with your new knowledge. If the api call has parameters, call it like this: <<FunctionName>>{{parametersJsonEncoded}}<</FunctionName>>. Make sure to json encode the data and drop it between the function tags. Note: You can only make one API call at a time. The API is as follows (in xml format):\n\n${api}`;
+        return { role: 'developer', content: message };
+    }
+    renderStateMessage(state) {
+        return {
+            role: 'developer',
+            content: `The current state of this conversation is:\n\n${JSON.stringify(state)}. As the state is being updated, send it back to me in json format (something in can JSON.parse()) at the end of each response (it's not meant for reading, but for parsing, so don't call it out, but send it as we progress), surrounded by a boundary, like this: ${templates_1.STATE_BOUNDARY} { "fieldName": "fieldValue" } ${templates_1.STATE_BOUNDARY}`,
+        };
+    }
+    async setSkillSendMessageWithSchemaAndAssertSystemMessagesEqualExpected(schema) {
+        await this.setSkillSendMessageAndAssertSystemMessagesEqual({
+            stateSchema: schema,
+        }, [this.renderSchemaMessage(schema), this.renderStateMessage({})]);
+    }
+    renderSchemaMessage(schema) {
+        return {
+            role: 'developer',
+            content: `We will be tracking state for this conversation. The following schema is what we'll use to define the shape of the state:\n\n${JSON.stringify(schema)}`,
+        };
+    }
+    async setSkillSendMessageAndAssertSystemMessagesEqual(skillOptions, messages) {
+        const skill = this.Skill({
+            yourJobIfYouChooseToAcceptItIs: this.skillJob,
+            weAreDoneWhen: undefined,
+            ...skillOptions,
+        });
+        this.bot.setSkill(skill);
+        const message = (0, test_utils_1.generateId)();
+        await this.setAndSendMessage(message);
+        this.assertLastCompletionEquals([
+            {
+                role: 'developer',
+                content: `For this interaction, your job is ${this.skillJob}.`,
+            },
+            ...messages,
+            {
+                role: 'user',
+                content: message,
+            },
+        ]);
+    }
+    assertLastCompletionEquals(expected) {
+        const params = {
+            model: 'gpt-4o',
+            messages: [
+                {
+                    role: 'developer',
+                    content: `You are ${this.youAre}.`,
+                },
+                ...expected,
+            ],
+        };
+        if (process.env.OPENAI_REASONING_EFFORT) {
+            params.reasoning_effort = process.env
+                .OPENAI_REASONING_EFFORT;
+        }
+        test_utils_1.assert.isEqualDeep(this.stripTabsAndNewlinesFromCompletion(SpyOpenAiApi_1.default.lastSentCompletion), this.stripTabsAndNewlinesFromCompletion(params), 'Last completion does not match expected.');
+    }
+    stripTabsAndNewlinesFromCompletion(completion) {
+        const { messages } = completion;
+        completion.messages = messages.map((message) => ({
+            ...message,
+            content: typeof message.content === 'string'
+                ? message.content
+                    .replace(/\t|\n|/g, '')
+                    .replace(/\s+/g, ' ')
+                : message.content,
+        }));
+        return completion;
+    }
+    async assertResponseEquals(expected) {
+        const response = await this.setAndSendMessage();
+        test_utils_1.assert.isEqual(response, expected, 'Response does not match expected value.');
+    }
+    async setAndSendMessage(message, options) {
+        this.bot.setMessages([
+            {
+                from: 'Me',
+                message: message ?? (0, test_utils_1.generateId)(),
+            },
+        ]);
+        return await this.sendMessage(options);
+    }
+    async sendMessage(options) {
+        return await this.openAi.sendMessage(this.bot, options);
+    }
+    OpenAi(key) {
+        return OpenAi_1.default.Adapter(key ?? (0, test_utils_1.generateId)());
+    }
+    setupSpys() {
+        OpenAi_1.default.OpenAI = SpyOpenAiApi_1.default;
+        SpyOpenAiApi_1.default.lastSentCompletion = undefined;
+    }
+};
+__decorate([
+    (0, test_utils_1.test)()
+], OpenAiTest.prototype, "throwsWhenMissingKey", null);
+__decorate([
+    (0, test_utils_1.test)()
+], OpenAiTest.prototype, "instantiatingOpenAiSetsKeyToConfig", null);
+__decorate([
+    (0, test_utils_1.test)()
+], OpenAiTest.prototype, "canSendMessage", null);
+__decorate([
+    (0, test_utils_1.test)()
+], OpenAiTest.prototype, "returnsResponseFromSendMessage", null);
+__decorate([
+    (0, test_utils_1.test)()
+], OpenAiTest.prototype, "trimsResponseMessage", null);
+__decorate([
+    (0, test_utils_1.test)()
+], OpenAiTest.prototype, "noResponseReturnsDefaultErrorMesssage", null);
+__decorate([
+    (0, test_utils_1.test)()
+], OpenAiTest.prototype, "sendMessageCanAcceptModel", null);
+__decorate([
+    (0, test_utils_1.test)()
+], OpenAiTest.prototype, "sendsAllMessagesToOpenAi", null);
+__decorate([
+    (0, test_utils_1.test)()
+], OpenAiTest.prototype, "sendsExpectedMessageIfSkillIsPassedWithJustJustJob", null);
+__decorate([
+    (0, test_utils_1.test)()
+], OpenAiTest.prototype, "sendsExpectedMessageIfSkillPassedWithWhenWeAreDone", null);
+__decorate([
+    (0, test_utils_1.test)()
+], OpenAiTest.prototype, "sendsExpectedWithOnePleaseKeepInMind", null);
+__decorate([
+    (0, test_utils_1.test)()
+], OpenAiTest.prototype, "sendsExpectedWithMultiplePleaseKeepInMind", null);
+__decorate([
+    (0, test_utils_1.test)()
+], OpenAiTest.prototype, "sendsExpectedWithSchema", null);
+__decorate([
+    (0, test_utils_1.test)()
+], OpenAiTest.prototype, "sendsExpectedWithState", null);
+__decorate([
+    (0, test_utils_1.test)()
+], OpenAiTest.prototype, "sendsExpectedMessageWithSimpleCallback", null);
+__decorate([
+    (0, test_utils_1.test)()
+], OpenAiTest.prototype, "sendsExectedMessageWithDifferentSimpleCallback", null);
+__decorate([
+    (0, test_utils_1.test)()
+], OpenAiTest.prototype, "sendsExpectedMessagesWithMultipleCallbacks", null);
+__decorate([
+    (0, test_utils_1.test)()
+], OpenAiTest.prototype, "sendsExpectedWithCallbackWithParameters", null);
+__decorate([
+    (0, test_utils_1.test)()
+], OpenAiTest.prototype, "sendsExpectedWithCallbackParameterWithDescription", null);
+__decorate([
+    (0, test_utils_1.test)()
+], OpenAiTest.prototype, "sendsExpectedWithCallbackParmaterThatIsRequired", null);
+__decorate([
+    (0, test_utils_1.test)()
+], OpenAiTest.prototype, "sendsExpectedWithMultipleCallbackParameters", null);
+__decorate([
+    (0, test_utils_1.test)()
+], OpenAiTest.prototype, "chatHistoryCanBeLimitedByEnvTo1", null);
+__decorate([
+    (0, test_utils_1.test)()
+], OpenAiTest.prototype, "chatHistoryCanBeLimitedByEnvTo2", null);
+__decorate([
+    (0, test_utils_1.test)()
+], OpenAiTest.prototype, "pleaseKeepInMindIsLast", null);
+__decorate([
+    (0, test_utils_1.test)()
+], OpenAiTest.prototype, "canSendImageAsBase64", null);
+__decorate([
+    (0, test_utils_1.test)()
+], OpenAiTest.prototype, "rendersSelectOptionsAsExpected", null);
+__decorate([
+    (0, test_utils_1.test)()
+], OpenAiTest.prototype, "rendersDifferentSelectOptionsAsExpected", null);
+__decorate([
+    (0, test_utils_1.test)()
+], OpenAiTest.prototype, "canSetReasoningEffortViaEnv", null);
+OpenAiTest = __decorate([
+    (0, test_utils_1.suite)()
+], OpenAiTest);
+exports.default = OpenAiTest;
+//# sourceMappingURL=OpenAi.test.js.map