retell-cli 1.0.2 → 1.1.0

package/dist/index.js

@@ -25,7 +25,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 
 // src/index.ts
 var import_commander = require("commander");
-var import_fs5 = require("fs");
+var import_fs15 = require("fs");
 var import_path6 = require("path");
 
 // src/commands/login.ts
@@ -1375,142 +1375,2332 @@ async function publishAgentCommand(agentId) {
   }
 }
 
-// src/index.ts
-var packageJson = JSON.parse(
-  (0, import_fs5.readFileSync)((0, import_path6.join)(__dirname, "../package.json"), "utf-8")
-);
-var program = new import_commander.Command();
-program.name("retell").description("Retell AI CLI - Manage transcripts and agent prompts").version(packageJson.version, "-v, --version", "Display version number").helpOption("-h, --help", "Display help for command").option("--json", "Output as JSON (default)", true);
-program.command("login").description("Authenticate with Retell AI").addHelpText("after", `
-Examples:
-  $ retell login
-  # Enter your API key when prompted
-  # Creates .retellrc.json in current directory
-  `).action(async () => {
-  await loginCommand();
-});
-var transcripts = program.command("transcripts").description("Manage call transcripts");
-transcripts.command("list").description("List all call transcripts").option("-l, --limit <number>", "Maximum number of calls to return (default: 50)", "50").option("--fields <fields>", "Comma-separated list of fields to return (e.g., call_id,call_status,metadata.duration)").addHelpText("after", `
-Examples:
-  $ retell transcripts list
-  $ retell transcripts list --limit 100
-  $ retell transcripts list --fields call_id,call_status
-  $ retell transcripts list | jq '.[] | select(.call_status == "error")'
-  `).action(async (options) => {
-  const limit = parseInt(options.limit, 10);
-  if (isNaN(limit) || limit < 1) {
-    console.error("Error: limit must be a positive number");
-    process.exit(1);
+// src/services/tool-resolver.ts
+async function resolveToolsSource(agentId) {
+  const client = getRetellClient();
+  const agent = await client.agent.retrieve(agentId);
+  if (agent.response_engine.type === "retell-llm") {
+    const llm = await client.llm.retrieve(agent.response_engine.llm_id);
+    const generalTools = llm.general_tools ?? [];
+    const stateTools = {};
+    if (llm.states) {
+      for (const state of llm.states) {
+        const tools2 = state.tools ?? [];
+        if (tools2.length > 0) {
+          stateTools[state.name] = tools2;
+        }
+      }
+    }
+    const stateToolCount = Object.values(stateTools).reduce((sum, t) => sum + t.length, 0);
+    const totalCount = generalTools.length + stateToolCount;
+    return {
+      type: "retell-llm",
+      agentId,
+      agentName: agent.agent_name ?? "Unknown",
+      llmId: llm.llm_id,
+      generalTools,
+      stateTools,
+      totalCount
+    };
   }
-  await listTranscriptsCommand({
-    limit,
-    fields: options.fields
-  });
-});
-transcripts.command("get <call_id>").description("Get a specific call transcript").option("--fields <fields>", "Comma-separated list of fields to return (e.g., call_id,metadata.duration,analysis)").addHelpText("after", `
-Examples:
-  $ retell transcripts get call_abc123
-  $ retell transcripts get call_abc123 --fields call_id,metadata.duration
-  $ retell transcripts get call_abc123 | jq '.transcript_object'
-  `).action(async (callId, options) => {
-  await getTranscriptCommand(callId, {
-    fields: options.fields
-  });
-});
-transcripts.command("analyze <call_id>").description("Analyze a call transcript with performance metrics and insights").option("--fields <fields>", "Comma-separated list of fields to return (e.g., call_id,performance,analysis.summary)").option("--raw", "Return unmodified API response instead of enriched analysis").option("--hotspots-only", "Return only conversation hotspots/issues for troubleshooting").option("--latency-threshold <ms>", `Latency threshold in ms for hotspot detection (default: ${DEFAULT_LATENCY_THRESHOLD})`, String(DEFAULT_LATENCY_THRESHOLD)).option("--silence-threshold <ms>", `Silence threshold in ms for hotspot detection (default: ${DEFAULT_SILENCE_THRESHOLD})`, String(DEFAULT_SILENCE_THRESHOLD)).addHelpText("after", `
-Examples:
-  $ retell transcripts analyze call_abc123
-  $ retell transcripts analyze call_abc123 --fields call_id,performance
-  $ retell transcripts analyze call_abc123 --raw
-  $ retell transcripts analyze call_abc123 --raw --fields call_id,transcript_object
-  $ retell transcripts analyze call_abc123 --hotspots-only
-  $ retell transcripts analyze call_abc123 --hotspots-only --latency-threshold 1500
-  $ retell transcripts analyze call_abc123 --hotspots-only --fields hotspots
-  $ retell transcripts analyze call_abc123 | jq '.performance.latency_p50_ms'
-  `).action(async (callId, options) => {
-  await analyzeTranscriptCommand(callId, {
-    fields: options.fields,
-    raw: options.raw,
-    hotspotsOnly: options.hotspotsOnly,
-    latencyThreshold: options.latencyThreshold ? parseInt(options.latencyThreshold) : void 0,
-    silenceThreshold: options.silenceThreshold ? parseInt(options.silenceThreshold) : void 0
-  });
-});
-transcripts.command("search").description("Search transcripts with advanced filtering").option("--status <status>", "Filter by call status (error, ended, ongoing)").option("--agent-id <id>", "Filter by agent ID").option("--since <date>", "Filter calls after this date (YYYY-MM-DD or ISO format)").option("--until <date>", "Filter calls before this date (YYYY-MM-DD or ISO format)").option("--limit <number>", "Maximum number of results (default: 50)", "50").option("--fields <fields>", "Comma-separated list of fields to return").addHelpText("after", `
-Examples:
-  $ retell transcripts search --status error
-  $ retell transcripts search --agent-id agent_123 --since 2025-11-01
-  $ retell transcripts search --status error --limit 10
-  $ retell transcripts search --status error --fields call_id,agent_id,call_status
-  $ retell transcripts search --since 2025-11-01 --until 2025-11-15
-  `).action(async (options) => {
-  await searchTranscriptsCommand({
-    status: options.status,
-    agentId: options.agentId,
-    since: options.since,
-    until: options.until,
-    limit: options.limit ? Number(options.limit) : void 0,
-    fields: options.fields
-  });
-});
-var agents = program.command("agents").description("Manage agents");
-agents.command("list").description("List all agents").option("-l, --limit <number>", "Maximum number of agents to return (default: 100)", "100").option("--fields <fields>", "Comma-separated list of fields to return (e.g., agent_id,agent_name,response_engine_type)").addHelpText("after", `
-Examples:
-  $ retell agents list
-  $ retell agents list --limit 10
-  $ retell agents list --fields agent_id,agent_name
-  $ retell agents list | jq '.[] | select(.response_engine.type == "retell-llm")'
-  `).action(async (options) => {
-  const limit = parseInt(options.limit, 10);
-  if (isNaN(limit) || limit < 1) {
-    console.error("Error: limit must be a positive number");
-    process.exit(1);
+  if (agent.response_engine.type === "conversation-flow") {
+    const flow = await client.conversationFlow.retrieve(
+      agent.response_engine.conversation_flow_id
+    );
+    const flowTools = flow.tools ?? [];
+    const componentTools = {};
+    if (flow.components) {
+      for (const component of flow.components) {
+        const tools2 = component.tools ?? [];
+        if (tools2.length > 0) {
+          componentTools[component.name] = tools2;
+        }
+      }
+    }
+    const componentToolCount = Object.values(componentTools).reduce((sum, t) => sum + t.length, 0);
+    const totalCount = flowTools.length + componentToolCount;
+    return {
+      type: "conversation-flow",
+      agentId,
+      agentName: agent.agent_name ?? "Unknown",
+      flowId: flow.conversation_flow_id,
+      flowTools,
+      componentTools,
+      totalCount
+    };
   }
-  await listAgentsCommand({
-    limit,
-    fields: options.fields
-  });
-});
-agents.command("info <agent_id>").description("Get detailed agent information").option("--fields <fields>", "Comma-separated list of fields to return (e.g., agent_name,response_engine.type,voice_config)").addHelpText("after", `
-Examples:
-  $ retell agents info agent_123abc
-  $ retell agents info agent_123abc --fields agent_name,response_engine.type
-  $ retell agents info agent_123abc | jq '.response_engine.type'
-  `).action(async (agentId, options) => {
-  await agentInfoCommand(agentId, {
-    fields: options.fields
-  });
-});
-var prompts = program.command("prompts").description("Manage agent prompts");
-prompts.command("pull <agent_id>").description("Download agent prompts to a local file").option("-o, --output <path>", "Output file path (default: .retell-prompts/<agent_id>.json)", ".retell-prompts").addHelpText("after", `
-Examples:
-  $ retell prompts pull agent_123abc
-  $ retell prompts pull agent_123abc --output my-prompts.json
-  `).action(async (agentId, options) => {
-  await pullPromptsCommand(agentId, options);
-});
-prompts.command("diff <agent_id>").description("Show differences between local and remote prompts").option("-s, --source <path>", "Source directory path (default: .retell-prompts)", ".retell-prompts").option("-f, --fields <fields>", "Comma-separated list of fields to return").addHelpText("after", `
-Examples:
-  $ retell prompts diff agent_123abc
-  $ retell prompts diff agent_123abc --source ./custom-prompts
-  $ retell prompts diff agent_123abc --fields has_changes,changes.general_prompt
-  `).action(async (agentId, options) => {
-  await diffPromptsCommand(agentId, options);
-});
-prompts.command("update <agent_id>").description("Update agent prompts from a local file").option("-s, --source <path>", "Source file path (default: .retell-prompts/<agent_id>.json)", ".retell-prompts").option("--dry-run", "Preview changes without applying them", false).addHelpText("after", `
-Examples:
-  $ retell prompts update agent_123abc --source my-prompts.json --dry-run
-  $ retell prompts update agent_123abc --source my-prompts.json
-  # Remember to publish: retell agent-publish agent_123abc
-  `).action(async (agentId, options) => {
-  await updatePromptsCommand(agentId, options);
-});
-program.command("agent-publish <agent_id>").description("Publish a draft agent to make changes live").addHelpText("after", `
-Examples:
-  $ retell agent-publish agent_123abc
-  # Run this after updating prompts to make changes live
-  `).action(async (agentId) => {
-  await publishAgentCommand(agentId);
+  return {
+    type: "custom-llm",
+    error: "Custom LLM agents cannot be managed via API. Use the Retell dashboard to manage tools for custom LLM agents."
+  };
+}
+async function findToolInLlm(agentId, toolName, stateName) {
+  const source = await resolveToolsSource(agentId);
+  if (source.type !== "retell-llm") {
+    return null;
+  }
+  if (stateName) {
+    const stateTools = source.stateTools[stateName];
+    if (stateTools) {
+      const tool = stateTools.find((t) => t.name === toolName);
+      if (tool) {
+        return {
+          tool,
+          location: { location: "state", stateName }
+        };
+      }
+    }
+    return null;
+  }
+  const generalTool = source.generalTools.find((t) => t.name === toolName);
+  if (generalTool) {
+    return {
+      tool: generalTool,
+      location: { location: "general" }
+    };
+  }
+  for (const [state, tools2] of Object.entries(source.stateTools)) {
+    const tool = tools2.find((t) => t.name === toolName);
+    if (tool) {
+      return {
+        tool,
+        location: { location: "state", stateName: state }
+      };
+    }
+  }
+  return null;
+}
+async function findToolInFlow(agentId, toolName, componentId) {
+  const source = await resolveToolsSource(agentId);
+  if (source.type !== "conversation-flow") {
+    return null;
+  }
+  if (componentId) {
+    const componentTools = source.componentTools[componentId];
+    if (componentTools) {
+      const tool = componentTools.find((t) => t.name === toolName);
+      if (tool) {
+        return {
+          tool,
+          location: { location: "component", componentId }
+        };
+      }
+    }
+    return null;
+  }
+  const flowTool = source.flowTools.find((t) => t.name === toolName);
+  if (flowTool) {
+    return {
+      tool: flowTool,
+      location: { location: "flow" }
+    };
+  }
+  for (const [compId, tools2] of Object.entries(source.componentTools)) {
+    const tool = tools2.find((t) => t.name === toolName);
+    if (tool) {
+      return {
+        tool,
+        location: { location: "component", componentId: compId }
+      };
+    }
+  }
+  return null;
+}
+async function findTool(agentId, toolName, locationHint) {
+  const source = await resolveToolsSource(agentId);
+  if (source.type === "custom-llm") {
+    return null;
+  }
+  if (source.type === "retell-llm") {
+    const result = await findToolInLlm(agentId, toolName, locationHint);
+    if (result) {
+      return {
+        tool: result,
+        agentName: source.agentName,
+        engineType: "retell-llm"
+      };
+    }
+  }
+  if (source.type === "conversation-flow") {
+    const result = await findToolInFlow(agentId, toolName, locationHint);
+    if (result) {
+      return {
+        tool: result,
+        agentName: source.agentName,
+        engineType: "conversation-flow"
+      };
+    }
+  }
+  return null;
+}
+function summarizeTool(tool) {
+  return {
+    name: tool.name,
+    type: tool.type,
+    description: tool.description
+  };
+}
+function getAllToolNames(source) {
+  if (source.type === "custom-llm") {
+    return [];
+  }
+  if (source.type === "retell-llm") {
+    const names = source.generalTools.map((t) => t.name);
+    for (const tools2 of Object.values(source.stateTools)) {
+      names.push(...tools2.map((t) => t.name));
+    }
+    return names;
+  }
+  if (source.type === "conversation-flow") {
+    const names = source.flowTools.map((t) => t.name);
+    for (const tools2 of Object.values(source.componentTools)) {
+      names.push(...tools2.map((t) => t.name));
+    }
+    return names;
+  }
+  return [];
+}
+
+// src/commands/tools/list.ts
+async function listToolsCommand(agentId, options) {
+  try {
+    const source = await resolveToolsSource(agentId);
+    if (source.type === "custom-llm") {
+      outputError(source.error, "CUSTOM_LLM_NOT_SUPPORTED");
+      return;
+    }
+    let output;
+    if (source.type === "retell-llm") {
+      if (options.state) {
+        const stateTools = source.stateTools[options.state];
+        if (!stateTools) {
+          outputError(
+            `State '${options.state}' not found. Available states: ${Object.keys(source.stateTools).join(", ") || "none"}`,
+            "STATE_NOT_FOUND"
+          );
+          return;
+        }
+        output = {
+          agent_id: source.agentId,
+          agent_name: source.agentName,
+          engine_type: "retell-llm",
+          llm_id: source.llmId,
+          general_tools: [],
+          state_tools: {
+            [options.state]: stateTools.map(summarizeTool)
+          },
+          total_count: stateTools.length
+        };
+      } else {
+        const stateToolsSummary = {};
+        for (const [stateName, tools2] of Object.entries(source.stateTools)) {
+          stateToolsSummary[stateName] = tools2.map(summarizeTool);
+        }
+        output = {
+          agent_id: source.agentId,
+          agent_name: source.agentName,
+          engine_type: "retell-llm",
+          llm_id: source.llmId,
+          general_tools: source.generalTools.map(summarizeTool),
+          state_tools: stateToolsSummary,
+          total_count: source.totalCount
+        };
+      }
+    } else {
+      if (options.component) {
+        const componentTools = source.componentTools[options.component];
+        if (!componentTools) {
+          outputError(
+            `Component '${options.component}' not found. Available components: ${Object.keys(source.componentTools).join(", ") || "none"}`,
+            "COMPONENT_NOT_FOUND"
+          );
+          return;
+        }
+        output = {
+          agent_id: source.agentId,
+          agent_name: source.agentName,
+          engine_type: "conversation-flow",
+          flow_id: source.flowId,
+          flow_tools: [],
+          component_tools: {
+            [options.component]: componentTools.map(summarizeTool)
+          },
+          total_count: componentTools.length
+        };
+      } else {
+        const componentToolsSummary = {};
+        for (const [compId, tools2] of Object.entries(source.componentTools)) {
+          componentToolsSummary[compId] = tools2.map(summarizeTool);
+        }
+        output = {
+          agent_id: source.agentId,
+          agent_name: source.agentName,
+          engine_type: "conversation-flow",
+          flow_id: source.flowId,
+          flow_tools: source.flowTools.map(summarizeTool),
+          component_tools: componentToolsSummary,
+          total_count: source.totalCount
+        };
+      }
+    }
+    if (options.fields) {
+      const filtered = filterFields(output, options.fields.split(",").map((f) => f.trim()));
+      outputJson(filtered);
+    } else {
+      outputJson(output);
+    }
+  } catch (error) {
+    handleSdkError(error);
+  }
+}
+
+// src/commands/tools/get.ts
+async function getToolCommand(agentId, toolName, options) {
+  try {
+    const source = await resolveToolsSource(agentId);
+    if (source.type === "custom-llm") {
+      outputError(source.error, "CUSTOM_LLM_NOT_SUPPORTED");
+      return;
+    }
+    const locationHint = source.type === "retell-llm" ? options.state : options.component;
+    const result = await findTool(agentId, toolName, locationHint);
+    if (!result) {
+      let errorMsg = `Tool '${toolName}' not found`;
+      if (locationHint) {
+        errorMsg += ` in ${source.type === "retell-llm" ? "state" : "component"} '${locationHint}'`;
+      }
+      outputError(errorMsg, "TOOL_NOT_FOUND");
+      return;
+    }
+    const output = {
+      agent_id: agentId,
+      agent_name: result.agentName,
+      tool_name: toolName,
+      location: result.tool.location,
+      tool: result.tool.tool
+    };
+    if (options.fields) {
+      const filtered = filterFields(output, options.fields.split(",").map((f) => f.trim()));
+      outputJson(filtered);
+    } else {
+      outputJson(output);
+    }
+  } catch (error) {
+    handleSdkError(error);
+  }
+}
+
+// src/commands/tools/add.ts
+var import_fs5 = require("fs");
+async function addToolCommand(agentId, options) {
+  try {
+    if (!(0, import_fs5.existsSync)(options.file)) {
+      outputError(`Tool file not found: ${options.file}`, "FILE_NOT_FOUND");
+      return;
+    }
+    let tool;
+    try {
+      const content = (0, import_fs5.readFileSync)(options.file, "utf-8");
+      tool = JSON.parse(content);
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        outputError(`Invalid JSON in tool file: ${error.message}`, "INVALID_JSON");
+      } else {
+        outputError(`Error reading tool file: ${error.message}`, "FILE_READ_ERROR");
+      }
+      return;
+    }
+    if (!tool.name) {
+      outputError('Tool must have a "name" field', "INVALID_TOOL");
+      return;
+    }
+    if (!tool.type) {
+      outputError('Tool must have a "type" field', "INVALID_TOOL");
+      return;
+    }
+    const source = await resolveToolsSource(agentId);
+    if (source.type === "custom-llm") {
+      outputError(source.error, "CUSTOM_LLM_NOT_SUPPORTED");
+      return;
+    }
+    const existingNames = getAllToolNames(source);
+    if (existingNames.includes(tool.name)) {
+      outputError(
+        `Tool with name '${tool.name}' already exists. Use 'retell tools update' to modify it.`,
+        "DUPLICATE_TOOL"
+      );
+      return;
+    }
+    const client = getRetellClient();
+    if (source.type === "retell-llm") {
+      if (options.dryRun) {
+        const location = options.state ? `state '${options.state}'` : "general tools";
+        outputJson({
+          message: "Dry run - no changes applied",
+          agent_id: agentId,
+          agent_name: source.agentName,
+          tool_name: tool.name,
+          operation: "add",
+          location: options.state ? { location: "state", stateName: options.state } : { location: "general" },
+          tool_preview: tool,
+          would_add_to: location
+        });
+        return;
+      }
+      const llm = await client.llm.retrieve(source.llmId);
+      if (options.state) {
+        const states = llm.states ?? [];
+        const stateIndex = states.findIndex((s) => s.name === options.state);
+        if (stateIndex === -1) {
+          outputError(
+            `State '${options.state}' not found. Available states: ${states.map((s) => s.name).join(", ") || "none"}`,
+            "STATE_NOT_FOUND"
+          );
+          return;
+        }
+        const updatedStates = [...states];
+        const stateTools = [...updatedStates[stateIndex].tools ?? []];
+        stateTools.push(tool);
+        updatedStates[stateIndex] = { ...updatedStates[stateIndex], tools: stateTools };
+        await client.llm.update(source.llmId, { states: updatedStates });
+        const output = {
+          message: "Tool added successfully (draft version)",
+          agent_id: agentId,
+          agent_name: source.agentName,
+          tool_name: tool.name,
+          operation: "add",
+          location: { location: "state", stateName: options.state },
+          note: `Run 'retell agent-publish ${agentId}' to publish changes to production`
+        };
+        outputJson(output);
+      } else {
+        const generalTools = [...llm.general_tools ?? []];
+        generalTools.push(tool);
+        await client.llm.update(source.llmId, { general_tools: generalTools });
+        const output = {
+          message: "Tool added successfully (draft version)",
+          agent_id: agentId,
+          agent_name: source.agentName,
+          tool_name: tool.name,
+          operation: "add",
+          location: { location: "general" },
+          note: `Run 'retell agent-publish ${agentId}' to publish changes to production`
+        };
+        outputJson(output);
+      }
+    } else {
+      if (options.dryRun) {
+        const location = options.component ? `component '${options.component}'` : "flow tools";
+        outputJson({
+          message: "Dry run - no changes applied",
+          agent_id: agentId,
+          agent_name: source.agentName,
+          tool_name: tool.name,
+          operation: "add",
+          location: options.component ? { location: "component", componentId: options.component } : { location: "flow" },
+          tool_preview: tool,
+          would_add_to: location
+        });
+        return;
+      }
+      const flow = await client.conversationFlow.retrieve(source.flowId);
+      if (options.component) {
+        const components = flow.components ?? [];
+        const compIndex = components.findIndex((c) => c.name === options.component);
+        if (compIndex === -1) {
+          outputError(
+            `Component '${options.component}' not found. Available components: ${components.map((c) => c.name).join(", ") || "none"}`,
+            "COMPONENT_NOT_FOUND"
+          );
+          return;
+        }
+        const updatedComponents = [...components];
+        const compTools = [...updatedComponents[compIndex].tools ?? []];
+        compTools.push(tool);
+        updatedComponents[compIndex] = { ...updatedComponents[compIndex], tools: compTools };
+        await client.conversationFlow.update(source.flowId, { components: updatedComponents });
+        const output = {
+          message: "Tool added successfully (draft version)",
+          agent_id: agentId,
+          agent_name: source.agentName,
+          tool_name: tool.name,
+          operation: "add",
+          location: { location: "component", componentId: options.component },
+          note: `Run 'retell agent-publish ${agentId}' to publish changes to production`
+        };
+        outputJson(output);
+      } else {
+        const flowTools = [...flow.tools ?? []];
+        flowTools.push(tool);
+        await client.conversationFlow.update(source.flowId, { tools: flowTools });
+        const output = {
+          message: "Tool added successfully (draft version)",
+          agent_id: agentId,
+          agent_name: source.agentName,
+          tool_name: tool.name,
+          operation: "add",
+          location: { location: "flow" },
+          note: `Run 'retell agent-publish ${agentId}' to publish changes to production`
+        };
+        outputJson(output);
+      }
+    }
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      outputError(`Invalid JSON: ${error.message}`, "INVALID_JSON");
+      return;
+    }
+    handleSdkError(error);
+  }
+}
+
+// src/commands/tools/update.ts
+var import_fs6 = require("fs");
+async function updateToolCommand(agentId, toolName, options) {
+  try {
+    if (!(0, import_fs6.existsSync)(options.file)) {
+      outputError(`Tool file not found: ${options.file}`, "FILE_NOT_FOUND");
+      return;
+    }
+    let newTool;
+    try {
+      const content = (0, import_fs6.readFileSync)(options.file, "utf-8");
+      newTool = JSON.parse(content);
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        outputError(`Invalid JSON in tool file: ${error.message}`, "INVALID_JSON");
+      } else {
+        outputError(`Error reading tool file: ${error.message}`, "FILE_READ_ERROR");
+      }
+      return;
+    }
+    if (!newTool.name) {
+      outputError('Tool must have a "name" field', "INVALID_TOOL");
+      return;
+    }
+    if (!newTool.type) {
+      outputError('Tool must have a "type" field', "INVALID_TOOL");
+      return;
+    }
+    const source = await resolveToolsSource(agentId);
+    if (source.type === "custom-llm") {
+      outputError(source.error, "CUSTOM_LLM_NOT_SUPPORTED");
+      return;
+    }
+    const locationHint = source.type === "retell-llm" ? options.state : options.component;
+    const existingTool = await findTool(agentId, toolName, locationHint);
+    if (!existingTool) {
+      let errorMsg = `Tool '${toolName}' not found`;
+      if (locationHint) {
+        errorMsg += ` in ${source.type === "retell-llm" ? "state" : "component"} '${locationHint}'`;
+      }
+      outputError(errorMsg, "TOOL_NOT_FOUND");
+      return;
+    }
+    const client = getRetellClient();
+    if (source.type === "retell-llm") {
+      if (options.dryRun) {
+        outputJson({
+          message: "Dry run - no changes applied",
+          agent_id: agentId,
+          agent_name: source.agentName,
+          tool_name: toolName,
+          operation: "update",
+          location: existingTool.tool.location,
+          old_tool: existingTool.tool.tool,
+          new_tool: newTool
+        });
+        return;
+      }
+      const llm = await client.llm.retrieve(source.llmId);
+      if (existingTool.tool.location.location === "state") {
+        const stateName = existingTool.tool.location.stateName;
+        const states = llm.states ?? [];
+        const stateIndex = states.findIndex((s) => s.name === stateName);
+        if (stateIndex === -1) {
+          outputError(`State '${stateName}' not found`, "STATE_NOT_FOUND");
+          return;
+        }
+        const updatedStates = [...states];
+        const stateTools = [...updatedStates[stateIndex].tools ?? []];
+        const toolIndex = stateTools.findIndex((t) => t.name === toolName);
+        if (toolIndex === -1) {
+          outputError(`Tool '${toolName}' not found in state '${stateName}'`, "TOOL_NOT_FOUND");
+          return;
+        }
+        stateTools[toolIndex] = newTool;
+        updatedStates[stateIndex] = { ...updatedStates[stateIndex], tools: stateTools };
+        await client.llm.update(source.llmId, { states: updatedStates });
+        const output = {
+          message: "Tool updated successfully (draft version)",
+          agent_id: agentId,
+          agent_name: source.agentName,
+          tool_name: newTool.name,
+          operation: "update",
+          location: { location: "state", stateName },
+          note: `Run 'retell agent-publish ${agentId}' to publish changes to production`
+        };
+        outputJson(output);
+      } else {
+        const generalTools = [...llm.general_tools ?? []];
+        const toolIndex = generalTools.findIndex((t) => t.name === toolName);
+        if (toolIndex === -1) {
+          outputError(`Tool '${toolName}' not found in general tools`, "TOOL_NOT_FOUND");
+          return;
+        }
+        generalTools[toolIndex] = newTool;
+        await client.llm.update(source.llmId, { general_tools: generalTools });
+        const output = {
+          message: "Tool updated successfully (draft version)",
+          agent_id: agentId,
+          agent_name: source.agentName,
+          tool_name: newTool.name,
+          operation: "update",
+          location: { location: "general" },
+          note: `Run 'retell agent-publish ${agentId}' to publish changes to production`
+        };
+        outputJson(output);
+      }
+    } else {
+      if (options.dryRun) {
+        outputJson({
+          message: "Dry run - no changes applied",
+          agent_id: agentId,
+          agent_name: source.agentName,
+          tool_name: toolName,
+          operation: "update",
+          location: existingTool.tool.location,
+          old_tool: existingTool.tool.tool,
+          new_tool: newTool
+        });
+        return;
+      }
+      const flow = await client.conversationFlow.retrieve(source.flowId);
+      if (existingTool.tool.location.location === "component") {
+        const componentId = existingTool.tool.location.componentId;
+        const components = flow.components ?? [];
+        const compIndex = components.findIndex((c) => c.name === componentId);
+        if (compIndex === -1) {
+          outputError(`Component '${componentId}' not found`, "COMPONENT_NOT_FOUND");
+          return;
+        }
+        const updatedComponents = [...components];
+        const compTools = [...updatedComponents[compIndex].tools ?? []];
+        const toolIndex = compTools.findIndex((t) => t.name === toolName);
+        if (toolIndex === -1) {
+          outputError(`Tool '${toolName}' not found in component '${componentId}'`, "TOOL_NOT_FOUND");
+          return;
+        }
+        compTools[toolIndex] = newTool;
+        updatedComponents[compIndex] = { ...updatedComponents[compIndex], tools: compTools };
+        await client.conversationFlow.update(source.flowId, { components: updatedComponents });
+        const output = {
+          message: "Tool updated successfully (draft version)",
+          agent_id: agentId,
+          agent_name: source.agentName,
+          tool_name: newTool.name,
+          operation: "update",
+          location: { location: "component", componentId },
+          note: `Run 'retell agent-publish ${agentId}' to publish changes to production`
+        };
+        outputJson(output);
+      } else {
+        const flowTools = [...flow.tools ?? []];
+        const toolIndex = flowTools.findIndex((t) => t.name === toolName);
+        if (toolIndex === -1) {
+          outputError(`Tool '${toolName}' not found in flow tools`, "TOOL_NOT_FOUND");
+          return;
+        }
+        flowTools[toolIndex] = newTool;
+        await client.conversationFlow.update(source.flowId, { tools: flowTools });
+        const output = {
+          message: "Tool updated successfully (draft version)",
+          agent_id: agentId,
+          agent_name: source.agentName,
+          tool_name: newTool.name,
+          operation: "update",
+          location: { location: "flow" },
+          note: `Run 'retell agent-publish ${agentId}' to publish changes to production`
+        };
+        outputJson(output);
+      }
+    }
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      outputError(`Invalid JSON: ${error.message}`, "INVALID_JSON");
+      return;
+    }
+    handleSdkError(error);
+  }
+}
+
+// src/commands/tools/remove.ts
+async function removeToolCommand(agentId, toolName, options) {
+  try {
+    const source = await resolveToolsSource(agentId);
+    if (source.type === "custom-llm") {
+      outputError(source.error, "CUSTOM_LLM_NOT_SUPPORTED");
+      return;
+    }
+    const locationHint = source.type === "retell-llm" ? options.state : options.component;
+    const existingTool = await findTool(agentId, toolName, locationHint);
+    if (!existingTool) {
+      let errorMsg = `Tool '${toolName}' not found`;
+      if (locationHint) {
+        errorMsg += ` in ${source.type === "retell-llm" ? "state" : "component"} '${locationHint}'`;
+      }
+      outputError(errorMsg, "TOOL_NOT_FOUND");
+      return;
+    }
+    const client = getRetellClient();
+    if (source.type === "retell-llm") {
+      if (options.dryRun) {
+        outputJson({
+          message: "Dry run - no changes applied",
+          agent_id: agentId,
+          agent_name: source.agentName,
+          tool_name: toolName,
+          operation: "remove",
+          location: existingTool.tool.location,
+          tool_to_remove: existingTool.tool.tool
+        });
+        return;
+      }
+      const llm = await client.llm.retrieve(source.llmId);
+      if (existingTool.tool.location.location === "state") {
+        const stateName = existingTool.tool.location.stateName;
+        const states = llm.states ?? [];
+        const stateIndex = states.findIndex((s) => s.name === stateName);
+        if (stateIndex === -1) {
+          outputError(`State '${stateName}' not found`, "STATE_NOT_FOUND");
+          return;
+        }
+        const updatedStates = [...states];
+        const stateTools = [...updatedStates[stateIndex].tools ?? []];
+        const toolIndex = stateTools.findIndex((t) => t.name === toolName);
+        if (toolIndex === -1) {
+          outputError(`Tool '${toolName}' not found in state '${stateName}'`, "TOOL_NOT_FOUND");
+          return;
+        }
+        stateTools.splice(toolIndex, 1);
+        updatedStates[stateIndex] = { ...updatedStates[stateIndex], tools: stateTools };
+        await client.llm.update(source.llmId, { states: updatedStates });
+        const output = {
+          message: "Tool removed successfully (draft version)",
+          agent_id: agentId,
+          agent_name: source.agentName,
+          tool_name: toolName,
+          operation: "remove",
+          location: { location: "state", stateName },
+          note: `Run 'retell agent-publish ${agentId}' to publish changes to production`
+        };
+        outputJson(output);
+      } else {
+        const generalTools = [...llm.general_tools ?? []];
+        const toolIndex = generalTools.findIndex((t) => t.name === toolName);
+        if (toolIndex === -1) {
+          outputError(`Tool '${toolName}' not found in general tools`, "TOOL_NOT_FOUND");
+          return;
+        }
+        generalTools.splice(toolIndex, 1);
+        await client.llm.update(source.llmId, { general_tools: generalTools });
+        const output = {
+          message: "Tool removed successfully (draft version)",
+          agent_id: agentId,
+          agent_name: source.agentName,
+          tool_name: toolName,
+          operation: "remove",
+          location: { location: "general" },
+          note: `Run 'retell agent-publish ${agentId}' to publish changes to production`
+        };
+        outputJson(output);
+      }
+    } else {
+      if (options.dryRun) {
+        outputJson({
+          message: "Dry run - no changes applied",
+          agent_id: agentId,
+          agent_name: source.agentName,
+          tool_name: toolName,
+          operation: "remove",
+          location: existingTool.tool.location,
+          tool_to_remove: existingTool.tool.tool
+        });
+        return;
+      }
+      const flow = await client.conversationFlow.retrieve(source.flowId);
+      if (existingTool.tool.location.location === "component") {
+        const componentId = existingTool.tool.location.componentId;
+        const components = flow.components ?? [];
+        const compIndex = components.findIndex((c) => c.name === componentId);
+        if (compIndex === -1) {
+          outputError(`Component '${componentId}' not found`, "COMPONENT_NOT_FOUND");
+          return;
+        }
+        const updatedComponents = [...components];
+        const compTools = [...updatedComponents[compIndex].tools ?? []];
+        const toolIndex = compTools.findIndex((t) => t.name === toolName);
+        if (toolIndex === -1) {
+          outputError(`Tool '${toolName}' not found in component '${componentId}'`, "TOOL_NOT_FOUND");
+          return;
+        }
+        compTools.splice(toolIndex, 1);
+        updatedComponents[compIndex] = { ...updatedComponents[compIndex], tools: compTools };
+        await client.conversationFlow.update(source.flowId, { components: updatedComponents });
+        const output = {
+          message: "Tool removed successfully (draft version)",
+          agent_id: agentId,
+          agent_name: source.agentName,
+          tool_name: toolName,
+          operation: "remove",
+          location: { location: "component", componentId },
+          note: `Run 'retell agent-publish ${agentId}' to publish changes to production`
+        };
+        outputJson(output);
+      } else {
+        const flowTools = [...flow.tools ?? []];
+        const toolIndex = flowTools.findIndex((t) => t.name === toolName);
+        if (toolIndex === -1) {
+          outputError(`Tool '${toolName}' not found in flow tools`, "TOOL_NOT_FOUND");
+          return;
+        }
+        flowTools.splice(toolIndex, 1);
+        await client.conversationFlow.update(source.flowId, { tools: flowTools });
+        const output = {
+          message: "Tool removed successfully (draft version)",
+          agent_id: agentId,
+          agent_name: source.agentName,
+          tool_name: toolName,
+          operation: "remove",
+          location: { location: "flow" },
+          note: `Run 'retell agent-publish ${agentId}' to publish changes to production`
+        };
+        outputJson(output);
+      }
+    }
+  } catch (error) {
+    handleSdkError(error);
+  }
+}
+
+// src/commands/tools/export.ts
+var import_fs7 = require("fs");
+async function exportToolsCommand(agentId, options) {
+  try {
+    const source = await resolveToolsSource(agentId);
+    if (source.type === "custom-llm") {
+      outputError(source.error, "CUSTOM_LLM_NOT_SUPPORTED");
+      return;
+    }
+    let exportData;
+    if (source.type === "retell-llm") {
+      const stateToolsExport = {};
+      for (const [stateName, tools2] of Object.entries(source.stateTools)) {
+        if (tools2.length > 0) {
+          stateToolsExport[stateName] = tools2;
+        }
+      }
+      exportData = {
+        agent_id: source.agentId,
+        agent_name: source.agentName,
+        engine_type: "retell-llm",
+        exported_at: (/* @__PURE__ */ new Date()).toISOString(),
+        tools: {
+          general: source.generalTools.length > 0 ? source.generalTools : void 0,
+          states: Object.keys(stateToolsExport).length > 0 ? stateToolsExport : void 0
+        },
+        total_count: source.totalCount
+      };
+    } else {
+      const componentToolsExport = {};
+      for (const [compId, tools2] of Object.entries(source.componentTools)) {
+        if (tools2.length > 0) {
+          componentToolsExport[compId] = tools2;
+        }
+      }
+      exportData = {
+        agent_id: source.agentId,
+        agent_name: source.agentName,
+        engine_type: "conversation-flow",
+        exported_at: (/* @__PURE__ */ new Date()).toISOString(),
+        tools: {
+          flow: source.flowTools.length > 0 ? source.flowTools : void 0,
+          components: Object.keys(componentToolsExport).length > 0 ? componentToolsExport : void 0
+        },
+        total_count: source.totalCount
+      };
+    }
+    if (options.output) {
+      try {
+        (0, import_fs7.writeFileSync)(options.output, JSON.stringify(exportData, null, 2), "utf-8");
+        outputJson({
+          message: "Tools exported successfully",
+          agent_id: agentId,
+          agent_name: exportData.agent_name,
+          engine_type: exportData.engine_type,
+          output_file: options.output,
+          total_count: exportData.total_count
+        });
+      } catch (error) {
+        if (error.code === "EACCES") {
+          outputError(`Permission denied writing to: ${options.output}`, "PERMISSION_DENIED");
+        } else if (error.code === "ENOSPC") {
+          outputError("No space left on device", "NO_SPACE");
+        } else {
+          outputError(`Error writing file: ${error.message}`, "WRITE_ERROR");
+        }
+      }
+    } else {
+      outputJson(exportData);
+    }
+  } catch (error) {
+    handleSdkError(error);
+  }
+}
+
+// src/commands/tools/import.ts
+var import_fs8 = require("fs");
+async function importToolsCommand(agentId, options) {
+  try {
+    if (!(0, import_fs8.existsSync)(options.file)) {
+      outputError(`Import file not found: ${options.file}`, "FILE_NOT_FOUND");
+      return;
+    }
+    let importData;
+    try {
+      const content = (0, import_fs8.readFileSync)(options.file, "utf-8");
+      importData = JSON.parse(content);
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        outputError(`Invalid JSON in import file: ${error.message}`, "INVALID_JSON");
+      } else {
+        outputError(`Error reading import file: ${error.message}`, "FILE_READ_ERROR");
+      }
+      return;
+    }
+    if (!importData.tools) {
+      outputError('Import file must contain a "tools" object', "INVALID_IMPORT");
+      return;
+    }
+    const source = await resolveToolsSource(agentId);
+    if (source.type === "custom-llm") {
+      outputError(source.error, "CUSTOM_LLM_NOT_SUPPORTED");
+      return;
+    }
+    const client = getRetellClient();
+    const existingNames = new Set(getAllToolNames(source));
+    const toolsAdded = [];
+    const toolsSkipped = [];
+    const toolsReplaced = [];
+    if (source.type === "retell-llm") {
+      if (importData.tools.flow || importData.tools.components) {
+        outputError(
+          "Import file contains Conversation Flow tools, but agent is Retell LLM",
+          "TYPE_MISMATCH"
+        );
+        return;
+      }
+      const llm = await client.llm.retrieve(source.llmId);
+      let generalTools = [...llm.general_tools ?? []];
+      const states = [...llm.states ?? []];
+      if (importData.tools.general) {
+        for (const tool of importData.tools.general) {
+          if (existingNames.has(tool.name)) {
+            if (options.replace) {
+              const idx = generalTools.findIndex((t) => t.name === tool.name);
+              if (idx !== -1) {
+                generalTools[idx] = tool;
+                toolsReplaced.push(tool.name);
+              }
+            } else {
+              toolsSkipped.push(tool.name);
+            }
+          } else {
+            generalTools.push(tool);
+            toolsAdded.push(tool.name);
+            existingNames.add(tool.name);
+          }
+        }
+      }
+      if (importData.tools.states) {
+        for (const [stateName, tools2] of Object.entries(importData.tools.states)) {
+          const stateIndex = states.findIndex((s) => s.name === stateName);
+          if (stateIndex === -1) {
+            outputError(
+              `State '${stateName}' not found in agent. Available states: ${states.map((s) => s.name).join(", ") || "none"}`,
+              "STATE_NOT_FOUND"
+            );
+            return;
+          }
+          const stateTools = [...states[stateIndex].tools ?? []];
+          for (const tool of tools2) {
+            if (existingNames.has(tool.name)) {
+              if (options.replace) {
+                const idx = stateTools.findIndex((t) => t.name === tool.name);
+                if (idx !== -1) {
+                  stateTools[idx] = tool;
+                  toolsReplaced.push(`${stateName}/${tool.name}`);
+                }
+              } else {
+                toolsSkipped.push(`${stateName}/${tool.name}`);
+              }
+            } else {
+              stateTools.push(tool);
+              toolsAdded.push(`${stateName}/${tool.name}`);
+              existingNames.add(tool.name);
+            }
+          }
+          states[stateIndex] = { ...states[stateIndex], tools: stateTools };
+        }
+      }
+      if (options.dryRun) {
+        outputJson({
+          message: "Dry run - no changes applied",
+          agent_id: agentId,
+          agent_name: source.agentName,
+          engine_type: "retell-llm",
+          tools_would_add: toolsAdded,
+          tools_would_replace: toolsReplaced,
+          tools_would_skip: toolsSkipped,
+          total_changes: toolsAdded.length + toolsReplaced.length
+        });
+        return;
+      }
+      await client.llm.update(source.llmId, {
+        general_tools: generalTools,
+        states
+      });
+      const output = {
+        message: "Tools imported successfully (draft version)",
+        agent_id: agentId,
+        agent_name: source.agentName,
+        imported_count: toolsAdded.length + toolsReplaced.length,
+        tools_added: [...toolsAdded, ...toolsReplaced],
+        note: toolsSkipped.length > 0 ? `Skipped ${toolsSkipped.length} existing tools. Use --replace to overwrite. Run 'retell agent-publish ${agentId}' to publish changes.` : `Run 'retell agent-publish ${agentId}' to publish changes to production`
+      };
+      outputJson(output);
+    } else {
+      if (importData.tools.general || importData.tools.states) {
+        outputError(
+          "Import file contains Retell LLM tools, but agent is Conversation Flow",
+          "TYPE_MISMATCH"
+        );
+        return;
+      }
+      const flow = await client.conversationFlow.retrieve(source.flowId);
+      let flowTools = [...flow.tools ?? []];
+      const components = [...flow.components ?? []];
+      if (importData.tools.flow) {
+        for (const tool of importData.tools.flow) {
+          if (existingNames.has(tool.name)) {
+            if (options.replace) {
+              const idx = flowTools.findIndex((t) => t.name === tool.name);
+              if (idx !== -1) {
+                flowTools[idx] = tool;
+                toolsReplaced.push(tool.name);
+              }
+            } else {
+              toolsSkipped.push(tool.name);
+            }
+          } else {
+            flowTools.push(tool);
+            toolsAdded.push(tool.name);
+            existingNames.add(tool.name);
+          }
+        }
+      }
+      if (importData.tools.components) {
+        for (const [compId, tools2] of Object.entries(importData.tools.components)) {
+          const compIndex = components.findIndex((c) => c.name === compId);
+          if (compIndex === -1) {
+            outputError(
+              `Component '${compId}' not found in agent. Available components: ${components.map((c) => c.name).join(", ") || "none"}`,
+              "COMPONENT_NOT_FOUND"
+            );
+            return;
+          }
+          const compTools = [...components[compIndex].tools ?? []];
+          for (const tool of tools2) {
+            if (existingNames.has(tool.name)) {
+              if (options.replace) {
+                const idx = compTools.findIndex((t) => t.name === tool.name);
+                if (idx !== -1) {
+                  compTools[idx] = tool;
+                  toolsReplaced.push(`${compId}/${tool.name}`);
+                }
+              } else {
+                toolsSkipped.push(`${compId}/${tool.name}`);
+              }
+            } else {
+              compTools.push(tool);
+              toolsAdded.push(`${compId}/${tool.name}`);
+              existingNames.add(tool.name);
+            }
+          }
+          components[compIndex] = { ...components[compIndex], tools: compTools };
+        }
+      }
+      if (options.dryRun) {
+        outputJson({
+          message: "Dry run - no changes applied",
+          agent_id: agentId,
+          agent_name: source.agentName,
+          engine_type: "conversation-flow",
+          tools_would_add: toolsAdded,
+          tools_would_replace: toolsReplaced,
+          tools_would_skip: toolsSkipped,
+          total_changes: toolsAdded.length + toolsReplaced.length
+        });
+        return;
+      }
+      await client.conversationFlow.update(source.flowId, {
+        tools: flowTools,
+        components
+      });
+      const output = {
+        message: "Tools imported successfully (draft version)",
+        agent_id: agentId,
+        agent_name: source.agentName,
+        imported_count: toolsAdded.length + toolsReplaced.length,
+        tools_added: [...toolsAdded, ...toolsReplaced],
+        note: toolsSkipped.length > 0 ? `Skipped ${toolsSkipped.length} existing tools. Use --replace to overwrite. Run 'retell agent-publish ${agentId}' to publish changes.` : `Run 'retell agent-publish ${agentId}' to publish changes to production`
+      };
+      outputJson(output);
+    }
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      outputError(`Invalid JSON: ${error.message}`, "INVALID_JSON");
+      return;
+    }
+    handleSdkError(error);
+  }
+}
+
+// src/services/test-api.ts
+var BASE_URL = "https://api.retellai.com";
+async function apiRequest(method, path, body) {
+  const config = getConfig();
+  const response = await fetch(`${BASE_URL}${path}`, {
+    method,
+    headers: {
+      "Authorization": `Bearer ${config.apiKey}`,
+      "Content-Type": "application/json"
+    },
+    body: body ? JSON.stringify(body) : void 0
+  });
+  if (!response.ok) {
+    const errorBody = await response.text();
+    let errorMessage = `API error: ${response.status} ${response.statusText}`;
+    try {
+      const errorJson = JSON.parse(errorBody);
+      if (errorJson.message) {
+        errorMessage = errorJson.message;
+      } else if (errorJson.error) {
+        errorMessage = errorJson.error;
+      }
+    } catch {
+      if (errorBody) {
+        errorMessage = errorBody;
+      }
+    }
+    throw new Error(errorMessage);
+  }
+  const text = await response.text();
+  if (!text) {
+    return {};
+  }
+  return JSON.parse(text);
+}
+async function listTestCaseDefinitions(responseEngine) {
+  const params = new URLSearchParams();
+  if (responseEngine.type === "retell-llm") {
+    params.set("type", "retell-llm");
+    params.set("llm_id", responseEngine.llm_id);
+  } else {
+    params.set("type", "conversation-flow");
+    params.set("conversation_flow_id", responseEngine.conversation_flow_id);
+  }
+  return apiRequest(
+    "GET",
+    `/list-test-case-definitions?${params.toString()}`
+  );
+}
+async function getTestCaseDefinition(testCaseDefinitionId) {
+  return apiRequest(
+    "GET",
+    `/get-test-case-definition/${testCaseDefinitionId}`
+  );
+}
+async function createTestCaseDefinition(params) {
+  return apiRequest(
+    "POST",
+    "/create-test-case-definition",
+    params
+  );
+}
+async function updateTestCaseDefinition(testCaseDefinitionId, params) {
+  return apiRequest(
+    "PUT",
+    `/update-test-case-definition/${testCaseDefinitionId}`,
+    params
+  );
+}
+async function deleteTestCaseDefinition(testCaseDefinitionId) {
+  await apiRequest(
+    "DELETE",
+    `/delete-test-case-definition/${testCaseDefinitionId}`
+  );
+}
+async function listBatchTests(responseEngine) {
+  const params = new URLSearchParams();
+  if (responseEngine.type === "retell-llm") {
+    params.set("type", "retell-llm");
+    params.set("llm_id", responseEngine.llm_id);
+  } else {
+    params.set("type", "conversation-flow");
+    params.set("conversation_flow_id", responseEngine.conversation_flow_id);
+  }
+  return apiRequest(
+    "GET",
+    `/list-batch-tests?${params.toString()}`
+  );
+}
+async function getBatchTest(batchJobId) {
+  return apiRequest(
+    "GET",
+    `/get-batch-test/${batchJobId}`
+  );
+}
+async function createBatchTest(params) {
+  return apiRequest(
+    "POST",
+    "/create-batch-test",
+    params
+  );
+}
+async function listTestRuns(batchJobId) {
+  return apiRequest(
+    "GET",
+    `/list-test-runs/${batchJobId}`
+  );
+}
+async function getTestRun(testRunId) {
+  return apiRequest(
+    "GET",
+    `/get-test-run/${testRunId}`
+  );
+}
+
+// src/commands/tests/cases/list.ts
+function buildResponseEngine(options) {
+  if (options.type === "retell-llm") {
+    if (!options.llmId) {
+      outputError("--llm-id is required when type is retell-llm", "MISSING_PARAMETER");
+      return null;
+    }
+    return { type: "retell-llm", llm_id: options.llmId };
+  } else {
+    if (!options.flowId) {
+      outputError("--flow-id is required when type is conversation-flow", "MISSING_PARAMETER");
+      return null;
+    }
+    return { type: "conversation-flow", conversation_flow_id: options.flowId };
+  }
+}
+async function listTestCasesCommand(options) {
+  try {
+    const responseEngine = buildResponseEngine(options);
+    if (!responseEngine)
+      return;
+    const testCases = await listTestCaseDefinitions(responseEngine);
+    const output = {
+      response_engine: responseEngine,
+      test_case_definitions: testCases || [],
+      total_count: (testCases || []).length
+    };
+    if (options.fields) {
+      const filtered = filterFields(output, options.fields.split(",").map((f) => f.trim()));
+      outputJson(filtered);
+    } else {
+      outputJson(output);
+    }
+  } catch (error) {
+    handleSdkError(error);
+  }
+}
+
+// src/commands/tests/cases/get.ts
+async function getTestCaseCommand(testCaseDefinitionId, options) {
+  try {
+    const testCase = await getTestCaseDefinition(testCaseDefinitionId);
+    if (options.fields) {
+      const filtered = filterFields(testCase, options.fields.split(",").map((f) => f.trim()));
+      outputJson(filtered);
+    } else {
+      outputJson(testCase);
+    }
+  } catch (error) {
+    handleSdkError(error);
+  }
+}
+
+// src/commands/tests/cases/create.ts
+var import_fs9 = require("fs");
+function buildResponseEngine2(options) {
+  if (options.llmId && options.flowId) {
+    outputError("Cannot specify both --llm-id and --flow-id", "INVALID_PARAMETERS");
+    return null;
+  }
+  if (!options.llmId && !options.flowId) {
+    outputError("Either --llm-id or --flow-id is required", "MISSING_PARAMETER");
+    return null;
+  }
+  if (options.llmId) {
+    const engine = { type: "retell-llm", llm_id: options.llmId };
+    if (options.version !== void 0) {
+      engine.version = options.version;
+    }
+    return engine;
+  } else {
+    const engine = { type: "conversation-flow", conversation_flow_id: options.flowId };
+    if (options.version !== void 0) {
+      engine.version = options.version;
+    }
+    return engine;
+  }
+}
+async function createTestCaseCommand(options) {
+  try {
+    if (!(0, import_fs9.existsSync)(options.file)) {
+      outputError(`Test case file not found: ${options.file}`, "FILE_NOT_FOUND");
+      return;
+    }
+    let input;
+    try {
+      const content = (0, import_fs9.readFileSync)(options.file, "utf-8");
+      input = JSON.parse(content);
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        outputError(`Invalid JSON in test case file: ${error.message}`, "INVALID_JSON");
+      } else {
+        outputError(`Error reading test case file: ${error.message}`, "FILE_READ_ERROR");
+      }
+      return;
+    }
+    if (!input.name) {
+      outputError('Test case must have a "name" field', "INVALID_INPUT");
+      return;
+    }
+    const responseEngine = buildResponseEngine2(options);
+    if (!responseEngine)
+      return;
+    const testCase = await createTestCaseDefinition({
+      name: input.name,
+      user_prompt: input.user_prompt,
+      scenario: input.scenario,
+      metrics: input.metrics,
+      response_engine: responseEngine
+    });
+    const output = {
+      message: "Test case definition created successfully",
+      test_case_definition_id: testCase.test_case_definition_id,
+      name: testCase.name,
+      operation: "create",
+      response_engine: responseEngine
+    };
+    outputJson(output);
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      outputError(`Invalid JSON: ${error.message}`, "INVALID_JSON");
+      return;
+    }
+    handleSdkError(error);
+  }
+}
+
+// src/commands/tests/cases/update.ts
+var import_fs10 = require("fs");
+async function updateTestCaseCommand(testCaseDefinitionId, options) {
+  try {
+    if (!(0, import_fs10.existsSync)(options.file)) {
+      outputError(`Test case file not found: ${options.file}`, "FILE_NOT_FOUND");
+      return;
+    }
+    let input;
+    try {
+      const content = (0, import_fs10.readFileSync)(options.file, "utf-8");
+      input = JSON.parse(content);
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        outputError(`Invalid JSON in test case file: ${error.message}`, "INVALID_JSON");
+      } else {
+        outputError(`Error reading test case file: ${error.message}`, "FILE_READ_ERROR");
+      }
+      return;
+    }
+    const testCase = await updateTestCaseDefinition(testCaseDefinitionId, {
+      name: input.name,
+      user_prompt: input.user_prompt,
+      scenario: input.scenario,
+      metrics: input.metrics
+    });
+    const output = {
+      message: "Test case definition updated successfully",
+      test_case_definition_id: testCase.test_case_definition_id,
+      name: testCase.name,
+      operation: "update",
+      response_engine: testCase.response_engine
+    };
+    outputJson(output);
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      outputError(`Invalid JSON: ${error.message}`, "INVALID_JSON");
+      return;
+    }
+    handleSdkError(error);
+  }
+}
+
+// src/commands/tests/cases/delete.ts
+async function deleteTestCaseCommand(testCaseDefinitionId) {
+  try {
+    await deleteTestCaseDefinition(testCaseDefinitionId);
+    outputJson({
+      message: "Test case definition deleted successfully",
+      test_case_definition_id: testCaseDefinitionId,
+      operation: "delete"
+    });
+  } catch (error) {
+    handleSdkError(error);
+  }
+}
+
+// src/commands/tests/batch/list.ts
+function buildResponseEngine3(options) {
+  if (options.type === "retell-llm") {
+    if (!options.llmId) {
+      outputError("--llm-id is required when type is retell-llm", "MISSING_PARAMETER");
+      return null;
+    }
+    return { type: "retell-llm", llm_id: options.llmId };
+  } else {
+    if (!options.flowId) {
+      outputError("--flow-id is required when type is conversation-flow", "MISSING_PARAMETER");
+      return null;
+    }
+    return { type: "conversation-flow", conversation_flow_id: options.flowId };
+  }
+}
+async function listBatchTestsCommand(options) {
+  try {
+    const responseEngine = buildResponseEngine3(options);
+    if (!responseEngine)
+      return;
+    const batchTests = await listBatchTests(responseEngine);
+    const output = {
+      response_engine: responseEngine,
+      batch_tests: batchTests || [],
+      total_count: (batchTests || []).length
+    };
+    if (options.fields) {
+      const filtered = filterFields(output, options.fields.split(",").map((f) => f.trim()));
+      outputJson(filtered);
+    } else {
+      outputJson(output);
+    }
+  } catch (error) {
+    handleSdkError(error);
+  }
+}
+
+// src/commands/tests/batch/get.ts
+async function getBatchTestCommand(batchJobId, options) {
+  try {
+    const batchTest = await getBatchTest(batchJobId);
+    if (options.fields) {
+      const filtered = filterFields(batchTest, options.fields.split(",").map((f) => f.trim()));
+      outputJson(filtered);
+    } else {
+      outputJson(batchTest);
+    }
+  } catch (error) {
+    handleSdkError(error);
+  }
+}
+
+// src/commands/tests/batch/create.ts
+function buildResponseEngine4(options) {
+  if (options.llmId && options.flowId) {
+    outputError("Cannot specify both --llm-id and --flow-id", "INVALID_PARAMETERS");
+    return null;
+  }
+  if (!options.llmId && !options.flowId) {
+    outputError("Either --llm-id or --flow-id is required", "MISSING_PARAMETER");
+    return null;
+  }
+  if (options.llmId) {
+    const engine = { type: "retell-llm", llm_id: options.llmId };
+    if (options.version !== void 0) {
+      engine.version = options.version;
+    }
+    return engine;
+  } else {
+    const engine = { type: "conversation-flow", conversation_flow_id: options.flowId };
+    if (options.version !== void 0) {
+      engine.version = options.version;
+    }
+    return engine;
+  }
+}
+async function createBatchTestCommand(options) {
+  try {
+    const responseEngine = buildResponseEngine4(options);
+    if (!responseEngine)
+      return;
+    const testCaseDefinitionIds = options.cases.split(",").map((id) => id.trim()).filter(Boolean);
+    if (testCaseDefinitionIds.length === 0) {
+      outputError("At least one test case definition ID is required", "MISSING_PARAMETER");
+      return;
+    }
+    const batchTest = await createBatchTest({
+      response_engine: responseEngine,
+      test_case_definition_ids: testCaseDefinitionIds
+    });
+    const output = {
+      message: "Batch test created successfully",
+      test_case_batch_job_id: batchTest.test_case_batch_job_id,
+      status: batchTest.status,
+      response_engine: responseEngine,
+      test_case_definition_ids: testCaseDefinitionIds
+    };
+    outputJson(output);
+  } catch (error) {
+    handleSdkError(error);
+  }
+}
+
+// src/commands/tests/runs/list.ts
+async function listTestRunsCommand(batchJobId, options) {
+  try {
+    const testRuns = await listTestRuns(batchJobId);
+    const output = {
+      batch_job_id: batchJobId,
+      test_runs: testRuns || [],
+      total_count: (testRuns || []).length
+    };
+    if (options.fields) {
+      const filtered = filterFields(output, options.fields.split(",").map((f) => f.trim()));
+      outputJson(filtered);
+    } else {
+      outputJson(output);
+    }
+  } catch (error) {
+    handleSdkError(error);
+  }
+}
+
+// src/commands/tests/runs/get.ts
+async function getTestRunCommand(testRunId, options) {
+  try {
+    const testRun = await getTestRun(testRunId);
+    if (options.fields) {
+      const filtered = filterFields(testRun, options.fields.split(",").map((f) => f.trim()));
+      outputJson(filtered);
+    } else {
+      outputJson(testRun);
+    }
+  } catch (error) {
+    handleSdkError(error);
+  }
+}
+
+// src/commands/kb/list.ts
+async function listKnowledgeBasesCommand(options) {
+  try {
+    const client = getRetellClient();
+    const knowledgeBases = await client.knowledgeBase.list();
+    const output = options.fields ? filterFields(knowledgeBases, options.fields.split(",").map((f) => f.trim())) : knowledgeBases;
+    outputJson(output);
+  } catch (error) {
+    handleSdkError(error);
+  }
+}
+
+// src/commands/kb/get.ts
+async function getKnowledgeBaseCommand(knowledgeBaseId, options) {
+  try {
+    const client = getRetellClient();
+    const knowledgeBase = await client.knowledgeBase.retrieve(knowledgeBaseId);
+    const output = options.fields ? filterFields(knowledgeBase, options.fields.split(",").map((f) => f.trim())) : knowledgeBase;
+    outputJson(output);
+  } catch (error) {
+    handleSdkError(error);
+  }
+}
+
+// src/commands/kb/create.ts
+var import_fs11 = require("fs");
+async function createKnowledgeBaseCommand(options) {
+  try {
+    if (options.name.length > 40) {
+      outputError("Knowledge base name must be 40 characters or less", "INVALID_NAME");
+      return;
+    }
+    const createParams = {
+      knowledge_base_name: options.name
+    };
+    if (options.autoRefresh) {
+      createParams.enable_auto_refresh = true;
+    }
+    if (options.urls) {
+      const urls = options.urls.split(",").map((u) => u.trim()).filter((u) => u.length > 0);
+      if (urls.length > 0) {
+        createParams.knowledge_base_urls = urls;
+      }
+    }
+    if (options.texts) {
+      if (!(0, import_fs11.existsSync)(options.texts)) {
+        outputError(`Texts file not found: ${options.texts}`, "FILE_NOT_FOUND");
+        return;
+      }
+      try {
+        const content = (0, import_fs11.readFileSync)(options.texts, "utf-8");
+        const textsData = JSON.parse(content);
+        if (!Array.isArray(textsData)) {
+          outputError("Texts file must contain an array of { title, text } objects", "INVALID_TEXTS");
+          return;
+        }
+        const texts = textsData.map((entry, index) => {
+          if (typeof entry !== "object" || entry === null) {
+            throw new Error(`Entry at index ${index} must be an object`);
+          }
+          const e = entry;
+          if (typeof e.title !== "string" || typeof e.text !== "string") {
+            throw new Error(`Entry at index ${index} must have "title" and "text" string fields`);
+          }
+          return { title: e.title, text: e.text };
+        });
+        if (texts.length > 0) {
+          createParams.knowledge_base_texts = texts;
+        }
+      } catch (error) {
+        if (error instanceof SyntaxError) {
+          outputError(`Invalid JSON in texts file: ${error.message}`, "INVALID_JSON");
+        } else if (error instanceof Error) {
+          outputError(`Error parsing texts file: ${error.message}`, "INVALID_TEXTS");
+        }
+        return;
+      }
+    }
+    const client = getRetellClient();
+    const knowledgeBase = await client.knowledgeBase.create(createParams);
+    const output = {
+      message: "Knowledge base created successfully",
+      knowledge_base_id: knowledgeBase.knowledge_base_id,
+      knowledge_base_name: knowledgeBase.knowledge_base_name,
+      operation: "create"
+    };
+    outputJson({
+      ...output,
+      status: knowledgeBase.status,
+      sources_count: knowledgeBase.knowledge_base_sources?.length ?? 0
+    });
+  } catch (error) {
+    handleSdkError(error);
+  }
+}
+
+// src/commands/kb/delete.ts
+async function deleteKnowledgeBaseCommand(knowledgeBaseId) {
+  try {
+    const client = getRetellClient();
+    await client.knowledgeBase.delete(knowledgeBaseId);
+    const output = {
+      message: "Knowledge base deleted successfully",
+      knowledge_base_id: knowledgeBaseId,
+      operation: "delete"
+    };
+    outputJson(output);
+  } catch (error) {
+    handleSdkError(error);
+  }
+}
+
+// src/commands/kb/sources/add.ts
+var import_fs12 = require("fs");
+async function addKnowledgeBaseSourcesCommand(knowledgeBaseId, options) {
+  try {
+    if (!options.urls && !options.texts) {
+      outputError("At least one of --urls or --texts must be provided", "MISSING_SOURCES");
+      return;
+    }
+    const addParams = {};
+    if (options.urls) {
+      const urls = options.urls.split(",").map((u) => u.trim()).filter((u) => u.length > 0);
+      if (urls.length > 0) {
+        addParams.knowledge_base_urls = urls;
+      }
+    }
+    if (options.texts) {
+      if (!(0, import_fs12.existsSync)(options.texts)) {
+        outputError(`Texts file not found: ${options.texts}`, "FILE_NOT_FOUND");
+        return;
+      }
+      try {
+        const content = (0, import_fs12.readFileSync)(options.texts, "utf-8");
+        const textsData = JSON.parse(content);
+        if (!Array.isArray(textsData)) {
+          outputError("Texts file must contain an array of { title, text } objects", "INVALID_TEXTS");
+          return;
+        }
+        const texts = textsData.map((entry, index) => {
+          if (typeof entry !== "object" || entry === null) {
+            throw new Error(`Entry at index ${index} must be an object`);
+          }
+          const e = entry;
+          if (typeof e.title !== "string" || typeof e.text !== "string") {
+            throw new Error(`Entry at index ${index} must have "title" and "text" string fields`);
+          }
+          return { title: e.title, text: e.text };
+        });
+        if (texts.length > 0) {
+          addParams.knowledge_base_texts = texts;
+        }
+      } catch (error) {
+        if (error instanceof SyntaxError) {
+          outputError(`Invalid JSON in texts file: ${error.message}`, "INVALID_JSON");
+        } else if (error instanceof Error) {
+          outputError(`Error parsing texts file: ${error.message}`, "INVALID_TEXTS");
+        }
+        return;
+      }
+    }
+    const client = getRetellClient();
+    const knowledgeBase = await client.knowledgeBase.addSources(knowledgeBaseId, addParams);
+    const output = {
+      message: "Sources added successfully",
+      knowledge_base_id: knowledgeBase.knowledge_base_id,
+      knowledge_base_name: knowledgeBase.knowledge_base_name,
+      operation: "add_sources"
+    };
+    outputJson({
+      ...output,
+      status: knowledgeBase.status,
+      sources_count: knowledgeBase.knowledge_base_sources?.length ?? 0
+    });
+  } catch (error) {
+    handleSdkError(error);
+  }
+}
+
+// src/commands/kb/sources/delete.ts
+async function deleteKnowledgeBaseSourceCommand(knowledgeBaseId, sourceId) {
+  try {
+    const client = getRetellClient();
+    const knowledgeBase = await client.knowledgeBase.deleteSource(knowledgeBaseId, sourceId);
+    const output = {
+      message: "Source deleted successfully",
+      knowledge_base_id: knowledgeBase.knowledge_base_id,
+      knowledge_base_name: knowledgeBase.knowledge_base_name,
+      operation: "delete_source"
+    };
+    outputJson({
+      ...output,
+      status: knowledgeBase.status,
+      sources_count: knowledgeBase.knowledge_base_sources?.length ?? 0
+    });
+  } catch (error) {
+    handleSdkError(error);
+  }
+}
+
+// src/commands/flows/list.ts
+async function listFlowsCommand(options) {
+  try {
+    const client = getRetellClient();
+    const flows2 = await client.conversationFlow.list({
+      limit: options.limit || 100
+    });
+    const output = options.fields ? filterFields(flows2, options.fields.split(",").map((f) => f.trim())) : flows2;
+    outputJson(output);
+  } catch (error) {
+    handleSdkError(error);
+  }
+}
+
+// src/commands/flows/get.ts
+async function getFlowCommand(conversationFlowId, options) {
+  try {
+    const client = getRetellClient();
+    const retrieveOptions = {};
+    if (options.version !== void 0) {
+      retrieveOptions.version = options.version;
+    }
+    const flow = await client.conversationFlow.retrieve(conversationFlowId, retrieveOptions);
+    const output = options.fields ? filterFields(flow, options.fields.split(",").map((f) => f.trim())) : flow;
+    outputJson(output);
+  } catch (error) {
+    handleSdkError(error);
+  }
+}
+
+// src/commands/flows/create.ts
+var import_fs13 = require("fs");
+async function createFlowCommand(options) {
+  try {
+    if (!(0, import_fs13.existsSync)(options.file)) {
+      outputError(`Flow file not found: ${options.file}`, "FILE_NOT_FOUND");
+      return;
+    }
+    let flowConfig;
+    try {
+      const content = (0, import_fs13.readFileSync)(options.file, "utf-8");
+      flowConfig = JSON.parse(content);
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        outputError(`Invalid JSON in flow file: ${error.message}`, "INVALID_JSON");
+      } else if (error instanceof Error) {
+        outputError(`Error reading flow file: ${error.message}`, "FILE_READ_ERROR");
+      }
+      return;
+    }
+    if (!flowConfig.start_speaker) {
+      outputError('Flow configuration must have a "start_speaker" field (user or agent)', "INVALID_FLOW");
+      return;
+    }
+    const client = getRetellClient();
+    const flow = await client.conversationFlow.create(flowConfig);
+    const output = {
+      message: "Conversation flow created successfully",
+      conversation_flow_id: flow.conversation_flow_id,
+      version: flow.version,
+      operation: "create"
+    };
+    outputJson(output);
+  } catch (error) {
+    handleSdkError(error);
+  }
+}
+
+// src/commands/flows/update.ts
+var import_fs14 = require("fs");
+async function updateFlowCommand(conversationFlowId, options) {
+  try {
+    if (!(0, import_fs14.existsSync)(options.file)) {
+      outputError(`Flow file not found: ${options.file}`, "FILE_NOT_FOUND");
+      return;
+    }
+    let flowUpdates;
+    try {
+      const content = (0, import_fs14.readFileSync)(options.file, "utf-8");
+      flowUpdates = JSON.parse(content);
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        outputError(`Invalid JSON in flow file: ${error.message}`, "INVALID_JSON");
+      } else if (error instanceof Error) {
+        outputError(`Error reading flow file: ${error.message}`, "FILE_READ_ERROR");
+      }
+      return;
+    }
+    if (options.version !== void 0) {
+      flowUpdates.version = options.version;
+    }
+    const client = getRetellClient();
+    const flow = await client.conversationFlow.update(conversationFlowId, flowUpdates);
+    const output = {
+      message: "Conversation flow updated successfully",
+      conversation_flow_id: flow.conversation_flow_id,
+      version: flow.version,
+      operation: "update"
+    };
+    outputJson(output);
+  } catch (error) {
+    handleSdkError(error);
+  }
+}
+
+// src/commands/flows/delete.ts
+async function deleteFlowCommand(conversationFlowId) {
+  try {
+    const client = getRetellClient();
+    await client.conversationFlow.delete(conversationFlowId);
+    const output = {
+      message: "Conversation flow deleted successfully",
+      conversation_flow_id: conversationFlowId,
+      operation: "delete"
+    };
+    outputJson(output);
+  } catch (error) {
+    handleSdkError(error);
+  }
+}
+
+// src/index.ts
+var packageJson = JSON.parse(
+  (0, import_fs15.readFileSync)((0, import_path6.join)(__dirname, "../package.json"), "utf-8")
+);
+var program = new import_commander.Command();
+program.name("retell").description("Retell AI CLI - Manage transcripts and agent prompts").version(packageJson.version, "-v, --version", "Display version number").helpOption("-h, --help", "Display help for command").option("--json", "Output as JSON (default)", true);
+program.command("login").description("Authenticate with Retell AI").addHelpText("after", `
+Examples:
+  $ retell login
+  # Enter your API key when prompted
+  # Creates .retellrc.json in current directory
+  `).action(async () => {
+  await loginCommand();
+});
+var transcripts = program.command("transcripts").description("Manage call transcripts");
+transcripts.command("list").description("List all call transcripts").option("-l, --limit <number>", "Maximum number of calls to return (default: 50)", "50").option("--fields <fields>", "Comma-separated list of fields to return (e.g., call_id,call_status,metadata.duration)").addHelpText("after", `
+Examples:
+  $ retell transcripts list
+  $ retell transcripts list --limit 100
+  $ retell transcripts list --fields call_id,call_status
+  $ retell transcripts list | jq '.[] | select(.call_status == "error")'
+  `).action(async (options) => {
+  const limit = parseInt(options.limit, 10);
+  if (isNaN(limit) || limit < 1) {
+    console.error("Error: limit must be a positive number");
+    process.exit(1);
+  }
+  await listTranscriptsCommand({
+    limit,
+    fields: options.fields
+  });
+});
+transcripts.command("get <call_id>").description("Get a specific call transcript").option("--fields <fields>", "Comma-separated list of fields to return (e.g., call_id,metadata.duration,analysis)").addHelpText("after", `
+Examples:
+  $ retell transcripts get call_abc123
+  $ retell transcripts get call_abc123 --fields call_id,metadata.duration
+  $ retell transcripts get call_abc123 | jq '.transcript_object'
+  `).action(async (callId, options) => {
+  await getTranscriptCommand(callId, {
+    fields: options.fields
+  });
+});
+transcripts.command("analyze <call_id>").description("Analyze a call transcript with performance metrics and insights").option("--fields <fields>", "Comma-separated list of fields to return (e.g., call_id,performance,analysis.summary)").option("--raw", "Return unmodified API response instead of enriched analysis").option("--hotspots-only", "Return only conversation hotspots/issues for troubleshooting").option("--latency-threshold <ms>", `Latency threshold in ms for hotspot detection (default: ${DEFAULT_LATENCY_THRESHOLD})`, String(DEFAULT_LATENCY_THRESHOLD)).option("--silence-threshold <ms>", `Silence threshold in ms for hotspot detection (default: ${DEFAULT_SILENCE_THRESHOLD})`, String(DEFAULT_SILENCE_THRESHOLD)).addHelpText("after", `
+Examples:
+  $ retell transcripts analyze call_abc123
+  $ retell transcripts analyze call_abc123 --fields call_id,performance
+  $ retell transcripts analyze call_abc123 --raw
+  $ retell transcripts analyze call_abc123 --raw --fields call_id,transcript_object
+  $ retell transcripts analyze call_abc123 --hotspots-only
+  $ retell transcripts analyze call_abc123 --hotspots-only --latency-threshold 1500
+  $ retell transcripts analyze call_abc123 --hotspots-only --fields hotspots
+  $ retell transcripts analyze call_abc123 | jq '.performance.latency_p50_ms'
+  `).action(async (callId, options) => {
+  await analyzeTranscriptCommand(callId, {
+    fields: options.fields,
+    raw: options.raw,
+    hotspotsOnly: options.hotspotsOnly,
+    latencyThreshold: options.latencyThreshold ? parseInt(options.latencyThreshold) : void 0,
+    silenceThreshold: options.silenceThreshold ? parseInt(options.silenceThreshold) : void 0
+  });
+});
+transcripts.command("search").description("Search transcripts with advanced filtering").option("--status <status>", "Filter by call status (error, ended, ongoing)").option("--agent-id <id>", "Filter by agent ID").option("--since <date>", "Filter calls after this date (YYYY-MM-DD or ISO format)").option("--until <date>", "Filter calls before this date (YYYY-MM-DD or ISO format)").option("--limit <number>", "Maximum number of results (default: 50)", "50").option("--fields <fields>", "Comma-separated list of fields to return").addHelpText("after", `
+Examples:
+  $ retell transcripts search --status error
+  $ retell transcripts search --agent-id agent_123 --since 2025-11-01
+  $ retell transcripts search --status error --limit 10
+  $ retell transcripts search --status error --fields call_id,agent_id,call_status
+  $ retell transcripts search --since 2025-11-01 --until 2025-11-15
+  `).action(async (options) => {
+  await searchTranscriptsCommand({
+    status: options.status,
+    agentId: options.agentId,
+    since: options.since,
+    until: options.until,
+    limit: options.limit ? Number(options.limit) : void 0,
+    fields: options.fields
+  });
+});
+var agents = program.command("agents").description("Manage agents");
+agents.command("list").description("List all agents").option("-l, --limit <number>", "Maximum number of agents to return (default: 100)", "100").option("--fields <fields>", "Comma-separated list of fields to return (e.g., agent_id,agent_name,response_engine_type)").addHelpText("after", `
+Examples:
+  $ retell agents list
+  $ retell agents list --limit 10
+  $ retell agents list --fields agent_id,agent_name
+  $ retell agents list | jq '.[] | select(.response_engine.type == "retell-llm")'
+  `).action(async (options) => {
+  const limit = parseInt(options.limit, 10);
+  if (isNaN(limit) || limit < 1) {
+    console.error("Error: limit must be a positive number");
+    process.exit(1);
+  }
+  await listAgentsCommand({
+    limit,
+    fields: options.fields
+  });
+});
+agents.command("info <agent_id>").description("Get detailed agent information").option("--fields <fields>", "Comma-separated list of fields to return (e.g., agent_name,response_engine.type,voice_config)").addHelpText("after", `
+Examples:
+  $ retell agents info agent_123abc
+  $ retell agents info agent_123abc --fields agent_name,response_engine.type
+  $ retell agents info agent_123abc | jq '.response_engine.type'
+  `).action(async (agentId, options) => {
+  await agentInfoCommand(agentId, {
+    fields: options.fields
+  });
+});
+var prompts = program.command("prompts").description("Manage agent prompts");
+prompts.command("pull <agent_id>").description("Download agent prompts to a local file").option("-o, --output <path>", "Output file path (default: .retell-prompts/<agent_id>.json)", ".retell-prompts").addHelpText("after", `
+Examples:
+  $ retell prompts pull agent_123abc
+  $ retell prompts pull agent_123abc --output my-prompts.json
+  `).action(async (agentId, options) => {
+  await pullPromptsCommand(agentId, options);
+});
+prompts.command("diff <agent_id>").description("Show differences between local and remote prompts").option("-s, --source <path>", "Source directory path (default: .retell-prompts)", ".retell-prompts").option("-f, --fields <fields>", "Comma-separated list of fields to return").addHelpText("after", `
+Examples:
+  $ retell prompts diff agent_123abc
+  $ retell prompts diff agent_123abc --source ./custom-prompts
+  $ retell prompts diff agent_123abc --fields has_changes,changes.general_prompt
+  `).action(async (agentId, options) => {
+  await diffPromptsCommand(agentId, options);
+});
+prompts.command("update <agent_id>").description("Update agent prompts from a local file").option("-s, --source <path>", "Source file path (default: .retell-prompts/<agent_id>.json)", ".retell-prompts").option("--dry-run", "Preview changes without applying them", false).addHelpText("after", `
+Examples:
+  $ retell prompts update agent_123abc --source my-prompts.json --dry-run
+  $ retell prompts update agent_123abc --source my-prompts.json
+  # Remember to publish: retell agent-publish agent_123abc
+  `).action(async (agentId, options) => {
+  await updatePromptsCommand(agentId, options);
+});
+program.command("agent-publish <agent_id>").description("Publish a draft agent to make changes live").addHelpText("after", `
+Examples:
+  $ retell agent-publish agent_123abc
+  # Run this after updating prompts to make changes live
+  `).action(async (agentId) => {
+  await publishAgentCommand(agentId);
+});
+var tools = program.command("tools").description("Manage agent tools (custom functions, webhooks, etc.)");
+tools.command("list <agent_id>").description("List all tools configured for an agent").option("--state <name>", "Filter by state name (Retell LLM only)").option("--component <id>", "Filter by component ID (Conversation Flow only)").option("--fields <fields>", "Comma-separated list of fields to return").addHelpText("after", `
+Examples:
+  $ retell tools list agent_123abc
+  $ retell tools list agent_123abc --state greeting
+  $ retell tools list agent_123abc --fields total_count,general_tools
+  `).action(async (agentId, options) => {
+  await listToolsCommand(agentId, {
+    state: options.state,
+    component: options.component,
+    fields: options.fields
+  });
+});
+tools.command("get <agent_id> <tool_name>").description("Get detailed information about a specific tool").option("--state <name>", "State name to search within (Retell LLM only)").option("--component <id>", "Component ID to search within (Conversation Flow only)").option("--fields <fields>", "Comma-separated list of fields to return").addHelpText("after", `
+Examples:
+  $ retell tools get agent_123abc lookup_customer
+  $ retell tools get agent_123abc book_cal --state booking
+  $ retell tools get agent_123abc my_tool --fields tool.name,tool.type
+  `).action(async (agentId, toolName, options) => {
+  await getToolCommand(agentId, toolName, {
+    state: options.state,
+    component: options.component,
+    fields: options.fields
+  });
+});
+tools.command("add <agent_id>").description("Add a new tool to an agent").requiredOption("-f, --file <path>", "Path to JSON file containing tool definition").option("--state <name>", "Add to specific state (Retell LLM only)").option("--component <id>", "Add to specific component (Conversation Flow only)").option("--dry-run", "Preview changes without applying them").addHelpText("after", `
+Examples:
+  $ retell tools add agent_123abc --file tool.json
+  $ retell tools add agent_123abc --file tool.json --state booking
+  $ retell tools add agent_123abc --file tool.json --dry-run
+  `).action(async (agentId, options) => {
+  await addToolCommand(agentId, {
+    file: options.file,
+    state: options.state,
+    component: options.component,
+    dryRun: options.dryRun
+  });
+});
+tools.command("update <agent_id> <tool_name>").description("Update an existing tool").requiredOption("-f, --file <path>", "Path to JSON file containing updated tool definition").option("--state <name>", "State where tool exists (Retell LLM only)").option("--component <id>", "Component where tool exists (Conversation Flow only)").option("--dry-run", "Preview changes without applying them").addHelpText("after", `
+Examples:
+  $ retell tools update agent_123abc lookup_customer --file tool.json
+  $ retell tools update agent_123abc book_cal --file tool.json --state booking
+  $ retell tools update agent_123abc my_tool --file tool.json --dry-run
+  `).action(async (agentId, toolName, options) => {
+  await updateToolCommand(agentId, toolName, {
+    file: options.file,
+    state: options.state,
+    component: options.component,
+    dryRun: options.dryRun
+  });
+});
+tools.command("remove <agent_id> <tool_name>").description("Remove a tool from an agent").option("--state <name>", "State where tool exists (Retell LLM only)").option("--component <id>", "Component where tool exists (Conversation Flow only)").option("--dry-run", "Preview changes without applying them").addHelpText("after", `
+Examples:
+  $ retell tools remove agent_123abc lookup_customer
+  $ retell tools remove agent_123abc book_cal --state booking
+  $ retell tools remove agent_123abc my_tool --dry-run
+  `).action(async (agentId, toolName, options) => {
+  await removeToolCommand(agentId, toolName, {
+    state: options.state,
+    component: options.component,
+    dryRun: options.dryRun
+  });
+});
+tools.command("export <agent_id>").description("Export all tools from an agent to a JSON file").option("-o, --output <path>", "Output file path (prints to stdout if not specified)").addHelpText("after", `
+Examples:
+  $ retell tools export agent_123abc
+  $ retell tools export agent_123abc --output tools.json
+  $ retell tools export agent_123abc > tools.json
+  `).action(async (agentId, options) => {
+  await exportToolsCommand(agentId, {
+    output: options.output
+  });
+});
+tools.command("import <agent_id>").description("Import tools from a JSON file to an agent").requiredOption("-f, --file <path>", "Path to JSON file containing tools to import").option("--dry-run", "Preview changes without applying them").option("--replace", "Replace existing tools with same name instead of skipping").addHelpText("after", `
+Examples:
+  $ retell tools import agent_123abc --file tools.json
+  $ retell tools import agent_123abc --file tools.json --dry-run
+  $ retell tools import agent_123abc --file tools.json --replace
+  `).action(async (agentId, options) => {
+  await importToolsCommand(agentId, {
+    file: options.file,
+    dryRun: options.dryRun,
+    replace: options.replace
+  });
+});
+var tests = program.command("tests").description("Manage test cases, batch tests, and test runs");
+var testsCases = tests.command("cases").description("Manage test case definitions");
+testsCases.command("list").description("List all test case definitions for an LLM or flow").requiredOption("-t, --type <type>", "Response engine type (retell-llm or conversation-flow)").option("--llm-id <id>", "LLM ID (required when type is retell-llm)").option("--flow-id <id>", "Flow ID (required when type is conversation-flow)").option("--fields <fields>", "Comma-separated list of fields to return").addHelpText("after", `
+Examples:
+  $ retell tests cases list --type retell-llm --llm-id llm_abc123
+  $ retell tests cases list --type conversation-flow --flow-id cf_abc123
+  $ retell tests cases list --type retell-llm --llm-id llm_abc123 --fields test_case_definitions
+  `).action(async (options) => {
+  if (options.type !== "retell-llm" && options.type !== "conversation-flow") {
+    console.error('Error: type must be "retell-llm" or "conversation-flow"');
+    process.exit(1);
+  }
+  await listTestCasesCommand({
+    type: options.type,
+    llmId: options.llmId,
+    flowId: options.flowId,
+    fields: options.fields
+  });
+});
+testsCases.command("get <test_case_definition_id>").description("Get a specific test case definition").option("--fields <fields>", "Comma-separated list of fields to return").addHelpText("after", `
+Examples:
+  $ retell tests cases get tcd_abc123
+  $ retell tests cases get tcd_abc123 --fields name,user_prompt
+  `).action(async (testCaseDefinitionId, options) => {
+  await getTestCaseCommand(testCaseDefinitionId, {
+    fields: options.fields
+  });
+});
+testsCases.command("create").description("Create a new test case definition from a JSON file").requiredOption("-f, --file <path>", "Path to JSON file containing test case definition").option("--llm-id <id>", "LLM ID (mutually exclusive with --flow-id)").option("--flow-id <id>", "Flow ID (mutually exclusive with --llm-id)").option("--version <number>", "Version of the LLM or flow (optional)").addHelpText("after", `
+Examples:
+  $ retell tests cases create --file test-case.json --llm-id llm_abc123
+  $ retell tests cases create --file test-case.json --flow-id cf_abc123
+  $ retell tests cases create --file test-case.json --llm-id llm_abc123 --version 2
+
+Test case JSON format:
+  {
+    "name": "Greeting Test",
+    "user_prompt": "Hello, I need help with my order",
+    "scenario": "User is calling about an order issue",
+    "metrics": ["response_quality", "task_completion"]
+  }
+  `).action(async (options) => {
+  await createTestCaseCommand({
+    file: options.file,
+    llmId: options.llmId,
+    flowId: options.flowId,
+    version: options.version ? parseInt(options.version, 10) : void 0
+  });
+});
+testsCases.command("update <test_case_definition_id>").description("Update an existing test case definition from a JSON file").requiredOption("-f, --file <path>", "Path to JSON file containing test case updates").addHelpText("after", `
+Examples:
+  $ retell tests cases update tcd_abc123 --file test-case.json
+  `).action(async (testCaseDefinitionId, options) => {
+  await updateTestCaseCommand(testCaseDefinitionId, {
+    file: options.file
+  });
+});
+testsCases.command("delete <test_case_definition_id>").description("Delete a test case definition").addHelpText("after", `
+Examples:
+  $ retell tests cases delete tcd_abc123
+  `).action(async (testCaseDefinitionId) => {
+  await deleteTestCaseCommand(testCaseDefinitionId);
+});
+var testsBatch = tests.command("batch").description("Manage batch tests");
+testsBatch.command("list").description("List all batch tests for an LLM or flow").requiredOption("-t, --type <type>", "Response engine type (retell-llm or conversation-flow)").option("--llm-id <id>", "LLM ID (required when type is retell-llm)").option("--flow-id <id>", "Flow ID (required when type is conversation-flow)").option("--fields <fields>", "Comma-separated list of fields to return").addHelpText("after", `
+Examples:
+  $ retell tests batch list --type retell-llm --llm-id llm_abc123
+  $ retell tests batch list --type conversation-flow --flow-id cf_abc123
+  $ retell tests batch list --type retell-llm --llm-id llm_abc123 --fields batch_tests
+  `).action(async (options) => {
+  if (options.type !== "retell-llm" && options.type !== "conversation-flow") {
+    console.error('Error: type must be "retell-llm" or "conversation-flow"');
+    process.exit(1);
+  }
+  await listBatchTestsCommand({
+    type: options.type,
+    llmId: options.llmId,
+    flowId: options.flowId,
+    fields: options.fields
+  });
+});
+testsBatch.command("get <batch_job_id>").description("Get a specific batch test with its status and stats").option("--fields <fields>", "Comma-separated list of fields to return").addHelpText("after", `
+Examples:
+  $ retell tests batch get bjj_abc123
+  $ retell tests batch get bjj_abc123 --fields status,stats
+  `).action(async (batchJobId, options) => {
+  await getBatchTestCommand(batchJobId, {
+    fields: options.fields
+  });
+});
+testsBatch.command("create").description("Create a new batch test with specified test case definitions").option("--llm-id <id>", "LLM ID (mutually exclusive with --flow-id)").option("--flow-id <id>", "Flow ID (mutually exclusive with --llm-id)").requiredOption("--cases <ids>", "Comma-separated list of test case definition IDs").option("--version <number>", "Version of the LLM or flow (optional)").addHelpText("after", `
+Examples:
+  $ retell tests batch create --llm-id llm_abc123 --cases tcd_xxx,tcd_yyy,tcd_zzz
+  $ retell tests batch create --flow-id cf_abc123 --cases tcd_xxx,tcd_yyy
+  $ retell tests batch create --llm-id llm_abc123 --cases tcd_xxx --version 2
+  `).action(async (options) => {
+  await createBatchTestCommand({
+    llmId: options.llmId,
+    flowId: options.flowId,
+    cases: options.cases,
+    version: options.version ? parseInt(options.version, 10) : void 0
+  });
+});
+var testsRuns = tests.command("runs").description("View test run results");
+testsRuns.command("list <batch_job_id>").description("List all test runs for a batch test").option("--fields <fields>", "Comma-separated list of fields to return").addHelpText("after", `
+Examples:
+  $ retell tests runs list bjj_abc123
+  $ retell tests runs list bjj_abc123 --fields test_runs
+  `).action(async (batchJobId, options) => {
+  await listTestRunsCommand(batchJobId, {
+    fields: options.fields
+  });
+});
+testsRuns.command("get <test_run_id>").description("Get a specific test run result").option("--fields <fields>", "Comma-separated list of fields to return").addHelpText("after", `
+Examples:
+  $ retell tests runs get tcj_abc123
+  $ retell tests runs get tcj_abc123 --fields status,metric_results
+  `).action(async (testRunId, options) => {
+  await getTestRunCommand(testRunId, {
+    fields: options.fields
+  });
+});
+var kb = program.command("kb").description("Manage RAG knowledge bases");
+kb.command("list").description("List all knowledge bases").option("--fields <fields>", "Comma-separated list of fields to return").addHelpText("after", `
+Examples:
+  $ retell kb list
+  $ retell kb list --fields knowledge_base_id,knowledge_base_name,status
+  `).action(async (options) => {
+  await listKnowledgeBasesCommand({
+    fields: options.fields
+  });
+});
+kb.command("get <knowledge_base_id>").description("Get a specific knowledge base").option("--fields <fields>", "Comma-separated list of fields to return").addHelpText("after", `
+Examples:
+  $ retell kb get kb_abc123
+  $ retell kb get kb_abc123 --fields knowledge_base_name,status,knowledge_base_sources
+  `).action(async (knowledgeBaseId, options) => {
+  await getKnowledgeBaseCommand(knowledgeBaseId, {
+    fields: options.fields
+  });
+});
+kb.command("create").description("Create a new knowledge base").requiredOption("-n, --name <name>", "Knowledge base name (max 40 characters)").option("--urls <urls>", "Comma-separated list of URLs to scrape").option("--texts <file>", "Path to JSON file with text entries [{ title, text }, ...]").option("--auto-refresh", "Enable 12-hour automatic refresh for URL sources").addHelpText("after", `
+Examples:
+  $ retell kb create --name "Product Docs"
+  $ retell kb create --name "Support KB" --urls https://docs.example.com,https://help.example.com
+  $ retell kb create --name "FAQ" --texts texts.json
+  $ retell kb create --name "Docs" --urls https://docs.example.com --auto-refresh
+
+Text file format (texts.json):
+  [
+    { "title": "Getting Started", "text": "Welcome to our product..." },
+    { "title": "FAQ", "text": "Frequently asked questions..." }
+  ]
+  `).action(async (options) => {
+  await createKnowledgeBaseCommand({
+    name: options.name,
+    urls: options.urls,
+    texts: options.texts,
+    autoRefresh: options.autoRefresh
+  });
+});
+kb.command("delete <knowledge_base_id>").description("Delete a knowledge base").addHelpText("after", `
+Examples:
+  $ retell kb delete kb_abc123
+  `).action(async (knowledgeBaseId) => {
+  await deleteKnowledgeBaseCommand(knowledgeBaseId);
+});
+var kbSources = kb.command("sources").description("Manage knowledge base sources");
+kbSources.command("add <knowledge_base_id>").description("Add sources to an existing knowledge base").option("--urls <urls>", "Comma-separated list of URLs to scrape").option("--texts <file>", "Path to JSON file with text entries [{ title, text }, ...]").addHelpText("after", `
+Examples:
+  $ retell kb sources add kb_abc123 --urls https://docs.example.com/new
+  $ retell kb sources add kb_abc123 --texts additional-texts.json
+  $ retell kb sources add kb_abc123 --urls https://faq.example.com --texts more-texts.json
+  `).action(async (knowledgeBaseId, options) => {
+  await addKnowledgeBaseSourcesCommand(knowledgeBaseId, {
+    urls: options.urls,
+    texts: options.texts
+  });
+});
+kbSources.command("delete <knowledge_base_id> <source_id>").description("Remove a source from a knowledge base").addHelpText("after", `
+Examples:
+  $ retell kb sources delete kb_abc123 source_xyz789
+  `).action(async (knowledgeBaseId, sourceId) => {
+  await deleteKnowledgeBaseSourceCommand(knowledgeBaseId, sourceId);
+});
+var flows = program.command("flows").description("Manage conversation flow response engines");
+flows.command("list").description("List all conversation flows").option("-l, --limit <number>", "Maximum number of flows to return (default: 100, max: 1000)", "100").option("--fields <fields>", "Comma-separated list of fields to return").addHelpText("after", `
+Examples:
+  $ retell flows list
+  $ retell flows list --limit 50
+  $ retell flows list --fields conversation_flow_id,version,start_speaker
+  `).action(async (options) => {
+  const limit = parseInt(options.limit, 10);
+  if (isNaN(limit) || limit < 1 || limit > 1e3) {
+    console.error("Error: limit must be a positive number between 1 and 1000");
+    process.exit(1);
+  }
+  await listFlowsCommand({
+    limit,
+    fields: options.fields
+  });
+});
+flows.command("get <conversation_flow_id>").description("Get a specific conversation flow").option("--version <number>", "Specific version to retrieve (defaults to latest)").option("--fields <fields>", "Comma-separated list of fields to return").addHelpText("after", `
+Examples:
+  $ retell flows get cf_abc123
+  $ retell flows get cf_abc123 --version 2
+  $ retell flows get cf_abc123 --fields conversation_flow_id,nodes,edges
+  `).action(async (conversationFlowId, options) => {
+  await getFlowCommand(conversationFlowId, {
+    version: options.version ? parseInt(options.version, 10) : void 0,
+    fields: options.fields
+  });
+});
+flows.command("create").description("Create a new conversation flow from a JSON file").requiredOption("-f, --file <path>", "Path to JSON file containing flow configuration").addHelpText("after", `
+Examples:
+  $ retell flows create --file flow.json
+
+Flow JSON format (minimal):
+  {
+    "start_speaker": "agent",
+    "start_node_id": "node_1",
+    "nodes": [...],
+    "edges": [...]
+  }
+  `).action(async (options) => {
+  await createFlowCommand({
+    file: options.file
+  });
+});
+flows.command("update <conversation_flow_id>").description("Update an existing conversation flow from a JSON file").requiredOption("-f, --file <path>", "Path to JSON file containing flow updates").option("--version <number>", "Specific version to update (defaults to latest)").addHelpText("after", `
+Examples:
+  $ retell flows update cf_abc123 --file updates.json
+  $ retell flows update cf_abc123 --file updates.json --version 2
+  `).action(async (conversationFlowId, options) => {
+  await updateFlowCommand(conversationFlowId, {
+    file: options.file,
+    version: options.version ? parseInt(options.version, 10) : void 0
+  });
+});
+flows.command("delete <conversation_flow_id>").description("Delete a conversation flow").addHelpText("after", `
+Examples:
+  $ retell flows delete cf_abc123
+  `).action(async (conversationFlowId) => {
+  await deleteFlowCommand(conversationFlowId);
 });
 program.parse(process.argv);
 if (!process.argv.slice(2).length) {