@fonoster/autopilot 0.7.4 → 0.7.5

package/dist/models/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/server.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/*
+ * 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 voiceServerSetup_1 = require("./voiceServerSetup");
+const skipIdentity = process.env.NODE_ENV === "dev";
+(0, voiceServerSetup_1.startVoiceServer)(skipIdentity);

package/dist/tools/ToolSchema.d.ts

@@ -0,0 +1,107 @@
+import { z } from "zod";
+declare enum AllowedOperations {
+    GET = "get",
+    POST = "post",
+    BUILT_IN = "built-in"
+}
+declare const toolSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    parameters: z.ZodObject<{
+        type: z.ZodEnum<["object", "array"]>;
+        properties: z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodObject<{
+            type: z.ZodString;
+            format: z.ZodOptional<z.ZodString>;
+            pattern: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            type: string;
+            format?: string | undefined;
+            pattern?: string | undefined;
+        }, {
+            type: string;
+            format?: string | undefined;
+            pattern?: string | undefined;
+        }>, {
+            type: string;
+            format?: string | undefined;
+            pattern?: string | undefined;
+        }, {
+            type: string;
+            format?: string | undefined;
+            pattern?: string | undefined;
+        }>>;
+        required: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        type: "object" | "array";
+        properties: Record<string, {
+            type: string;
+            format?: string | undefined;
+            pattern?: string | undefined;
+        }>;
+        required?: string[] | undefined;
+    }, {
+        type: "object" | "array";
+        properties: Record<string, {
+            type: string;
+            format?: string | undefined;
+            pattern?: string | undefined;
+        }>;
+        required?: string[] | undefined;
+    }>;
+    operation: z.ZodEffects<z.ZodObject<{
+        type: z.ZodNativeEnum<typeof AllowedOperations>;
+        url: z.ZodOptional<z.ZodString>;
+        waitForResponse: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        type: AllowedOperations;
+        url?: string | undefined;
+        waitForResponse?: boolean | undefined;
+    }, {
+        type: AllowedOperations;
+        url?: string | undefined;
+        waitForResponse?: boolean | undefined;
+    }>, {
+        type: AllowedOperations;
+        url?: string | undefined;
+        waitForResponse?: boolean | undefined;
+    }, {
+        type: AllowedOperations;
+        url?: string | undefined;
+        waitForResponse?: boolean | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description: string;
+    parameters: {
+        type: "object" | "array";
+        properties: Record<string, {
+            type: string;
+            format?: string | undefined;
+            pattern?: string | undefined;
+        }>;
+        required?: string[] | undefined;
+    };
+    operation: {
+        type: AllowedOperations;
+        url?: string | undefined;
+        waitForResponse?: boolean | undefined;
+    };
+}, {
+    name: string;
+    description: string;
+    parameters: {
+        type: "object" | "array";
+        properties: Record<string, {
+            type: string;
+            format?: string | undefined;
+            pattern?: string | undefined;
+        }>;
+        required?: string[] | undefined;
+    };
+    operation: {
+        type: AllowedOperations;
+        url?: string | undefined;
+        waitForResponse?: boolean | undefined;
+    };
+}>;
+export { AllowedOperations, toolSchema };

package/dist/tools/ToolSchema.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toolSchema = exports.AllowedOperations = 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 zod_1 = require("zod");
+var AllowedOperations;
+(function (AllowedOperations) {
+    AllowedOperations["GET"] = "get";
+    AllowedOperations["POST"] = "post";
+    AllowedOperations["BUILT_IN"] = "built-in";
+})(AllowedOperations || (exports.AllowedOperations = AllowedOperations = {}));
+const propertySchema = zod_1.z
+    .object({
+    type: zod_1.z.string(),
+    format: zod_1.z.string().optional(),
+    pattern: zod_1.z.string().optional()
+})
+    .refine((data) => {
+    return !("format" in data && "pattern" in data);
+}, {
+    message: "Property can only have either 'format' or 'pattern', not both."
+});
+const toolSchema = zod_1.z.object({
+    name: zod_1.z.string(),
+    description: zod_1.z.string(),
+    parameters: zod_1.z.object({
+        type: zod_1.z.enum(["object", "array"]),
+        properties: zod_1.z.record(propertySchema),
+        required: zod_1.z.array(zod_1.z.string()).optional()
+    }),
+    operation: 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()
+    })
+        .superRefine(({ url, type }, ctx) => {
+        if (type !== AllowedOperations.BUILT_IN && !url) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                message: "Url is required for non built-in operations."
+            });
+        }
+    })
+});
+exports.toolSchema = toolSchema;

package/dist/tools/ToolsCatalog.d.ts

@@ -0,0 +1,11 @@
+import { Tool } from "./type";
+declare class ToolsCatalog {
+    private tools;
+    constructor(tools: Tool[]);
+    invokeTool(toolName: string, args: Record<string, unknown>): Promise<{
+        result: string;
+    }>;
+    addTool(toolDef: Tool): void;
+    listTools(): Tool[];
+}
+export { ToolsCatalog };

package/dist/tools/ToolsCatalog.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolsCatalog = 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 sendRequest_1 = require("./sendRequest");
+const logger = (0, logger_1.getLogger)({ service: "autopilot", filePath: __filename });
+class ToolsCatalog {
+    constructor(tools) {
+        this.tools = new Map();
+        tools.forEach((tool) => {
+            logger.verbose(`adding the '${tool.name}' tool to the catalog`);
+            this.addTool(tool);
+        });
+    }
+    async invokeTool(toolName, args) {
+        const tool = this.tools.get(toolName);
+        if (!tool) {
+            throw new Error(`Tool '${toolName}' not found in the catalog`);
+        }
+        return await (0, sendRequest_1.sendRequest)({
+            method: tool.operation.type,
+            url: tool.operation.url,
+            waitForResponse: tool.operation.waitForResponse,
+            body: args
+        });
+    }
+    addTool(toolDef) {
+        this.tools.set(toolDef.name, toolDef);
+    }
+    listTools() {
+        return Array.from(this.tools.values());
+    }
+}
+exports.ToolsCatalog = ToolsCatalog;

package/dist/tools/builtin/hangupToolDefinition.d.ts

@@ -0,0 +1,3 @@
+import { Tool } from "../type";
+declare const hangupToolDefinition: Tool;
+export { hangupToolDefinition };

package/dist/tools/builtin/hangupToolDefinition.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hangupToolDefinition = 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 ToolSchema_1 = require("../ToolSchema");
+const hangupToolDefinition = {
+    name: "hangup",
+    description: "Hangup the call and end the conversation",
+    parameters: {
+        type: "object",
+        properties: {},
+        required: ["message"]
+    },
+    operation: {
+        type: ToolSchema_1.AllowedOperations.BUILT_IN
+    }
+};
+exports.hangupToolDefinition = hangupToolDefinition;

package/dist/tools/builtin/transferToolDefinition.d.ts

@@ -0,0 +1,3 @@
+import { Tool } from "../type";
+declare const transferToolDefinition: Tool;
+export { transferToolDefinition };

package/dist/tools/builtin/transferToolDefinition.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transferToolDefinition = 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 ToolSchema_1 = require("../ToolSchema");
+const transferToolDefinition = {
+    name: "transfer",
+    description: "Transfer the call to a live agent",
+    parameters: {
+        type: "object",
+        properties: {},
+        required: []
+    },
+    operation: {
+        type: ToolSchema_1.AllowedOperations.BUILT_IN
+    }
+};
+exports.transferToolDefinition = transferToolDefinition;

package/dist/tools/convertToolToOpenAITool.d.ts

@@ -0,0 +1,3 @@
+import { OpenAITool, Tool } from "./type";
+declare function convertToolToOpenAITool(tool: Tool): OpenAITool;
+export { convertToolToOpenAITool };

package/dist/tools/convertToolToOpenAITool.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToolToOpenAITool = convertToolToOpenAITool;
+function convertToolToOpenAITool(tool) {
+    return {
+        type: "function",
+        function: {
+            ...tool
+        }
+    };
+}

package/dist/tools/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./ToolsCatalog";
+export * from "./builtin/hangupToolDefinition";
+export * from "./builtin/transferToolDefinition";
+export * from "./convertToolToOpenAITool";

package/dist/tools/index.js

@@ -0,0 +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 __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 });
+/*
+ * 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("./ToolsCatalog"), exports);
+__exportStar(require("./builtin/hangupToolDefinition"), exports);
+__exportStar(require("./builtin/transferToolDefinition"), exports);
+__exportStar(require("./convertToolToOpenAITool"), exports);

package/dist/tools/sendRequest.d.ts

@@ -0,0 +1,11 @@
+import { AllowedOperations } from "./ToolSchema";
+declare function sendRequest(input: {
+    method: AllowedOperations;
+    url: string;
+    waitForResponse: boolean;
+    headers?: Record<string, string>;
+    body?: Record<string, unknown>;
+}): Promise<{
+    result: string;
+}>;
+export { sendRequest };

package/dist/tools/sendRequest.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendRequest = sendRequest;
+/*
+ * 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 zod_1 = require("zod");
+const ToolSchema_1 = require("./ToolSchema");
+const responseSchema = zod_1.z.object({
+    result: zod_1.z.string()
+});
+async function sendRequest(input) {
+    const { url, method, body, headers, waitForResponse } = input;
+    const options = {
+        method,
+        headers,
+        body: method === ToolSchema_1.AllowedOperations.POST ? JSON.stringify(body) : undefined
+    };
+    if (waitForResponse && method === ToolSchema_1.AllowedOperations.POST) {
+        setTimeout(() => fetch(url, options), 0);
+        return { result: "request sent" };
+    }
+    else {
+        const response = await fetch(url, options);
+        const data = await response.json();
+        return responseSchema.parse(data);
+    }
+}

package/dist/tools/type.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+import { toolSchema } from "./ToolSchema";
+type Tool = z.infer<typeof toolSchema>;
+type OpenAITool = {
+    type: "function";
+    function: Omit<Tool, "operation">;
+};
+export { OpenAITool, Tool };

package/dist/tools/type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types.d.ts

@@ -1,7 +1,15 @@
-import { VoiceResponse } from "@fonoster/voice";
-import { AssistantConfig } from "./assistants/types";
-type AutopilotConfig = {
-    voice: VoiceResponse;
-    assistantConfig: AssistantConfig;
+import { ConversationSettings } from "./assistants";
+import { LanguageModel } from "./models";
+import { Vad } from "./vad";
+import { Voice } from "./voice";
+declare enum LANGUAGE_MODEL_PROVIDER {
+    OPENAI = "openai",
+    GROQ = "groq"
+}
+type AutopilotParams = {
+    voice: Voice;
+    vad: Vad;
+    conversationSettings: ConversationSettings;
+    languageModel: LanguageModel;
 };
-export { AutopilotConfig };
+export { AutopilotParams, LANGUAGE_MODEL_PROVIDER };

package/dist/types.js

@@ -1,2 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.LANGUAGE_MODEL_PROVIDER = void 0;
+var LANGUAGE_MODEL_PROVIDER;
+(function (LANGUAGE_MODEL_PROVIDER) {
+    LANGUAGE_MODEL_PROVIDER["OPENAI"] = "openai";
+    LANGUAGE_MODEL_PROVIDER["GROQ"] = "groq";
+})(LANGUAGE_MODEL_PROVIDER || (exports.LANGUAGE_MODEL_PROVIDER = LANGUAGE_MODEL_PROVIDER = {}));

package/dist/vad/SileroVad.d.ts

@@ -0,0 +1,8 @@
+import { Vad } from "./types";
+declare class SileroVad implements Vad {
+    private vad;
+    constructor();
+    private init;
+    processChunk(data: Uint8Array, callback: (event: "SPEECH_START" | "SPEECH_END") => void): void;
+}
+export { SileroVad };

package/dist/vad/SileroVad.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SileroVad = void 0;
+/* eslint-disable no-loops/no-loops */
+/*
+ * 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 makeVad_1 = require("./makeVad");
+class SileroVad {
+    constructor() {
+        this.init();
+    }
+    async init() {
+        // FIXME: It feels not to do this in the constructor
+        this.vad = await (0, makeVad_1.makeVad)();
+    }
+    processChunk(data, callback) {
+        if (!this.vad) {
+            throw new Error("VAD not initialized)");
+        }
+        this.vad(data, callback);
+    }
+}
+exports.SileroVad = SileroVad;

package/dist/vad/index.d.ts

@@ -1,3 +1,2 @@
-export * from "./SileroVadModel";
+export * from "./SileroVad";
 export * from "./types";
-export * from "./makeVad";

package/dist/vad/index.js

@@ -33,6 +33,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-__exportStar(require("./SileroVadModel"), exports);
+__exportStar(require("./SileroVad"), exports);
 __exportStar(require("./types"), exports);
-__exportStar(require("./makeVad"), exports);

package/dist/vad/makeVad.d.ts

@@ -1,2 +1,2 @@
-declare function makeVad(pathToModel?: string): Promise<(chunk: Uint8Array, callback: (event: "SPEECH_START" | "SPEECH_END", data: Record<string, unknown>) => void) => Promise<void>>;
+declare function makeVad(pathToModel?: string): Promise<(chunk: Uint8Array, callback: (event: "SPEECH_START" | "SPEECH_END") => void) => Promise<void>>;
 export { makeVad };

package/dist/vad/makeVad.js

@@ -65,13 +65,13 @@ async function makeVad(pathToModel) {
             if (result.isSpeech > 0.5) {
                 if (!isSpeechActive) {
                     isSpeechActive = true;
-                    callback("SPEECH_START", {});
+                    callback("SPEECH_START");
                     return processBuffer(remainingBuffer);
                 }
             }
             else if (isSpeechActive) {
                 isSpeechActive = false;
-                callback("SPEECH_END", {});
+                callback("SPEECH_END");
                 return processBuffer(remainingBuffer);
             }
             return processBuffer(remainingBuffer);

package/dist/vad/types.d.ts

@@ -1,4 +1,6 @@
-type Vad = (chunk: Uint8Array, cb: (event: string) => void) => Promise<void>;
+type Vad = {
+    processChunk: (chunk: Uint8Array, callback: (event: "SPEECH_START" | "SPEECH_END") => void) => void;
+};
 type SpeechProbabilities = {
     notSpeech: number;
     isSpeech: number;
@@ -14,4 +16,4 @@ type ONNXRuntimeAPI = {
         new (type: "float32", data: Float32Array, dims: [1, number]): unknown;
     };
 };
-export { SpeechProbabilities, ONNXRuntimeAPI, Vad };
+export { ONNXRuntimeAPI, SpeechProbabilities, Vad };

package/dist/voice/Voice.d.ts

@@ -0,0 +1,25 @@
+import { VoiceResponse } from "@fonoster/voice";
+import { Voice } from "./types";
+declare class VoiceImpl implements Voice {
+    private voice;
+    private playbackRef;
+    sessionRef: string;
+    constructor(sessionRef: string, voice: VoiceResponse);
+    answer(): Promise<void>;
+    hangup(): Promise<void>;
+    say(text: string): Promise<void>;
+    sgather(): Promise<{
+        stop: () => Promise<void>;
+        onData: (cb: (speech: string) => void) => void;
+    }>;
+    stream(): Promise<{
+        stop: () => Promise<void>;
+        onData: (cb: (chunk: Uint8Array) => void) => void;
+    }>;
+    transfer(to: string, options: {
+        record: boolean;
+        timeout: number;
+    }): Promise<void>;
+    stopSpeech(): Promise<void>;
+}
+export { VoiceImpl };