retell-utils 0.3.2 → 0.4.0

package/dist/llm.js

@@ -0,0 +1,118 @@
+import { z } from "zod";
+import { KbConfigSchema, McpConfigSchema } from "./agent.js";
+import { LlmModelSchema, LlmToolTypeSchema, S2sModelSchema, StartSpeakerSchema, ToolHttpMethodSchema, ToolParameterTypeSchema, } from "./enums.js";
+// ---------------------------------------------------------------------------
+// Tool sub-schemas
+// ---------------------------------------------------------------------------
+/** Handoff option within a transfer (prompt the receiving agent, etc.). */
+const HandoffOptionSchema = z.object({
+    type: z.string().optional(),
+    prompt: z.string().optional(),
+});
+/** Transfer destination configuration. */
+export const TransferDestinationSchema = z.object({
+    type: z.string().optional(),
+    prompt: z.string().optional(),
+    number: z.string().optional(),
+    extension: z.string().optional(),
+});
+/** Transfer option configuration (warm/cold transfer behavior). */
+export const TransferOptionSchema = z.object({
+    type: z.string().optional(),
+    option: HandoffOptionSchema.optional(),
+    public_handoff_option: HandoffOptionSchema.optional(),
+    private_handoff_option: HandoffOptionSchema.optional(),
+    on_hold_music: z.string().optional(),
+    opt_out_initial_message: z.boolean().optional(),
+    opt_out_human_detection: z.boolean().optional(),
+    agent_detection_timeout_ms: z.number().optional(),
+    show_transferee_as_caller: z.boolean().optional(),
+    enable_bridge_audio_cue: z.boolean().optional(),
+});
+// ---------------------------------------------------------------------------
+// Tools & states
+// ---------------------------------------------------------------------------
+/**
+ * Schema for an LLM tool. Tools are highly polymorphic (end_call,
+ * transfer_call, custom, cal, etc.) so we explicitly declare all known fields
+ * and use catchall to preserve any we haven't seen yet.
+ */
+export const LlmToolSchema = z.object({
+    // Common
+    type: LlmToolTypeSchema,
+    name: z.string().optional(),
+    description: z.string().optional(),
+    tool_id: z.string().optional(),
+    // Custom tool HTTP config
+    url: z.string().optional(),
+    method: ToolHttpMethodSchema.optional(),
+    parameter_type: ToolParameterTypeSchema.optional(),
+    parameters: z.unknown().optional(),
+    headers: z.record(z.string(), z.string()).optional(),
+    query_params: z.record(z.string(), z.string()).optional(),
+    args_at_root: z.boolean().optional(),
+    timeout_ms: z.number().optional(),
+    response_variables: z.record(z.string(), z.string()).optional(),
+    // Speech behavior
+    speak_during_execution: z.boolean().optional(),
+    speak_after_execution: z.boolean().optional(),
+    execution_message_description: z.string().optional(),
+    // Transfer
+    transfer_destination: TransferDestinationSchema.optional(),
+    transfer_option: TransferOptionSchema.optional(),
+    custom_sip_headers: z.record(z.string(), z.string()).optional(),
+    // Cal.com integration
+    cal_api_key: z.string().optional(),
+    event_type_id: z.number().optional(),
+    timezone: z.string().optional(),
+});
+/** State transition edge within multi-prompt LLM. */
+export const LlmStateEdgeSchema = z.object({
+    destination_state_name: z.string(),
+    description: z.string().optional(),
+    parameters: z.unknown().optional(),
+});
+/** A state within a multi-prompt LLM. */
+export const LlmStateSchema = z.object({
+    name: z.string(),
+    state_prompt: z.string().optional(),
+    edges: z.array(LlmStateEdgeSchema).optional(),
+    tools: z.array(LlmToolSchema).nullable().optional(),
+});
+// ---------------------------------------------------------------------------
+// LLM response
+// ---------------------------------------------------------------------------
+/** Zod schema for a Retell LLM response from the API. */
+export const LlmResponseSchema = z.object({
+    // Required
+    llm_id: z.string(),
+    last_modification_timestamp: z.number(),
+    // Version
+    version: z.number().optional(),
+    is_published: z.boolean().optional(),
+    // Model selection
+    model: LlmModelSchema.nullable().optional(),
+    s2s_model: S2sModelSchema.nullable().optional(),
+    model_temperature: z.number().optional(),
+    model_high_priority: z.boolean().nullable().optional(),
+    tool_call_strict_mode: z.boolean().nullable().optional(),
+    // Knowledge base
+    knowledge_base_ids: z.array(z.string()).nullable().optional(),
+    kb_config: KbConfigSchema.nullable().optional(),
+    // Conversation
+    start_speaker: StartSpeakerSchema.optional(),
+    begin_after_user_silence_ms: z.number().nullable().optional(),
+    begin_message: z.string().nullable().optional(),
+    general_prompt: z.string().nullable().optional(),
+    // Tools & states
+    general_tools: z.array(LlmToolSchema).nullable().optional(),
+    states: z.array(LlmStateSchema).nullable().optional(),
+    starting_state: z.string().nullable().optional(),
+    // Dynamic variables
+    default_dynamic_variables: z
+        .record(z.string(), z.string())
+        .nullable()
+        .optional(),
+    // MCP
+    mcps: z.array(McpConfigSchema).nullable().optional(),
+});

package/dist/pagination.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Fetches all pages from a paginated Retell API list endpoint. The Retell API
+ * uses cursor-based pagination where the last item's ID and version are passed
+ * as the cursor for the next page.
+ */
+export declare function retellPagination<T>(
+/** The list API call, receiving pagination options. */
+op: (opts: {
+    limit?: number;
+    pagination_key?: string;
+    pagination_key_version?: number;
+}) => Promise<T[]>, 
+/** The property name used as the pagination key (e.g. "agent_id", "llm_id"). */
+idKey: keyof T & string, limit?: number): Promise<T[]>;

package/dist/pagination.js

@@ -0,0 +1,35 @@
+/**
+ * Fetches all pages from a paginated Retell API list endpoint. The Retell API
+ * uses cursor-based pagination where the last item's ID and version are passed
+ * as the cursor for the next page.
+ */
+export async function retellPagination(
+/** The list API call, receiving pagination options. */
+op, 
+/** The property name used as the pagination key (e.g. "agent_id", "llm_id"). */
+idKey, limit = 1000) {
+    const results = [];
+    let paginationKey;
+    let paginationKeyVersion;
+    while (true) {
+        const page = await op({
+            limit,
+            pagination_key: paginationKey,
+            pagination_key_version: paginationKeyVersion,
+        });
+        for (const item of page)
+            results.push(item);
+        if (page.length < limit)
+            break;
+        const lastItem = page.at(-1);
+        if (!lastItem)
+            break;
+        const id = lastItem[idKey];
+        if (typeof id !== "string")
+            break;
+        paginationKey = id;
+        const version = lastItem.version;
+        paginationKeyVersion = typeof version === "number" ? version : undefined;
+    }
+    return results;
+}

package/dist/phone-number.d.ts

@@ -0,0 +1,38 @@
+import { z } from "zod";
+/** Weighted agent entry used in phone number inbound/outbound lists. */
+export declare const PhoneNumberAgentEntrySchema: z.ZodObject<{
+    agent_id: z.ZodString;
+    agent_version: z.ZodOptional<z.ZodNumber>;
+    weight: z.ZodNumber;
+}, z.core.$strip>;
+/** Zod schema for a phone number response from the Retell API. */
+export declare const PhoneNumberResponseSchema: z.ZodObject<{
+    phone_number: z.ZodString;
+    phone_number_type: z.ZodOptional<z.ZodEnum<{
+        custom: "custom";
+        "retell-twilio": "retell-twilio";
+        "retell-telnyx": "retell-telnyx";
+    }>>;
+    nickname: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    last_modification_timestamp: z.ZodNumber;
+    inbound_agents: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        agent_id: z.ZodString;
+        agent_version: z.ZodOptional<z.ZodNumber>;
+        weight: z.ZodNumber;
+    }, z.core.$strip>>>>;
+    outbound_agents: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        agent_id: z.ZodString;
+        agent_version: z.ZodOptional<z.ZodNumber>;
+        weight: z.ZodNumber;
+    }, z.core.$strip>>>>;
+    inbound_sms_agents: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        agent_id: z.ZodString;
+        agent_version: z.ZodOptional<z.ZodNumber>;
+        weight: z.ZodNumber;
+    }, z.core.$strip>>>>;
+    outbound_sms_agents: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        agent_id: z.ZodString;
+        agent_version: z.ZodOptional<z.ZodNumber>;
+        weight: z.ZodNumber;
+    }, z.core.$strip>>>>;
+}, z.core.$strip>;

package/dist/phone-number.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+/** Weighted agent entry used in phone number inbound/outbound lists. */
+export const PhoneNumberAgentEntrySchema = z.object({
+    agent_id: z.string(),
+    agent_version: z.number().optional(),
+    weight: z.number(),
+});
+/** Zod schema for a phone number response from the Retell API. */
+export const PhoneNumberResponseSchema = z.object({
+    phone_number: z.string(),
+    phone_number_type: z
+        .enum(["retell-twilio", "retell-telnyx", "custom"])
+        .optional(),
+    nickname: z.string().nullable().optional(),
+    last_modification_timestamp: z.number(),
+    inbound_agents: z.array(PhoneNumberAgentEntrySchema).nullable().optional(),
+    outbound_agents: z.array(PhoneNumberAgentEntrySchema).nullable().optional(),
+    inbound_sms_agents: z
+        .array(PhoneNumberAgentEntrySchema)
+        .nullable()
+        .optional(),
+    outbound_sms_agents: z
+        .array(PhoneNumberAgentEntrySchema)
+        .nullable()
+        .optional(),
+});

package/dist/phone.d.ts

@@ -1,8 +1,11 @@
 import { z } from "zod";
-/** Validates an international E.164 phone number (`+` followed by 1–15 digits). */
-export declare const E164PhoneSchema: z.ZodString;
+/**
+ * Validates and normalizes a phone number to E.164 format (`+` followed by 1–15
+ * digits).
+ */
+export declare const e164PhoneSchema: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string | undefined, string>>, z.ZodString>;
 /**
  * E.164 phone number or null. Invalid, empty, or missing numbers are caught as
  * null — useful for `from_number` where caller ID may be unavailable.
  */
-export declare const e164OrNullSchema: z.ZodCatch<z.ZodNullable<z.ZodString>>;
+export declare const e164OrNullSchema: z.ZodCatch<z.ZodNullable<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string | undefined, string>>, z.ZodString>>>;

package/dist/phone.js

@@ -1,8 +1,15 @@
 import { z } from "zod";
-/** Validates an international E.164 phone number (`+` followed by 1–15 digits). */
-export const E164PhoneSchema = z.string().regex(/^\+[1-9]\d{1,14}$/);
+import { parsePhoneNumberFromString } from "libphonenumber-js";
+/**
+ * Validates and normalizes a phone number to E.164 format (`+` followed by 1–15
+ * digits).
+ */
+export const e164PhoneSchema = z
+    .string()
+    .transform((v) => parsePhoneNumberFromString(v, "US")?.format("E.164"))
+    .pipe(z.string().regex(/^\+[1-9]\d{1,14}$/));
 /**
  * E.164 phone number or null. Invalid, empty, or missing numbers are caught as
  * null — useful for `from_number` where caller ID may be unavailable.
  */
-export const e164OrNullSchema = E164PhoneSchema.nullable().catch(null);
+export const e164OrNullSchema = e164PhoneSchema.nullable().catch(null);

package/dist/test-case.d.ts

@@ -0,0 +1,76 @@
+import { z } from "zod";
+/** Zod schema for input match rule types in test case tool mocks. */
+export declare const InputMatchRuleSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"any">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"partial_match">;
+    args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>], "type">;
+/** Zod schema for tool mock configurations in test cases. */
+export declare const ToolMockSchema: z.ZodObject<{
+    tool_name: z.ZodString;
+    input_match_rule: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"any">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"partial_match">;
+        args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>], "type">;
+    output: z.ZodString;
+    result: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+}, z.core.$strip>;
+/** Zod schema for response engine references in test cases. */
+export declare const TestCaseResponseEngineSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"retell-llm">;
+    llm_id: z.ZodString;
+    version: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"conversation-flow">;
+    conversation_flow_id: z.ZodString;
+    version: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>], "type">;
+/** Zod schema for a test case definition from the Retell API. */
+export declare const TestCaseDefinitionSchema: z.ZodObject<{
+    test_case_definition_id: z.ZodString;
+    name: z.ZodString;
+    response_engine: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"retell-llm">;
+        llm_id: z.ZodString;
+        version: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"conversation-flow">;
+        conversation_flow_id: z.ZodString;
+        version: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>], "type">;
+    dynamic_variables: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    metrics: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    user_prompt: z.ZodString;
+    creation_timestamp: z.ZodNumber;
+    user_modified_timestamp: z.ZodNumber;
+    type: z.ZodLiteral<"simulation">;
+    tool_mocks: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        tool_name: z.ZodString;
+        input_match_rule: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"any">;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"partial_match">;
+            args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>], "type">;
+        output: z.ZodString;
+        result: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    }, z.core.$strip>>>>;
+    llm_model: z.ZodEnum<{
+        "gpt-4.1": "gpt-4.1";
+        "gpt-4.1-mini": "gpt-4.1-mini";
+        "gpt-4.1-nano": "gpt-4.1-nano";
+        "gpt-5": "gpt-5";
+        "gpt-5.1": "gpt-5.1";
+        "gpt-5.2": "gpt-5.2";
+        "gpt-5-mini": "gpt-5-mini";
+        "gpt-5-nano": "gpt-5-nano";
+        "claude-4.5-sonnet": "claude-4.5-sonnet";
+        "claude-4.5-haiku": "claude-4.5-haiku";
+        "gemini-2.5-flash": "gemini-2.5-flash";
+        "gemini-2.5-flash-lite": "gemini-2.5-flash-lite";
+        "gemini-3.0-flash": "gemini-3.0-flash";
+    }>;
+}, z.core.$strip>;

package/dist/test-case.js

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import { LlmModelSchema } from "./enums.js";
+/** Zod schema for input match rule types in test case tool mocks. */
+export const InputMatchRuleSchema = z.discriminatedUnion("type", [
+    z.object({ type: z.literal("any") }),
+    z.object({
+        type: z.literal("partial_match"),
+        args: z.record(z.string(), z.unknown()),
+    }),
+]);
+/** Zod schema for tool mock configurations in test cases. */
+export const ToolMockSchema = z.object({
+    tool_name: z.string(),
+    input_match_rule: InputMatchRuleSchema,
+    output: z.string(),
+    result: z.boolean().nullable().optional(),
+});
+/** Zod schema for response engine references in test cases. */
+export const TestCaseResponseEngineSchema = z.discriminatedUnion("type", [
+    z.object({
+        type: z.literal("retell-llm"),
+        llm_id: z.string(),
+        version: z.number().optional(),
+    }),
+    z.object({
+        type: z.literal("conversation-flow"),
+        conversation_flow_id: z.string(),
+        version: z.number().optional(),
+    }),
+]);
+/** Zod schema for a test case definition from the Retell API. */
+export const TestCaseDefinitionSchema = z.object({
+    test_case_definition_id: z.string(),
+    name: z.string(),
+    response_engine: TestCaseResponseEngineSchema,
+    dynamic_variables: z.record(z.string(), z.unknown()).optional().default({}),
+    metrics: z.array(z.string()).optional().default([]),
+    user_prompt: z.string(),
+    creation_timestamp: z.number(),
+    user_modified_timestamp: z.number(),
+    type: z.literal("simulation"),
+    tool_mocks: z.array(ToolMockSchema).optional().default([]),
+    llm_model: LlmModelSchema,
+});

package/dist/transcript.d.ts

@@ -11,8 +11,8 @@ export declare const WordTimestampSchema: z.ZodObject<{
  */
 export declare const UtteranceSchema: z.ZodObject<{
     role: z.ZodEnum<{
-        agent: "agent";
         user: "user";
+        agent: "agent";
         transfer_target: "transfer_target";
     }>;
     content: z.ZodString;
@@ -113,8 +113,8 @@ export declare const TranscriptEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject
  */
 export declare const TimestampedUtteranceSchema: z.ZodObject<{
     role: z.ZodEnum<{
-        agent: "agent";
         user: "user";
+        agent: "agent";
         transfer_target: "transfer_target";
     }>;
     content: z.ZodString;

package/dist/utils.d.ts

@@ -0,0 +1,18 @@
+/** Converts a string to snake_case, stripping non-alphanumeric characters. */
+export declare function toSnakeCase(str: string): string;
+/**
+ * Simple English pluralizer. Handles common suffix rules (-y -> -ies, add -s).
+ * Optionally prefixes the quantity.
+ */
+export declare function pluralize(word: string, q: number, includeQuantity?: boolean): string;
+/**
+ * Recursively searches through an object/array structure and replaces `file://`
+ * placeholders with resolved file contents. Mutates the structure in place.
+ *
+ * @param resolveFileContent Called with the relative file path (after stripping
+ *   the `file://` prefix) and should return the raw file content.
+ * @param transformContent Optional post-processor applied to each resolved
+ *   file's content before it replaces the placeholder (e.g. strip YAML
+ *   frontmatter from markdown).
+ */
+export declare function resolveFilePlaceholders(value: unknown, resolveFileContent: (filePath: string) => string | Promise<string>, transformContent?: (content: string) => string | Promise<string>): Promise<void>;

package/dist/utils.js

@@ -0,0 +1,63 @@
+/** Converts a string to snake_case, stripping non-alphanumeric characters. */
+export function toSnakeCase(str) {
+    return str
+        .replace(/\s+/g, "_")
+        .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+        .replace(/[^a-z0-9_]/gi, "")
+        .toLowerCase()
+        .replace(/_+/g, "_")
+        .replace(/^_|_$/g, "");
+}
+/**
+ * Simple English pluralizer. Handles common suffix rules (-y -> -ies, add -s).
+ * Optionally prefixes the quantity.
+ */
+export function pluralize(word, q, includeQuantity = false) {
+    let pluralWord = word;
+    if (q !== 1) {
+        if (word.endsWith("y") && !/[aeiou]y$/i.test(word)) {
+            pluralWord = `${word.slice(0, -1)}ies`;
+        }
+        else if (!word.endsWith("s")) {
+            pluralWord = `${word}s`;
+        }
+    }
+    const quantity = includeQuantity ? `${q} ` : "";
+    return `${quantity}${pluralWord}`;
+}
+/**
+ * Recursively searches through an object/array structure and replaces `file://`
+ * placeholders with resolved file contents. Mutates the structure in place.
+ *
+ * @param resolveFileContent Called with the relative file path (after stripping
+ *   the `file://` prefix) and should return the raw file content.
+ * @param transformContent Optional post-processor applied to each resolved
+ *   file's content before it replaces the placeholder (e.g. strip YAML
+ *   frontmatter from markdown).
+ */
+export async function resolveFilePlaceholders(value, resolveFileContent, transformContent) {
+    const resolveValue = async (val) => {
+        if (typeof val !== "string" || !val.startsWith("file://"))
+            return undefined;
+        const filePath = val.slice(7); // strip "file://"
+        const content = await resolveFileContent(filePath);
+        return transformContent ? transformContent(content) : content;
+    };
+    if (Array.isArray(value)) {
+        await Promise.all(value.map(async (item, i) => {
+            const resolved = await resolveValue(item);
+            if (resolved)
+                value[i] = resolved;
+            await resolveFilePlaceholders(item, resolveFileContent, transformContent);
+        }));
+    }
+    else if (value != null && typeof value === "object") {
+        const record = value;
+        await Promise.all(Object.entries(record).map(async ([key, propValue]) => {
+            const resolved = await resolveValue(propValue);
+            if (resolved)
+                record[key] = resolved;
+            await resolveFilePlaceholders(propValue, resolveFileContent, transformContent);
+        }));
+    }
+}

package/dist/webhook.d.ts

@@ -140,8 +140,8 @@ export declare const WebhookSchemas: {
             }, z.core.$strip>], "role">>>;
         }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
             call_type: z.ZodLiteral<"phone_call">;
-            from_number: z.ZodCatch<z.ZodNullable<z.ZodString>>;
-            to_number: z.ZodString;
+            from_number: z.ZodCatch<z.ZodNullable<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string | undefined, string>>, z.ZodString>>>;
+            to_number: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string | undefined, string>>, z.ZodString>;
             direction: z.ZodEnum<{
                 inbound: "inbound";
                 outbound: "outbound";
@@ -231,8 +231,8 @@ export declare const WebhookSchemas: {
             }, z.core.$strip>], "role">>>;
         }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
             call_type: z.ZodLiteral<"phone_call">;
-            from_number: z.ZodCatch<z.ZodNullable<z.ZodString>>;
-            to_number: z.ZodString;
+            from_number: z.ZodCatch<z.ZodNullable<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string | undefined, string>>, z.ZodString>>>;
+            to_number: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string | undefined, string>>, z.ZodString>;
             direction: z.ZodEnum<{
                 inbound: "inbound";
                 outbound: "outbound";
@@ -279,8 +279,8 @@ export declare const WebhookSchemas: {
             transcript: z.ZodOptional<z.ZodString>;
             transcript_object: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 role: z.ZodEnum<{
-                    agent: "agent";
                     user: "user";
+                    agent: "agent";
                     transfer_target: "transfer_target";
                 }>;
                 content: z.ZodString;
@@ -515,8 +515,8 @@ export declare const WebhookSchemas: {
             }, z.core.$strip>], "role">>>;
         }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
             call_type: z.ZodLiteral<"phone_call">;
-            from_number: z.ZodCatch<z.ZodNullable<z.ZodString>>;
-            to_number: z.ZodString;
+            from_number: z.ZodCatch<z.ZodNullable<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string | undefined, string>>, z.ZodString>>>;
+            to_number: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string | undefined, string>>, z.ZodString>;
             direction: z.ZodEnum<{
                 inbound: "inbound";
                 outbound: "outbound";
@@ -563,8 +563,8 @@ export declare const WebhookSchemas: {
             transcript: z.ZodOptional<z.ZodString>;
             transcript_object: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 role: z.ZodEnum<{
-                    agent: "agent";
                     user: "user";
+                    agent: "agent";
                     transfer_target: "transfer_target";
                 }>;
                 content: z.ZodString;
@@ -968,8 +968,8 @@ export declare const WebhookSchemas: {
             }, z.core.$strip>], "role">>>;
         }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
             call_type: z.ZodLiteral<"phone_call">;
-            from_number: z.ZodCatch<z.ZodNullable<z.ZodString>>;
-            to_number: z.ZodString;
+            from_number: z.ZodCatch<z.ZodNullable<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string | undefined, string>>, z.ZodString>>>;
+            to_number: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string | undefined, string>>, z.ZodString>;
             direction: z.ZodEnum<{
                 inbound: "inbound";
                 outbound: "outbound";
@@ -1058,8 +1058,8 @@ export declare const WebhookSchemas: {
             }, z.core.$strip>], "role">>>;
         }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
             call_type: z.ZodLiteral<"phone_call">;
-            from_number: z.ZodCatch<z.ZodNullable<z.ZodString>>;
-            to_number: z.ZodString;
+            from_number: z.ZodCatch<z.ZodNullable<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string | undefined, string>>, z.ZodString>>>;
+            to_number: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string | undefined, string>>, z.ZodString>;
             direction: z.ZodEnum<{
                 inbound: "inbound";
                 outbound: "outbound";
@@ -1106,8 +1106,8 @@ export declare const WebhookSchemas: {
             transcript: z.ZodOptional<z.ZodString>;
             transcript_object: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 role: z.ZodEnum<{
-                    agent: "agent";
                     user: "user";
+                    agent: "agent";
                     transfer_target: "transfer_target";
                 }>;
                 content: z.ZodString;
@@ -1341,8 +1341,8 @@ export declare const WebhookSchemas: {
             }, z.core.$strip>], "role">>>;
         }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
             call_type: z.ZodLiteral<"phone_call">;
-            from_number: z.ZodCatch<z.ZodNullable<z.ZodString>>;
-            to_number: z.ZodString;
+            from_number: z.ZodCatch<z.ZodNullable<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string | undefined, string>>, z.ZodString>>>;
+            to_number: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string | undefined, string>>, z.ZodString>;
             direction: z.ZodEnum<{
                 inbound: "inbound";
                 outbound: "outbound";
@@ -1389,8 +1389,8 @@ export declare const WebhookSchemas: {
             transcript: z.ZodOptional<z.ZodString>;
             transcript_object: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 role: z.ZodEnum<{
-                    agent: "agent";
                     user: "user";
+                    agent: "agent";
                     transfer_target: "transfer_target";
                 }>;
                 content: z.ZodString;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "retell-utils",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "description": "Type-safe Zod schemas for Retell AI API resources with lifecycle-aware discriminated unions and generic customization",
   "type": "module",
   "zshy": {
@@ -17,8 +17,9 @@
     "test": "bun test",
     "prepublishOnly": "bun run build"
   },
-  "peerDependencies": {
-    "zod": "^4.0.0"
+  "dependencies": {
+    "libphonenumber-js": "^1.12.36",
+    "zod": "^4.3.5"
   },
   "devDependencies": {
     "@types/bun": "latest",
@@ -27,7 +28,6 @@
     "prettier": "latest",
     "prettier-plugin-jsdoc": "^1.8.0",
     "typescript": "^5.8.3",
-    "zod": "^4.3.5",
     "zshy": "^0.7.0"
   },
   "license": "MIT",