@fonoster/common 0.8.59 → 0.9.0

package/dist/assistants/assistantSchema.d.ts

@@ -164,31 +164,21 @@ declare const assistantSchema: z.ZodObject<{
                 required?: string[];
             }>;
             requestStartMessage: z.ZodOptional<z.ZodString>;
-            operation: z.ZodEffects<z.ZodObject<{
-                type: z.ZodNativeEnum<typeof import("./tools/AllowedOperations").AllowedOperations>;
-                url: z.ZodOptional<z.ZodString>;
-                waitForResponse: z.ZodOptional<z.ZodBoolean>;
+            operation: z.ZodObject<{
+                method: z.ZodDefault<z.ZodNativeEnum<typeof import("..").AllowedHttpMethod>>;
+                url: z.ZodString;
+                waitForResponse: z.ZodDefault<z.ZodBoolean>;
                 headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
             }, "strip", z.ZodTypeAny, {
-                type?: import("./tools/AllowedOperations").AllowedOperations;
                 url?: string;
-                waitForResponse?: boolean;
+                method?: import("..").AllowedHttpMethod;
                 headers?: Record<string, string>;
-            }, {
-                type?: import("./tools/AllowedOperations").AllowedOperations;
-                url?: string;
                 waitForResponse?: boolean;
-                headers?: Record<string, string>;
-            }>, {
-                type?: import("./tools/AllowedOperations").AllowedOperations;
-                url?: string;
-                waitForResponse?: boolean;
-                headers?: Record<string, string>;
             }, {
-                type?: import("./tools/AllowedOperations").AllowedOperations;
                 url?: string;
-                waitForResponse?: boolean;
+                method?: import("..").AllowedHttpMethod;
                 headers?: Record<string, string>;
+                waitForResponse?: boolean;
             }>;
         }, "strip", z.ZodTypeAny, {
             name?: string;
@@ -204,10 +194,10 @@ declare const assistantSchema: z.ZodObject<{
             };
             requestStartMessage?: string;
             operation?: {
-                type?: import("./tools/AllowedOperations").AllowedOperations;
                 url?: string;
-                waitForResponse?: boolean;
+                method?: import("..").AllowedHttpMethod;
                 headers?: Record<string, string>;
+                waitForResponse?: boolean;
             };
         }, {
             name?: string;
@@ -223,10 +213,10 @@ declare const assistantSchema: z.ZodObject<{
             };
             requestStartMessage?: string;
             operation?: {
-                type?: import("./tools/AllowedOperations").AllowedOperations;
                 url?: string;
-                waitForResponse?: boolean;
+                method?: import("..").AllowedHttpMethod;
                 headers?: Record<string, string>;
+                waitForResponse?: boolean;
             };
         }>, "many">>;
     }, "strip", z.ZodTypeAny, {
@@ -255,10 +245,10 @@ declare const assistantSchema: z.ZodObject<{
             };
             requestStartMessage?: string;
             operation?: {
-                type?: import("./tools/AllowedOperations").AllowedOperations;
                 url?: string;
-                waitForResponse?: boolean;
+                method?: import("..").AllowedHttpMethod;
                 headers?: Record<string, string>;
+                waitForResponse?: boolean;
             };
         }[];
     }, {
@@ -287,13 +277,26 @@ declare const assistantSchema: z.ZodObject<{
             };
             requestStartMessage?: string;
             operation?: {
-                type?: import("./tools/AllowedOperations").AllowedOperations;
                 url?: string;
-                waitForResponse?: boolean;
+                method?: import("..").AllowedHttpMethod;
                 headers?: Record<string, string>;
+                waitForResponse?: boolean;
             };
         }[];
     }>;
+    eventsHook: z.ZodOptional<z.ZodObject<{
+        url: z.ZodString;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        events: z.ZodDefault<z.ZodArray<z.ZodNativeEnum<typeof import("./eventsHookSchema").EventsHookAllowedEvents>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        url?: string;
+        headers?: Record<string, string>;
+        events?: import("./eventsHookSchema").EventsHookAllowedEvents[];
+    }, {
+        url?: string;
+        headers?: Record<string, string>;
+        events?: import("./eventsHookSchema").EventsHookAllowedEvents[];
+    }>>;
     testCases: z.ZodOptional<z.ZodObject<{
         evalsLanguageModel: z.ZodObject<{
             provider: z.ZodEnum<["openai"]>;
@@ -546,13 +549,18 @@ declare const assistantSchema: z.ZodObject<{
             };
             requestStartMessage?: string;
             operation?: {
-                type?: import("./tools/AllowedOperations").AllowedOperations;
                 url?: string;
-                waitForResponse?: boolean;
+                method?: import("..").AllowedHttpMethod;
                 headers?: Record<string, string>;
+                waitForResponse?: boolean;
             };
         }[];
     };
+    eventsHook?: {
+        url?: string;
+        headers?: Record<string, string>;
+        events?: import("./eventsHookSchema").EventsHookAllowedEvents[];
+    };
     testCases?: {
         evalsLanguageModel?: {
             provider?: "openai";
@@ -635,13 +643,18 @@ declare const assistantSchema: z.ZodObject<{
             };
             requestStartMessage?: string;
             operation?: {
-                type?: import("./tools/AllowedOperations").AllowedOperations;
                 url?: string;
-                waitForResponse?: boolean;
+                method?: import("..").AllowedHttpMethod;
                 headers?: Record<string, string>;
+                waitForResponse?: boolean;
             };
         }[];
     };
+    eventsHook?: {
+        url?: string;
+        headers?: Record<string, string>;
+        events?: import("./eventsHookSchema").EventsHookAllowedEvents[];
+    };
     testCases?: {
         evalsLanguageModel?: {
             provider?: "openai";

package/dist/assistants/assistantSchema.js

@@ -23,9 +23,11 @@ const zod_1 = require("zod");
 const conversationSettingsSchema_1 = require("./conversationSettingsSchema");
 const languageModelConfigSchema_1 = require("./languageModelConfigSchema");
 const testCasesSchema_1 = require("./testCasesSchema");
+const eventsHookSchema_1 = require("./eventsHookSchema");
 const assistantSchema = zod_1.z.object({
     conversationSettings: conversationSettingsSchema_1.conversationSettingsSchema,
     languageModel: languageModelConfigSchema_1.languageModelConfigSchema,
+    eventsHook: eventsHookSchema_1.eventsHookSchema.optional(),
     testCases: testCasesSchema_1.testCasesSchema.optional()
 });
 exports.assistantSchema = assistantSchema;

package/dist/assistants/eventsHookSchema.d.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+declare enum EventsHookAllowedEvents {
+    ALL = "all",
+    CONVERSATION_STARTED = "conversation.started",
+    CONVERSATION_ENDED = "conversation.ended"
+}
+declare const eventsHookSchema: z.ZodObject<{
+    url: z.ZodString;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    events: z.ZodDefault<z.ZodArray<z.ZodNativeEnum<typeof EventsHookAllowedEvents>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    url?: string;
+    headers?: Record<string, string>;
+    events?: EventsHookAllowedEvents[];
+}, {
+    url?: string;
+    headers?: Record<string, string>;
+    events?: EventsHookAllowedEvents[];
+}>;
+export { eventsHookSchema, EventsHookAllowedEvents };

package/dist/assistants/eventsHookSchema.js

@@ -0,0 +1,71 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventsHookAllowedEvents = exports.eventsHookSchema = void 0;
+/*
+ * Copyright (C) 2025 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 Messages = __importStar(require("../messages"));
+var EventsHookAllowedEvents;
+(function (EventsHookAllowedEvents) {
+    EventsHookAllowedEvents["ALL"] = "all";
+    EventsHookAllowedEvents["CONVERSATION_STARTED"] = "conversation.started";
+    EventsHookAllowedEvents["CONVERSATION_ENDED"] = "conversation.ended";
+})(EventsHookAllowedEvents || (exports.EventsHookAllowedEvents = EventsHookAllowedEvents = {}));
+const eventsHookSchema = zod_1.z.object({
+    url: zod_1.z.string().url({ message: Messages.VALID_URL }),
+    headers: zod_1.z.record(zod_1.z.string()).optional(),
+    events: zod_1.z
+        .array(zod_1.z.nativeEnum(EventsHookAllowedEvents))
+        .min(1)
+        .default([EventsHookAllowedEvents.ALL])
+});
+exports.eventsHookSchema = eventsHookSchema;

package/dist/assistants/index.d.ts

@@ -3,3 +3,4 @@ export * from "./assistantSchema";
 export * from "./LanguageModelProvider";
 export * from "./conversationSettingsSchema";
 export * from "./languageModelConfigSchema";
+export * from "./eventsHookSchema";

package/dist/assistants/index.js

@@ -37,3 +37,4 @@ __exportStar(require("./assistantSchema"), exports);
 __exportStar(require("./LanguageModelProvider"), exports);
 __exportStar(require("./conversationSettingsSchema"), exports);
 __exportStar(require("./languageModelConfigSchema"), exports);
+__exportStar(require("./eventsHookSchema"), exports);

package/dist/assistants/languageModelConfigSchema.d.ts

@@ -65,31 +65,21 @@ declare const languageModelConfigSchema: z.ZodObject<{
             required?: string[];
         }>;
         requestStartMessage: z.ZodOptional<z.ZodString>;
-        operation: z.ZodEffects<z.ZodObject<{
-            type: z.ZodNativeEnum<typeof import("./tools/AllowedOperations").AllowedOperations>;
-            url: z.ZodOptional<z.ZodString>;
-            waitForResponse: z.ZodOptional<z.ZodBoolean>;
+        operation: z.ZodObject<{
+            method: z.ZodDefault<z.ZodNativeEnum<typeof import("..").AllowedHttpMethod>>;
+            url: z.ZodString;
+            waitForResponse: z.ZodDefault<z.ZodBoolean>;
             headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         }, "strip", z.ZodTypeAny, {
-            type?: import("./tools/AllowedOperations").AllowedOperations;
             url?: string;
-            waitForResponse?: boolean;
+            method?: import("..").AllowedHttpMethod;
             headers?: Record<string, string>;
-        }, {
-            type?: import("./tools/AllowedOperations").AllowedOperations;
-            url?: string;
             waitForResponse?: boolean;
-            headers?: Record<string, string>;
-        }>, {
-            type?: import("./tools/AllowedOperations").AllowedOperations;
-            url?: string;
-            waitForResponse?: boolean;
-            headers?: Record<string, string>;
         }, {
-            type?: import("./tools/AllowedOperations").AllowedOperations;
             url?: string;
-            waitForResponse?: boolean;
+            method?: import("..").AllowedHttpMethod;
             headers?: Record<string, string>;
+            waitForResponse?: boolean;
         }>;
     }, "strip", z.ZodTypeAny, {
         name?: string;
@@ -105,10 +95,10 @@ declare const languageModelConfigSchema: z.ZodObject<{
         };
         requestStartMessage?: string;
         operation?: {
-            type?: import("./tools/AllowedOperations").AllowedOperations;
             url?: string;
-            waitForResponse?: boolean;
+            method?: import("..").AllowedHttpMethod;
             headers?: Record<string, string>;
+            waitForResponse?: boolean;
         };
     }, {
         name?: string;
@@ -124,10 +114,10 @@ declare const languageModelConfigSchema: z.ZodObject<{
         };
         requestStartMessage?: string;
         operation?: {
-            type?: import("./tools/AllowedOperations").AllowedOperations;
             url?: string;
-            waitForResponse?: boolean;
+            method?: import("..").AllowedHttpMethod;
             headers?: Record<string, string>;
+            waitForResponse?: boolean;
         };
     }>, "many">>;
 }, "strip", z.ZodTypeAny, {
@@ -156,10 +146,10 @@ declare const languageModelConfigSchema: z.ZodObject<{
         };
         requestStartMessage?: string;
         operation?: {
-            type?: import("./tools/AllowedOperations").AllowedOperations;
             url?: string;
-            waitForResponse?: boolean;
+            method?: import("..").AllowedHttpMethod;
             headers?: Record<string, string>;
+            waitForResponse?: boolean;
         };
     }[];
 }, {
@@ -188,10 +178,10 @@ declare const languageModelConfigSchema: z.ZodObject<{
         };
         requestStartMessage?: string;
         operation?: {
-            type?: import("./tools/AllowedOperations").AllowedOperations;
             url?: string;
-            waitForResponse?: boolean;
+            method?: import("..").AllowedHttpMethod;
             headers?: Record<string, string>;
+            waitForResponse?: boolean;
         };
     }[];
 }>;

package/dist/assistants/tools/toolSchema.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { AllowedOperations } from "./AllowedOperations";
+import { AllowedHttpMethod } from "../../utils/sendHttpRequest";
 declare const toolSchema: z.ZodObject<{
     name: z.ZodString;
     description: z.ZodString;
@@ -45,31 +45,21 @@ declare const toolSchema: z.ZodObject<{
         required?: string[];
     }>;
     requestStartMessage: z.ZodOptional<z.ZodString>;
-    operation: z.ZodEffects<z.ZodObject<{
-        type: z.ZodNativeEnum<typeof AllowedOperations>;
-        url: z.ZodOptional<z.ZodString>;
-        waitForResponse: z.ZodOptional<z.ZodBoolean>;
+    operation: z.ZodObject<{
+        method: z.ZodDefault<z.ZodNativeEnum<typeof AllowedHttpMethod>>;
+        url: z.ZodString;
+        waitForResponse: z.ZodDefault<z.ZodBoolean>;
         headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     }, "strip", z.ZodTypeAny, {
-        type?: AllowedOperations;
         url?: string;
-        waitForResponse?: boolean;
+        method?: AllowedHttpMethod;
         headers?: Record<string, string>;
-    }, {
-        type?: AllowedOperations;
-        url?: string;
         waitForResponse?: boolean;
-        headers?: Record<string, string>;
-    }>, {
-        type?: AllowedOperations;
-        url?: string;
-        waitForResponse?: boolean;
-        headers?: Record<string, string>;
     }, {
-        type?: AllowedOperations;
         url?: string;
-        waitForResponse?: boolean;
+        method?: AllowedHttpMethod;
         headers?: Record<string, string>;
+        waitForResponse?: boolean;
     }>;
 }, "strip", z.ZodTypeAny, {
     name?: string;
@@ -85,10 +75,10 @@ declare const toolSchema: z.ZodObject<{
     };
     requestStartMessage?: string;
     operation?: {
-        type?: AllowedOperations;
         url?: string;
-        waitForResponse?: boolean;
+        method?: AllowedHttpMethod;
         headers?: Record<string, string>;
+        waitForResponse?: boolean;
     };
 }, {
     name?: string;
@@ -104,10 +94,10 @@ declare const toolSchema: z.ZodObject<{
     };
     requestStartMessage?: string;
     operation?: {
-        type?: AllowedOperations;
         url?: string;
-        waitForResponse?: boolean;
+        method?: AllowedHttpMethod;
         headers?: Record<string, string>;
+        waitForResponse?: boolean;
     };
 }>;
 export { toolSchema };

package/dist/assistants/tools/toolSchema.js

@@ -55,7 +55,7 @@ exports.toolSchema = void 0;
 const zod_1 = require("zod");
 const propertySchema_1 = require("./propertySchema");
 const Messages = __importStar(require("../../messages"));
-const AllowedOperations_1 = require("./AllowedOperations");
+const sendHttpRequest_1 = require("../../utils/sendHttpRequest");
 const toolSchema = zod_1.z.object({
     name: zod_1.z.string(),
     description: zod_1.z.string(),
@@ -65,23 +65,15 @@ const toolSchema = zod_1.z.object({
         required: zod_1.z.array(zod_1.z.string()).optional()
     }),
     requestStartMessage: zod_1.z.string().optional(),
-    operation: zod_1.z
-        .object({
-        type: zod_1.z.nativeEnum(AllowedOperations_1.AllowedOperations, {
-            message: "Invalid operation type"
-        }),
-        // Make url required if operation type is not built-in
-        url: zod_1.z.string().url({ message: Messages.VALID_URL }).optional(),
-        waitForResponse: zod_1.z.boolean().optional(),
+    operation: zod_1.z.object({
+        method: zod_1.z
+            .nativeEnum(sendHttpRequest_1.AllowedHttpMethod, {
+            message: "Invalid method"
+        })
+            .default(sendHttpRequest_1.AllowedHttpMethod.GET),
+        url: zod_1.z.string().url({ message: Messages.VALID_URL }),
+        waitForResponse: zod_1.z.boolean().default(true),
         headers: zod_1.z.record(zod_1.z.string()).optional()
     })
-        .superRefine(({ url, type }, ctx) => {
-        if (type !== AllowedOperations_1.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/utils/index.d.ts

@@ -12,3 +12,4 @@ export * from "./withValidation";
 export * from "./types";
 export * from "./createFetchSingleCallByCallId";
 export * from "./findIntegrationsCredentials";
+export * from "./sendHttpRequest";

package/dist/utils/index.js

@@ -46,3 +46,4 @@ __exportStar(require("./withValidation"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./createFetchSingleCallByCallId"), exports);
 __exportStar(require("./findIntegrationsCredentials"), exports);
+__exportStar(require("./sendHttpRequest"), exports);

package/dist/utils/sendHttpRequest.d.ts

@@ -0,0 +1,14 @@
+declare enum AllowedHttpMethod {
+    GET = "get",
+    POST = "post"
+}
+declare function sendHttpRequest(params: {
+    method: AllowedHttpMethod;
+    url: string;
+    waitForResponse: boolean;
+    headers?: Record<string, string>;
+    body?: Record<string, unknown>;
+}): Promise<{
+    result: string;
+}>;
+export { sendHttpRequest, AllowedHttpMethod };

package/dist/utils/sendHttpRequest.js

@@ -0,0 +1,71 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AllowedHttpMethod = void 0;
+exports.sendHttpRequest = sendHttpRequest;
+/*
+ * Copyright (C) 2025 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 zod_1 = require("zod");
+const responseSchema = zod_1.z.object({
+    result: zod_1.z.string()
+});
+const logger = (0, logger_1.getLogger)({ service: "common", filePath: __filename });
+var AllowedHttpMethod;
+(function (AllowedHttpMethod) {
+    AllowedHttpMethod["GET"] = "get";
+    AllowedHttpMethod["POST"] = "post";
+})(AllowedHttpMethod || (exports.AllowedHttpMethod = AllowedHttpMethod = {}));
+function sendHttpRequest(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { url, method, body, headers, waitForResponse } = params;
+        const effectiveMethod = method.toLowerCase();
+        const options = {
+            method,
+            headers: Object.assign({ "Content-Type": "application/json" }, headers),
+            body: effectiveMethod === "post" ? JSON.stringify(body) : undefined
+        };
+        logger.silly(`sending request to ${url}`, {
+            body,
+            method: effectiveMethod
+        });
+        if (waitForResponse && effectiveMethod === "post") {
+            setTimeout(() => fetch(url, options), 0);
+            return { result: "request sent" };
+        }
+        else {
+            const response = yield fetch(url, options);
+            const data = yield response.json();
+            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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fonoster/common",
-  "version": "0.8.59",
+  "version": "0.9.0",
   "description": "Common library for Fonoster projects",
   "author": "Pedro Sanders <psanders@fonoster.com>",
   "homepage": "https://github.com/fonoster/fonoster#readme",
@@ -18,7 +18,7 @@
     "clean": "rimraf ./dist node_modules tsconfig.tsbuildinfo"
   },
   "dependencies": {
-    "@fonoster/logger": "^0.8.59",
+    "@fonoster/logger": "^0.9.0",
     "@grpc/grpc-js": "~1.10.6",
     "@grpc/proto-loader": "^0.7.12",
     "@influxdata/influxdb-client": "^1.35.0",
@@ -48,5 +48,5 @@
   "devDependencies": {
     "@types/nodemailer": "^6.4.14"
   },
-  "gitHead": "6a5255febb9e4bcd9184d93abe72281f945c8c4d"
+  "gitHead": "0ec8e6ef5b6ee8adfb5b1856a177a0e0bf1070b9"
 }

package/dist/assistants/tools/AllowedOperations.d.ts

@@ -1,6 +0,0 @@
-declare enum AllowedOperations {
-    GET = "get",
-    POST = "post",
-    BUILT_IN = "built-in"
-}
-export { AllowedOperations };

package/dist/assistants/tools/AllowedOperations.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AllowedOperations = void 0;
-/*
- * Copyright (C) 2025 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.
- */
-var AllowedOperations;
-(function (AllowedOperations) {
-    AllowedOperations["GET"] = "get";
-    AllowedOperations["POST"] = "post";
-    AllowedOperations["BUILT_IN"] = "built-in";
-})(AllowedOperations || (exports.AllowedOperations = AllowedOperations = {}));