@fonoster/autopilot 0.7.4 → 0.7.5

package/dist/machine/machine.js

@@ -19,11 +19,10 @@ exports.machine = void 0;
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-const common_1 = require("@fonoster/common");
 const logger_1 = require("@fonoster/logger");
-const uuid_1 = require("uuid");
 const xstate_1 = require("xstate");
 const logger = (0, logger_1.getLogger)({ service: "autopilot", filePath: __filename });
+// eslint-disable-next-line mocha/no-top-level-hooks
 const machine = (0, xstate_1.setup)({
     types: {
         context: {},
@@ -36,55 +35,66 @@ const machine = (0, xstate_1.setup)({
                 firstMessage: context.firstMessage
             });
             await context.voice.answer();
-            await context.voice.say(context.firstMessage, {
-                playbackRef: context.playbackRef
-            });
+            await context.voice.say(context.firstMessage);
         },
         goodbye: async ({ context }) => {
             logger.verbose("called goodbye action", {
                 goodbyeMessage: context.goodbyeMessage
             });
-            await context.voice.say(context.goodbyeMessage, {
-                playbackRef: context.playbackRef
-            });
+            await context.voice.say(context.goodbyeMessage);
             await context.voice.hangup();
         },
         announceSystemError: async ({ context }) => {
             logger.verbose("called announceSystemError action", {
                 systemErrorMessage: context.systemErrorMessage
             });
-            await context.voice.say(context.systemErrorMessage, {
-                playbackRef: context.playbackRef
-            });
+            await context.voice.say(context.systemErrorMessage);
         },
         interruptPlayback: async ({ context }) => {
             logger.verbose("called interruptPlayback action", {
-                playbackRef: context.playbackRef
+                sessionRef: context.sessionRef
             });
-            await context.voice.playbackControl(context.playbackRef, common_1.PlaybackControlAction.STOP);
+            await context.voice.stopSpeech();
         },
         processUserRequest: async ({ context }) => {
             logger.verbose("called processUserRequest action", {
                 speechBuffer: context.speechBuffer
             });
             const speech = context.speechBuffer.trim();
-            const response = await context.assistant.invoke({ text: speech });
+            const languageModel = context.languageModel;
+            const response = await languageModel.invoke(speech);
             const speechResponseTime = Date.now() - context.speechResponseStartTime;
             context.speechResponseTime = speechResponseTime;
-            context.speechBuffer = "";
             context.speechResponseStartTime = 0;
-            await context.voice.say(response, {
-                playbackRef: context.playbackRef
-            });
+            if (!response) {
+                logger.verbose("call might already be hung up");
+                (0, xstate_1.raise)({ type: "USER_REQUEST_PROCESSED" });
+                return;
+            }
+            if (response.type === "hangup") {
+                const message = context.goodbyeMessage;
+                await context.voice.say(message);
+                await context.voice.hangup();
+                return;
+            }
+            else if (response.type === "transfer") {
+                const message = context.transferMessage;
+                await context.voice.say(message);
+                // TODO: The record and timeout options should be configurable
+                await context.voice.transfer(context.transferPhoneNumber, {
+                    record: true,
+                    timeout: 30
+                });
+                return;
+            }
+            await context.voice.say(response.content);
             (0, xstate_1.raise)({ type: "USER_REQUEST_PROCESSED" });
         },
         announceIdleTimeout: async ({ context }) => {
             logger.verbose("called announceIdleTimeout action", {
                 idleMessage: context.idleMessage
             });
-            await context.voice.say(context.idleMessage, {
-                playbackRef: context.playbackRef
-            });
+            await context.voice.say(context.idleMessage);
         },
         increaseIdleTimeoutCount: (0, xstate_1.assign)(({ context }) => {
             logger.verbose("called increaseIdleTimeoutCount action", {
@@ -99,7 +109,9 @@ const machine = (0, xstate_1.setup)({
                 speech: event.speech
             });
             const speech = event.speech;
-            context.speechBuffer = (context.speechBuffer || "") + " " + speech;
+            context.speechBuffer = ((context.speechBuffer || "") +
+                " " +
+                speech).trimStart();
             context.speechResponseStartTime = Date.now();
             return context;
         }),
@@ -150,16 +162,18 @@ const machine = (0, xstate_1.setup)({
     }
 }).createMachine({
     context: ({ input }) => ({
+        sessionRef: input.voice.sessionRef,
         voice: input.voice,
-        assistant: input.assistant,
-        playbackRef: (0, uuid_1.v4)(),
+        languageModel: input.languageModel,
         speechBuffer: "",
-        firstMessage: input.firstMessage,
-        goodbyeMessage: input.goodbyeMessage,
-        systemErrorMessage: input.systemErrorMessage,
-        idleMessage: input.idleMessage,
-        idleTimeout: input.idleTimeout,
-        maxIdleTimeoutCount: input.maxIdleTimeoutCount,
+        firstMessage: input.conversationSettings.firstMessage,
+        goodbyeMessage: input.conversationSettings.goodbyeMessage,
+        transferMessage: input.conversationSettings.transferOptions?.message,
+        transferPhoneNumber: input.conversationSettings.transferOptions?.phoneNumber,
+        systemErrorMessage: input.conversationSettings.systemErrorMessage,
+        idleMessage: input.conversationSettings.idleOptions?.message || "",
+        idleTimeout: input.conversationSettings.idleOptions?.timeout || 10000,
+        maxIdleTimeoutCount: input.conversationSettings.idleOptions?.maxTimeoutCount || 3,
         idleTimeoutCount: 0,
         speechResponseStartTime: 0,
         speechResponseTime: 0,

package/dist/models/AbstractLanguageModel.d.ts

@@ -0,0 +1,11 @@
+import { InvocationResult, LanguageModel, LanguageModelParams } from "./types";
+import { ToolsCatalog } from "../tools";
+declare abstract class AbstractLanguageModel implements LanguageModel {
+    private params;
+    private chain;
+    private chatHistory;
+    toolsCatalog: ToolsCatalog;
+    constructor(params: LanguageModelParams);
+    invoke(text: string): Promise<InvocationResult>;
+}
+export { AbstractLanguageModel };

package/dist/models/AbstractLanguageModel.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractLanguageModel = void 0;
+/*
+ * Copyright (C) 2024 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const logger_1 = require("@fonoster/logger");
+const chatHistory_1 = require("./chatHistory");
+const createChain_1 = require("./createChain");
+const createPromptTemplate_1 = require("./createPromptTemplate");
+const tools_1 = require("../tools");
+const logger = (0, logger_1.getLogger)({ service: "autopilot", filePath: __filename });
+class AbstractLanguageModel {
+    constructor(params) {
+        this.params = params;
+        const { model, systemTemplate, knowledgeBase, tools } = this.params;
+        const promptTemplate = (0, createPromptTemplate_1.createPromptTemplate)(systemTemplate);
+        this.chatHistory = (0, chatHistory_1.createChatHistory)();
+        this.toolsCatalog = new tools_1.ToolsCatalog(tools);
+        this.chain = (0, createChain_1.createChain)(model, knowledgeBase, promptTemplate, this.chatHistory);
+    }
+    async invoke(text) {
+        const { chain, chatHistory, toolsCatalog } = this;
+        const response = (await chain.invoke({ text }));
+        if (response.additional_kwargs?.tool_calls) {
+            // eslint-disable-next-line no-loops/no-loops
+            for (const toolCall of response.additional_kwargs.tool_calls) {
+                const { arguments: args, name } = toolCall.function;
+                logger.verbose(`invoking tool: ${name} with args: ${args}`);
+                switch (name) {
+                    case "hangup":
+                        await chatHistory.addAIMessage("tool result: call hangup initiated");
+                        return { type: "hangup" };
+                    case "transfer":
+                        await chatHistory.addAIMessage("tool result: call transfer initiated");
+                        return { type: "transfer" };
+                    default:
+                        try {
+                            const toolResult = await toolsCatalog.invokeTool(name, JSON.parse(args));
+                            logger.verbose("tool result: ", toolResult);
+                            await chatHistory.addAIMessage(`tool result: ${toolResult.result}`);
+                        }
+                        catch (error) {
+                            logger.error(`tool error: ${error.message}`);
+                            await chatHistory.addAIMessage(`tool error: ${error.message}`);
+                        }
+                }
+            }
+            const finalResponse = (await chain.invoke({
+                text: "Please provide a final response based on the tool results."
+            }));
+            response.content = finalResponse.content ?? "";
+        }
+        await chatHistory.addUserMessage(text);
+        await chatHistory.addAIMessage(response.content?.toString() ?? "");
+        logger.verbose("system will say", { content: response.content });
+        return {
+            type: "say",
+            content: response.content.toString()
+        };
+    }
+}
+exports.AbstractLanguageModel = AbstractLanguageModel;

package/dist/models/LanguageModelFactory.d.ts

@@ -0,0 +1,16 @@
+import { AbstractLanguageModel } from "./AbstractLanguageModel";
+import { GroqParams } from "./groq";
+import { OpenAIParams } from "./openai";
+import { BaseModelParams } from "./types";
+import { LANGUAGE_MODEL_PROVIDER } from "../types";
+type LanguageModelConstructor<T extends BaseModelParams = BaseModelParams> = new (options: T) => AbstractLanguageModel;
+type LanguageModelConfigMap = {
+    [LANGUAGE_MODEL_PROVIDER.OPENAI]: OpenAIParams;
+    [LANGUAGE_MODEL_PROVIDER.GROQ]: GroqParams;
+};
+declare class LanguageModelFactory {
+    private static languageModels;
+    static registerLanguageModel<T extends BaseModelParams>(name: string, ctor: LanguageModelConstructor<T>): void;
+    static getLanguageModel<T extends keyof LanguageModelConfigMap>(languageModel: T, config: LanguageModelConfigMap[T]): AbstractLanguageModel;
+}
+export { LanguageModelFactory };

package/dist/models/LanguageModelFactory.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LanguageModelFactory = void 0;
+/*
+ * Copyright (C) 2024 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const logger_1 = require("@fonoster/logger");
+const groq_1 = require("./groq");
+const openai_1 = require("./openai");
+const types_1 = require("../types");
+const logger = (0, logger_1.getLogger)({ service: "autopilot", filePath: __filename });
+class LanguageModelFactory {
+    static registerLanguageModel(name, ctor) {
+        logger.verbose("registering llm provider", { name });
+        this.languageModels.set(name, ctor);
+    }
+    static getLanguageModel(languageModel, config) {
+        const LanguageModelConstructor = this.languageModels.get(`llm.${languageModel}`);
+        if (!LanguageModelConstructor) {
+            throw new Error(`Language model ${languageModel} not found`);
+        }
+        return new LanguageModelConstructor(config);
+    }
+}
+exports.LanguageModelFactory = LanguageModelFactory;
+LanguageModelFactory.languageModels = new Map();
+// Register language models
+LanguageModelFactory.registerLanguageModel(openai_1.LANGUAGE_MODEL_NAME, openai_1.OpenAI);
+LanguageModelFactory.registerLanguageModel(groq_1.LANGUAGE_MODEL_NAME, groq_1.Groq);

package/dist/models/chatHistory.d.ts

@@ -0,0 +1,6 @@
+export declare function createChatHistory(): {
+    getMessages: () => Promise<import("@langchain/core/messages").BaseMessage[]>;
+    addUserMessage: (text: string) => Promise<void>;
+    addAIMessage: (text: string) => Promise<void>;
+    clear: () => Promise<void>;
+};

package/dist/models/chatHistory.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createChatHistory = createChatHistory;
+/*
+ * Copyright (C) 2024 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const messages_1 = require("@langchain/core/messages");
+const in_memory_1 = require("langchain/stores/message/in_memory");
+function createChatHistory() {
+    const chatHistory = new in_memory_1.ChatMessageHistory();
+    return {
+        getMessages: () => chatHistory.getMessages(),
+        addUserMessage: (text) => chatHistory.addMessage(new messages_1.HumanMessage(text)),
+        addAIMessage: (text) => chatHistory.addMessage(new messages_1.AIMessage(text)),
+        clear: () => chatHistory.clear()
+    };
+}

package/dist/models/createChain.d.ts

@@ -0,0 +1,7 @@
+import { BaseChatModel } from "@langchain/core/language_models/chat_models";
+import { RunnableSequence } from "@langchain/core/runnables";
+import { createChatHistory } from "./chatHistory";
+import { createPromptTemplate } from "./createPromptTemplate";
+import { KnowledgeBase } from "../knowledge";
+declare function createChain(model: BaseChatModel, knowledgeBase: KnowledgeBase, promptTemplate: ReturnType<typeof createPromptTemplate>, chatHistory: ReturnType<typeof createChatHistory>): RunnableSequence<any, import("@langchain/core/messages").BaseMessageChunk>;
+export { createChain };

package/dist/models/createChain.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createChain = createChain;
+const runnables_1 = require("@langchain/core/runnables");
+function createChain(model, knowledgeBase, promptTemplate, chatHistory) {
+    return runnables_1.RunnableSequence.from([
+        {
+            input: (input) => input.text,
+            context: async (input) => knowledgeBase.queryKnowledgeBase(input.text),
+            history: async () => chatHistory.getMessages()
+        },
+        promptTemplate,
+        model
+    ]);
+}

package/dist/models/createPromptTemplate.d.ts

@@ -0,0 +1,2 @@
+import { ChatPromptTemplate } from "@langchain/core/prompts";
+export declare function createPromptTemplate(systemTemplate: string): ChatPromptTemplate<any, any>;

package/dist/{assistants/assistants.js → models/createPromptTemplate.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeAssistant = makeAssistant;
+exports.createPromptTemplate = createPromptTemplate;
 /*
  * Copyright (C) 2024 by Fonoster Inc (https://fonoster.com)
  * http://github.com/fonoster/fonoster
@@ -19,21 +19,12 @@ exports.makeAssistant = makeAssistant;
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-const output_parsers_1 = require("@langchain/core/output_parsers");
 const prompts_1 = require("@langchain/core/prompts");
-const openai_1 = require("@langchain/openai");
-function makeAssistant(config) {
-    const model = new openai_1.ChatOpenAI({
-        model: config.model,
-        apiKey: config.apiKey,
-        maxTokens: config.maxTokens,
-        temperature: config.temperature
-    });
-    const { systemTemplate } = config;
-    const parser = new output_parsers_1.StringOutputParser();
-    const promptTemplate = prompts_1.ChatPromptTemplate.fromMessages([
-        ["system", systemTemplate],
-        ["user", "{text}"]
+function createPromptTemplate(systemTemplate) {
+    return prompts_1.ChatPromptTemplate.fromMessages([
+        new prompts_1.MessagesPlaceholder("history"),
+        prompts_1.SystemMessagePromptTemplate.fromTemplate(systemTemplate),
+        prompts_1.SystemMessagePromptTemplate.fromTemplate("{context}"),
+        prompts_1.HumanMessagePromptTemplate.fromTemplate("{input}")
     ]);
-    return promptTemplate.pipe(model).pipe(parser);
 }

package/dist/models/groq/Groq.d.ts

@@ -0,0 +1,7 @@
+import { GroqParams } from "./types";
+import { AbstractLanguageModel } from "../AbstractLanguageModel";
+declare const LANGUAGE_MODEL_NAME = "llm.groq";
+declare class Groq extends AbstractLanguageModel {
+    constructor(params: GroqParams);
+}
+export { Groq, LANGUAGE_MODEL_NAME };

package/dist/models/groq/Groq.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LANGUAGE_MODEL_NAME = exports.Groq = void 0;
+const groq_1 = require("@langchain/groq");
+const tools_1 = require("../../tools");
+const AbstractLanguageModel_1 = require("../AbstractLanguageModel");
+const LANGUAGE_MODEL_NAME = "llm.groq";
+exports.LANGUAGE_MODEL_NAME = LANGUAGE_MODEL_NAME;
+class Groq extends AbstractLanguageModel_1.AbstractLanguageModel {
+    constructor(params) {
+        const model = new groq_1.ChatGroq({
+            ...params
+        }).bind({
+            tools: params.tools.map(tools_1.convertToolToOpenAITool)
+        });
+        super({
+            ...params,
+            model
+        });
+    }
+}
+exports.Groq = Groq;

package/dist/models/groq/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Groq";
+export * from "./types";

package/dist/models/groq/index.js

@@ -0,0 +1,36 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Groq"), exports);
+/*
+ * Copyright (C) 2024 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+__exportStar(require("./types"), exports);

package/dist/models/groq/types.d.ts

@@ -0,0 +1,13 @@
+import { BaseModelParams } from "../types";
+declare enum GroqModel {
+    GEMMA7B = "gemma-7b-it",
+    LLAMA3_GROQ_70B_8192_TOOL_USE_PREVIEW = "llama3-groq-70b-8192-tool-use-preview",
+    LLAMA3_1_8B_INSTANT = "llama-3.1-8b-instant"
+}
+type GroqParams = BaseModelParams & {
+    model: GroqModel;
+    apiKey: string;
+    maxTokens: number;
+    temperature: number;
+};
+export { GroqModel, GroqParams };

package/dist/models/groq/types.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroqModel = void 0;
+var GroqModel;
+(function (GroqModel) {
+    GroqModel["GEMMA7B"] = "gemma-7b-it";
+    GroqModel["LLAMA3_GROQ_70B_8192_TOOL_USE_PREVIEW"] = "llama3-groq-70b-8192-tool-use-preview";
+    GroqModel["LLAMA3_1_8B_INSTANT"] = "llama-3.1-8b-instant";
+})(GroqModel || (exports.GroqModel = GroqModel = {}));

package/dist/models/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./LanguageModelFactory";
+export * from "./types";

package/dist/models/index.js

@@ -0,0 +1,36 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./LanguageModelFactory"), exports);
+/*
+ * Copyright (C) 2024 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+__exportStar(require("./types"), exports);

package/dist/models/openai/OpenAI.d.ts

@@ -0,0 +1,7 @@
+import { OpenAIParams } from "./types";
+import { AbstractLanguageModel } from "../AbstractLanguageModel";
+declare const LANGUAGE_MODEL_NAME = "llm.openai";
+declare class OpenAI extends AbstractLanguageModel {
+    constructor(params: OpenAIParams);
+}
+export { LANGUAGE_MODEL_NAME, OpenAI };

package/dist/models/openai/OpenAI.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAI = exports.LANGUAGE_MODEL_NAME = void 0;
+const openai_1 = require("@langchain/openai");
+const tools_1 = require("../../tools");
+const AbstractLanguageModel_1 = require("../AbstractLanguageModel");
+const LANGUAGE_MODEL_NAME = "llm.openai";
+exports.LANGUAGE_MODEL_NAME = LANGUAGE_MODEL_NAME;
+class OpenAI extends AbstractLanguageModel_1.AbstractLanguageModel {
+    constructor(params) {
+        const model = new openai_1.ChatOpenAI({
+            ...params
+        }).bind({
+            tools: params.tools.map(tools_1.convertToolToOpenAITool)
+        });
+        super({
+            ...params,
+            model
+        });
+    }
+}
+exports.OpenAI = OpenAI;

package/dist/models/openai/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./OpenAI";
+export * from "./types";

package/dist/models/openai/index.js

@@ -0,0 +1,36 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./OpenAI"), exports);
+/*
+ * Copyright (C) 2024 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+__exportStar(require("./types"), exports);

package/dist/models/openai/types.d.ts

@@ -0,0 +1,12 @@
+import { BaseModelParams } from "../types";
+declare enum OpenAIModel {
+    GPT_4O = "gpt-4o",
+    GPT_4O_MINI = "gpt-4o-mini"
+}
+type OpenAIParams = BaseModelParams & {
+    model: OpenAIModel;
+    apiKey: string;
+    maxTokens: number;
+    temperature: number;
+};
+export { OpenAIModel, OpenAIParams };

package/dist/models/openai/types.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIModel = void 0;
+var OpenAIModel;
+(function (OpenAIModel) {
+    OpenAIModel["GPT_4O"] = "gpt-4o";
+    OpenAIModel["GPT_4O_MINI"] = "gpt-4o-mini";
+})(OpenAIModel || (exports.OpenAIModel = OpenAIModel = {}));

package/dist/models/types.d.ts

@@ -0,0 +1,19 @@
+import { BaseChatModel } from "@langchain/core/language_models/chat_models";
+import { KnowledgeBase } from "../knowledge";
+import { Tool } from "../tools/type";
+type LanguageModel = {
+    invoke: (text: string) => Promise<InvocationResult>;
+};
+type BaseModelParams = {
+    systemTemplate: string;
+    knowledgeBase: KnowledgeBase;
+    tools: Tool[];
+};
+type LanguageModelParams = BaseModelParams & {
+    model: BaseChatModel;
+};
+type InvocationResult = {
+    type: "say" | "hangup" | "transfer";
+    content?: string;
+};
+export { BaseModelParams, InvocationResult, LanguageModel, LanguageModelParams };