@runtypelabs/cli 2.59.0 → 2.59.2

package/dist/chunk-CrlqIfmb.js

@@ -0,0 +1,337 @@
+#!/usr/bin/env node
+import { I as __exportAll } from "./index.js";
+import { s as getDashboardUrl } from "./chunk-BW2fg46T.js";
+import open from "open";
+import { useCallback, useMemo, useRef, useState } from "react";
+import { Box, Text, useInput, useStdout } from "ink";
+import { theme } from "@runtypelabs/ink-components";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+// src/ink/talk/ModelPicker.tsx
+var ModelPicker_exports = /* @__PURE__ */ __exportAll({
+	DEFAULT_MODELS: () => DEFAULT_MODELS,
+	ModelPicker: () => ModelPicker
+});
+const DEFAULT_MODELS = [
+	{
+		label: "Claude Opus 4.6",
+		value: "claude-opus-4-6",
+		group: "Anthropic"
+	},
+	{
+		label: "Claude Sonnet 4.6",
+		value: "claude-sonnet-4-6",
+		group: "Anthropic"
+	},
+	{
+		label: "Claude Haiku 4.5",
+		value: "claude-haiku-4-5",
+		group: "Anthropic"
+	},
+	{
+		label: "GPT-5",
+		value: "gpt-5",
+		group: "OpenAI"
+	},
+	{
+		label: "GPT-5 Mini",
+		value: "gpt-5-mini",
+		group: "OpenAI"
+	},
+	{
+		label: "GPT-4.1",
+		value: "gpt-4.1",
+		group: "OpenAI"
+	},
+	{
+		label: "GPT-4.1 Mini",
+		value: "gpt-4.1-mini",
+		group: "OpenAI"
+	},
+	{
+		label: "GPT-4.1 Nano",
+		value: "gpt-4.1-nano",
+		group: "OpenAI"
+	},
+	{
+		label: "GPT-5 Nano",
+		value: "gpt-5-nano",
+		group: "OpenAI"
+	},
+	{
+		label: "Gemini 3.1 Pro",
+		value: "gemini-3.1-pro",
+		group: "Google"
+	},
+	{
+		label: "Gemini 3 Pro Image",
+		value: "gemini-3-pro-image",
+		group: "Google"
+	},
+	{
+		label: "Gemini 3.1 Flash-Lite",
+		value: "gemini-3-1-flash-lite",
+		group: "Google"
+	},
+	{
+		label: "Gemini 2.5 Pro",
+		value: "gemini-2.5-pro",
+		group: "Google"
+	},
+	{
+		label: "Gemini 2.5 Flash",
+		value: "gemini-2.5-flash",
+		group: "Google"
+	},
+	{
+		label: "Gemini 2.5 Flash Image",
+		value: "gemini-2.5-flash-image",
+		group: "Google"
+	},
+	{
+		label: "Gemini 2.5 Flash-Lite",
+		value: "gemini-2.5-flash-lite",
+		group: "Google"
+	},
+	{
+		label: "Grok 4",
+		value: "grok-4",
+		group: "xAI"
+	},
+	{
+		label: "Grok 4 Fast",
+		value: "grok-4-fast",
+		group: "xAI"
+	},
+	{
+		label: "Grok 4.1 Fast",
+		value: "grok-4.1-fast",
+		group: "xAI"
+	},
+	{
+		label: "Qwen 3.5 Plus",
+		value: "qwen3.5-plus",
+		group: "Qwen"
+	},
+	{
+		label: "Qwen 3.5 35B A3B",
+		value: "qwen3.5-35b-a3b",
+		group: "Qwen"
+	},
+	{
+		label: "Qwen 3.5 Flash",
+		value: "qwen3.5-flash",
+		group: "Qwen"
+	},
+	{
+		label: "Qwen 3 8B",
+		value: "qwen/qwen3-8b",
+		group: "Qwen"
+	}
+];
+/** Max visible rows in the model list (excluding header/footer) */
+const MAX_VISIBLE = 12;
+function ModelPicker({ currentModel, onSelect, onCancel, models }) {
+	const { stdout } = useStdout();
+	const [search, setSearch] = useState("");
+	const availableModels = models && models.length > 0 ? models : DEFAULT_MODELS;
+	const contentWidth = (stdout?.columns ?? 120) - 4;
+	const pad = useCallback((text) => text.length < contentWidth ? text + " ".repeat(contentWidth - text.length) : text, [contentWidth]);
+	const sorted = useMemo(() => [...availableModels].sort((a, b) => a.group.localeCompare(b.group)), [availableModels]);
+	const filtered = useMemo(() => {
+		if (!search.trim()) return sorted;
+		const q = search.toLowerCase();
+		return sorted.filter((m) => m.label.toLowerCase().includes(q) || m.value.toLowerCase().includes(q) || m.group.toLowerCase().includes(q));
+	}, [sorted, search]);
+	const searchRef = useRef("");
+	const cursorRef = useRef(0);
+	const [cursorPos, setCursorPos] = useState(0);
+	const [selectedIndex, setSelectedIndex] = useState(() => {
+		const currentIndex = sorted.findIndex((model) => model.value === currentModel);
+		return currentIndex >= 0 ? currentIndex : 0;
+	});
+	const safeIndex = filtered.length > 0 ? Math.min(selectedIndex, filtered.length - 1) : 0;
+	const applySearch = useCallback((newValue, newCursor) => {
+		searchRef.current = newValue;
+		cursorRef.current = newCursor;
+		setSearch(newValue);
+		setCursorPos(newCursor);
+		if (!newValue.trim()) {
+			const idx = sorted.findIndex((model) => model.value === currentModel);
+			setSelectedIndex(idx >= 0 ? idx : 0);
+		} else setSelectedIndex(0);
+	}, [sorted, currentModel]);
+	useInput((input, key) => {
+		if (key.escape) {
+			onCancel();
+			return;
+		}
+		if (key.return) {
+			if (filtered.length > 0) onSelect(filtered[safeIndex].value);
+			return;
+		}
+		if (key.upArrow) {
+			setSelectedIndex((prev) => prev > 0 ? prev - 1 : filtered.length - 1);
+			return;
+		}
+		if (key.downArrow) {
+			setSelectedIndex((prev) => prev < filtered.length - 1 ? prev + 1 : 0);
+			return;
+		}
+		if (key.tab) {
+			open(`${getDashboardUrl()}/settings/models`);
+			return;
+		}
+		if (key.backspace || key.delete) {
+			const cursor = cursorRef.current;
+			if (cursor > 0) {
+				const prev = searchRef.current;
+				applySearch(prev.slice(0, cursor - 1) + prev.slice(cursor), cursor - 1);
+			}
+			return;
+		}
+		if (key.leftArrow) {
+			const nc = Math.max(0, cursorRef.current - 1);
+			cursorRef.current = nc;
+			setCursorPos(nc);
+			return;
+		}
+		if (key.rightArrow) {
+			const nc = Math.min(searchRef.current.length, cursorRef.current + 1);
+			cursorRef.current = nc;
+			setCursorPos(nc);
+			return;
+		}
+		if (input && !key.ctrl && !key.meta) {
+			const cursor = cursorRef.current;
+			const prev = searchRef.current;
+			applySearch(prev.slice(0, cursor) + input + prev.slice(cursor), cursor + input.length);
+		}
+	});
+	let modelWindow = 8;
+	let modelWindowStart = 0;
+	let modelWindowEnd = 0;
+	let rows = [];
+	for (let attempt = 0; attempt < 3; attempt++) {
+		modelWindowStart = Math.max(0, Math.min(safeIndex - Math.floor(modelWindow / 2), filtered.length - modelWindow));
+		modelWindowEnd = Math.min(modelWindowStart + modelWindow, filtered.length);
+		rows = [];
+		let lastGroup = "";
+		for (let i = modelWindowStart; i < modelWindowEnd; i++) {
+			const model = filtered[i];
+			if (model.group !== lastGroup) {
+				rows.push({
+					type: "group",
+					label: model.group
+				});
+				lastGroup = model.group;
+			}
+			rows.push({
+				type: "model",
+				model,
+				isHighlighted: i === safeIndex,
+				isCurrent: model.value === currentModel
+			});
+		}
+		if (rows.length <= MAX_VISIBLE) break;
+		modelWindow = Math.max(1, modelWindow - (rows.length - MAX_VISIBLE));
+	}
+	while (rows.length < MAX_VISIBLE) rows.push({ type: "blank" });
+	const showScrollUp = modelWindowStart > 0;
+	const showScrollDown = modelWindowEnd < filtered.length;
+	return /* @__PURE__ */ jsxs(Box, {
+		borderStyle: "single",
+		borderColor: theme.border,
+		backgroundColor: theme.surfaceElevated,
+		paddingX: theme.panelPaddingX,
+		paddingY: theme.panelPaddingY,
+		flexDirection: "column",
+		children: [
+			/* @__PURE__ */ jsxs(Box, {
+				marginBottom: 1,
+				children: [/* @__PURE__ */ jsx(Text, {
+					color: theme.accent,
+					bold: true,
+					children: "Select Model"
+				}), /* @__PURE__ */ jsxs(Text, {
+					color: theme.textSubtle,
+					children: [
+						"  ",
+						filtered.length,
+						" models"
+					]
+				})]
+			}),
+			/* @__PURE__ */ jsxs(Box, {
+				marginBottom: 1,
+				children: [/* @__PURE__ */ jsx(Text, {
+					color: theme.textSubtle,
+					children: "/ "
+				}), search.length > 0 ? /* @__PURE__ */ jsxs(Fragment, { children: [
+					/* @__PURE__ */ jsx(Text, { children: search.slice(0, cursorPos) }),
+					/* @__PURE__ */ jsx(Text, {
+						inverse: true,
+						children: search[cursorPos] ?? " "
+					}),
+					cursorPos < search.length && /* @__PURE__ */ jsx(Text, { children: search.slice(cursorPos + 1) })
+				] }) : /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(Text, {
+					inverse: true,
+					children: " "
+				}), /* @__PURE__ */ jsx(Text, {
+					color: theme.textSubtle,
+					children: "Search models..."
+				})] })]
+			}),
+			/* @__PURE__ */ jsx(Box, {
+				height: 1,
+				children: /* @__PURE__ */ jsx(Text, {
+					color: theme.textSubtle,
+					children: pad(showScrollUp ? "  ..." : "")
+				})
+			}),
+			/* @__PURE__ */ jsx(Box, {
+				flexDirection: "column",
+				height: MAX_VISIBLE,
+				children: filtered.length === 0 ? /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(Text, {
+					color: theme.textSubtle,
+					children: pad("  No matching models")
+				}), Array.from({ length: 11 }, (_, i) => /* @__PURE__ */ jsx(Text, { children: pad("") }, `empty-${i}`))] }) : rows.map((row, i) => {
+					if (row.type === "blank") return /* @__PURE__ */ jsx(Text, { children: pad("") }, `blank-${i}`);
+					if (row.type === "group") return /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Text, {
+						color: theme.textSubtle,
+						dimColor: true,
+						children: pad(`  ${row.label}`)
+					}) }, `group-${row.label}`);
+					const { model, isHighlighted, isCurrent } = row;
+					const indicator = isHighlighted ? "› " : "  ";
+					const suffix = isCurrent ? " *" : "";
+					return /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Text, {
+						color: isHighlighted ? theme.accentActive : isCurrent ? theme.accent : theme.textMuted,
+						bold: isHighlighted,
+						children: pad(`${indicator}${model.label}${suffix}`)
+					}) }, model.value);
+				})
+			}),
+			/* @__PURE__ */ jsx(Box, {
+				height: 1,
+				children: /* @__PURE__ */ jsx(Text, {
+					color: theme.textSubtle,
+					children: pad(showScrollDown ? "  ..." : "")
+				})
+			}),
+			/* @__PURE__ */ jsx(Box, {
+				marginTop: 1,
+				children: /* @__PURE__ */ jsx(Text, {
+					color: theme.textSubtle,
+					children: [
+						"↑↓ navigate",
+						"Enter select",
+						"Tab manage models",
+						"Esc cancel"
+					].join(theme.separator ?? " · ")
+				})
+			})
+		]
+	});
+}
+export { ModelPicker_exports as n, ModelPicker as t };
+

package/dist/chunk-Cs4pwCQ-.js

@@ -0,0 +1,324 @@
+#!/usr/bin/env node
+import { g as isOwnExecutionFrame } from "./chunk-ucu5lrDZ.js";
+import { r as createCliClient } from "./chunk-BW2fg46T.js";
+import { n as ensureAuth } from "./chunk-CJraEBVd.js";
+import { a as printJson } from "./chunk-CcFCyqbB.js";
+import chalk from "chalk";
+import { readFileSync } from "fs";
+import { RuntypeApiError, parseFinalBuffer, parseSSEChunk } from "@runtypelabs/sdk";
+// src/lib/execution-input.ts
+function addExecutionInputOptions(command) {
+	return command.option("--inputs <json>", "Typed input variables as a JSON object").option("--inputs-file <file|->", "Read input variables from a JSON object file or stdin").option("-v, --variable <key=value>", "Set a string variable (repeatable)", collectVariables, []).option("--messages-file <file|->", "Read structured messages from a JSON array file or stdin");
+}
+function collectVariables(value, previous) {
+	return [...previous, value];
+}
+function usesExecutionStdin(options) {
+	return [
+		options.inputsFile,
+		options.messagesFile,
+		options.recordJson
+	].includes("-");
+}
+function parseJson(raw, label) {
+	try {
+		return JSON.parse(raw);
+	} catch {
+		throw new Error(`Invalid JSON in ${label}`);
+	}
+}
+function readJson(path, label) {
+	if (path === "-" && process.stdin.isTTY) throw new Error(`Pipe ${label} JSON to stdin when using -`);
+	let raw;
+	try {
+		raw = readFileSync(path === "-" ? 0 : path, "utf-8");
+	} catch {
+		throw new Error(`Failed to read ${label}`);
+	}
+	return parseJson(raw, label);
+}
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requireObject(value, label) {
+	if (!isObject(value)) throw new Error(`${label} must be a JSON object`);
+	return value;
+}
+function validateContent(content, agent) {
+	if (typeof content === "string" && (agent || content.length > 0)) return;
+	if (!Array.isArray(content) || content.length === 0) throw new Error("Message content must be a string or a nonempty multimodal array");
+	for (const part of content) {
+		if (!isObject(part) || typeof part.type !== "string" || !part.type) throw new Error("Message content parts must be objects with a type");
+		const required = {
+			text: ["text"],
+			image: ["image"],
+			file: agent ? ["data"] : [
+				"data",
+				"mimeType",
+				"filename"
+			],
+			reasoning: ["text"]
+		};
+		const fields = Object.hasOwn(required, part.type) ? required[part.type] : void 0;
+		if (!agent && !fields || fields?.some((field) => typeof part[field] !== "string")) throw new Error(`Invalid ${part.type} message content part`);
+	}
+}
+function resolveExecutionInput(options, agent = false) {
+	if ([
+		options.inputsFile,
+		options.messagesFile,
+		options.recordJson
+	].filter((p) => p === "-").length > 1) throw new Error("Only one input source may read stdin");
+	if (options.inputs !== void 0 && options.inputsFile !== void 0) throw new Error("Use only one of --inputs and --inputs-file");
+	if (options.message !== void 0 && options.messagesFile !== void 0) throw new Error("Use only one of --message and --messages-file");
+	if (options.record !== void 0 && options.recordJson !== void 0) throw new Error("Use only one of --record and --record-json");
+	let inputs;
+	if (options.inputs !== void 0 || options.inputsFile !== void 0) inputs = { ...requireObject(options.inputsFile !== void 0 ? readJson(options.inputsFile, "Inputs") : parseJson(options.inputs, "Inputs"), "Inputs") };
+	for (const variable of options.variable ?? []) {
+		const separator = variable.indexOf("=");
+		if (separator <= 0 || !variable.slice(0, separator).trim()) throw new Error("--variable must be key=value with a nonempty key");
+		const key = variable.slice(0, separator);
+		inputs ??= {};
+		if (Object.hasOwn(inputs, key)) throw new Error(`Duplicate input key: ${key}`);
+		Object.defineProperty(inputs, key, {
+			value: variable.slice(separator + 1),
+			enumerable: true
+		});
+	}
+	const messages = options.messagesFile !== void 0 ? readJson(options.messagesFile, "Messages") : options.message !== void 0 ? [{
+		role: "user",
+		content: options.message
+	}] : void 0;
+	if (messages !== void 0) {
+		if (!Array.isArray(messages) || messages.length === 0) throw new Error("Messages must be a nonempty JSON array");
+		const roles = agent ? [
+			"system",
+			"user",
+			"assistant",
+			"tool"
+		] : [
+			"system",
+			"user",
+			"assistant"
+		];
+		for (const message of messages) {
+			if (!isObject(message) || !roles.includes(String(message.role))) throw new Error(`Invalid message role: ${agent ? "agent execute" : "dispatch (including agents with inputs)"} accepts ${roles.join(", ")}`);
+			validateContent(message.content, agent);
+		}
+	} else if (agent) throw new Error("Either --message or --messages-file is required");
+	const record = options.record !== void 0 ? { id: options.record } : options.recordJson !== void 0 ? { metadata: requireObject(readJson(options.recordJson, "Record"), "Record") } : void 0;
+	return {
+		...inputs !== void 0 ? { inputs } : {},
+		...messages !== void 0 ? { messages } : {},
+		...record ? { record } : {}
+	};
+}
+// src/lib/execution-output.ts
+function asObject(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function executionFailed(value) {
+	const result = asObject(value);
+	if (!result) return false;
+	return result.success === false || result.success === void 0 && typeof result.failedSteps === "number" && result.failedSteps > 0 || [
+		"failed",
+		"error",
+		"cancelled",
+		"canceled"
+	].includes(String(result.status)) || executionFailed(result.executionSummary) || executionFailed(result.execution);
+}
+function normalizeExecutionResult(value) {
+	const result = asObject(value);
+	if (result && ([
+		"paused",
+		"awaiting",
+		"awaiting_input",
+		"awaiting_approval"
+	].includes(String(result.status)) || result.stopReason === "paused")) {
+		const awaiting = {
+			...result,
+			status: "awaiting_input"
+		};
+		delete awaiting.success;
+		return awaiting;
+	}
+	return value;
+}
+function executionError(error, code) {
+	const source = asObject(error);
+	const data = error instanceof RuntypeApiError ? asObject(error.data) : source;
+	const nested = asObject(data?.error);
+	const requestId = nested?.requestId ?? data?.requestId ?? (error instanceof RuntypeApiError ? error.headers?.get("x-request-id") : void 0);
+	return {
+		success: false,
+		error: {
+			code: nested?.code ?? data?.code ?? code,
+			message: error instanceof Error ? error.message : nested?.message ?? data?.message ?? (typeof data?.error === "string" ? data.error : void 0) ?? (typeof error === "string" ? error : "Execution failed"),
+			...error instanceof RuntypeApiError ? { status: error.statusCode } : {},
+			...requestId ? { requestId } : {}
+		}
+	};
+}
+function emitResult(value, options) {
+	if (options.jsonl && !options.json) console.log(JSON.stringify({
+		type: "execution_summary",
+		data: value
+	}));
+	else printJson(value);
+}
+async function consumeExecutionStream(response, options) {
+	if (!response.ok) {
+		let data;
+		try {
+			data = await response.json();
+		} catch {
+			data = void 0;
+		}
+		throw new RuntypeApiError(`HTTP ${response.status}: ${response.statusText}`, response.status, data, response.headers);
+	}
+	if (response.headers.get("content-type")?.includes("application/json")) {
+		const result = asObject(await response.json());
+		if (!result) throw new Error("Invalid execution response");
+		if (result.error && result.success === void 0 && result.status === void 0) return executionError(result, "EXECUTION_FAILED");
+		if (result.success === void 0 && result.status === void 0 && !result.executionSummary && !result.execution) return executionError("Execution response did not contain a terminal or await summary", "INCOMPLETE_STREAM");
+		return result;
+	}
+	const reader = response.body?.getReader();
+	if (!reader) throw new Error("Response body is not readable");
+	const decoder = new TextDecoder();
+	let buffer = "";
+	let terminal;
+	let awaiting;
+	let failure;
+	let ownerExecutionId;
+	const results = {};
+	const accept = (raw) => {
+		let parsed;
+		try {
+			parsed = JSON.parse(raw);
+		} catch {
+			throw new Error("Invalid JSON in execution stream");
+		}
+		const event = asObject(parsed);
+		if (!event || typeof event.type !== "string") throw new Error("Invalid execution stream event");
+		if (options.jsonl) console.log(JSON.stringify(event));
+		const data = asObject(event.data) ?? event;
+		const executionId = typeof data.executionId === "string" ? data.executionId : typeof event.executionId === "string" ? event.executionId : void 0;
+		const attributedSubagent = Object.hasOwn(event, "subagent") || Object.hasOwn(data, "subagent");
+		if (!attributedSubagent && !data.parentToolCallId && !event.parentToolCallId) ownerExecutionId ??= executionId;
+		if (attributedSubagent && (!ownerExecutionId || executionId !== ownerExecutionId)) return;
+		if (isOwnExecutionFrame({ executionId: executionId ?? ownerExecutionId }, ownerExecutionId)) {
+			if ([
+				"execution_complete",
+				"flow_complete",
+				"agent_complete"
+			].includes(event.type)) terminal = data;
+			if ([
+				"execution_error",
+				"flow_error",
+				"agent_error"
+			].includes(event.type)) failure = executionError(data, "EXECUTION_FAILED");
+			if ([
+				"await",
+				"flow_await",
+				"agent_await"
+			].includes(event.type)) awaiting = {
+				...data,
+				status: "awaiting_input",
+				await: event
+			};
+			if (["approval_start", "agent_approval_start"].includes(event.type)) awaiting = {
+				...data,
+				status: "awaiting_input",
+				awaitReason: "approval_required",
+				await: event
+			};
+			if (["approval_complete", "agent_approval_complete"].includes(event.type)) awaiting = void 0;
+			if (event.type === "step_complete") {
+				const name = String(data.name ?? data.stepName ?? data.stepId ?? "");
+				Object.defineProperty(results, name, {
+					value: data.result ?? data.output,
+					enumerable: true,
+					configurable: true
+				});
+			}
+		}
+		if (!options.json && !options.jsonl) {
+			if (event.type === "text_delta" || event.type === "step_delta" || ["turn_delta", "agent_turn_delta"].includes(event.type) && data.contentType === "text") process.stdout.write(String(data.text ?? data.delta ?? data.chunk ?? ""));
+			if (options.debug && ["step_start", "step_complete"].includes(event.type)) console.log(chalk.gray(`\n[${String(data.name ?? data.stepName ?? data.stepId ?? "")}] ${event.type === "step_start" ? "Running..." : "Complete"}`));
+		}
+	};
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			const parsed = parseSSEChunk(done ? decoder.decode() : decoder.decode(value, { stream: true }), buffer);
+			buffer = parsed.remainingBuffer;
+			for (const raw of parsed.events) accept(raw);
+			if (done) break;
+		}
+		const final = parseFinalBuffer(buffer);
+		if (final) accept(final);
+	} catch (error) {
+		await reader.cancel().catch(() => void 0);
+		throw error;
+	} finally {
+		reader.releaseLock();
+	}
+	const resultFields = Object.keys(results).length ? { results } : {};
+	if (failure) return {
+		...terminal,
+		...failure,
+		...resultFields
+	};
+	if (terminal) return {
+		...terminal,
+		...resultFields
+	};
+	if (awaiting && awaiting.awaitReason !== "detached") {
+		delete awaiting.success;
+		return {
+			...awaiting,
+			...resultFields
+		};
+	}
+	return executionError("Execution stream ended without a terminal or await event", "INCOMPLETE_STREAM");
+}
+async function runExecution(options, build, execute, label, renderResult) {
+	let errorCode = "INVALID_INPUT";
+	try {
+		if (options.json && options.jsonl) throw new Error("--json and --jsonl are mutually exclusive");
+		const payload = build();
+		errorCode = "AUTH_REQUIRED";
+		const apiKey = await ensureAuth({
+			exitOnFailure: false,
+			...usesExecutionStdin(options) || options.json || options.jsonl ? { interactive: false } : {}
+		});
+		if (!apiKey) throw new Error("Authentication required");
+		errorCode = "EXECUTION_FAILED";
+		if (!options.json && !options.jsonl) console.log(chalk.gray(`${options.stream ? "Starting" : "Executing"} ${label}...`));
+		const response = await execute(createCliClient(apiKey), payload);
+		const result = normalizeExecutionResult(options.stream ? await consumeExecutionStream(response, options) : response);
+		if (executionFailed(result)) process.exitCode = 1;
+		else if ([
+			"awaiting",
+			"awaiting_input",
+			"awaiting_approval"
+		].includes(String(asObject(result)?.status))) process.exitCode = 2;
+		if (options.json || options.jsonl) emitResult(result, options);
+		else if (!options.stream) {
+			if (renderResult) renderResult(result);
+			else printJson(result);
+		} else {
+			console.log();
+			if (executionFailed(result)) console.error(chalk.red("Execution failed"));
+			else if (asObject(result)?.status === "awaiting_input") printJson(result);
+		}
+	} catch (error) {
+		process.exitCode = 1;
+		const result = executionError(error, errorCode);
+		if (options.json || options.jsonl) emitResult(result, options);
+		else console.error(chalk.red(String(result.error.message)));
+	}
+}
+export { addExecutionInputOptions as n, resolveExecutionInput as r, runExecution as t };
+