@retell-ai/retell-cli 0.3.0

package/dist/src/index.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+import { catalogMetadata, operations as generatedOperations } from "./generated/operations.js";
+import { parseArguments } from "./runtime/args.js";
+import { handleAuth } from "./runtime/auth.js";
+import { resolveApiKey } from "./runtime/credentials.js";
+import { commandHelp, rootHelp } from "./runtime/help.js";
+import { sendRequest } from "./runtime/http.js";
+import { renderOutput, resolveOutputFormat } from "./runtime/output.js";
+import { dryRunOutput, prepareRequest } from "./runtime/request.js";
+import { cliVersion } from "./runtime/version.js";
+const operations = generatedOperations;
+async function main() {
+    const [first, ...rest] = process.argv.slice(2);
+    if (!first || first === "--help" || first === "-h" || first === "help" && !rest[0]) {
+        process.stdout.write(rootHelp(operations));
+        return;
+    }
+    if (first === "--version" || first === "version") {
+        process.stdout.write(`retell ${cliVersion()} (OpenAPI ${catalogMetadata.apiVersion}, catalog v${catalogMetadata.schemaVersion})\n`);
+        return;
+    }
+    if (first === "auth") {
+        await handleAuth(rest);
+        return;
+    }
+    const commandName = first === "help" ? rest.shift() : first;
+    const operation = operations.find((candidate) => candidate.command === commandName);
+    if (!operation)
+        throw new Error(`Unknown command: ${commandName}. Run 'retell --help' to list commands.`);
+    if (first === "help" || rest.includes("--help") || rest.includes("-h")) {
+        process.stdout.write(commandHelp(operation));
+        return;
+    }
+    const args = parseArguments(operation, rest);
+    const credential = await resolveApiKey();
+    const request = await prepareRequest(operation, args, credential.value, catalogMetadata.server);
+    if (args.dryRun) {
+        process.stdout.write(`${JSON.stringify(dryRunOutput(operation, request), null, 2)}\n`);
+        return;
+    }
+    const response = await sendRequest(operation, request.url, request.init);
+    const text = await response.text();
+    const value = text ? (() => { try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    } })() : null;
+    if (!response.ok) {
+        const requestId = response.headers.get("x-request-id");
+        throw new Error(`Retell API request failed (${response.status}${requestId ? `, request ${requestId}` : ""}): ${typeof value === "string" ? value : JSON.stringify(value)}`);
+    }
+    const format = resolveOutputFormat(args.output);
+    process.stdout.write(`${renderOutput(value, format, operation.pagination)}\n`);
+}
+main().catch((error) => {
+    process.stderr.write(`Error: ${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 1;
+});

package/dist/src/runtime/args.js

@@ -0,0 +1,92 @@
+import { fieldNameToFlag } from "./naming.js";
+import { parsePromptValue } from "./prompt.js";
+function takeValue(tokens, index, flag) {
+    const value = tokens[index + 1];
+    if (value === undefined || value.startsWith("--"))
+        throw new Error(`${flag} requires a value`);
+    return [value, index + 1];
+}
+function parameterForFlag(operation, flag) {
+    return operation.parameters.find((parameter) => parameter.in !== "path" && parameter.flag === flag);
+}
+function bodyFieldForFlag(operation, flag) {
+    return operation.requestBody?.contentType === "application/json"
+        ? operation.requestBody.fields?.find((field) => field.flag === flag)
+        : undefined;
+}
+function multipartFieldForFlag(operation, flag) {
+    return operation.requestBody?.contentType === "multipart/form-data"
+        ? operation.requestBody.multipartFields?.find((field) => fieldNameToFlag(field.name) === flag)
+        : undefined;
+}
+export function parseArguments(operation, tokens) {
+    const result = {
+        pathValues: new Map(),
+        queryValues: new Map(),
+        headerValues: new Map(),
+        cookieValues: new Map(),
+        bodyValues: new Map(),
+        multipartValues: new Map(),
+        dryRun: false,
+    };
+    const positionals = [];
+    for (let index = 0; index < tokens.length; index += 1) {
+        const token = tokens[index];
+        if (!token.startsWith("-")) {
+            positionals.push(token);
+            continue;
+        }
+        if (token === "--dry-run") {
+            result.dryRun = true;
+            continue;
+        }
+        if (token === "--body" || token === "--output" || token === "--base-url") {
+            const [value, consumed] = takeValue(tokens, index, token);
+            index = consumed;
+            if (token === "--body")
+                result.bodyFile = value;
+            if (token === "--base-url")
+                result.baseUrl = value;
+            if (token === "--output") {
+                if (!new Set(["table", "json", "jsonl"]).has(value))
+                    throw new Error(`Unsupported output format: ${value}`);
+                result.output = value;
+            }
+            continue;
+        }
+        const parameter = parameterForFlag(operation, token);
+        const bodyField = bodyFieldForFlag(operation, token);
+        const multipartField = multipartFieldForFlag(operation, token);
+        if (!parameter && !bodyField && !multipartField)
+            throw new Error(`Unknown option for ${operation.command}: ${token}`);
+        let value;
+        const type = parameter?.type ?? bodyField?.type ?? multipartField.type;
+        if (type === "boolean" && (tokens[index + 1] === undefined || tokens[index + 1].startsWith("-"))) {
+            value = "true";
+        }
+        else {
+            const taken = takeValue(tokens, index, token);
+            value = taken[0];
+            index = taken[1];
+        }
+        if (parameter) {
+            const values = parameter.in === "query" ? result.queryValues : parameter.in === "header" ? result.headerValues : result.cookieValues;
+            values.set(parameter.name, [...(values.get(parameter.name) ?? []), value]);
+        }
+        else if (bodyField)
+            result.bodyValues.set(bodyField.name, parsePromptValue(bodyField, value));
+        else
+            result.multipartValues.set(multipartField.name, [...(result.multipartValues.get(multipartField.name) ?? []), value]);
+    }
+    const pathParameters = operation.parameters.filter((parameter) => parameter.in === "path");
+    if (positionals.length !== pathParameters.length) {
+        throw new Error(`${operation.command} expects ${pathParameters.length} path argument(s), received ${positionals.length}`);
+    }
+    pathParameters.forEach((parameter, index) => result.pathValues.set(parameter.name, positionals[index]));
+    for (const parameter of operation.parameters.filter((item) => item.in !== "path" && item.required)) {
+        const values = parameter.in === "query" ? result.queryValues : parameter.in === "header" ? result.headerValues : result.cookieValues;
+        if (!values.has(parameter.name))
+            throw new Error(`Missing required option: ${parameter.flag}`);
+    }
+    return result;
+}

package/dist/src/runtime/auth.js

@@ -0,0 +1,116 @@
+import { clearApiKey, maskApiKey, resolveApiKey, storeApiKey } from "./credentials.js";
+function authHelp() {
+    return `Manage Retell API authentication.\n\n` +
+        `Usage:\n` +
+        `  retell auth login [--with-token]\n` +
+        `  retell auth whoami\n` +
+        `  retell auth logout\n\n` +
+        `Commands:\n` +
+        `  login    Prompt for and securely store a Retell API key\n` +
+        `  whoami   Show whether authentication is configured and its source\n` +
+        `  logout   Delete the stored Retell API key\n\n` +
+        `RETELL_API_KEY overrides any stored credential.\n`;
+}
+async function readAllStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(Buffer.from(chunk));
+    return Buffer.concat(chunks).toString("utf8");
+}
+async function promptHidden(prompt) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY || !process.stdin.setRawMode) {
+        throw new Error("Interactive login requires a terminal. Pipe the key to 'retell auth login --with-token' instead.");
+    }
+    process.stdout.write(prompt);
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding("utf8");
+    return new Promise((resolve, reject) => {
+        let value = "";
+        const cleanup = () => {
+            process.stdin.setRawMode(false);
+            process.stdin.pause();
+            process.stdin.removeListener("data", onData);
+            process.stdout.write("\n");
+        };
+        const onData = (chunk) => {
+            for (const character of chunk) {
+                if (character === "\u0003") {
+                    cleanup();
+                    reject(new Error("Login cancelled"));
+                    return;
+                }
+                if (character === "\r" || character === "\n") {
+                    cleanup();
+                    resolve(value);
+                    return;
+                }
+                if (character === "\u007f" || character === "\b")
+                    value = value.slice(0, -1);
+                else
+                    value += character;
+            }
+        };
+        process.stdin.on("data", onData);
+    });
+}
+export async function handleAuth(tokens) {
+    const [command, ...options] = tokens;
+    if (!command || command === "--help" || command === "-h") {
+        process.stdout.write(authHelp());
+        return;
+    }
+    if (command === "login") {
+        if (options.some((option) => option !== "--with-token" && option !== "--help" && option !== "-h")) {
+            throw new Error(`Unknown auth login option: ${options.find((option) => !["--with-token", "--help", "-h"].includes(option))}`);
+        }
+        if (options.includes("--help") || options.includes("-h")) {
+            process.stdout.write(`Store a Retell API key.\n\nUsage:\n  retell auth login\n  printf '%s' "$RETELL_API_KEY" | retell auth login --with-token\n`);
+            return;
+        }
+        const current = await resolveApiKey();
+        if (current.source !== "unset") {
+            process.stdout.write(`Already authenticated.\nSource: ${current.source}\nAPI key: ${maskApiKey(current.value)}\n`);
+        }
+        if (current.source === "env") {
+            const guidance = "RETELL_API_KEY overrides stored credentials. Run 'unset RETELL_API_KEY' in this shell before logging in with a different key.";
+            if (options.includes("--with-token"))
+                throw new Error(guidance);
+            process.stdout.write(`${guidance}\n`);
+            return;
+        }
+        const token = options.includes("--with-token")
+            ? await readAllStdin()
+            : await promptHidden(current.source === "unset" ? "Retell API key: " : "New Retell API key (press Enter to keep current): ");
+        if (!token.trim() && current.source !== "unset") {
+            process.stdout.write("Existing Retell API key kept unchanged.\n");
+            return;
+        }
+        const source = await storeApiKey(token);
+        process.stdout.write(source === "keyring"
+            ? "Retell API key stored in the OS keychain.\n"
+            : "OS keychain unavailable; Retell API key stored in ~/.config/retell/credentials.json with mode 0600.\n");
+        return;
+    }
+    if (command === "whoami") {
+        const credential = await resolveApiKey();
+        process.stdout.write(`Authentication: ${credential.source === "unset" ? "not configured" : "configured"}\n`);
+        process.stdout.write(`Source: ${credential.source}\n`);
+        process.stdout.write(`API key: ${maskApiKey(credential.value)}\n`);
+        return;
+    }
+    if (command === "logout") {
+        const remainingSource = await clearApiKey();
+        if (remainingSource === "env") {
+            process.stdout.write("Stored Retell API credentials cleared.\n");
+            process.stdout.write("WARNING: Authentication is still active through RETELL_API_KEY. Run 'unset RETELL_API_KEY' in this shell to finish logging out.\n");
+            return;
+        }
+        if (remainingSource !== "unset") {
+            throw new Error(`Failed to clear the ${remainingSource} credential; authentication is still active.`);
+        }
+        process.stdout.write("Logged out. Stored Retell API credentials were cleared.\n");
+        return;
+    }
+    throw new Error(`Unknown auth command: ${command}. Run 'retell auth --help'.`);
+}

package/dist/src/runtime/credentials.js

@@ -0,0 +1,102 @@
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { chmod, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+const KEYRING_SERVICE = "retell-cli";
+const KEYRING_ACCOUNT = "api-key";
+function credentialsPath() {
+    const configDir = process.env.RETELL_CONFIG_DIR ?? join(homedir(), ".config", "retell");
+    return join(configDir, "credentials.json");
+}
+export function normalizeApiKey(value) {
+    return value.trim().replace(/^Bearer\s+/i, "").trim();
+}
+export function maskApiKey(value) {
+    if (!value)
+        return "not configured";
+    if (value.length <= 8)
+        return "********";
+    return `${value.slice(0, 3)}${"*".repeat(Math.min(12, value.length - 7))}${value.slice(-4)}`;
+}
+async function keyringEntry() {
+    if (process.env.RETELL_DISABLE_KEYRING === "1")
+        throw new Error("keyring disabled");
+    const { Entry } = await import("@napi-rs/keyring");
+    return new Entry(KEYRING_SERVICE, KEYRING_ACCOUNT);
+}
+async function readKeyring() {
+    try {
+        const entry = await keyringEntry();
+        const value = normalizeApiKey(entry.getPassword() ?? "");
+        return value || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function writeKeyring(value) {
+    try {
+        const entry = await keyringEntry();
+        entry.setPassword(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function deleteKeyring() {
+    try {
+        const entry = await keyringEntry();
+        entry.deletePassword();
+    }
+    catch {
+        // Missing or unavailable keychains are treated as already logged out.
+    }
+}
+async function readConfigCredential() {
+    try {
+        const parsed = JSON.parse(await readFile(credentialsPath(), "utf8"));
+        const value = normalizeApiKey(parsed.api_key ?? "");
+        return value || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function writeConfigCredential(value) {
+    const path = credentialsPath();
+    const directory = dirname(path);
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    await chmod(directory, 0o700);
+    const temporary = `${path}.${process.pid}.tmp`;
+    await writeFile(temporary, `${JSON.stringify({ api_key: value }, null, 2)}\n`, { mode: 0o600 });
+    await rename(temporary, path);
+    await chmod(path, 0o600);
+}
+export async function resolveApiKey() {
+    const environmentValue = normalizeApiKey(process.env.RETELL_API_KEY ?? "");
+    if (environmentValue)
+        return { value: environmentValue, source: "env" };
+    const keyringValue = await readKeyring();
+    if (keyringValue)
+        return { value: keyringValue, source: "keyring" };
+    const configValue = await readConfigCredential();
+    if (configValue)
+        return { value: configValue, source: "config" };
+    return { source: "unset" };
+}
+export async function storeApiKey(input) {
+    const value = normalizeApiKey(input);
+    if (!value)
+        throw new Error("API key cannot be empty");
+    if (await writeKeyring(value)) {
+        await rm(credentialsPath(), { force: true });
+        return "keyring";
+    }
+    await writeConfigCredential(value);
+    return "config";
+}
+export async function clearApiKey() {
+    await deleteKeyring();
+    await rm(credentialsPath(), { force: true });
+    return (await resolveApiKey()).source;
+}

package/dist/src/runtime/help.js

@@ -0,0 +1,210 @@
+import { fieldNameToFlag } from "./naming.js";
+import { isSensitiveName } from "./security.js";
+function shortDescription(description) {
+    return description.replace(/\s+/g, " ").split(/(?<=[.!?])\s/)[0].trim();
+}
+function displayDefault(value) {
+    return typeof value === "string" ? value : JSON.stringify(value);
+}
+function bodyFieldType(type) {
+    return ["object", "array", "oneOf", "anyOf", "unknown"].includes(type) ? "<json>" : `<${type}>`;
+}
+function shellValue(value) {
+    const rendered = typeof value === "string" ? value : JSON.stringify(value);
+    return /^[A-Za-z0-9_./:+-]+$/.test(rendered) ? rendered : `'${rendered.replaceAll("'", "'\\''")}'`;
+}
+function multipartSample(schema) {
+    if (schema.enum?.length)
+        return schema.enum[0];
+    if (schema.type === "boolean")
+        return true;
+    if (schema.type === "integer" || schema.type === "number")
+        return 1;
+    if (schema.type === "object") {
+        const required = new Set(schema.required ?? []);
+        const properties = Object.entries(schema.properties ?? {}).filter(([name]) => required.has(name));
+        return Object.fromEntries(properties.map(([name, property]) => [name, multipartSample(property)]));
+    }
+    if (schema.type === "array")
+        return schema.items ? [multipartSample(schema.items)] : [];
+    return "example";
+}
+function multipartValueSchema(field) {
+    return field.array && field.schema.items ? field.schema.items : field.schema;
+}
+function multipartOptionType(field) {
+    if (field.file)
+        return "path";
+    const valueSchema = multipartValueSchema(field);
+    return valueSchema.type === "object" || valueSchema.type === "array" ? "json" : valueSchema.type;
+}
+function multipartOptionDescription(field) {
+    const parts = [];
+    const valueSchema = multipartValueSchema(field);
+    if (field.file) {
+        parts.push(field.array ? "Local file path; repeat to upload multiple files." : "Local file path.");
+    }
+    else if (field.array) {
+        const item = valueSchema.type === "object" || valueSchema.type === "array" ? `JSON ${valueSchema.type}` : valueSchema.type;
+        parts.push(`Provide one ${item} per use; repeat for more.`);
+    }
+    else if (valueSchema.type === "object" || valueSchema.type === "array") {
+        parts.push(`Provide a JSON ${valueSchema.type}.`);
+    }
+    else if (valueSchema.type === "boolean") {
+        parts.push("Use without a value for true, or pass true/false.");
+    }
+    if (field.description)
+        parts.push(field.description.replace(/\s+/g, " ").trim());
+    return parts.join(" ");
+}
+function multipartExample(operation, positional) {
+    const fields = operation.requestBody?.multipartFields ?? [];
+    const selected = [
+        ...fields.filter((field) => field.required),
+        fields.find((field) => !field.file && field.serialization === "json"),
+        fields.find((field) => field.file),
+    ].filter((field) => field !== undefined)
+        .filter((field, index, all) => all.indexOf(field) === index);
+    if (!selected.length)
+        return [];
+    const command = `  retell ${operation.command}${positional.replaceAll(/[<>]/g, "")}`;
+    const options = selected.map((field) => {
+        if (field.file)
+            return `${fieldNameToFlag(field.name)} ./path/to/file`;
+        const schema = multipartValueSchema(field);
+        const sample = field.serialization === "json" ? JSON.stringify(multipartSample(schema)) : String(multipartSample(schema));
+        return `${fieldNameToFlag(field.name)} ${shellValue(sample)}`;
+    });
+    if (options.length === 1)
+        return [`${command} ${options[0]}`];
+    return [`${command} \\`, ...options.map((option, index) => `    ${option}${index < options.length - 1 ? " \\" : ""}`)];
+}
+export function rootHelp(operations) {
+    const width = Math.max(...operations.map((operation) => operation.command.length));
+    const commands = operations
+        .map((operation) => `  ${operation.command.padEnd(width)}  ${shortDescription(operation.description)}`)
+        .join("\n");
+    return `Retell CLI\n\n` +
+        `Usage:\n  retell <command> [arguments] [options]\n\n` +
+        `Authentication:\n  Run 'retell auth login' or set RETELL_API_KEY before invoking an API command.\n\n` +
+        `Authentication commands:\n` +
+        `  auth login                     Store a Retell API key\n` +
+        `  auth whoami                    Show authentication status\n` +
+        `  auth logout                    Clear stored credentials\n\n` +
+        `Commands:\n${commands}\n\n` +
+        `Global options:\n` +
+        `  --version                      Show the CLI and OpenAPI catalog versions\n` +
+        `  -h, --help                     Show help\n\n` +
+        `Input conventions:\n` +
+        `  Path parameters are positional arguments. Query parameters and JSON fields use named flags.\n` +
+        `  Pass nested objects and arrays as JSON strings. Multipart file options accept local paths.\n\n` +
+        `Run 'retell <command> --help' for command-specific help.\n`;
+}
+export function commandHelp(operation) {
+    const pathParameters = operation.parameters.filter((parameter) => parameter.in === "path");
+    const optionParameters = operation.parameters.filter((parameter) => parameter.in !== "path");
+    const positional = pathParameters.map((parameter) => ` <${parameter.name.toUpperCase()}>`).join("");
+    const lines = [
+        operation.description.trim(),
+        "",
+        "Usage:",
+        `  retell ${operation.command}${positional} [options]`,
+        "",
+        `OpenAPI operation: ${operation.operationId}`,
+        `Request: ${operation.method} ${operation.path}`,
+    ];
+    if (operation.deprecated)
+        lines.push("", "WARNING: This operation is deprecated.");
+    if (pathParameters.length) {
+        lines.push("", "Arguments:");
+        for (const parameter of pathParameters) {
+            lines.push(`  ${parameter.name.toUpperCase().padEnd(28)} ${parameter.description ?? "Required path parameter"}`);
+        }
+    }
+    const requiredBodyFields = operation.requestBody?.fields?.filter((field) => field.required) ?? [];
+    if (!pathParameters.length && requiredBodyFields.length && requiredBodyFields.every((field) => field.example !== undefined && !isSensitiveName(field.name))) {
+        const flags = requiredBodyFields.map((field) => `${field.flag} ${shellValue(field.example)}`).join(" ");
+        lines.push("", "Example:", `  retell ${operation.command} ${flags}`);
+    }
+    if (operation.requestBody?.contentType === "multipart/form-data") {
+        const example = multipartExample(operation, positional);
+        if (example.length)
+            lines.push("", "Example:", ...example);
+    }
+    if (optionParameters.length) {
+        lines.push("", "Request options:");
+        for (const parameter of optionParameters) {
+            const type = parameter.array ? `<${parameter.arrayItemType ?? "value"}>...` : parameter.type === "object" ? "<json>" : `<${parameter.type}>`;
+            const details = [parameter.required ? "Required." : "Optional.", parameter.description, parameter.in !== "query" ? `${parameter.in[0].toUpperCase()}${parameter.in.slice(1)} parameter.` : undefined];
+            if (parameter.enum?.length)
+                details.push(`Allowed: ${parameter.enum.map(displayDefault).join(", ")}`);
+            if (parameter.default !== undefined)
+                details.push(`Default: ${displayDefault(parameter.default)}`);
+            lines.push(`  ${(parameter.flag + " " + type).padEnd(40)} ${details.filter(Boolean).join(" ")}`);
+        }
+    }
+    if (operation.requestBody?.contentType === "application/json") {
+        const required = operation.requestBody.required ? "required" : "optional";
+        const bodyDetails = [
+            operation.requestBody.schemaName ? `Schema: ${operation.requestBody.schemaName}.` : undefined,
+            operation.requestBody.propertyCount ? `${operation.requestBody.propertyCount} top-level fields.` : undefined,
+            operation.requestBody.requiredFields?.length ? `Required: ${operation.requestBody.requiredFields.join(", ")}.` : undefined,
+        ].filter(Boolean);
+        const simple = operation.requestBody.fields?.find((field) => !["object", "array", "oneOf", "anyOf", "unknown"].includes(field.type));
+        const structured = operation.requestBody.fields?.find((field) => ["object", "array", "oneOf", "anyOf", "unknown"].includes(field.type));
+        lines.push("", "Input methods:");
+        lines.push(`  ${"Named options".padEnd(20)} Pass individual fields with the options listed below.`);
+        if (simple)
+            lines.push(`  ${"Scalar example".padEnd(20)} ${simple.flag} VALUE`);
+        if (structured)
+            lines.push(`  ${"JSON example".padEnd(20)} ${structured.flag} '${structured.type === "array" ? "[\"value\"]" : "{\"key\":\"value\"}"}'`);
+        lines.push(`  ${"--body <FILE|->".padEnd(20)} Provide the complete JSON payload (${required}); use '-' for stdin.`);
+        if (bodyDetails.length)
+            lines.push(`  ${"".padEnd(20)} ${bodyDetails.join(" ")}`);
+        if (operation.requestBody.requiredFields?.length)
+            lines.push(`  ${"".padEnd(20)} Missing required fields are prompted in an interactive terminal.`);
+    }
+    if (operation.requestBody?.contentType === "multipart/form-data") {
+        lines.push("", "Input methods:", `  ${"Named options".padEnd(20)} Pass individual fields with the options listed below.`, `  ${"File options".padEnd(20)} Pass a local path; the CLI reads and uploads that file.`, `  ${"Repeated options".padEnd(20)} Repeat an option to provide multiple values or files.`, `  ${"JSON values".padEnd(20)} Wrap JSON in single quotes so the shell passes it unchanged.`);
+    }
+    const inputFields = operation.requestBody?.contentType === "application/json"
+        ? operation.requestBody.fields ?? []
+        : operation.requestBody?.contentType === "multipart/form-data"
+            ? operation.requestBody.multipartFields ?? []
+            : [];
+    for (const [heading, required] of [["Required input options:", true], ["Optional input options:", false]]) {
+        const fields = inputFields.filter((field) => field.required === required);
+        if (!fields.length)
+            continue;
+        lines.push("", heading);
+        for (const field of fields) {
+            if ("file" in field) {
+                const label = `${fieldNameToFlag(field.name)} <${multipartOptionType(field)}>`;
+                lines.push(`  ${label.padEnd(40)} ${multipartOptionDescription(field)}`.trimEnd());
+                if (field.enum?.length)
+                    lines.push(`  ${"".padEnd(40)} Allowed values: ${field.enum.map(displayDefault).join(", ")}`);
+            }
+            else {
+                const label = `${field.flag} ${bodyFieldType(field.type)}`;
+                lines.push(`  ${label.padEnd(40)} ${field.description?.replace(/\s+/g, " ").trim() ?? ""}`.trimEnd());
+                if (field.enum?.length)
+                    lines.push(`  ${"".padEnd(40)} Allowed: ${field.enum.map(displayDefault).join(", ")}`);
+                if (field.default !== undefined)
+                    lines.push(`  ${"".padEnd(40)} Default: ${displayDefault(field.default)}`);
+                if (field.example !== undefined)
+                    lines.push(`  ${"".padEnd(40)} Example: ${displayDefault(field.example)}`);
+                if (field.nullable)
+                    lines.push(`  ${"".padEnd(40)} Accepts: null`);
+                if (isSensitiveName(field.name))
+                    lines.push(`  ${"".padEnd(40)} Sensitive: prefer JSON through stdin with --body - to avoid shell history.`);
+            }
+        }
+    }
+    lines.push("", "Common options:");
+    lines.push(`  ${"--output <FORMAT>".padEnd(28)} json (default), table, or jsonl`, `  ${"--base-url <URL>".padEnd(28)} Override the API base URL; credentials are sent to this URL`, `  ${"--dry-run".padEnd(28)} Print the request without sending it`, `  ${"-h, --help".padEnd(28)} Show command help`);
+    if (operation.pagination) {
+        lines.push(`Pagination: items=${operation.pagination.itemsField}, cursor=${operation.pagination.cursorField}, has-more=${operation.pagination.hasMoreField}.`);
+    }
+    return `${lines.join("\n")}\n`;
+}

package/dist/src/runtime/http.js

@@ -0,0 +1,32 @@
+const DEFAULT_TIMEOUT_MS = 60_000;
+const MULTIPART_TIMEOUT_MS = 300_000;
+export function requestTimeoutMs(operation) {
+    return operation.requestBody?.contentType === "multipart/form-data"
+        ? MULTIPART_TIMEOUT_MS
+        : DEFAULT_TIMEOUT_MS;
+}
+function errorDetail(error) {
+    if (!(error instanceof Error))
+        return String(error);
+    const cause = error.cause;
+    if (cause instanceof Error) {
+        const code = "code" in cause && typeof cause.code === "string" ? ` (${cause.code})` : "";
+        return `${cause.message}${code}`;
+    }
+    return error.message;
+}
+export async function sendRequest(operation, url, init, fetchImplementation = fetch) {
+    const timeoutMs = requestTimeoutMs(operation);
+    try {
+        return await fetchImplementation(url, {
+            ...init,
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+    }
+    catch (error) {
+        if (error instanceof Error && (error.name === "TimeoutError" || error.name === "AbortError")) {
+            throw new Error(`Retell API request timed out after ${timeoutMs / 1_000} seconds`);
+        }
+        throw new Error(`Retell API network request failed: ${errorDetail(error)}`);
+    }
+}