@fonoster/autopilot 0.7.14 → 0.7.15

package/README.md

@@ -137,6 +137,8 @@ You can configure a new tool by adding a new entry in the `tools` array in the c
 
 In addition to the `get` operation type, you can use the `post` operation type. The `post` operation type is used when sending data to the tool. When sending a post, you can optionally set `waitForResponse` to false, which will "fire and forget" the request. The default behavior is to wait for the response.
 
+If your tool needs the number of the caller or the number that received the call, you can use the reserved variables `ingressNumber` and `callerNumber`. Similarly, you can use the reserved variable `callReceivedAt` to get the date and time when the call was received in `ISO 8601` format.
+
 The expected format for the response is a JSON object with the following structure:
 
 ```json

package/dist/assistants/AssistantSchema.d.ts

@@ -131,22 +131,27 @@ declare const languageModelConfigSchema: z.ZodObject<{
             type: z.ZodNativeEnum<typeof import("../tools/ToolSchema").AllowedOperations>;
             url: z.ZodOptional<z.ZodString>;
             waitForResponse: z.ZodOptional<z.ZodBoolean>;
+            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         }, "strip", z.ZodTypeAny, {
             type: import("../tools/ToolSchema").AllowedOperations;
             url?: string | undefined;
             waitForResponse?: boolean | undefined;
+            headers?: Record<string, string> | undefined;
         }, {
             type: import("../tools/ToolSchema").AllowedOperations;
             url?: string | undefined;
             waitForResponse?: boolean | undefined;
+            headers?: Record<string, string> | undefined;
         }>, {
             type: import("../tools/ToolSchema").AllowedOperations;
             url?: string | undefined;
             waitForResponse?: boolean | undefined;
+            headers?: Record<string, string> | undefined;
         }, {
             type: import("../tools/ToolSchema").AllowedOperations;
             url?: string | undefined;
             waitForResponse?: boolean | undefined;
+            headers?: Record<string, string> | undefined;
         }>;
     }, "strip", z.ZodTypeAny, {
         name: string;
@@ -164,6 +169,7 @@ declare const languageModelConfigSchema: z.ZodObject<{
             type: import("../tools/ToolSchema").AllowedOperations;
             url?: string | undefined;
             waitForResponse?: boolean | undefined;
+            headers?: Record<string, string> | undefined;
         };
     }, {
         name: string;
@@ -181,6 +187,7 @@ declare const languageModelConfigSchema: z.ZodObject<{
             type: import("../tools/ToolSchema").AllowedOperations;
             url?: string | undefined;
             waitForResponse?: boolean | undefined;
+            headers?: Record<string, string> | undefined;
         };
     }>, "many">;
 }, "strip", z.ZodTypeAny, {
@@ -206,6 +213,7 @@ declare const languageModelConfigSchema: z.ZodObject<{
             type: import("../tools/ToolSchema").AllowedOperations;
             url?: string | undefined;
             waitForResponse?: boolean | undefined;
+            headers?: Record<string, string> | undefined;
         };
     }[];
     temperature: number;
@@ -234,6 +242,7 @@ declare const languageModelConfigSchema: z.ZodObject<{
             type: import("../tools/ToolSchema").AllowedOperations;
             url?: string | undefined;
             waitForResponse?: boolean | undefined;
+            headers?: Record<string, string> | undefined;
         };
     }[];
     temperature: number;
@@ -372,22 +381,27 @@ declare const assistantSchema: z.ZodObject<{
                 type: z.ZodNativeEnum<typeof import("../tools/ToolSchema").AllowedOperations>;
                 url: z.ZodOptional<z.ZodString>;
                 waitForResponse: z.ZodOptional<z.ZodBoolean>;
+                headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
             }, "strip", z.ZodTypeAny, {
                 type: import("../tools/ToolSchema").AllowedOperations;
                 url?: string | undefined;
                 waitForResponse?: boolean | undefined;
+                headers?: Record<string, string> | undefined;
             }, {
                 type: import("../tools/ToolSchema").AllowedOperations;
                 url?: string | undefined;
                 waitForResponse?: boolean | undefined;
+                headers?: Record<string, string> | undefined;
             }>, {
                 type: import("../tools/ToolSchema").AllowedOperations;
                 url?: string | undefined;
                 waitForResponse?: boolean | undefined;
+                headers?: Record<string, string> | undefined;
             }, {
                 type: import("../tools/ToolSchema").AllowedOperations;
                 url?: string | undefined;
                 waitForResponse?: boolean | undefined;
+                headers?: Record<string, string> | undefined;
             }>;
         }, "strip", z.ZodTypeAny, {
             name: string;
@@ -405,6 +419,7 @@ declare const assistantSchema: z.ZodObject<{
                 type: import("../tools/ToolSchema").AllowedOperations;
                 url?: string | undefined;
                 waitForResponse?: boolean | undefined;
+                headers?: Record<string, string> | undefined;
             };
         }, {
             name: string;
@@ -422,6 +437,7 @@ declare const assistantSchema: z.ZodObject<{
                 type: import("../tools/ToolSchema").AllowedOperations;
                 url?: string | undefined;
                 waitForResponse?: boolean | undefined;
+                headers?: Record<string, string> | undefined;
             };
         }>, "many">;
     }, "strip", z.ZodTypeAny, {
@@ -447,6 +463,7 @@ declare const assistantSchema: z.ZodObject<{
                 type: import("../tools/ToolSchema").AllowedOperations;
                 url?: string | undefined;
                 waitForResponse?: boolean | undefined;
+                headers?: Record<string, string> | undefined;
             };
         }[];
         temperature: number;
@@ -475,6 +492,7 @@ declare const assistantSchema: z.ZodObject<{
                 type: import("../tools/ToolSchema").AllowedOperations;
                 url?: string | undefined;
                 waitForResponse?: boolean | undefined;
+                headers?: Record<string, string> | undefined;
             };
         }[];
         temperature: number;
@@ -522,6 +540,7 @@ declare const assistantSchema: z.ZodObject<{
                 type: import("../tools/ToolSchema").AllowedOperations;
                 url?: string | undefined;
                 waitForResponse?: boolean | undefined;
+                headers?: Record<string, string> | undefined;
             };
         }[];
         temperature: number;
@@ -569,6 +588,7 @@ declare const assistantSchema: z.ZodObject<{
                 type: import("../tools/ToolSchema").AllowedOperations;
                 url?: string | undefined;
                 waitForResponse?: boolean | undefined;
+                headers?: Record<string, string> | undefined;
             };
         }[];
         temperature: number;

package/dist/createLanguageModel.d.ts

@@ -1,3 +1,3 @@
-import { AssistantConfig, FilesKnowledgeBase } from ".";
-declare function createLanguageModel(assistantConfig: AssistantConfig, knowledgeBase: FilesKnowledgeBase): import("./models/AbstractLanguageModel").AbstractLanguageModel;
+import { AssistantConfig, FilesKnowledgeBase, TelephonyContext } from ".";
+declare function createLanguageModel(assistantConfig: AssistantConfig, knowledgeBase: FilesKnowledgeBase, telephonyContext: TelephonyContext): import("./models/AbstractLanguageModel").AbstractLanguageModel;
 export { createLanguageModel };

package/dist/createLanguageModel.js

@@ -21,7 +21,7 @@ exports.createLanguageModel = createLanguageModel;
  */
 const envs_1 = require("./envs");
 const _1 = require(".");
-function createLanguageModel(assistantConfig, knowledgeBase) {
+function createLanguageModel(assistantConfig, knowledgeBase, telephonyContext) {
     const { languageModel: languageModelSettings, conversationSettings } = assistantConfig;
     return _1.LanguageModelFactory.getLanguageModel(languageModelSettings.provider, {
         apiKey: envs_1.OPENAI_API_KEY,
@@ -36,5 +36,5 @@ function createLanguageModel(assistantConfig, knowledgeBase) {
             _1.hangupToolDefinition,
             _1.transferToolDefinition
         ]
-    });
+    }, telephonyContext);
 }

package/dist/handleVoiceRequest.js

@@ -56,7 +56,10 @@ async function handleVoiceRequest(req, res) {
     const knowledgeBase = await (0, loadKnowledgeBase_1.loadKnowledgeBase)();
     const voice = new _1.VoiceImpl(sessionRef, res);
     const vad = new _1.SileroVad();
-    const languageModel = (0, createLanguageModel_1.createLanguageModel)(assistantConfig, knowledgeBase);
+    const languageModel = (0, createLanguageModel_1.createLanguageModel)(assistantConfig, knowledgeBase, {
+        ingressNumber: req.ingressNumber,
+        callerNumber: req.callerNumber
+    });
     const autopilot = new _1.default({
         conversationSettings: assistantConfig.conversationSettings,
         voice,

package/dist/machine/machine.js

@@ -84,6 +84,9 @@ const machine = (0, xstate_1.setup)({
                     return;
                 }
                 else if (response.type === "transfer") {
+                    logger.verbose("transferring call to a number in the pstn", {
+                        phoneNumber: context.transferPhoneNumber
+                    });
                     const message = context.transferMessage;
                     await context.voice.say(message);
                     await context.voice.transfer(context.transferPhoneNumber, {

package/dist/models/AbstractLanguageModel.d.ts

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

package/dist/models/AbstractLanguageModel.js

@@ -26,10 +26,9 @@ 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);
+    constructor(params, telephonyContext) {
+        const { model, systemTemplate, knowledgeBase, tools } = params;
+        const promptTemplate = (0, createPromptTemplate_1.createPromptTemplate)(systemTemplate, telephonyContext);
         this.chatHistory = (0, chatHistory_1.createChatHistory)();
         this.toolsCatalog = new tools_1.ToolsCatalog(tools);
         this.chain = (0, createChain_1.createChain)(model, knowledgeBase, promptTemplate, this.chatHistory);

package/dist/models/LanguageModelFactory.d.ts

@@ -1,9 +1,9 @@
 import { AbstractLanguageModel } from "./AbstractLanguageModel";
 import { GroqParams } from "./groq";
 import { OpenAIParams } from "./openai";
-import { BaseModelParams } from "./types";
+import { BaseModelParams, TelephonyContext } from "./types";
 import { LANGUAGE_MODEL_PROVIDER } from "../types";
-type LanguageModelConstructor<T extends BaseModelParams = BaseModelParams> = new (options: T) => AbstractLanguageModel;
+type LanguageModelConstructor<T extends BaseModelParams = BaseModelParams> = new (options: T, telephonyContext: TelephonyContext) => AbstractLanguageModel;
 type LanguageModelConfigMap = {
     [LANGUAGE_MODEL_PROVIDER.OPENAI]: OpenAIParams;
     [LANGUAGE_MODEL_PROVIDER.GROQ]: GroqParams;
@@ -11,6 +11,6 @@ type LanguageModelConfigMap = {
 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;
+    static getLanguageModel<T extends keyof LanguageModelConfigMap>(languageModel: T, config: LanguageModelConfigMap[T], telephonyContext: TelephonyContext): AbstractLanguageModel;
 }
 export { LanguageModelFactory };

package/dist/models/LanguageModelFactory.js

@@ -29,12 +29,12 @@ class LanguageModelFactory {
         logger.verbose("registering llm provider", { name });
         this.languageModels.set(name, ctor);
     }
-    static getLanguageModel(languageModel, config) {
+    static getLanguageModel(languageModel, config, telephonyContext) {
         const LanguageModelConstructor = this.languageModels.get(`llm.${languageModel}`);
         if (!LanguageModelConstructor) {
             throw new Error(`Language model ${languageModel} not found`);
         }
-        return new LanguageModelConstructor(config);
+        return new LanguageModelConstructor(config, telephonyContext);
     }
 }
 exports.LanguageModelFactory = LanguageModelFactory;

package/dist/models/createPromptTemplate.d.ts

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

package/dist/models/createPromptTemplate.js

@@ -20,13 +20,14 @@ exports.createPromptTemplate = createPromptTemplate;
  * limitations under the License.
  */
 const prompts_1 = require("@langchain/core/prompts");
-function createPromptTemplate(systemTemplate) {
+function createPromptTemplate(systemTemplate, telephonyContext) {
     return prompts_1.ChatPromptTemplate.fromMessages([
         new prompts_1.MessagesPlaceholder("history"),
         prompts_1.SystemMessagePromptTemplate.fromTemplate(systemTemplate),
         prompts_1.SystemMessagePromptTemplate.fromTemplate("{context}"),
-        // This is how the model will know the current date
-        prompts_1.SystemMessagePromptTemplate.fromTemplate(`current date:${new Date().toISOString()}`),
+        prompts_1.SystemMessagePromptTemplate.fromTemplate(`callReceivedAt:${new Date().toISOString()}
+       ingressNumber:${telephonyContext.ingressNumber}
+       callerNumber:${telephonyContext.callerNumber}`),
         prompts_1.HumanMessagePromptTemplate.fromTemplate("{input}")
     ]);
 }

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

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

package/dist/models/groq/Groq.js

@@ -7,7 +7,7 @@ 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) {
+    constructor(params, telephonyContext) {
         const model = new groq_1.ChatGroq({
             ...params
         }).bind({
@@ -16,7 +16,7 @@ class Groq extends AbstractLanguageModel_1.AbstractLanguageModel {
         super({
             ...params,
             model
-        });
+        }, telephonyContext);
     }
 }
 exports.Groq = Groq;

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

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

package/dist/models/openai/OpenAI.js

@@ -7,7 +7,7 @@ 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) {
+    constructor(params, telephonyContext) {
         const model = new openai_1.ChatOpenAI({
             ...params
         }).bind({
@@ -16,7 +16,7 @@ class OpenAI extends AbstractLanguageModel_1.AbstractLanguageModel {
         super({
             ...params,
             model
-        });
+        }, telephonyContext);
     }
 }
 exports.OpenAI = OpenAI;

package/dist/models/types.d.ts

@@ -8,6 +8,7 @@ type BaseModelParams = {
     systemTemplate: string;
     knowledgeBase: KnowledgeBase;
     tools: Tool[];
+    telephonyContext: TelephonyContext;
 };
 type LanguageModelParams = BaseModelParams & {
     model: BaseChatModel;
@@ -16,4 +17,8 @@ type InvocationResult = {
     type: "say" | "hangup" | "transfer";
     content?: string;
 };
-export { BaseModelParams, InvocationResult, LanguageModel, LanguageModelParams };
+type TelephonyContext = {
+    ingressNumber: string;
+    callerNumber: string;
+};
+export { BaseModelParams, InvocationResult, LanguageModel, LanguageModelParams, TelephonyContext };

package/dist/tools/ToolSchema.d.ts

@@ -52,22 +52,27 @@ declare const toolSchema: z.ZodObject<{
         type: z.ZodNativeEnum<typeof AllowedOperations>;
         url: z.ZodOptional<z.ZodString>;
         waitForResponse: z.ZodOptional<z.ZodBoolean>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     }, "strip", z.ZodTypeAny, {
         type: AllowedOperations;
         url?: string | undefined;
         waitForResponse?: boolean | undefined;
+        headers?: Record<string, string> | undefined;
     }, {
         type: AllowedOperations;
         url?: string | undefined;
         waitForResponse?: boolean | undefined;
+        headers?: Record<string, string> | undefined;
     }>, {
         type: AllowedOperations;
         url?: string | undefined;
         waitForResponse?: boolean | undefined;
+        headers?: Record<string, string> | undefined;
     }, {
         type: AllowedOperations;
         url?: string | undefined;
         waitForResponse?: boolean | undefined;
+        headers?: Record<string, string> | undefined;
     }>;
 }, "strip", z.ZodTypeAny, {
     name: string;
@@ -85,6 +90,7 @@ declare const toolSchema: z.ZodObject<{
         type: AllowedOperations;
         url?: string | undefined;
         waitForResponse?: boolean | undefined;
+        headers?: Record<string, string> | undefined;
     };
 }, {
     name: string;
@@ -102,6 +108,7 @@ declare const toolSchema: z.ZodObject<{
         type: AllowedOperations;
         url?: string | undefined;
         waitForResponse?: boolean | undefined;
+        headers?: Record<string, string> | undefined;
     };
 }>;
 export { AllowedOperations, toolSchema };

package/dist/tools/ToolSchema.js

@@ -50,7 +50,8 @@ const toolSchema = zod_1.z.object({
         type: zod_1.z.nativeEnum(AllowedOperations),
         // Make url required if operation type is not built-in
         url: zod_1.z.string().optional(),
-        waitForResponse: zod_1.z.boolean().optional()
+        waitForResponse: zod_1.z.boolean().optional(),
+        headers: zod_1.z.record(zod_1.z.string()).optional()
     })
         .superRefine(({ url, type }, ctx) => {
         if (type !== AllowedOperations.BUILT_IN && !url) {

package/dist/tools/ToolsCatalog.js

@@ -39,6 +39,7 @@ class ToolsCatalog {
             method: tool.operation.type,
             url: tool.operation.url,
             waitForResponse: tool.operation.waitForResponse,
+            headers: tool.operation.headers,
             body: args
         });
     }

package/dist/tools/sendRequest.js

@@ -38,6 +38,11 @@ async function sendRequest(input) {
     else {
         const response = await fetch(url, options);
         const data = await response.json();
-        return responseSchema.parse(data);
+        try {
+            return responseSchema.parse(data);
+        }
+        catch (error) {
+            throw new Error(`Invalid response: expected ${JSON.stringify(responseSchema, null, 2)}, got ${JSON.stringify(data, null, 2)}`);
+        }
     }
 }

package/dist/vad/SileroVad.js

@@ -26,7 +26,7 @@ class SileroVad {
         this.init();
     }
     async init() {
-        // FIXME: It feels not to do this in the constructor
+        // FIXME: It feels strange to do this in the constructor
         this.vad = await (0, makeVad_1.makeVad)();
     }
     processChunk(data, callback) {

package/dist/vad/makeVad.js

@@ -44,9 +44,11 @@ exports.makeVad = makeVad;
  * limitations under the License.
  */
 const path_1 = require("path");
+const logger_1 = require("@fonoster/logger");
 const ort = __importStar(require("onnxruntime-node"));
 const chunkToFloat32Array_1 = require("./chunkToFloat32Array");
 const SileroVadModel_1 = require("./SileroVadModel");
+const logger = (0, logger_1.getLogger)({ service: "autopilot", filePath: __filename });
 const BUFFER_SIZE = 16000;
 async function makeVad(pathToModel) {
     const effectivePath = pathToModel || (0, path_1.join)(__dirname, "..", "..", "silero_vad.onnx");
@@ -62,6 +64,7 @@ async function makeVad(pathToModel) {
             const audioFrame = buffer.slice(0, BUFFER_SIZE);
             const remainingBuffer = buffer.slice(BUFFER_SIZE);
             const result = await silero.process(new Float32Array(audioFrame));
+            logger.silly("last vad result", { ...result });
             if (result.isSpeech > 0.5) {
                 if (!isSpeechActive) {
                     isSpeechActive = true;
@@ -72,6 +75,9 @@ async function makeVad(pathToModel) {
             else if (isSpeechActive) {
                 isSpeechActive = false;
                 callback("SPEECH_END");
+                // WARNING: I'm unsure if this has any effect on the model
+                // but it seems to work fine to ensure the model works optimally
+                silero.resetState();
                 return processBuffer(remainingBuffer);
             }
             return processBuffer(remainingBuffer);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fonoster/autopilot",
-  "version": "0.7.14",
+  "version": "0.7.15",
   "description": "Voice AI for the Fonoster platform",
   "author": "Pedro Sanders <psanders@fonoster.com>",
   "homepage": "https://github.com/fonoster/fonoster#readme",
@@ -35,10 +35,10 @@
     "url": "https://github.com/fonoster/fonoster/issues"
   },
   "dependencies": {
-    "@fonoster/common": "^0.7.13",
-    "@fonoster/logger": "^0.7.13",
-    "@fonoster/types": "^0.7.13",
-    "@fonoster/voice": "^0.7.13",
+    "@fonoster/common": "^0.7.15",
+    "@fonoster/logger": "^0.7.15",
+    "@fonoster/types": "^0.7.15",
+    "@fonoster/voice": "^0.7.15",
     "@langchain/community": "^0.2.31",
     "@langchain/core": "^0.2.32",
     "@langchain/groq": "^0.0.17",
@@ -55,5 +55,5 @@
   "devDependencies": {
     "typescript": "^5.5.4"
   },
-  "gitHead": "e53cc1ba6d17ce64a9541bd51364ace3dcd43aaa"
+  "gitHead": "13997c49e69d79aa1a58cd0de1120984e3b8b6f1"
 }