@retell-ai/retell-cli 0.3.0

package/dist/src/runtime/multipart.js

@@ -0,0 +1,106 @@
+import { openAsBlob } from "node:fs";
+import { basename } from "node:path";
+import { schemaDefinitions } from "../generated/operations.js";
+import { fieldNameToFlag } from "./naming.js";
+import { assertValid } from "./validate.js";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseText(raw, schema, name) {
+    if (schema.type === "object") {
+        const value = JSON.parse(raw);
+        if (!isRecord(value))
+            throw new Error(`Multipart field ${name} expects a JSON object`);
+        return value;
+    }
+    if (schema.type === "array") {
+        if (!schema.items)
+            throw new Error(`Multipart field ${name} has no item schema`);
+        if (raw.trim().startsWith("[")) {
+            const value = JSON.parse(raw);
+            if (!Array.isArray(value))
+                throw new Error(`Multipart field ${name} expects a JSON array or repeated values`);
+            return value;
+        }
+        return [parseText(raw, schema.items, name)];
+    }
+    return raw;
+}
+function appendText(form, definition, value) {
+    if (definition.serialization === "json") {
+        if (definition.schema.type !== "array" && definition.schema.type !== "object") {
+            throw new Error(`Multipart field ${definition.name} has incompatible JSON serialization metadata`);
+        }
+        form.append(definition.name, JSON.stringify(value));
+        return;
+    }
+    if (definition.serialization === "file")
+        throw new Error(`Multipart field ${definition.name} has incompatible file serialization metadata`);
+    if (definition.schema.type === "array" || definition.schema.type === "object") {
+        throw new Error(`Multipart field ${definition.name} has incompatible text serialization metadata`);
+    }
+    if (definition.schema.format === "binary")
+        throw new Error(`Multipart field ${definition.name} has incompatible binary metadata`);
+    form.append(definition.name, typeof value === "string" ? value : JSON.stringify(value));
+}
+function assertCount(definition, count) {
+    if (!definition.array && count > 1)
+        throw new Error(`Multipart field ${definition.name} accepts exactly one value`);
+    if (definition.array && typeof definition.schema.minItems === "number" && count < definition.schema.minItems) {
+        throw new Error(`Multipart field ${definition.name} requires at least ${definition.schema.minItems} value(s)`);
+    }
+    if (definition.array && typeof definition.schema.maxItems === "number" && count > definition.schema.maxItems) {
+        throw new Error(`Multipart field ${definition.name} accepts at most ${definition.schema.maxItems} value(s)`);
+    }
+}
+function combinedText(rawValues, definition) {
+    if (!definition.array) {
+        assertCount(definition, rawValues.length);
+        return parseText(rawValues[0], definition.schema, definition.name);
+    }
+    if (!definition.schema.items)
+        throw new Error(`Multipart field ${definition.name} has no item schema`);
+    const values = rawValues.flatMap((raw) => {
+        const parsed = parseText(raw, definition.schema, definition.name);
+        return Array.isArray(parsed) ? parsed : [parsed];
+    });
+    assertCount(definition, values.length);
+    return values;
+}
+export async function prepareMultipartBody(operation, args) {
+    const body = new FormData();
+    const supplied = new Set();
+    const displayBody = {};
+    for (const [name, rawValues] of args.multipartValues) {
+        const definition = operation.requestBody?.multipartFields?.find((field) => field.name === name);
+        if (!definition)
+            throw new Error(`Unknown multipart field: ${name}`);
+        if (definition.file) {
+            if (definition.serialization !== "file")
+                throw new Error(`Multipart field ${name} has incompatible file serialization metadata`);
+            assertCount(definition, rawValues.length);
+            for (const filePath of rawValues) {
+                try {
+                    body.append(name, await openAsBlob(filePath), basename(filePath));
+                }
+                catch (cause) {
+                    const flag = fieldNameToFlag(name);
+                    throw new Error(`Cannot read ${filePath} for ${flag}. Check that the path exists and is readable.`, { cause });
+                }
+            }
+            displayBody[name] = definition.array ? rawValues : rawValues[0];
+        }
+        else {
+            const parsed = combinedText(rawValues, definition);
+            assertValid(parsed, definition.schema, schemaDefinitions, `requestBody.${name}`, { coerceStrings: true });
+            appendText(body, definition, parsed);
+            displayBody[name] = parsed;
+        }
+        supplied.add(name);
+    }
+    for (const field of operation.requestBody?.multipartFields ?? []) {
+        if (field.required && !supplied.has(field.name))
+            throw new Error(`Missing required option: ${fieldNameToFlag(field.name)}`);
+    }
+    return { body, displayBody };
+}

package/dist/src/runtime/naming.js

@@ -0,0 +1,3 @@
+export function fieldNameToFlag(name) {
+    return `--${name.replaceAll("_", "-")}`;
+}

package/dist/src/runtime/output.js

@@ -0,0 +1,43 @@
+function primitive(value) {
+    if (value === null || value === undefined)
+        return "";
+    if (typeof value === "object")
+        return JSON.stringify(value);
+    if (typeof value === "string")
+        return value.replace(/\s+/g, " ").trim();
+    return String(value);
+}
+export function resolveOutputFormat(format) {
+    return format ?? "json";
+}
+function tableRows(value, pagination) {
+    if (Array.isArray(value))
+        return value;
+    if (pagination && Array.isArray(value?.[pagination.itemsField]))
+        return value[pagination.itemsField];
+    return value && typeof value === "object" ? [value] : [{ value }];
+}
+function renderTable(value, pagination) {
+    const rows = tableRows(value, pagination);
+    if (!rows.length)
+        return "(no results)";
+    const columns = [...new Set(rows.flatMap((row) => Object.keys(row)))].slice(0, 10);
+    const widths = columns.map((column) => Math.min(40, Math.max(column.length, ...rows.map((row) => primitive(row[column]).length))));
+    const renderCell = (value, width) => {
+        const text = primitive(value);
+        const visible = text.length > width && width > 1 ? `${text.slice(0, width - 1)}…` : text.slice(0, width);
+        return visible.padEnd(width);
+    };
+    const renderRow = (row) => columns.map((column, index) => renderCell(row[column], widths[index])).join("  ").trimEnd();
+    return [renderRow(Object.fromEntries(columns.map((column) => [column, column]))), ...rows.map(renderRow)].join("\n");
+}
+export function renderOutput(value, format, pagination) {
+    if (format === "json")
+        return JSON.stringify(value, null, 2);
+    if (format === "jsonl") {
+        const items = pagination && value?.[pagination.itemsField];
+        const rows = Array.isArray(value) ? value : Array.isArray(items) ? items : [value];
+        return rows.map((row) => JSON.stringify(row)).join("\n");
+    }
+    return renderTable(value, pagination);
+}

package/dist/src/runtime/prompt.js

@@ -0,0 +1,91 @@
+import { createInterface } from "node:readline/promises";
+function fieldLabel(name) {
+    return name
+        .split("_")
+        .map((part) => part ? part[0].toUpperCase() + part.slice(1) : part)
+        .join(" ");
+}
+function compact(value) {
+    return value.replace(/\s+/g, " ").trim();
+}
+export function parsePromptValue(field, input) {
+    const value = input.trim();
+    if (!value)
+        throw new Error("A value is required");
+    if (field.nullable && value === "null")
+        return null;
+    let parsed;
+    if (field.type === "boolean") {
+        if (!/^(true|false)$/i.test(value))
+            throw new Error("Enter true or false");
+        parsed = value.toLowerCase() === "true";
+    }
+    else if (field.type === "integer" || field.type === "number") {
+        parsed = Number(value);
+        if (!Number.isFinite(parsed) || field.type === "integer" && !Number.isInteger(parsed)) {
+            throw new Error(`Enter a valid ${field.type}`);
+        }
+    }
+    else if (field.array || ["object", "oneOf", "anyOf", "unknown"].includes(field.type)) {
+        try {
+            parsed = JSON.parse(value);
+        }
+        catch {
+            throw new Error("Enter a valid JSON value");
+        }
+    }
+    else {
+        parsed = value;
+    }
+    if (field.enum?.length && !field.enum.some((candidate) => JSON.stringify(candidate) === JSON.stringify(parsed))) {
+        throw new Error(`Choose one of: ${field.enum.map((value) => typeof value === "string" ? value : JSON.stringify(value)).join(", ")}`);
+    }
+    return parsed;
+}
+function terminalDriver() {
+    const readline = createInterface({ input: process.stdin, output: process.stdout });
+    return {
+        write: (value) => process.stdout.write(value),
+        question: (value) => readline.question(value),
+        close: () => readline.close(),
+    };
+}
+export async function promptForRequiredJsonBody(operation, confirm, initial = {}, suppliedDriver) {
+    const fields = operation.requestBody?.fields?.filter((field) => field.required && !Object.hasOwn(initial, field.name)) ?? [];
+    if (!fields.length) {
+        return initial;
+    }
+    const driver = suppliedDriver ?? terminalDriver();
+    const result = { ...initial };
+    driver.write(`\n${operation.description.trim()}\n${fields.length} missing required field(s)\n`);
+    try {
+        for (const field of fields) {
+            driver.write(`\n${fieldLabel(field.name)} (required, ${field.type})\n`);
+            if (field.description)
+                driver.write(`${compact(field.description)}\n`);
+            if (field.example !== undefined)
+                driver.write(`Example: ${typeof field.example === "string" ? field.example : JSON.stringify(field.example)}\n`);
+            if (field.enum?.length)
+                driver.write(`Allowed: ${field.enum.map((value) => typeof value === "string" ? value : JSON.stringify(value)).join(", ")}\n`);
+            while (true) {
+                const input = await driver.question("> ");
+                try {
+                    result[field.name] = parsePromptValue(field, input);
+                    break;
+                }
+                catch (error) {
+                    driver.write(`${error instanceof Error ? error.message : String(error)}\n`);
+                }
+            }
+        }
+        if (confirm) {
+            const answer = (await driver.question("\nSend request? [Y/n] ")).trim().toLowerCase();
+            if (answer && answer !== "y" && answer !== "yes")
+                throw new Error("Request cancelled");
+        }
+        return result;
+    }
+    finally {
+        driver.close();
+    }
+}

package/dist/src/runtime/request.js

@@ -0,0 +1,179 @@
+import { readFile } from "node:fs/promises";
+import { schemaDefinitions } from "../generated/operations.js";
+import { prepareMultipartBody } from "./multipart.js";
+import { promptForRequiredJsonBody } from "./prompt.js";
+import { isSensitiveName, redactSecrets } from "./security.js";
+import { assertValid } from "./validate.js";
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(Buffer.from(chunk));
+    return Buffer.concat(chunks).toString("utf8");
+}
+async function readBody(file) {
+    return file === "-" ? readStdin() : readFile(file, "utf8");
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parameterValue(parameter, rawValues) {
+    let value;
+    if (parameter.array) {
+        if (rawValues.length === 1 && rawValues[0].trim().startsWith("[")) {
+            const parsed = JSON.parse(rawValues[0]);
+            if (!Array.isArray(parsed))
+                throw new Error(`${parameter.flag} expects a JSON array or repeated values`);
+            value = parsed.map((item) => String(item));
+        }
+        else {
+            value = rawValues;
+        }
+    }
+    else if (parameter.type === "object") {
+        if (rawValues.length !== 1)
+            throw new Error(`${parameter.flag} expects one JSON object`);
+        const parsed = JSON.parse(rawValues[0]);
+        if (!isRecord(parsed))
+            throw new Error(`${parameter.flag} expects a JSON object`);
+        value = parsed;
+    }
+    else {
+        value = rawValues.at(-1) ?? "";
+    }
+    assertValid(value, parameter.validationSchema, schemaDefinitions, `parameter.${parameter.name}`, { coerceStrings: true });
+    return value;
+}
+function scalar(value) {
+    return typeof value === "string" ? value : JSON.stringify(value);
+}
+function simpleValue(parameter, rawValues, encode) {
+    const value = parameterValue(parameter, rawValues);
+    if (Array.isArray(value))
+        return value.map((item) => encode(scalar(item))).join(",");
+    if (isRecord(value)) {
+        return Object.entries(value)
+            .flatMap(([key, item]) => parameter.explode ? [`${encode(key)}=${encode(scalar(item))}`] : [encode(key), encode(scalar(item))])
+            .join(",");
+    }
+    return encode(value);
+}
+function queryPairs(parameter, rawValues) {
+    const value = parameterValue(parameter, rawValues);
+    if (Array.isArray(value)) {
+        if (parameter.style === "form" && parameter.explode)
+            return value.map((item) => [parameter.name, scalar(item)]);
+        const separator = parameter.style === "spaceDelimited" ? " " : parameter.style === "pipeDelimited" ? "|" : ",";
+        return [[parameter.name, value.map(scalar).join(separator)]];
+    }
+    if (isRecord(value)) {
+        if (parameter.style === "deepObject")
+            return Object.entries(value).map(([key, item]) => [`${parameter.name}[${key}]`, scalar(item)]);
+        if (parameter.explode)
+            return Object.entries(value).map(([key, item]) => [key, scalar(item)]);
+        return [[parameter.name, Object.entries(value).flatMap(([key, item]) => [key, scalar(item)]).join(",")]];
+    }
+    return [[parameter.name, value]];
+}
+export async function prepareRequest(operation, args, apiKey, defaultBaseUrl) {
+    let path = operation.path;
+    for (const [name, rawValue] of args.pathValues) {
+        const parameter = operation.parameters.find((candidate) => candidate.in === "path" && candidate.name === name);
+        path = path.replace(`{${name}}`, simpleValue(parameter, [rawValue], encodeURIComponent));
+    }
+    const url = new URL(path, args.baseUrl ?? defaultBaseUrl);
+    for (const [name, values] of args.queryValues) {
+        const parameter = operation.parameters.find((candidate) => candidate.in === "query" && candidate.name === name);
+        for (const [key, value] of queryPairs(parameter, values))
+            url.searchParams.append(key, value);
+    }
+    if (operation.authenticated && !apiKey && !args.dryRun) {
+        throw new Error("No Retell API key is configured. Run 'retell auth login' or set RETELL_API_KEY.");
+    }
+    const headers = new Headers({ Accept: "application/json" });
+    if (operation.authenticated && apiKey)
+        headers.set("Authorization", `Bearer ${apiKey}`);
+    for (const [name, values] of args.headerValues) {
+        const parameter = operation.parameters.find((candidate) => candidate.in === "header" && candidate.name === name);
+        headers.set(name, simpleValue(parameter, values, (value) => value));
+    }
+    const cookies = [];
+    for (const [name, values] of args.cookieValues) {
+        const parameter = operation.parameters.find((candidate) => candidate.in === "cookie" && candidate.name === name);
+        for (const [key, value] of queryPairs(parameter, values))
+            cookies.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
+    }
+    if (cookies.length)
+        headers.set("Cookie", cookies.join("; "));
+    const request = { url: url.toString(), init: { method: operation.method, headers, redirect: "manual" } };
+    if (operation.requestBody?.contentType === "application/json") {
+        let bodyText;
+        if (args.bodyFile)
+            bodyText = await readBody(args.bodyFile);
+        else if (!process.stdin.isTTY)
+            bodyText = await readStdin();
+        let parsed;
+        if (bodyText?.trim()) {
+            parsed = JSON.parse(bodyText);
+        }
+        if (args.bodyValues.size) {
+            if (parsed === undefined)
+                parsed = {};
+            if (!isRecord(parsed))
+                throw new Error("JSON body flags can only be combined with an object request body.");
+            for (const [name, value] of args.bodyValues)
+                parsed[name] = value;
+        }
+        const requiredFields = operation.requestBody.fields?.filter((field) => field.required) ?? [];
+        if (parsed !== undefined && requiredFields.length && !isRecord(parsed)) {
+            throw new Error("This operation requires a JSON object request body.");
+        }
+        const supplied = isRecord(parsed) ? parsed : {};
+        const missing = requiredFields.filter((field) => !Object.hasOwn(supplied, field.name));
+        if (missing.length && process.stdin.isTTY && process.stdout.isTTY) {
+            parsed = await promptForRequiredJsonBody(operation, !args.dryRun, supplied);
+        }
+        else if (missing.length) {
+            throw new Error(`Missing required JSON body option(s): ${missing.map((field) => field.flag).join(", ")}. Use flags, --body FILE, or stdin.`);
+        }
+        else if (parsed === undefined && operation.requestBody.required && process.stdin.isTTY && process.stdout.isTTY) {
+            parsed = await promptForRequiredJsonBody(operation, !args.dryRun);
+        }
+        else if (parsed === undefined && operation.requestBody.required) {
+            throw new Error(`A JSON request body is required. Use body flags, --body FILE, or pipe JSON to stdin.`);
+        }
+        if (parsed !== undefined) {
+            assertValid(parsed, operation.requestBody.validationSchema, schemaDefinitions, "requestBody");
+            request.init.body = JSON.stringify(parsed);
+            headers.set("Content-Type", "application/json");
+            request.displayBody = parsed;
+        }
+    }
+    if (operation.requestBody?.contentType === "multipart/form-data") {
+        const multipart = await prepareMultipartBody(operation, args);
+        request.init.body = multipart.body;
+        request.displayBody = multipart.displayBody;
+    }
+    return request;
+}
+export function dryRunOutput(operation, request) {
+    const headers = Object.fromEntries(new Headers(request.init.headers).entries());
+    if (operation.authenticated)
+        headers.authorization = headers.authorization ? "Bearer [REDACTED]" : "Bearer <RETELL_API_KEY>";
+    for (const name of Object.keys(headers)) {
+        if (name !== "authorization" && isSensitiveName(name))
+            headers[name] = "[REDACTED]";
+    }
+    const url = new URL(request.url);
+    for (const name of [...new Set(url.searchParams.keys())]) {
+        if (isSensitiveName(name))
+            url.searchParams.set(name, "[REDACTED]");
+    }
+    return {
+        operationId: operation.operationId,
+        command: operation.command,
+        method: operation.method,
+        url: url.toString(),
+        headers,
+        body: redactSecrets(request.displayBody),
+    };
+}

package/dist/src/runtime/security.js

@@ -0,0 +1,13 @@
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function isSensitiveName(name) {
+    return /(?:^|[-_])(authorization|cookie|api[-_]?key|token|secret|password)(?:$|[-_])/i.test(name);
+}
+export function redactSecrets(value) {
+    if (Array.isArray(value))
+        return value.map(redactSecrets);
+    if (!isRecord(value))
+        return value;
+    return Object.fromEntries(Object.entries(value).map(([name, child]) => [name, isSensitiveName(name) ? "[REDACTED]" : redactSecrets(child)]));
+}

package/dist/src/runtime/validate.js

@@ -0,0 +1,172 @@
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sameValue(left, right) {
+    if (Object.is(left, right))
+        return true;
+    if (Array.isArray(left) && Array.isArray(right)) {
+        return left.length === right.length && left.every((value, index) => sameValue(value, right[index]));
+    }
+    if (isRecord(left) && isRecord(right)) {
+        const leftKeys = Object.keys(left).sort();
+        const rightKeys = Object.keys(right).sort();
+        return sameValue(leftKeys, rightKeys) && leftKeys.every((key) => sameValue(left[key], right[key]));
+    }
+    return false;
+}
+function coerce(value, type, enabled) {
+    if (!enabled || typeof value !== "string")
+        return value;
+    if (type === "boolean" && (value === "true" || value === "false"))
+        return value === "true";
+    if (type === "integer" && /^-?(?:0|[1-9]\d*)$/.test(value))
+        return Number(value);
+    if (type === "number" && /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(value))
+        return Number(value);
+    if (type === "null" && value === "null")
+        return null;
+    return value;
+}
+function typeMatches(value, type) {
+    if (type === "null")
+        return value === null;
+    if (type === "array")
+        return Array.isArray(value);
+    if (type === "object")
+        return isRecord(value);
+    if (type === "integer")
+        return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value);
+    if (type === "number")
+        return typeof value === "number" && Number.isFinite(value);
+    return typeof value === type;
+}
+function childPath(path, key) {
+    return typeof key === "number" ? `${path}[${key}]` : `${path}.${key}`;
+}
+function validate(value, schema, definitions, path, options, depth) {
+    if (depth > 100)
+        return [`${path} exceeds the supported validation depth`];
+    if (schema === true || schema === undefined)
+        return [];
+    if (schema === false)
+        return [`${path} is forbidden by the OpenAPI schema`];
+    if (!isRecord(schema))
+        return [`${path} has an invalid generated validation schema`];
+    const errors = [];
+    if (schema.readOnly === true)
+        errors.push(`${path} is read-only and cannot be sent in a request`);
+    if (value === null && schema.nullable === true)
+        return errors;
+    if (typeof schema.$ref === "string") {
+        const prefix = "#/components/schemas/";
+        if (!schema.$ref.startsWith(prefix))
+            return [`${path} uses unsupported schema reference ${schema.$ref}`];
+        const name = schema.$ref.slice(prefix.length).replace(/~1/g, "/").replace(/~0/g, "~");
+        const target = definitions[name];
+        if (!target)
+            return [`${path} references missing schema ${name}`];
+        errors.push(...validate(value, target, definitions, path, options, depth + 1));
+    }
+    const variants = (key) => Array.isArray(schema[key]) ? schema[key] : [];
+    for (const part of variants("allOf"))
+        errors.push(...validate(value, part, definitions, path, options, depth + 1));
+    const anyOf = variants("anyOf");
+    if (anyOf.length) {
+        const branchErrors = anyOf.map((part) => validate(value, part, definitions, path, options, depth + 1));
+        if (!branchErrors.some((issues) => issues.length === 0)) {
+            const closest = branchErrors.reduce((best, issues) => issues.length < best.length ? issues : best);
+            errors.push(`${path} does not match any allowed schema`, ...closest);
+        }
+    }
+    const oneOf = variants("oneOf");
+    if (oneOf.length) {
+        const branchErrors = oneOf.map((part) => validate(value, part, definitions, path, options, depth + 1));
+        const matches = branchErrors.filter((issues) => issues.length === 0).length;
+        if (matches !== 1) {
+            errors.push(`${path} must match exactly one allowed schema (matched ${matches})`);
+            if (matches === 0)
+                errors.push(...branchErrors.reduce((best, issues) => issues.length < best.length ? issues : best));
+        }
+    }
+    if (schema.not !== undefined && validate(value, schema.not, definitions, path, options, depth + 1).length === 0) {
+        errors.push(`${path} matches a forbidden schema`);
+    }
+    const rawTypes = Array.isArray(schema.type) ? schema.type : typeof schema.type === "string" ? [schema.type] : [];
+    const candidateTypes = rawTypes.filter((type) => typeof type === "string");
+    const effectiveValues = candidateTypes.map((type) => coerce(value, type, options.coerceStrings === true));
+    const matchedIndex = candidateTypes.findIndex((type, index) => typeMatches(effectiveValues[index], type));
+    if (candidateTypes.length && matchedIndex < 0) {
+        errors.push(`${path} must be ${candidateTypes.join(" or ")}; received ${Array.isArray(value) ? "array" : value === null ? "null" : typeof value}`);
+        return errors;
+    }
+    const effective = matchedIndex >= 0 ? effectiveValues[matchedIndex] : value;
+    if (Array.isArray(schema.enum) && !schema.enum.some((allowed) => sameValue(effective, allowed))) {
+        errors.push(`${path} must be one of ${schema.enum.map((item) => JSON.stringify(item)).join(", ")}`);
+    }
+    if (Object.hasOwn(schema, "const") && !sameValue(effective, schema.const))
+        errors.push(`${path} must equal ${JSON.stringify(schema.const)}`);
+    if (typeof effective === "number") {
+        const minimum = typeof schema.minimum === "number" ? schema.minimum : undefined;
+        const maximum = typeof schema.maximum === "number" ? schema.maximum : undefined;
+        if (minimum !== undefined && (schema.exclusiveMinimum === true ? effective <= minimum : effective < minimum)) {
+            errors.push(`${path} must be ${schema.exclusiveMinimum === true ? ">" : ">="} ${minimum}`);
+        }
+        if (maximum !== undefined && (schema.exclusiveMaximum === true ? effective >= maximum : effective > maximum)) {
+            errors.push(`${path} must be ${schema.exclusiveMaximum === true ? "<" : "<="} ${maximum}`);
+        }
+        if (typeof schema.exclusiveMinimum === "number" && effective <= schema.exclusiveMinimum)
+            errors.push(`${path} must be > ${schema.exclusiveMinimum}`);
+        if (typeof schema.exclusiveMaximum === "number" && effective >= schema.exclusiveMaximum)
+            errors.push(`${path} must be < ${schema.exclusiveMaximum}`);
+        if (typeof schema.multipleOf === "number" && Math.abs(effective / schema.multipleOf - Math.round(effective / schema.multipleOf)) > 1e-10) {
+            errors.push(`${path} must be a multiple of ${schema.multipleOf}`);
+        }
+    }
+    if (typeof effective === "string") {
+        if (typeof schema.minLength === "number" && [...effective].length < schema.minLength)
+            errors.push(`${path} must contain at least ${schema.minLength} characters`);
+        if (typeof schema.maxLength === "number" && [...effective].length > schema.maxLength)
+            errors.push(`${path} must contain at most ${schema.maxLength} characters`);
+        if (typeof schema.pattern === "string" && !new RegExp(schema.pattern).test(effective))
+            errors.push(`${path} must match ${schema.pattern}`);
+    }
+    if (Array.isArray(effective)) {
+        if (typeof schema.minItems === "number" && effective.length < schema.minItems)
+            errors.push(`${path} must contain at least ${schema.minItems} items`);
+        if (typeof schema.maxItems === "number" && effective.length > schema.maxItems)
+            errors.push(`${path} must contain at most ${schema.maxItems} items`);
+        if (schema.uniqueItems === true && effective.some((item, index) => effective.slice(0, index).some((prior) => sameValue(item, prior)))) {
+            errors.push(`${path} must contain unique items`);
+        }
+        if (schema.items !== undefined) {
+            effective.forEach((item, index) => errors.push(...validate(item, schema.items, definitions, childPath(path, index), options, depth + 1)));
+        }
+    }
+    if (isRecord(effective)) {
+        const keys = Object.keys(effective);
+        if (typeof schema.minProperties === "number" && keys.length < schema.minProperties)
+            errors.push(`${path} must contain at least ${schema.minProperties} properties`);
+        if (typeof schema.maxProperties === "number" && keys.length > schema.maxProperties)
+            errors.push(`${path} must contain at most ${schema.maxProperties} properties`);
+        const properties = isRecord(schema.properties) ? schema.properties : {};
+        const required = Array.isArray(schema.required) ? schema.required.filter((name) => typeof name === "string") : [];
+        for (const name of required)
+            if (!Object.hasOwn(effective, name))
+                errors.push(`${childPath(path, name)} is required`);
+        for (const [name, child] of Object.entries(effective)) {
+            if (Object.hasOwn(properties, name))
+                errors.push(...validate(child, properties[name], definitions, childPath(path, name), options, depth + 1));
+            else if (schema.additionalProperties === false)
+                errors.push(`${childPath(path, name)} is not allowed`);
+            else if (isRecord(schema.additionalProperties) || typeof schema.additionalProperties === "boolean") {
+                errors.push(...validate(child, schema.additionalProperties, definitions, childPath(path, name), options, depth + 1));
+            }
+        }
+    }
+    return errors;
+}
+export function assertValid(value, schema, definitions, path, options = {}) {
+    const errors = [...new Set(validate(value, schema, definitions, path, options, 0))];
+    if (errors.length)
+        throw new Error(`OpenAPI validation failed: ${errors.slice(0, 8).join("; ")}${errors.length > 8 ? `; and ${errors.length - 8} more` : ""}`);
+}

package/dist/src/runtime/version.js

@@ -0,0 +1,9 @@
+import { readFileSync } from "node:fs";
+export function cliVersion() {
+    const packageUrl = new URL("../../../package.json", import.meta.url);
+    const metadata = JSON.parse(readFileSync(packageUrl, "utf8"));
+    if (typeof metadata.version !== "string" || !metadata.version) {
+        throw new Error("CLI package version is missing from package.json");
+    }
+    return metadata.version;
+}

package/dist/src/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@retell-ai/retell-cli",
+  "version": "0.3.0",
+  "description": "Generated command line interface for the Retell API",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/RetellAI/retell-cli.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "bin": {
+    "retell": "dist/src/index.js"
+  },
+  "files": [
+    "dist/src",
+    "LICENSE",
+    "NOTICE",
+    "THIRD_PARTY_NOTICES.md"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "license:check": "node scripts/check-licenses.mjs",
+    "prepack": "pnpm build",
+    "release:check": "node scripts/check-release-version.mjs",
+    "test": "node --test dist/test/*.test.js"
+  },
+  "dependencies": {
+    "@napi-rs/keyring": "^1.3.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "typescript": "^5.9.0"
+  }
+}