@fonoster/common 0.8.51 → 0.8.56

package/dist/assistants/assistantSchema.d.ts

@@ -294,6 +294,206 @@ declare const assistantSchema: z.ZodObject<{
             };
         }[];
     }>;
+    testCases: z.ZodOptional<z.ZodObject<{
+        evalsLanguageModel: z.ZodObject<{
+            provider: z.ZodEnum<["openai"]>;
+            model: z.ZodString;
+            apiKey: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            provider?: "openai";
+            apiKey?: string;
+            model?: string;
+        }, {
+            provider?: "openai";
+            apiKey?: string;
+            model?: string;
+        }>;
+        evalsSystemPrompt: z.ZodOptional<z.ZodString>;
+        scenarios: z.ZodArray<z.ZodObject<{
+            ref: z.ZodString;
+            description: z.ZodString;
+            telephonyContext: z.ZodObject<{
+                callDirection: z.ZodNativeEnum<typeof import("@fonoster/types").CallDirection>;
+                ingressNumber: z.ZodString;
+                callerNumber: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                callDirection?: import("@fonoster/types").CallDirection;
+                ingressNumber?: string;
+                callerNumber?: string;
+            }, {
+                callDirection?: import("@fonoster/types").CallDirection;
+                ingressNumber?: string;
+                callerNumber?: string;
+            }>;
+            conversation: z.ZodArray<z.ZodObject<{
+                userInput: z.ZodString;
+                expected: z.ZodObject<{
+                    text: z.ZodObject<{
+                        type: z.ZodEnum<["exact", "similar"]>;
+                        response: z.ZodString;
+                    }, "strip", z.ZodTypeAny, {
+                        type?: "exact" | "similar";
+                        response?: string;
+                    }, {
+                        type?: "exact" | "similar";
+                        response?: string;
+                    }>;
+                    tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        tool: z.ZodString;
+                        parameters: z.ZodRecord<z.ZodString, z.ZodAny>;
+                    }, "strip", z.ZodTypeAny, {
+                        parameters?: Record<string, any>;
+                        tool?: string;
+                    }, {
+                        parameters?: Record<string, any>;
+                        tool?: string;
+                    }>, "many">>;
+                }, "strip", z.ZodTypeAny, {
+                    tools?: {
+                        parameters?: Record<string, any>;
+                        tool?: string;
+                    }[];
+                    text?: {
+                        type?: "exact" | "similar";
+                        response?: string;
+                    };
+                }, {
+                    tools?: {
+                        parameters?: Record<string, any>;
+                        tool?: string;
+                    }[];
+                    text?: {
+                        type?: "exact" | "similar";
+                        response?: string;
+                    };
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                expected?: {
+                    tools?: {
+                        parameters?: Record<string, any>;
+                        tool?: string;
+                    }[];
+                    text?: {
+                        type?: "exact" | "similar";
+                        response?: string;
+                    };
+                };
+                userInput?: string;
+            }, {
+                expected?: {
+                    tools?: {
+                        parameters?: Record<string, any>;
+                        tool?: string;
+                    }[];
+                    text?: {
+                        type?: "exact" | "similar";
+                        response?: string;
+                    };
+                };
+                userInput?: string;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            description?: string;
+            ref?: string;
+            telephonyContext?: {
+                callDirection?: import("@fonoster/types").CallDirection;
+                ingressNumber?: string;
+                callerNumber?: string;
+            };
+            conversation?: {
+                expected?: {
+                    tools?: {
+                        parameters?: Record<string, any>;
+                        tool?: string;
+                    }[];
+                    text?: {
+                        type?: "exact" | "similar";
+                        response?: string;
+                    };
+                };
+                userInput?: string;
+            }[];
+        }, {
+            description?: string;
+            ref?: string;
+            telephonyContext?: {
+                callDirection?: import("@fonoster/types").CallDirection;
+                ingressNumber?: string;
+                callerNumber?: string;
+            };
+            conversation?: {
+                expected?: {
+                    tools?: {
+                        parameters?: Record<string, any>;
+                        tool?: string;
+                    }[];
+                    text?: {
+                        type?: "exact" | "similar";
+                        response?: string;
+                    };
+                };
+                userInput?: string;
+            }[];
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        evalsLanguageModel?: {
+            provider?: "openai";
+            apiKey?: string;
+            model?: string;
+        };
+        evalsSystemPrompt?: string;
+        scenarios?: {
+            description?: string;
+            ref?: string;
+            telephonyContext?: {
+                callDirection?: import("@fonoster/types").CallDirection;
+                ingressNumber?: string;
+                callerNumber?: string;
+            };
+            conversation?: {
+                expected?: {
+                    tools?: {
+                        parameters?: Record<string, any>;
+                        tool?: string;
+                    }[];
+                    text?: {
+                        type?: "exact" | "similar";
+                        response?: string;
+                    };
+                };
+                userInput?: string;
+            }[];
+        }[];
+    }, {
+        evalsLanguageModel?: {
+            provider?: "openai";
+            apiKey?: string;
+            model?: string;
+        };
+        evalsSystemPrompt?: string;
+        scenarios?: {
+            description?: string;
+            ref?: string;
+            telephonyContext?: {
+                callDirection?: import("@fonoster/types").CallDirection;
+                ingressNumber?: string;
+                callerNumber?: string;
+            };
+            conversation?: {
+                expected?: {
+                    tools?: {
+                        parameters?: Record<string, any>;
+                        tool?: string;
+                    }[];
+                    text?: {
+                        type?: "exact" | "similar";
+                        response?: string;
+                    };
+                };
+                userInput?: string;
+            }[];
+        }[];
+    }>>;
 }, "strip", z.ZodTypeAny, {
     conversationSettings?: {
         firstMessage?: string;
@@ -353,6 +553,36 @@ declare const assistantSchema: z.ZodObject<{
             };
         }[];
     };
+    testCases?: {
+        evalsLanguageModel?: {
+            provider?: "openai";
+            apiKey?: string;
+            model?: string;
+        };
+        evalsSystemPrompt?: string;
+        scenarios?: {
+            description?: string;
+            ref?: string;
+            telephonyContext?: {
+                callDirection?: import("@fonoster/types").CallDirection;
+                ingressNumber?: string;
+                callerNumber?: string;
+            };
+            conversation?: {
+                expected?: {
+                    tools?: {
+                        parameters?: Record<string, any>;
+                        tool?: string;
+                    }[];
+                    text?: {
+                        type?: "exact" | "similar";
+                        response?: string;
+                    };
+                };
+                userInput?: string;
+            }[];
+        }[];
+    };
 }, {
     conversationSettings?: {
         firstMessage?: string;
@@ -412,5 +642,35 @@ declare const assistantSchema: z.ZodObject<{
             };
         }[];
     };
+    testCases?: {
+        evalsLanguageModel?: {
+            provider?: "openai";
+            apiKey?: string;
+            model?: string;
+        };
+        evalsSystemPrompt?: string;
+        scenarios?: {
+            description?: string;
+            ref?: string;
+            telephonyContext?: {
+                callDirection?: import("@fonoster/types").CallDirection;
+                ingressNumber?: string;
+                callerNumber?: string;
+            };
+            conversation?: {
+                expected?: {
+                    tools?: {
+                        parameters?: Record<string, any>;
+                        tool?: string;
+                    }[];
+                    text?: {
+                        type?: "exact" | "similar";
+                        response?: string;
+                    };
+                };
+                userInput?: string;
+            }[];
+        }[];
+    };
 }>;
 export { assistantSchema };

package/dist/assistants/assistantSchema.js

@@ -22,8 +22,10 @@ exports.assistantSchema = void 0;
 const zod_1 = require("zod");
 const conversationSettingsSchema_1 = require("./conversationSettingsSchema");
 const languageModelConfigSchema_1 = require("./languageModelConfigSchema");
+const testCasesSchema_1 = require("./testCasesSchema");
 const assistantSchema = zod_1.z.object({
     conversationSettings: conversationSettingsSchema_1.conversationSettingsSchema,
-    languageModel: languageModelConfigSchema_1.languageModelConfigSchema
+    languageModel: languageModelConfigSchema_1.languageModelConfigSchema,
+    testCases: testCasesSchema_1.testCasesSchema.optional()
 });
 exports.assistantSchema = assistantSchema;

package/dist/assistants/testCasesSchema.d.ts

@@ -0,0 +1,203 @@
+import { z } from "zod";
+import { CallDirection } from "@fonoster/types";
+declare const testCasesSchema: z.ZodObject<{
+    evalsLanguageModel: z.ZodObject<{
+        provider: z.ZodEnum<["openai"]>;
+        model: z.ZodString;
+        apiKey: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        provider?: "openai";
+        apiKey?: string;
+        model?: string;
+    }, {
+        provider?: "openai";
+        apiKey?: string;
+        model?: string;
+    }>;
+    evalsSystemPrompt: z.ZodOptional<z.ZodString>;
+    scenarios: z.ZodArray<z.ZodObject<{
+        ref: z.ZodString;
+        description: z.ZodString;
+        telephonyContext: z.ZodObject<{
+            callDirection: z.ZodNativeEnum<typeof CallDirection>;
+            ingressNumber: z.ZodString;
+            callerNumber: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            callDirection?: CallDirection;
+            ingressNumber?: string;
+            callerNumber?: string;
+        }, {
+            callDirection?: CallDirection;
+            ingressNumber?: string;
+            callerNumber?: string;
+        }>;
+        conversation: z.ZodArray<z.ZodObject<{
+            userInput: z.ZodString;
+            expected: z.ZodObject<{
+                text: z.ZodObject<{
+                    type: z.ZodEnum<["exact", "similar"]>;
+                    response: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    type?: "exact" | "similar";
+                    response?: string;
+                }, {
+                    type?: "exact" | "similar";
+                    response?: string;
+                }>;
+                tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    tool: z.ZodString;
+                    parameters: z.ZodRecord<z.ZodString, z.ZodAny>;
+                }, "strip", z.ZodTypeAny, {
+                    parameters?: Record<string, any>;
+                    tool?: string;
+                }, {
+                    parameters?: Record<string, any>;
+                    tool?: string;
+                }>, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                tools?: {
+                    parameters?: Record<string, any>;
+                    tool?: string;
+                }[];
+                text?: {
+                    type?: "exact" | "similar";
+                    response?: string;
+                };
+            }, {
+                tools?: {
+                    parameters?: Record<string, any>;
+                    tool?: string;
+                }[];
+                text?: {
+                    type?: "exact" | "similar";
+                    response?: string;
+                };
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            expected?: {
+                tools?: {
+                    parameters?: Record<string, any>;
+                    tool?: string;
+                }[];
+                text?: {
+                    type?: "exact" | "similar";
+                    response?: string;
+                };
+            };
+            userInput?: string;
+        }, {
+            expected?: {
+                tools?: {
+                    parameters?: Record<string, any>;
+                    tool?: string;
+                }[];
+                text?: {
+                    type?: "exact" | "similar";
+                    response?: string;
+                };
+            };
+            userInput?: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        description?: string;
+        ref?: string;
+        telephonyContext?: {
+            callDirection?: CallDirection;
+            ingressNumber?: string;
+            callerNumber?: string;
+        };
+        conversation?: {
+            expected?: {
+                tools?: {
+                    parameters?: Record<string, any>;
+                    tool?: string;
+                }[];
+                text?: {
+                    type?: "exact" | "similar";
+                    response?: string;
+                };
+            };
+            userInput?: string;
+        }[];
+    }, {
+        description?: string;
+        ref?: string;
+        telephonyContext?: {
+            callDirection?: CallDirection;
+            ingressNumber?: string;
+            callerNumber?: string;
+        };
+        conversation?: {
+            expected?: {
+                tools?: {
+                    parameters?: Record<string, any>;
+                    tool?: string;
+                }[];
+                text?: {
+                    type?: "exact" | "similar";
+                    response?: string;
+                };
+            };
+            userInput?: string;
+        }[];
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    evalsLanguageModel?: {
+        provider?: "openai";
+        apiKey?: string;
+        model?: string;
+    };
+    evalsSystemPrompt?: string;
+    scenarios?: {
+        description?: string;
+        ref?: string;
+        telephonyContext?: {
+            callDirection?: CallDirection;
+            ingressNumber?: string;
+            callerNumber?: string;
+        };
+        conversation?: {
+            expected?: {
+                tools?: {
+                    parameters?: Record<string, any>;
+                    tool?: string;
+                }[];
+                text?: {
+                    type?: "exact" | "similar";
+                    response?: string;
+                };
+            };
+            userInput?: string;
+        }[];
+    }[];
+}, {
+    evalsLanguageModel?: {
+        provider?: "openai";
+        apiKey?: string;
+        model?: string;
+    };
+    evalsSystemPrompt?: string;
+    scenarios?: {
+        description?: string;
+        ref?: string;
+        telephonyContext?: {
+            callDirection?: CallDirection;
+            ingressNumber?: string;
+            callerNumber?: string;
+        };
+        conversation?: {
+            expected?: {
+                tools?: {
+                    parameters?: Record<string, any>;
+                    tool?: string;
+                }[];
+                text?: {
+                    type?: "exact" | "similar";
+                    response?: string;
+                };
+            };
+            userInput?: string;
+        }[];
+    }[];
+}>;
+export { testCasesSchema };

package/dist/assistants/testCasesSchema.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testCasesSchema = 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 types_1 = require("@fonoster/types");
+const testCasesSchema = zod_1.z.object({
+    evalsLanguageModel: zod_1.z.object({
+        provider: zod_1.z.enum(["openai"], {
+            message: "Invalid language model provider. Only OpenAI is supported for evals."
+        }),
+        model: zod_1.z.string(),
+        apiKey: zod_1.z.string()
+    }),
+    evalsSystemPrompt: zod_1.z.string().optional(),
+    scenarios: zod_1.z.array(zod_1.z.object({
+        ref: zod_1.z.string(),
+        description: zod_1.z.string(),
+        telephonyContext: zod_1.z.object({
+            callDirection: zod_1.z.nativeEnum(types_1.CallDirection),
+            ingressNumber: zod_1.z.string(),
+            callerNumber: zod_1.z.string()
+        }),
+        conversation: zod_1.z.array(zod_1.z.object({
+            userInput: zod_1.z.string(),
+            expected: zod_1.z.object({
+                text: zod_1.z.object({
+                    type: zod_1.z.enum(["exact", "similar"]),
+                    response: zod_1.z.string()
+                }),
+                tools: zod_1.z
+                    .array(zod_1.z.object({
+                    tool: zod_1.z.string(),
+                    parameters: zod_1.z.record(zod_1.z.string(), zod_1.z.any())
+                }))
+                    .optional()
+            })
+        }))
+    }))
+});
+exports.testCasesSchema = testCasesSchema;

package/dist/protos/voice.proto

@@ -169,6 +169,7 @@ message GatherResponse {
     string speech = 2;
     string digits = 3;
   }
+  int32 response_time = 4;
 }
 
 // RecordRequest is the request message to initiate a recording
@@ -359,6 +360,7 @@ message StreamGatherPayload {
     string speech = 2;
     string digit = 3;
   }
+  int32 response_time = 4;
 }
 
 // VoiceInStream is the input stream for the voice service

package/dist/voice/Gather.d.ts

@@ -14,5 +14,6 @@ type GatherRequest = VerbRequest & GatherOptions;
 type GatherResponse = VerbResponse & {
     speech?: string;
     digits?: string;
+    responseTime: number;
 };
 export { GatherOptions, GatherRequest, GatherResponse, GatherSource };

package/dist/voice/StreamGather.d.ts

@@ -11,5 +11,6 @@ type StartStreamGatherRequest = VerbRequest & StreamGatherOptions;
 type StreamGatherPayload = VerbResponse & {
     speech?: string;
     digit?: string;
+    responseTime: number;
 };
 export { StartStreamGatherRequest, StreamGatherOptions, StreamGatherPayload, StreamGatherSource };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fonoster/common",
-  "version": "0.8.51",
+  "version": "0.8.56",
   "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.51",
+    "@fonoster/logger": "^0.8.56",
     "@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": "67a0f500926304550c2698943ba6e7a7aa4b9f06"
+  "gitHead": "eb95cb72d964068fe3d525b696f17c4d4b0522a2"
 }