praxis-agent 0.1.0

package/dist/cli/protocol.js

@@ -0,0 +1,2146 @@
+import { randomUUID } from 'node:crypto';
+export function createSuccessResult(result, info, startedAt, modelTurns) {
+    const duration = Date.now() - startedAt;
+    const modelUsage = result.modelUsage ?? { [info.model]: result.usage };
+    const usage = {
+        input_tokens: result.usage.inputTokens,
+        output_tokens: result.usage.outputTokens,
+        ...(result.usage.cacheReadInputTokens === undefined
+            ? {}
+            : { cache_read_input_tokens: result.usage.cacheReadInputTokens }),
+        ...(result.usage.cacheCreationInputTokens === undefined
+            ? {}
+            : {
+                cache_creation_input_tokens: result.usage.cacheCreationInputTokens,
+            }),
+    };
+    return {
+        type: 'result',
+        subtype: 'success',
+        is_error: false,
+        duration_ms: duration,
+        duration_api_ms: result.durationApiMs === undefined
+            ? null
+            : Math.round(result.durationApiMs),
+        num_turns: modelTurns,
+        result: result.text,
+        stop_reason: null,
+        session_id: result.sessionId,
+        total_cost_usd: result.costUsd ?? null,
+        usage,
+        modelUsage: Object.fromEntries(Object.entries(modelUsage).map(([model, modelUsage]) => [
+            model,
+            {
+                inputTokens: modelUsage.inputTokens,
+                outputTokens: modelUsage.outputTokens,
+                cacheReadInputTokens: modelUsage.cacheReadInputTokens ?? 0,
+                cacheCreationInputTokens: modelUsage.cacheCreationInputTokens ?? 0,
+                costUSD: model === info.model ? (result.costUsd ?? null) : null,
+            },
+        ])),
+        permission_denials: [],
+        ...(result.structuredOutput === undefined
+            ? {}
+            : { structured_output: result.structuredOutput }),
+        fast_mode_state: 'off',
+        uuid: randomUUID(),
+    };
+}
+function errorResultSubtype(message) {
+    if (/maximum budget|budget .* exceeded/iu.test(message))
+        return 'error_max_budget_usd';
+    if (/maximum model turns|model turn limit/iu.test(message))
+        return 'error_max_turns';
+    if (/StructuredOutput/iu.test(message))
+        return 'error_max_structured_output_retries';
+    return 'error_during_execution';
+}
+export function createErrorResult(message, sessionId, startedAt, modelTurns) {
+    const duration = Date.now() - startedAt;
+    return {
+        type: 'result',
+        subtype: errorResultSubtype(message),
+        is_error: true,
+        duration_ms: duration,
+        duration_api_ms: null,
+        num_turns: modelTurns,
+        stop_reason: null,
+        session_id: sessionId,
+        total_cost_usd: null,
+        usage: {
+            input_tokens: 0,
+            output_tokens: 0,
+            cache_creation_input_tokens: 0,
+            cache_read_input_tokens: 0,
+        },
+        modelUsage: {},
+        permission_denials: [],
+        errors: [message],
+        fast_mode_state: 'off',
+        uuid: randomUUID(),
+    };
+}
+const INPUT_FORMATS = ['text', 'stream-json'];
+const OUTPUT_FORMATS = ['text', 'json', 'stream-json'];
+const PERMISSION_MODES = [
+    'acceptEdits',
+    'auto',
+    'bypassPermissions',
+    'manual',
+    'dontAsk',
+    'plan',
+    'default',
+];
+const SETTING_SOURCES = ['user', 'project', 'local'];
+const MCP_SCOPES = ['local', 'project', 'user'];
+const MCP_TRANSPORTS = ['stdio', 'sse', 'http'];
+const EFFORT_LEVELS = ['low', 'medium', 'high', 'xhigh', 'max'];
+const THINKING_MODES = ['enabled', 'adaptive', 'disabled'];
+const MAX_INPUT_LINE_BYTES = 1024 * 1024;
+const IMAGE_MEDIA_TYPES = new Set([
+    'image/png',
+    'image/jpeg',
+    'image/gif',
+    'image/webp',
+]);
+const DOCUMENT_MEDIA_TYPES = new Set([
+    'application/pdf',
+    'text/plain',
+    'text/markdown',
+    'application/json',
+]);
+function isBase64Data(value) {
+    return (value.length > 0 &&
+        value.length % 4 === 0 &&
+        /^[A-Za-z0-9+/]*={0,2}$/.test(value) &&
+        Buffer.from(value, 'base64').toString('base64') === value);
+}
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const PLUGIN_INIT_COMPONENTS = new Set([
+    'skills',
+    'agents',
+    'hooks',
+    'mcp',
+    'lsp',
+    'output-style',
+    'channel',
+]);
+function requiredValue(argv, index, label) {
+    const value = argv[index + 1];
+    if (!value || value.startsWith('-'))
+        throw new Error(`${label} is required`);
+    return value;
+}
+function choice(value, label, choices) {
+    if (!choices.includes(value)) {
+        throw new Error(`${label} must be one of ${choices.join(', ')}`);
+    }
+    return value;
+}
+function positiveDecimal(value, label) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new Error(`${label} must be a positive number`);
+    }
+    return parsed;
+}
+function optionValue(argv, index, option) {
+    const current = argv[index];
+    if (current === option) {
+        return { value: requiredValue(argv, index, option), consumed: 1 };
+    }
+    const prefix = `${option}=`;
+    if (current?.startsWith(prefix)) {
+        const value = current.slice(prefix.length);
+        if (!value)
+            throw new Error(`${option} is required`);
+        return { value, consumed: 0 };
+    }
+    return null;
+}
+function optionalValue(argv, index, option) {
+    const current = argv[index];
+    if (current === option) {
+        const candidate = argv[index + 1];
+        if (candidate !== undefined &&
+            candidate !== '--' &&
+            !candidate.startsWith('-')) {
+            return { value: candidate, consumed: 1 };
+        }
+        return { value: true, consumed: 0 };
+    }
+    const prefix = `${option}=`;
+    if (current?.startsWith(prefix)) {
+        return { value: current.slice(prefix.length), consumed: 0 };
+    }
+    return null;
+}
+function listOptionValue(argv, index, options) {
+    const current = argv[index];
+    const option = options.find((candidate) => current === candidate);
+    if (option) {
+        const values = [];
+        let consumed = 0;
+        while (index + consumed + 1 < argv.length) {
+            const candidate = argv[index + consumed + 1];
+            if (candidate === undefined || candidate === '--')
+                break;
+            if (candidate.startsWith('-') && candidate !== '-')
+                break;
+            values.push(candidate);
+            consumed += 1;
+        }
+        if (values.length === 0)
+            throw new Error(`${option} is required`);
+        return { values, consumed };
+    }
+    for (const candidate of options) {
+        const prefix = `${candidate}=`;
+        if (current?.startsWith(prefix)) {
+            return { values: [current.slice(prefix.length)], consumed: 0 };
+        }
+    }
+    return null;
+}
+function pluginWithOptionValue(argv, index) {
+    const current = argv[index];
+    if (current?.startsWith('--with=')) {
+        const value = current.slice('--with='.length);
+        if (!value)
+            throw new Error('--with is required');
+        return { values: value.split(','), consumed: 0 };
+    }
+    if (current !== '--with')
+        return null;
+    const values = [];
+    let consumed = 0;
+    while (index + consumed + 1 < argv.length) {
+        const candidate = argv[index + consumed + 1];
+        if (candidate === undefined ||
+            candidate === '--' ||
+            candidate.startsWith('-')) {
+            break;
+        }
+        const components = candidate.split(',').map((value) => value.trim());
+        if (components.length === 0 ||
+            components.some((component) => !PLUGIN_INIT_COMPONENTS.has(component))) {
+            break;
+        }
+        values.push(...components);
+        consumed += 1;
+    }
+    if (values.length === 0) {
+        throw new Error(`--with requires one or more components: ${[...PLUGIN_INIT_COMPONENTS].join(', ')}`);
+    }
+    return { values, consumed };
+}
+function splitList(values) {
+    return values.flatMap((value) => value
+        .split(',')
+        .map((item) => item.trim())
+        .filter((item) => item.length > 0));
+}
+function positiveInteger(value, label) {
+    if (!/^\d+$/.test(value))
+        throw new Error(`${label} must be a positive integer`);
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed) || parsed < 1) {
+        throw new Error(`${label} must be a positive integer`);
+    }
+    return parsed;
+}
+function parseMcpTransport(value) {
+    if (value === 'streamable-http')
+        return 'http';
+    if (MCP_TRANSPORTS.includes(value)) {
+        return value;
+    }
+    throw new Error(`Invalid transport type: ${value}. Must be one of: stdio, sse, http (or streamable-http)`);
+}
+export function parseCliInvocation(argv) {
+    const args = [];
+    let agent;
+    let background = false;
+    let print = false;
+    let agentsAll = false;
+    let agentsCwd;
+    let inputFormat = 'text';
+    let outputFormat = 'text';
+    let includePartialMessages = false;
+    let includeHookEvents = false;
+    let replayUserMessages = false;
+    let retryInterruptedTools = false;
+    let sessionId;
+    let resumeSelector;
+    let resumeSessionAt;
+    let fromPr;
+    let verbose = false;
+    let legacyJson = false;
+    let pluginAvailable = false;
+    let pluginKeepData = false;
+    let pluginPrune = false;
+    let pluginYes = false;
+    let pluginStrict = false;
+    const pluginConfig = [];
+    let pluginAuthor;
+    let pluginAuthorEmail;
+    let pluginDescription;
+    let pluginForce = false;
+    const pluginWith = [];
+    let pluginDryRun = false;
+    let pluginMessage;
+    let pluginPush = false;
+    let pluginRemote;
+    const pluginSparsePaths = [];
+    let autoModeLabel;
+    let optionsEnded = false;
+    let settings;
+    let maxTurns;
+    const betas = [];
+    let debug;
+    let debugFile;
+    let brief = false;
+    let axScreenReader = false;
+    const fileResources = [];
+    let agentDefinitions;
+    const mcpConfigs = [];
+    let strictMcpConfig = false;
+    let disableSlashCommands = false;
+    let settingSources;
+    let safeMode = false;
+    let bare = false;
+    let systemPrompt;
+    let systemPromptFile;
+    let appendSystemPrompt;
+    let appendSystemPromptFile;
+    let excludeDynamicSystemPromptSections = false;
+    const addDirectories = [];
+    const pluginDirectories = [];
+    const pluginUrls = [];
+    let tools;
+    const allowedTools = [];
+    const disallowedTools = [];
+    let permissionMode = 'default';
+    let permissionPromptTool;
+    let init = false;
+    let initOnly = false;
+    let maintenance = false;
+    let dangerouslySkipPermissions = false;
+    let allowDangerouslySkipPermissions = false;
+    let continueSession = false;
+    let forkSession = false;
+    let rewindFiles;
+    let name;
+    let sessionPersistence = true;
+    let worktreeName;
+    let worktreeRequested = false;
+    let tmux;
+    let model;
+    let effort;
+    let thinking;
+    let maxThinkingTokens;
+    let fallbackModels;
+    let jsonSchema;
+    let maxBudgetUsd;
+    let prefill;
+    let promptSuggestions = false;
+    let mcpScope;
+    let mcpTransport;
+    const mcpEnv = [];
+    const mcpHeaders = [];
+    let mcpCallbackPort;
+    let mcpClientId;
+    let mcpClientSecret = false;
+    let mcpNoBrowser = false;
+    let mcpDebug = false;
+    for (let index = 0; index < argv.length; index += 1) {
+        const value = argv[index];
+        if (value === undefined)
+            continue;
+        if (!optionsEnded && value === '--') {
+            optionsEnded = true;
+            continue;
+        }
+        if (optionsEnded || !value.startsWith('-') || value === '-') {
+            args.push(value);
+            continue;
+        }
+        const input = optionValue(argv, index, '--input-format');
+        if (input) {
+            inputFormat = choice(input.value, '--input-format', INPUT_FORMATS);
+            index += input.consumed;
+            continue;
+        }
+        const output = optionValue(argv, index, '--output-format');
+        if (output) {
+            outputFormat = choice(output.value, '--output-format', OUTPUT_FORMATS);
+            index += output.consumed;
+            continue;
+        }
+        const selectedAgent = optionValue(argv, index, '--agent');
+        if (selectedAgent) {
+            if (agent !== undefined)
+                throw new Error('--agent may only be specified once');
+            agent = selectedAgent.value;
+            index += selectedAgent.consumed;
+            continue;
+        }
+        const selectedModel = optionValue(argv, index, '--model');
+        if (selectedModel) {
+            if (model !== undefined)
+                throw new Error('--model may only be specified once');
+            model = selectedModel.value;
+            index += selectedModel.consumed;
+            continue;
+        }
+        const selectedEffort = optionValue(argv, index, '--effort');
+        if (selectedEffort) {
+            if (effort !== undefined)
+                throw new Error('--effort may only be specified once');
+            effort = choice(selectedEffort.value, '--effort', EFFORT_LEVELS);
+            index += selectedEffort.consumed;
+            continue;
+        }
+        const selectedThinking = optionValue(argv, index, '--thinking');
+        if (selectedThinking) {
+            if (thinking !== undefined)
+                throw new Error('--thinking may only be specified once');
+            thinking = choice(selectedThinking.value, '--thinking', THINKING_MODES);
+            index += selectedThinking.consumed;
+            continue;
+        }
+        const selectedThinkingTokens = optionValue(argv, index, '--max-thinking-tokens');
+        if (selectedThinkingTokens) {
+            if (maxThinkingTokens !== undefined) {
+                throw new Error('--max-thinking-tokens may only be specified once');
+            }
+            maxThinkingTokens = positiveInteger(selectedThinkingTokens.value, '--max-thinking-tokens');
+            index += selectedThinkingTokens.consumed;
+            continue;
+        }
+        const selectedFallback = optionValue(argv, index, '--fallback-model');
+        if (selectedFallback) {
+            if (fallbackModels !== undefined)
+                throw new Error('--fallback-model may only be specified once');
+            fallbackModels = splitList([selectedFallback.value]);
+            if (fallbackModels.length === 0)
+                throw new Error('--fallback-model requires at least one model');
+            index += selectedFallback.consumed;
+            continue;
+        }
+        const selectedSchema = optionValue(argv, index, '--json-schema');
+        if (selectedSchema) {
+            if (jsonSchema !== undefined)
+                throw new Error('--json-schema may only be specified once');
+            let parsed;
+            try {
+                parsed = JSON.parse(selectedSchema.value);
+            }
+            catch (error) {
+                throw new Error('--json-schema must be valid JSON', { cause: error });
+            }
+            if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+                throw new Error('--json-schema must be a JSON object');
+            }
+            jsonSchema = parsed;
+            index += selectedSchema.consumed;
+            continue;
+        }
+        const selectedBudget = optionValue(argv, index, '--max-budget-usd');
+        if (selectedBudget) {
+            if (maxBudgetUsd !== undefined)
+                throw new Error('--max-budget-usd may only be specified once');
+            maxBudgetUsd = positiveDecimal(selectedBudget.value, '--max-budget-usd');
+            index += selectedBudget.consumed;
+            continue;
+        }
+        if (value === '--prefill') {
+            const candidate = argv[index + 1];
+            if (candidate === undefined || candidate.startsWith('-')) {
+                throw new Error('--prefill is required');
+            }
+            prefill = candidate;
+            index += 1;
+            continue;
+        }
+        if (value.startsWith('--prefill=')) {
+            prefill = value.slice('--prefill='.length);
+            continue;
+        }
+        const selectedMcpScope = value === '-s'
+            ? { value: requiredValue(argv, index, '--scope'), consumed: 1 }
+            : value.startsWith('-s=')
+                ? { value: value.slice(3), consumed: 0 }
+                : optionValue(argv, index, '--scope');
+        if (selectedMcpScope) {
+            if (mcpScope !== undefined)
+                throw new Error('--scope may only be specified once');
+            mcpScope = choice(selectedMcpScope.value, '--scope', MCP_SCOPES);
+            index += selectedMcpScope.consumed;
+            continue;
+        }
+        const selectedMcpTransport = value === '-t'
+            ? { value: requiredValue(argv, index, '--transport'), consumed: 1 }
+            : optionValue(argv, index, '--transport');
+        if (selectedMcpTransport) {
+            if (mcpTransport !== undefined) {
+                throw new Error('--transport may only be specified once');
+            }
+            mcpTransport = parseMcpTransport(selectedMcpTransport.value);
+            index += selectedMcpTransport.consumed;
+            continue;
+        }
+        const selectedMcpEnv = listOptionValue(argv, index, ['-e', '--env']);
+        if (selectedMcpEnv) {
+            mcpEnv.push(...selectedMcpEnv.values);
+            index += selectedMcpEnv.consumed;
+            continue;
+        }
+        const selectedMcpHeaders = listOptionValue(argv, index, ['-H', '--header']);
+        if (selectedMcpHeaders) {
+            mcpHeaders.push(...selectedMcpHeaders.values);
+            index += selectedMcpHeaders.consumed;
+            continue;
+        }
+        const selectedMcpCallbackPort = value === '--callback-port' && /^-\d+$/u.test(argv[index + 1] ?? '')
+            ? { value: argv[index + 1], consumed: 1 }
+            : optionValue(argv, index, '--callback-port');
+        if (selectedMcpCallbackPort) {
+            if (mcpCallbackPort !== undefined) {
+                throw new Error('--callback-port may only be specified once');
+            }
+            mcpCallbackPort = selectedMcpCallbackPort.value;
+            index += selectedMcpCallbackPort.consumed;
+            continue;
+        }
+        const selectedMcpClientId = optionValue(argv, index, '--client-id');
+        if (selectedMcpClientId) {
+            if (mcpClientId !== undefined) {
+                throw new Error('--client-id may only be specified once');
+            }
+            mcpClientId = selectedMcpClientId.value;
+            index += selectedMcpClientId.consumed;
+            continue;
+        }
+        if (value === '--client-secret') {
+            mcpClientSecret = true;
+            continue;
+        }
+        const selectedCwd = optionValue(argv, index, '--cwd');
+        if (selectedCwd) {
+            if (agentsCwd !== undefined)
+                throw new Error('--cwd may only be specified once');
+            agentsCwd = selectedCwd.value;
+            index += selectedCwd.consumed;
+            continue;
+        }
+        const selectedSession = optionValue(argv, index, '--session-id');
+        if (selectedSession) {
+            if (sessionId !== undefined) {
+                throw new Error('--session-id may only be specified once');
+            }
+            sessionId = selectedSession.value;
+            index += selectedSession.consumed;
+            continue;
+        }
+        const selectedResumeAt = optionValue(argv, index, '--resume-session-at');
+        if (selectedResumeAt) {
+            if (resumeSessionAt !== undefined) {
+                throw new Error('--resume-session-at may only be specified once');
+            }
+            resumeSessionAt = selectedResumeAt.value;
+            index += selectedResumeAt.consumed;
+            continue;
+        }
+        const selectedSettings = optionValue(argv, index, '--settings');
+        if (selectedSettings) {
+            if (settings !== undefined)
+                throw new Error('--settings may only be specified once');
+            settings = selectedSettings.value;
+            index += selectedSettings.consumed;
+            continue;
+        }
+        const selectedPluginConfig = optionValue(argv, index, '--config');
+        if (selectedPluginConfig) {
+            pluginConfig.push(selectedPluginConfig.value);
+            index += selectedPluginConfig.consumed;
+            continue;
+        }
+        const selectedPluginAuthor = optionValue(argv, index, '--author');
+        if (selectedPluginAuthor) {
+            if (pluginAuthor !== undefined)
+                throw new Error('--author may only be specified once');
+            pluginAuthor = selectedPluginAuthor.value;
+            index += selectedPluginAuthor.consumed;
+            continue;
+        }
+        const selectedPluginAuthorEmail = optionValue(argv, index, '--author-email');
+        if (selectedPluginAuthorEmail) {
+            if (pluginAuthorEmail !== undefined)
+                throw new Error('--author-email may only be specified once');
+            pluginAuthorEmail = selectedPluginAuthorEmail.value;
+            index += selectedPluginAuthorEmail.consumed;
+            continue;
+        }
+        const selectedPluginDescription = optionValue(argv, index, '--description');
+        if (selectedPluginDescription) {
+            if (pluginDescription !== undefined)
+                throw new Error('--description may only be specified once');
+            pluginDescription = selectedPluginDescription.value;
+            index += selectedPluginDescription.consumed;
+            continue;
+        }
+        const selectedPluginWith = pluginWithOptionValue(argv, index);
+        if (selectedPluginWith) {
+            pluginWith.push(...selectedPluginWith.values);
+            index += selectedPluginWith.consumed;
+            continue;
+        }
+        const selectedPluginMessage = value === '-m'
+            ? { value: requiredValue(argv, index, '--message'), consumed: 1 }
+            : value.startsWith('-m=')
+                ? { value: value.slice(3), consumed: 0 }
+                : optionValue(argv, index, '--message');
+        if (selectedPluginMessage) {
+            if (pluginMessage !== undefined)
+                throw new Error('--message may only be specified once');
+            pluginMessage = selectedPluginMessage.value;
+            index += selectedPluginMessage.consumed;
+            continue;
+        }
+        const selectedPluginRemote = optionValue(argv, index, '--remote');
+        if (selectedPluginRemote) {
+            if (pluginRemote !== undefined)
+                throw new Error('--remote may only be specified once');
+            pluginRemote = selectedPluginRemote.value;
+            index += selectedPluginRemote.consumed;
+            continue;
+        }
+        const selectedPluginSparse = listOptionValue(argv, index, ['--sparse']);
+        if (selectedPluginSparse) {
+            if (pluginSparsePaths.length > 0)
+                throw new Error('--sparse may only be specified once');
+            pluginSparsePaths.push(...selectedPluginSparse.values);
+            index += selectedPluginSparse.consumed;
+            continue;
+        }
+        const selectedAutoModeLabel = optionValue(argv, index, '--label');
+        if (selectedAutoModeLabel) {
+            if (autoModeLabel !== undefined)
+                throw new Error('--label may only be specified once');
+            autoModeLabel = selectedAutoModeLabel.value;
+            index += selectedAutoModeLabel.consumed;
+            continue;
+        }
+        const selectedMaxTurns = optionValue(argv, index, '--max-turns');
+        if (selectedMaxTurns) {
+            if (maxTurns !== undefined)
+                throw new Error('--max-turns may only be specified once');
+            maxTurns = positiveInteger(selectedMaxTurns.value, '--max-turns');
+            index += selectedMaxTurns.consumed;
+            continue;
+        }
+        const selectedBetas = listOptionValue(argv, index, ['--betas']);
+        if (selectedBetas) {
+            betas.push(...splitList(selectedBetas.values));
+            index += selectedBetas.consumed;
+            continue;
+        }
+        const mcpServe = args[0] === 'mcp' && args[1] === 'serve';
+        if (mcpServe && (value === '-d' || value === '--debug')) {
+            debug = true;
+            mcpDebug = true;
+            continue;
+        }
+        if (args[0] === 'mcp' &&
+            (value.startsWith('-d') || value.startsWith('--debug'))) {
+            throw new Error(`Unknown option: ${value}`);
+        }
+        const selectedDebug = optionalValue(argv, index, '--debug');
+        if (selectedDebug) {
+            debug = selectedDebug.value || true;
+            index += selectedDebug.consumed;
+            continue;
+        }
+        if (value === '-d' || value.startsWith('-d')) {
+            if (value.length > 2) {
+                debug = value.slice(2);
+            }
+            else {
+                const candidate = argv[index + 1];
+                if (candidate !== undefined &&
+                    candidate !== '--' &&
+                    !candidate.startsWith('-')) {
+                    debug = candidate;
+                    index += 1;
+                }
+                else {
+                    debug = true;
+                }
+            }
+            continue;
+        }
+        const selectedDebugFile = optionValue(argv, index, '--debug-file');
+        if (selectedDebugFile) {
+            if (debugFile !== undefined)
+                throw new Error('--debug-file may only be specified once');
+            debugFile = selectedDebugFile.value;
+            index += selectedDebugFile.consumed;
+            continue;
+        }
+        if (value === '--mcp-debug') {
+            mcpDebug = true;
+            continue;
+        }
+        if (value === '--brief') {
+            brief = true;
+            continue;
+        }
+        if (value === '--ax-screen-reader') {
+            axScreenReader = true;
+            continue;
+        }
+        const selectedFileResources = listOptionValue(argv, index, ['--file']);
+        if (selectedFileResources) {
+            fileResources.push(...selectedFileResources.values);
+            index += selectedFileResources.consumed;
+            continue;
+        }
+        const selectedAgents = optionValue(argv, index, '--agents');
+        if (selectedAgents) {
+            if (agentDefinitions !== undefined)
+                throw new Error('--agents may only be specified once');
+            agentDefinitions = selectedAgents.value;
+            index += selectedAgents.consumed;
+            continue;
+        }
+        const selectedMcpConfigs = listOptionValue(argv, index, ['--mcp-config']);
+        if (selectedMcpConfigs) {
+            mcpConfigs.push(...selectedMcpConfigs.values);
+            index += selectedMcpConfigs.consumed;
+            continue;
+        }
+        const selectedSources = value === '--setting-sources='
+            ? { value: '', consumed: 0 }
+            : optionValue(argv, index, '--setting-sources');
+        if (selectedSources) {
+            if (settingSources !== undefined)
+                throw new Error('--setting-sources may only be specified once');
+            const sources = splitList([selectedSources.value]);
+            for (const source of sources) {
+                if (!SETTING_SOURCES.includes(source)) {
+                    throw new Error(`Invalid setting source: ${source}`);
+                }
+            }
+            settingSources = sources;
+            index += selectedSources.consumed;
+            continue;
+        }
+        const selectedSystemPrompt = optionValue(argv, index, '--system-prompt');
+        if (selectedSystemPrompt) {
+            if (systemPrompt !== undefined)
+                throw new Error('--system-prompt may only be specified once');
+            systemPrompt = selectedSystemPrompt.value;
+            index += selectedSystemPrompt.consumed;
+            continue;
+        }
+        if (value === '--exclude-dynamic-system-prompt-sections') {
+            excludeDynamicSystemPromptSections = true;
+            continue;
+        }
+        const selectedSystemPromptFile = optionValue(argv, index, '--system-prompt-file');
+        if (selectedSystemPromptFile) {
+            if (systemPromptFile !== undefined)
+                throw new Error('--system-prompt-file may only be specified once');
+            systemPromptFile = selectedSystemPromptFile.value;
+            index += selectedSystemPromptFile.consumed;
+            continue;
+        }
+        const selectedAppendPrompt = optionValue(argv, index, '--append-system-prompt');
+        if (selectedAppendPrompt) {
+            if (appendSystemPrompt !== undefined)
+                throw new Error('--append-system-prompt may only be specified once');
+            appendSystemPrompt = selectedAppendPrompt.value;
+            index += selectedAppendPrompt.consumed;
+            continue;
+        }
+        const selectedAppendPromptFile = optionValue(argv, index, '--append-system-prompt-file');
+        if (selectedAppendPromptFile) {
+            if (appendSystemPromptFile !== undefined) {
+                throw new Error('--append-system-prompt-file may only be specified once');
+            }
+            appendSystemPromptFile = selectedAppendPromptFile.value;
+            index += selectedAppendPromptFile.consumed;
+            continue;
+        }
+        const selectedDirectories = listOptionValue(argv, index, ['--add-dir']);
+        if (selectedDirectories) {
+            addDirectories.push(...splitList(selectedDirectories.values));
+            index += selectedDirectories.consumed;
+            continue;
+        }
+        const selectedPluginDirectory = optionValue(argv, index, '--plugin-dir');
+        if (selectedPluginDirectory) {
+            pluginDirectories.push(selectedPluginDirectory.value);
+            index += selectedPluginDirectory.consumed;
+            continue;
+        }
+        const selectedPluginUrl = optionValue(argv, index, '--plugin-url');
+        if (selectedPluginUrl) {
+            pluginUrls.push(selectedPluginUrl.value);
+            index += selectedPluginUrl.consumed;
+            continue;
+        }
+        const selectedTools = listOptionValue(argv, index, ['--tools']);
+        if (selectedTools) {
+            if (tools !== undefined)
+                throw new Error('--tools may only be specified once');
+            tools = splitList(selectedTools.values);
+            index += selectedTools.consumed;
+            continue;
+        }
+        const selectedAllowedTools = listOptionValue(argv, index, [
+            '--allowedTools',
+            '--allowed-tools',
+        ]);
+        if (selectedAllowedTools) {
+            allowedTools.push(...splitList(selectedAllowedTools.values));
+            index += selectedAllowedTools.consumed;
+            continue;
+        }
+        const selectedDisallowedTools = listOptionValue(argv, index, [
+            '--disallowedTools',
+            '--disallowed-tools',
+        ]);
+        if (selectedDisallowedTools) {
+            disallowedTools.push(...splitList(selectedDisallowedTools.values));
+            index += selectedDisallowedTools.consumed;
+            continue;
+        }
+        const selectedPermissionMode = optionValue(argv, index, '--permission-mode');
+        if (selectedPermissionMode) {
+            permissionMode = choice(selectedPermissionMode.value, '--permission-mode', PERMISSION_MODES);
+            index += selectedPermissionMode.consumed;
+            continue;
+        }
+        if ((value === '--permission-prompt-tool' &&
+            (argv[index + 1] === undefined || argv[index + 1]?.startsWith('-'))) ||
+            value === '--permission-prompt-tool=') {
+            throw new Error("option '--permission-prompt-tool <tool>' argument missing");
+        }
+        const selectedPermissionPromptTool = optionValue(argv, index, '--permission-prompt-tool');
+        if (selectedPermissionPromptTool) {
+            permissionPromptTool = selectedPermissionPromptTool.value;
+            index += selectedPermissionPromptTool.consumed;
+            continue;
+        }
+        const selectedName = optionValue(argv, index, '--name');
+        if (selectedName || value === '-n') {
+            if (name !== undefined)
+                throw new Error('--name may only be specified once');
+            name = selectedName?.value ?? requiredValue(argv, index, '--name');
+            index += selectedName?.consumed ?? 1;
+            continue;
+        }
+        if (value === '--worktree' || value === '-w') {
+            worktreeRequested = true;
+            const candidate = argv[index + 1];
+            if (candidate !== undefined &&
+                candidate !== '--' &&
+                !candidate.startsWith('-')) {
+                worktreeName = candidate;
+                index += 1;
+            }
+            continue;
+        }
+        if (value.startsWith('--worktree=')) {
+            worktreeRequested = true;
+            worktreeName = value.slice('--worktree='.length);
+            if (!worktreeName)
+                throw new Error('--worktree name must not be empty');
+            continue;
+        }
+        if (value === '--tmux' || value === '--tmux=classic') {
+            if (tmux !== undefined)
+                throw new Error('--tmux may only be specified once');
+            tmux = value === '--tmux' ? 'native' : 'classic';
+            continue;
+        }
+        if (value.startsWith('--tmux='))
+            throw new Error('--tmux must be classic');
+        if (value === '-r' || value === '--resume') {
+            if (resumeSelector !== undefined)
+                throw new Error('--resume may only be specified once');
+            const candidate = argv[index + 1];
+            if (candidate !== undefined &&
+                candidate !== '--' &&
+                !candidate.startsWith('-')) {
+                resumeSelector = candidate;
+                index += 1;
+            }
+            else {
+                resumeSelector = true;
+            }
+            continue;
+        }
+        if (value.startsWith('--resume=')) {
+            if (resumeSelector !== undefined)
+                throw new Error('--resume may only be specified once');
+            resumeSelector = value.slice('--resume='.length) || true;
+            continue;
+        }
+        if (value.startsWith('-r') && value.length > 2) {
+            if (resumeSelector !== undefined)
+                throw new Error('--resume may only be specified once');
+            resumeSelector = value.slice(2);
+            continue;
+        }
+        const selectedRewindFiles = optionValue(argv, index, '--rewind-files');
+        if (selectedRewindFiles) {
+            if (rewindFiles !== undefined)
+                throw new Error('--rewind-files may only be specified once');
+            rewindFiles = selectedRewindFiles.value;
+            index += selectedRewindFiles.consumed;
+            continue;
+        }
+        if (value === '--from-pr') {
+            if (fromPr !== undefined)
+                throw new Error('--from-pr may only be specified once');
+            const candidate = argv[index + 1];
+            if (candidate !== undefined &&
+                candidate !== '--' &&
+                !candidate.startsWith('-')) {
+                fromPr = candidate;
+                index += 1;
+            }
+            else {
+                fromPr = true;
+            }
+            continue;
+        }
+        if (value.startsWith('--from-pr=')) {
+            if (fromPr !== undefined)
+                throw new Error('--from-pr may only be specified once');
+            const candidate = value.slice('--from-pr='.length);
+            if (!candidate)
+                throw new Error('--from-pr value must not be empty');
+            fromPr = candidate;
+            continue;
+        }
+        if (value === '-p' || value === '--print') {
+            print = true;
+            continue;
+        }
+        if (value === '--bg' || value === '--background') {
+            background = true;
+            continue;
+        }
+        if (value === '--all' || value === '-a') {
+            agentsAll = true;
+            continue;
+        }
+        if (value === '--available') {
+            pluginAvailable = true;
+            continue;
+        }
+        if (value === '--keep-data') {
+            pluginKeepData = true;
+            continue;
+        }
+        if (value === '--prune') {
+            pluginPrune = true;
+            continue;
+        }
+        if (value === '-y' || value === '--yes') {
+            pluginYes = true;
+            continue;
+        }
+        if (value === '--strict') {
+            pluginStrict = true;
+            continue;
+        }
+        if (value === '-f' || value === '--force') {
+            pluginForce = true;
+            continue;
+        }
+        if (value === '--dry-run') {
+            pluginDryRun = true;
+            continue;
+        }
+        if (value === '--push') {
+            pluginPush = true;
+            continue;
+        }
+        if (value === '-c' || value === '--continue') {
+            continueSession = true;
+            continue;
+        }
+        if (value === '--fork-session') {
+            forkSession = true;
+            continue;
+        }
+        if (value === '--no-session-persistence') {
+            sessionPersistence = false;
+            continue;
+        }
+        if (value === '--safe-mode') {
+            safeMode = true;
+            continue;
+        }
+        if (value === '--bare') {
+            bare = true;
+            continue;
+        }
+        if (value === '--init') {
+            init = true;
+            continue;
+        }
+        if (value === '--init-only') {
+            initOnly = true;
+            continue;
+        }
+        if (value === '--maintenance') {
+            maintenance = true;
+            continue;
+        }
+        if (value === '--strict-mcp-config') {
+            strictMcpConfig = true;
+            continue;
+        }
+        if (value === '--disable-slash-commands') {
+            disableSlashCommands = true;
+            continue;
+        }
+        if (value === '--dangerously-skip-permissions') {
+            dangerouslySkipPermissions = true;
+            continue;
+        }
+        if (value === '--allow-dangerously-skip-permissions') {
+            allowDangerouslySkipPermissions = true;
+            continue;
+        }
+        if (value === '--verbose') {
+            verbose = true;
+            continue;
+        }
+        if (value === '--no-browser') {
+            mcpNoBrowser = true;
+            continue;
+        }
+        if (value === '--json') {
+            legacyJson = true;
+            continue;
+        }
+        if (value === '--include-partial-messages') {
+            includePartialMessages = true;
+            continue;
+        }
+        if (value === '--include-hook-events') {
+            includeHookEvents = true;
+            continue;
+        }
+        if (value === '--replay-user-messages') {
+            replayUserMessages = true;
+            continue;
+        }
+        if (value === '--retry-interrupted-tools') {
+            retryInterruptedTools = true;
+            continue;
+        }
+        if (args[0] === 'mcp' && value.startsWith('--prompt-suggestions')) {
+            throw new Error(`Unknown option: ${value}`);
+        }
+        const selectedPromptSuggestions = optionalValue(argv, index, '--prompt-suggestions');
+        if (selectedPromptSuggestions) {
+            if (selectedPromptSuggestions.value === true) {
+                promptSuggestions = true;
+                continue;
+            }
+            const raw = selectedPromptSuggestions.value.trim().toLowerCase();
+            if (!['true', 'false', '1', '0', 'yes', 'no', 'on', 'off'].includes(raw)) {
+                throw new Error(`option '--prompt-suggestions [value]' argument '${selectedPromptSuggestions.value}' is invalid. Allowed choices are true, false, 1, 0, yes, no, on, off.`);
+            }
+            promptSuggestions = ['true', '1', 'yes', 'on'].includes(raw);
+            index += selectedPromptSuggestions.consumed;
+            continue;
+        }
+        throw new Error(`Unknown option: ${value}`);
+    }
+    if (legacyJson) {
+        if (outputFormat !== 'text') {
+            throw new Error('--json cannot be combined with --output-format');
+        }
+        outputFormat = 'stream-json';
+    }
+    if (thinking === 'disabled' && maxThinkingTokens !== undefined) {
+        throw new Error('--max-thinking-tokens cannot be combined with --thinking=disabled');
+    }
+    if (debug !== undefined && args[0] === 'mcp' && args[1] === 'serve') {
+        mcpDebug = true;
+    }
+    if (background && print) {
+        throw new Error("--bg and --print conflict: --print never starts the interactive session that `claude agents` attaches to, so the job would be unattachable. The prompt is the positional — drop --print: `claude --bg '<task>'`.");
+    }
+    if (inputFormat === 'stream-json' && outputFormat !== 'stream-json') {
+        throw new Error('--input-format=stream-json requires --output-format=stream-json');
+    }
+    if (inputFormat === 'stream-json' && legacyJson) {
+        throw new Error('--input-format=stream-json cannot be combined with --json');
+    }
+    if (outputFormat === 'stream-json' && !verbose && !legacyJson) {
+        throw new Error('--output-format=stream-json requires --verbose');
+    }
+    if (includePartialMessages && outputFormat !== 'stream-json') {
+        throw new Error('--include-partial-messages requires --output-format=stream-json');
+    }
+    if (includePartialMessages && legacyJson) {
+        throw new Error('--include-partial-messages cannot be combined with --json');
+    }
+    if (includeHookEvents && outputFormat !== 'stream-json') {
+        throw new Error('--include-hook-events requires --output-format=stream-json');
+    }
+    if (includeHookEvents && legacyJson) {
+        throw new Error('--include-hook-events cannot be combined with --json');
+    }
+    const managementCommand = [
+        'fork',
+        'sessions',
+        'inspect',
+        'export',
+        'agents',
+        'attach',
+        'logs',
+        'stop',
+        'mcp',
+        'auto-mode',
+        'plugin',
+        'doctor',
+    ].includes(args[0] ?? '');
+    if (promptSuggestions &&
+        !managementCommand &&
+        (!print || outputFormat !== 'stream-json')) {
+        throw new Error('--prompt-suggestions requires --print and --output-format=stream-json');
+    }
+    if (maxTurns !== undefined && !print) {
+        throw new Error('--max-turns requires --print');
+    }
+    if (replayUserMessages &&
+        (inputFormat !== 'stream-json' || outputFormat !== 'stream-json')) {
+        throw new Error('--replay-user-messages requires stream-json input and output');
+    }
+    if (systemPrompt !== undefined && systemPromptFile !== undefined) {
+        throw new Error('Cannot use both --system-prompt and --system-prompt-file');
+    }
+    if (appendSystemPrompt !== undefined &&
+        appendSystemPromptFile !== undefined) {
+        throw new Error('Cannot use both --append-system-prompt and --append-system-prompt-file');
+    }
+    if (tmux !== undefined && !worktreeRequested) {
+        throw new Error('--tmux requires --worktree');
+    }
+    if (resumeSessionAt !== undefined && typeof resumeSelector !== 'string') {
+        throw new Error('--resume-session-at requires an explicit --resume selector');
+    }
+    if (resumeSelector !== undefined) {
+        if (args[0] === 'resume')
+            throw new Error('resume command cannot be combined with --resume');
+        args.unshift('resume', ...(typeof resumeSelector === 'string' ? [resumeSelector] : []));
+    }
+    if (fromPr !== undefined &&
+        (args[0] === 'resume' || resumeSelector !== undefined || continueSession)) {
+        throw new Error('--from-pr cannot be combined with --resume or --continue');
+    }
+    if (sessionId !== undefined && !UUID_PATTERN.test(sessionId)) {
+        throw new Error('--session-id must be a valid UUID');
+    }
+    const resumesSession = args[0] === 'resume' || continueSession || fromPr !== undefined;
+    if (resumeSelector !== undefined && continueSession) {
+        throw new Error('--resume cannot be combined with --continue');
+    }
+    if (rewindFiles !== undefined &&
+        (args[0] !== 'resume' || args[1] === undefined)) {
+        throw new Error('--rewind-files requires --resume with an explicit selector');
+    }
+    if (sessionId !== undefined && resumesSession && !forkSession) {
+        throw new Error('--session-id can only be used with --continue, --resume, or --from-pr if --fork-session is also specified');
+    }
+    if (sessionId !== undefined &&
+        [
+            'fork',
+            'sessions',
+            'inspect',
+            'export',
+            'agents',
+            'attach',
+            'logs',
+            'stop',
+        ].includes(args[0] ?? '')) {
+        throw new Error('--session-id is only valid when starting a session');
+    }
+    const pluginDisableAll = agentsAll &&
+        ['plugin', 'plugins'].includes(args[0] ?? '') &&
+        args[1] === 'disable';
+    if ((pluginAvailable ||
+        pluginKeepData ||
+        pluginPrune ||
+        pluginYes ||
+        pluginStrict ||
+        pluginConfig.length > 0 ||
+        pluginAuthor !== undefined ||
+        pluginAuthorEmail !== undefined ||
+        pluginDescription !== undefined ||
+        pluginForce ||
+        pluginWith.length > 0 ||
+        pluginDryRun ||
+        pluginMessage !== undefined ||
+        pluginPush ||
+        pluginRemote !== undefined ||
+        pluginSparsePaths.length > 0) &&
+        !['plugin', 'plugins'].includes(args[0] ?? '')) {
+        throw new Error('Plugin options are only valid with plugin commands');
+    }
+    return {
+        command: args[0],
+        args,
+        agent,
+        background,
+        print,
+        agentsAll: pluginDisableAll ? false : agentsAll,
+        agentsCwd,
+        inputFormat,
+        outputFormat,
+        includePartialMessages,
+        includeHookEvents,
+        replayUserMessages,
+        retryInterruptedTools,
+        sessionId,
+        resumeSelector,
+        fromPr,
+        verbose,
+        legacyJson,
+        pluginAvailable,
+        pluginAll: pluginDisableAll,
+        pluginKeepData,
+        pluginPrune,
+        pluginYes,
+        pluginStrict,
+        pluginConfig,
+        ...(pluginAuthor === undefined ? {} : { pluginAuthor }),
+        ...(pluginAuthorEmail === undefined ? {} : { pluginAuthorEmail }),
+        ...(pluginDescription === undefined ? {} : { pluginDescription }),
+        pluginForce,
+        pluginWith,
+        pluginDryRun,
+        ...(pluginMessage === undefined ? {} : { pluginMessage }),
+        pluginPush,
+        ...(pluginRemote === undefined ? {} : { pluginRemote }),
+        pluginSparsePaths,
+        ...(autoModeLabel === undefined ? {} : { autoModeLabel }),
+        settings,
+        ...(agentDefinitions === undefined ? {} : { agentDefinitions }),
+        mcpConfigs,
+        strictMcpConfig,
+        disableSlashCommands,
+        settingSources,
+        safeMode,
+        bare,
+        systemPrompt,
+        systemPromptFile,
+        appendSystemPrompt,
+        appendSystemPromptFile,
+        excludeDynamicSystemPromptSections,
+        addDirectories,
+        pluginDirectories,
+        pluginUrls,
+        ...(maxTurns === undefined ? {} : { maxTurns }),
+        betas,
+        ...(debug === undefined ? {} : { debug }),
+        ...(debugFile === undefined ? {} : { debugFile }),
+        ...(brief ? { brief: true } : {}),
+        ...(axScreenReader ? { axScreenReader: true } : {}),
+        fileResources,
+        tools,
+        allowedTools,
+        disallowedTools,
+        permissionMode,
+        ...(permissionPromptTool === undefined ? {} : { permissionPromptTool }),
+        init,
+        initOnly,
+        maintenance,
+        dangerouslySkipPermissions,
+        allowDangerouslySkipPermissions,
+        continueSession,
+        forkSession,
+        resumeSessionAt,
+        ...(rewindFiles === undefined ? {} : { rewindFiles }),
+        name,
+        sessionPersistence,
+        ...(worktreeName === undefined ? {} : { worktreeName }),
+        ...(worktreeRequested ? { worktreeRequested: true } : {}),
+        ...(tmux === undefined ? {} : { tmux }),
+        ...(model === undefined ? {} : { model }),
+        ...(effort === undefined ? {} : { effort }),
+        ...(thinking === undefined ? {} : { thinking }),
+        ...(maxThinkingTokens === undefined ? {} : { maxThinkingTokens }),
+        ...(fallbackModels === undefined ? {} : { fallbackModels }),
+        ...(jsonSchema === undefined ? {} : { jsonSchema }),
+        ...(maxBudgetUsd === undefined ? {} : { maxBudgetUsd }),
+        prefill,
+        promptSuggestions,
+        ...(mcpScope === undefined ? {} : { mcpScope }),
+        ...(mcpTransport === undefined ? {} : { mcpTransport }),
+        mcpEnv,
+        mcpHeaders,
+        ...(mcpCallbackPort === undefined ? {} : { mcpCallbackPort }),
+        ...(mcpClientId === undefined ? {} : { mcpClientId }),
+        mcpClientSecret,
+        mcpNoBrowser,
+        mcpDebug,
+    };
+}
+function parseUserMessage(value, lineNumber) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error(`stream-json input line ${lineNumber} must be an object`);
+    }
+    const record = value;
+    if (record.type !== 'user') {
+        throw new Error(`stream-json input line ${lineNumber} must have type user`);
+    }
+    if (!record.message ||
+        typeof record.message !== 'object' ||
+        Array.isArray(record.message)) {
+        throw new Error(`stream-json input line ${lineNumber} requires a message object`);
+    }
+    const message = record.message;
+    if (message.role !== 'user') {
+        throw new Error(`stream-json input line ${lineNumber} message role must be user`);
+    }
+    const content = message.content;
+    if (typeof content === 'string') {
+        if (content.trim().length === 0) {
+            throw new Error(`stream-json input line ${lineNumber} has empty user content`);
+        }
+        return { message: { role: 'user', content }, prompt: content };
+    }
+    if (!Array.isArray(content) || content.length === 0) {
+        throw new Error(`stream-json input line ${lineNumber} requires text content`);
+    }
+    const images = [];
+    const documents = [];
+    const blocks = content.map((block) => {
+        if (!block ||
+            typeof block !== 'object' ||
+            Array.isArray(block) ||
+            typeof block.type !== 'string') {
+            throw new Error(`stream-json input line ${lineNumber} contains unsupported content`);
+        }
+        const record = block;
+        if (record.type === 'text' && typeof record.text === 'string') {
+            return { type: 'text', text: record.text };
+        }
+        const source = record.source;
+        if (record.type === 'image' &&
+            source &&
+            typeof source === 'object' &&
+            !Array.isArray(source) &&
+            source.type === 'base64' &&
+            typeof source.media_type === 'string' &&
+            IMAGE_MEDIA_TYPES.has(source.media_type) &&
+            typeof source.data === 'string' &&
+            isBase64Data(source.data)) {
+            const image = {
+                type: 'image',
+                mediaType: source
+                    .media_type,
+                data: source.data,
+            };
+            images.push(image);
+            return {
+                type: 'image',
+                source: {
+                    type: 'base64',
+                    media_type: image.mediaType,
+                    data: image.data,
+                },
+            };
+        }
+        if (record.type === 'document' &&
+            source &&
+            typeof source === 'object' &&
+            !Array.isArray(source) &&
+            source.type === 'base64' &&
+            typeof source.media_type === 'string' &&
+            DOCUMENT_MEDIA_TYPES.has(source
+                .media_type) &&
+            typeof source.data === 'string' &&
+            isBase64Data(source.data)) {
+            const document = {
+                type: 'document',
+                mediaType: source
+                    .media_type,
+                data: source.data,
+            };
+            documents.push(document);
+            return {
+                type: 'document',
+                source: {
+                    type: 'base64',
+                    media_type: document.mediaType,
+                    data: document.data,
+                },
+            };
+        }
+        throw new Error(`stream-json input line ${lineNumber} contains unsupported content`);
+    });
+    const prompt = blocks
+        .filter((block) => block.type === 'text')
+        .map((block) => block.text)
+        .join('');
+    if (prompt.trim().length === 0 &&
+        images.length === 0 &&
+        documents.length === 0) {
+        throw new Error(`stream-json input line ${lineNumber} has empty user content`);
+    }
+    return {
+        message: { role: 'user', content: blocks },
+        prompt,
+        ...(images.length > 0 ? { images } : {}),
+        ...(documents.length > 0 ? { documents } : {}),
+    };
+}
+function parseStreamJsonMessage(value, lineNumber) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error(`stream-json input line ${lineNumber} must be an object`);
+    }
+    const record = value;
+    if (record.type === 'user')
+        return parseUserMessage(value, lineNumber);
+    if (record.type === 'control_cancel_request') {
+        if (typeof record.request_id !== 'string' ||
+            record.request_id.length === 0) {
+            throw new Error(`stream-json input line ${lineNumber} has invalid request_id`);
+        }
+        return { type: 'control_cancel_request', request_id: record.request_id };
+    }
+    if (record.type === 'control_request') {
+        const request = record.request;
+        if (typeof record.request_id !== 'string' ||
+            record.request_id.length === 0 ||
+            !request ||
+            typeof request !== 'object' ||
+            Array.isArray(request) ||
+            request.subtype !== 'interrupt') {
+            throw new Error(`stream-json input line ${lineNumber} has invalid interrupt request`);
+        }
+        return {
+            type: 'control_request',
+            request_id: record.request_id,
+            request: { subtype: 'interrupt' },
+        };
+    }
+    if (record.type === 'control_response') {
+        const response = record.response;
+        if (!response || typeof response !== 'object' || Array.isArray(response)) {
+            throw new Error(`stream-json input line ${lineNumber} has invalid control response`);
+        }
+        const responseRecord = response;
+        if (typeof responseRecord.request_id !== 'string' ||
+            responseRecord.request_id.length === 0) {
+            throw new Error(`stream-json input line ${lineNumber} has invalid request_id`);
+        }
+        if (responseRecord.subtype === 'success') {
+            if (responseRecord.response !== undefined &&
+                (!responseRecord.response ||
+                    typeof responseRecord.response !== 'object' ||
+                    Array.isArray(responseRecord.response))) {
+                throw new Error(`stream-json input line ${lineNumber} has invalid success response`);
+            }
+            return {
+                type: 'control_response',
+                response: {
+                    subtype: 'success',
+                    request_id: responseRecord.request_id,
+                    ...(responseRecord.response === undefined
+                        ? {}
+                        : { response: responseRecord.response }),
+                },
+            };
+        }
+        if (responseRecord.subtype === 'error' &&
+            typeof responseRecord.error === 'string') {
+            return {
+                type: 'control_response',
+                response: {
+                    subtype: 'error',
+                    request_id: responseRecord.request_id,
+                    error: responseRecord.error,
+                },
+            };
+        }
+        throw new Error(`stream-json input line ${lineNumber} has invalid control response`);
+    }
+    throw new Error(`stream-json input line ${lineNumber} must have type user or a supported control type`);
+}
+export async function* readStreamJsonMessages(input) {
+    const decoder = new TextDecoder('utf-8', { fatal: true });
+    let buffer = '';
+    let lineNumber = 0;
+    const parseLine = (line) => {
+        lineNumber += 1;
+        if (line.trim().length === 0)
+            return null;
+        if (Buffer.byteLength(line) > MAX_INPUT_LINE_BYTES) {
+            throw new Error(`stream-json input line ${lineNumber} exceeds ${MAX_INPUT_LINE_BYTES} bytes`);
+        }
+        let value;
+        try {
+            value = JSON.parse(line);
+        }
+        catch {
+            throw new Error(`Invalid stream-json input at line ${lineNumber}`);
+        }
+        return parseStreamJsonMessage(value, lineNumber);
+    };
+    try {
+        for await (const chunk of input) {
+            buffer +=
+                typeof chunk === 'string'
+                    ? chunk
+                    : decoder.decode(chunk, { stream: true });
+            if (Buffer.byteLength(buffer) > MAX_INPUT_LINE_BYTES &&
+                !buffer.includes('\n')) {
+                throw new Error(`stream-json input line ${lineNumber + 1} exceeds ${MAX_INPUT_LINE_BYTES} bytes`);
+            }
+            for (;;) {
+                const newline = buffer.indexOf('\n');
+                if (newline < 0)
+                    break;
+                const line = buffer.slice(0, newline).replace(/\r$/, '');
+                buffer = buffer.slice(newline + 1);
+                const message = parseLine(line);
+                if (message)
+                    yield message;
+            }
+        }
+        buffer += decoder.decode();
+    }
+    catch (error) {
+        if (error instanceof TypeError)
+            throw new Error('stream-json input is not valid UTF-8');
+        throw error;
+    }
+    if (buffer.length > 0) {
+        const message = parseLine(buffer.replace(/\r$/, ''));
+        if (message)
+            yield message;
+    }
+}
+export async function* readStreamUserMessages(input) {
+    for await (const message of readStreamJsonMessages(input)) {
+        if (!('type' in message))
+            yield message;
+    }
+}
+const emptyUsage = () => ({ inputTokens: 0, outputTokens: 0 });
+export class StreamJsonOutput {
+    write;
+    info;
+    sessionId;
+    includePartialMessages;
+    includeHookEvents;
+    turnId = randomUUID();
+    turnText = '';
+    turnThinking = [];
+    turnCalls = [];
+    turnUsage = emptyUsage();
+    turnActive = false;
+    assistantFlushed = true;
+    contentStarted = false;
+    textContentIndex;
+    activeThinkingIndex;
+    nextContentIndex = 0;
+    modelTurns = 0;
+    compacting = false;
+    sessionState;
+    constructor(write, info, sessionId, includePartialMessages, includeHookEvents = false) {
+        this.write = write;
+        this.info = info;
+        this.sessionId = sessionId;
+        this.includePartialMessages = includePartialMessages;
+        this.includeHookEvents = includeHookEvents;
+    }
+    init() {
+        this.write({
+            type: 'system',
+            subtype: 'init',
+            cwd: this.info.cwd,
+            session_id: this.sessionId,
+            tools: this.info.tools,
+            mcp_servers: this.info.mcpServers,
+            model: this.info.model,
+            permissionMode: this.info.permissionMode,
+            slash_commands: this.info.slashCommands,
+            apiKeySource: 'PRAXIS_API_KEY',
+            praxis_version: '0.1.0',
+            claude_code_version: this.info.claudeCodeVersion,
+            agents: this.info.agents,
+            skills: this.info.skills,
+            output_style: 'default',
+            plugins: this.info.plugins ?? [],
+            fast_mode_state: 'off',
+            uuid: randomUUID(),
+        });
+    }
+    replayUser(message) {
+        this.write({ type: 'user', message, session_id: this.sessionId });
+    }
+    controlRequest(request) {
+        this.write({ type: 'control_request', ...request });
+    }
+    sink = (event) => this.onEvent(event);
+    result(result, startedAt) {
+        this.finishTurn();
+        this.write(createSuccessResult(result, this.info, startedAt, this.modelTurns));
+        this.modelTurns = 0;
+    }
+    promptSuggestion(suggestion) {
+        this.write({
+            type: 'prompt_suggestion',
+            suggestion,
+            uuid: randomUUID(),
+            session_id: this.sessionId,
+        });
+    }
+    error(message, startedAt) {
+        this.finishTurn();
+        this.write(createErrorResult(message, this.sessionId, startedAt, this.modelTurns));
+        this.modelTurns = 0;
+    }
+    onEvent(event) {
+        if (event.type === 'state') {
+            if (this.compacting && event.state !== 'compacting') {
+                this.compacting = false;
+                this.write({
+                    type: 'system',
+                    subtype: 'status',
+                    status: null,
+                    permissionMode: this.info.permissionMode,
+                    uuid: randomUUID(),
+                    session_id: this.sessionId,
+                });
+            }
+            if (event.state === 'awaiting-model') {
+                this.startTurn();
+                this.writeSessionState('running');
+            }
+            if (event.state === 'compacting') {
+                this.compacting = true;
+                this.write({
+                    type: 'system',
+                    subtype: 'status',
+                    status: 'compacting',
+                    permissionMode: this.info.permissionMode,
+                    uuid: randomUUID(),
+                    session_id: this.sessionId,
+                });
+            }
+            else if (event.state === 'awaiting-permission' ||
+                event.state === 'executing-tools' ||
+                event.state === 'persisting-results' ||
+                event.state === 'completed' ||
+                event.state === 'cancelled') {
+                this.flushAssistant();
+                if (event.state === 'awaiting-permission')
+                    this.writeSessionState('requires_action');
+                else if (event.state === 'completed' || event.state === 'cancelled') {
+                    this.writeSessionState('idle');
+                }
+            }
+            return;
+        }
+        if (event.type === 'text-delta') {
+            this.ensureTurn();
+            this.turnText += event.delta;
+            this.partialText(event.delta);
+            return;
+        }
+        if (event.type === 'thinking-start') {
+            this.ensureTurn();
+            if (this.includePartialMessages) {
+                if (this.activeThinkingIndex !== undefined) {
+                    throw new Error('Thinking content blocks cannot overlap');
+                }
+                this.activeThinkingIndex = this.nextContentIndex;
+                this.nextContentIndex += 1;
+                this.write({
+                    type: 'stream_event',
+                    event: {
+                        type: 'content_block_start',
+                        index: this.activeThinkingIndex,
+                        content_block: event.block,
+                    },
+                    parent_tool_use_id: null,
+                    session_id: this.sessionId,
+                });
+            }
+            return;
+        }
+        if (event.type === 'thinking-delta' ||
+            event.type === 'thinking-signature-delta') {
+            this.ensureTurn();
+            if (this.includePartialMessages) {
+                if (this.activeThinkingIndex === undefined) {
+                    throw new Error('Thinking delta arrived without an active block');
+                }
+                this.write({
+                    type: 'stream_event',
+                    event: {
+                        type: 'content_block_delta',
+                        index: this.activeThinkingIndex,
+                        delta: event.type === 'thinking-delta'
+                            ? { type: 'thinking_delta', thinking: event.delta }
+                            : { type: 'signature_delta', signature: event.delta },
+                    },
+                    parent_tool_use_id: null,
+                    session_id: this.sessionId,
+                });
+            }
+            return;
+        }
+        if (event.type === 'thinking-stop') {
+            this.ensureTurn();
+            this.turnThinking.push(event.block);
+            if (this.includePartialMessages) {
+                if (this.activeThinkingIndex === undefined) {
+                    throw new Error('Thinking block stopped without an active block');
+                }
+                this.write({
+                    type: 'stream_event',
+                    event: {
+                        type: 'content_block_stop',
+                        index: this.activeThinkingIndex,
+                    },
+                    parent_tool_use_id: null,
+                    session_id: this.sessionId,
+                });
+                this.activeThinkingIndex = undefined;
+            }
+            return;
+        }
+        if (event.type === 'user-message') {
+            this.write({
+                type: 'user_message',
+                message: event.message,
+                status: event.status,
+                ...(event.attachments?.length
+                    ? { attachments: event.attachments }
+                    : {}),
+                uuid: randomUUID(),
+                session_id: this.sessionId,
+            });
+            return;
+        }
+        if (event.type === 'tool-call') {
+            this.ensureTurn();
+            this.turnCalls.push(event.call);
+            return;
+        }
+        if (event.type === 'usage') {
+            this.turnUsage = event.usage;
+            return;
+        }
+        if (event.type === 'permission-decision') {
+            this.flushAssistant();
+            return;
+        }
+        if (event.type === 'tool-result') {
+            this.flushAssistant();
+            this.write({
+                type: 'user',
+                message: {
+                    role: 'user',
+                    content: [
+                        {
+                            tool_use_id: event.callId,
+                            type: 'tool_result',
+                            content: event.content,
+                            ...(event.isError ? { is_error: true } : {}),
+                        },
+                    ],
+                },
+                parent_tool_use_id: null,
+                session_id: this.sessionId,
+            });
+            return;
+        }
+        if (event.type === 'warning') {
+            this.write({
+                type: 'system',
+                subtype: 'warning',
+                message: event.message,
+                session_id: this.sessionId,
+            });
+            return;
+        }
+        if (event.type === 'compact-boundary') {
+            this.write({
+                type: 'system',
+                subtype: 'compact_boundary',
+                compact_metadata: {
+                    trigger: event.trigger,
+                    pre_tokens: event.preTokens,
+                },
+                uuid: event.uuid,
+                session_id: this.sessionId,
+            });
+            return;
+        }
+        if (event.type === 'tool-progress') {
+            this.write({
+                type: 'tool_progress',
+                tool_use_id: event.toolUseId,
+                tool_name: event.toolName,
+                parent_tool_use_id: null,
+                elapsed_time_seconds: event.elapsedTimeSeconds,
+                ...(event.taskId === undefined ? {} : { task_id: event.taskId }),
+                uuid: randomUUID(),
+                session_id: this.sessionId,
+            });
+            return;
+        }
+        if (event.type === 'task-started') {
+            this.write({
+                type: 'system',
+                subtype: 'task_started',
+                task_id: event.taskId,
+                ...(event.toolUseId === undefined
+                    ? {}
+                    : { tool_use_id: event.toolUseId }),
+                description: event.description,
+                ...(event.taskType === undefined ? {} : { task_type: event.taskType }),
+                ...(event.workflowName === undefined
+                    ? {}
+                    : { workflow_name: event.workflowName }),
+                ...(event.prompt === undefined ? {} : { prompt: event.prompt }),
+                uuid: randomUUID(),
+                session_id: this.sessionId,
+            });
+            return;
+        }
+        if (event.type === 'task-progress') {
+            this.write({
+                type: 'system',
+                subtype: 'task_progress',
+                task_id: event.taskId,
+                ...(event.toolUseId === undefined
+                    ? {}
+                    : { tool_use_id: event.toolUseId }),
+                description: event.description,
+                usage: {
+                    total_tokens: event.usage.totalTokens,
+                    tool_uses: event.usage.toolUses,
+                    duration_ms: event.usage.durationMs,
+                },
+                ...(event.lastToolName === undefined
+                    ? {}
+                    : { last_tool_name: event.lastToolName }),
+                ...(event.summary === undefined ? {} : { summary: event.summary }),
+                uuid: randomUUID(),
+                session_id: this.sessionId,
+            });
+            return;
+        }
+        if (event.type === 'task-notification') {
+            this.write({
+                type: 'system',
+                subtype: 'task_notification',
+                task_id: event.taskId,
+                ...(event.toolUseId === undefined
+                    ? {}
+                    : { tool_use_id: event.toolUseId }),
+                status: event.status,
+                output_file: event.outputFile,
+                summary: event.summary,
+                ...(event.usage === undefined
+                    ? {}
+                    : {
+                        usage: {
+                            total_tokens: event.usage.totalTokens,
+                            tool_uses: event.usage.toolUses,
+                            duration_ms: event.usage.durationMs,
+                        },
+                    }),
+                uuid: randomUUID(),
+                session_id: this.sessionId,
+            });
+            return;
+        }
+        if (event.type === 'session-state-changed') {
+            this.write({
+                type: 'system',
+                subtype: 'session_state_changed',
+                state: event.state,
+                uuid: randomUUID(),
+                session_id: this.sessionId,
+            });
+            return;
+        }
+        if (event.type === 'api-retry') {
+            this.write({
+                type: 'system',
+                subtype: 'api_retry',
+                attempt: event.attempt,
+                max_retries: event.maxRetries,
+                retry_delay_ms: event.retryDelayMs,
+                error_status: event.errorStatus,
+                error: event.error,
+                uuid: randomUUID(),
+                session_id: this.sessionId,
+            });
+            return;
+        }
+        if (event.type === 'elicitation-complete') {
+            this.write({
+                type: 'system',
+                subtype: 'elicitation_complete',
+                mcp_server_name: event.mcpServerName,
+                elicitation_id: event.elicitationId,
+                uuid: randomUUID(),
+                session_id: this.sessionId,
+            });
+            return;
+        }
+        if (event.type === 'tool-use-summary') {
+            this.write({
+                type: 'tool_use_summary',
+                summary: event.summary,
+                preceding_tool_use_ids: event.precedingToolUseIds,
+                uuid: randomUUID(),
+                session_id: this.sessionId,
+            });
+            return;
+        }
+        if (event.type === 'hook') {
+            if (!this.includeHookEvents)
+                return;
+            const hook = event.event;
+            this.write({
+                type: 'system',
+                subtype: `hook_${hook.type}`,
+                hook_id: hook.hookId,
+                hook_name: hook.hookName,
+                hook_event: hook.hookEvent,
+                ...(hook.stdout === undefined ? {} : { stdout: hook.stdout }),
+                ...(hook.stderr === undefined ? {} : { stderr: hook.stderr }),
+                ...(hook.output === undefined ? {} : { output: hook.output }),
+                ...(hook.exitCode === undefined ? {} : { exit_code: hook.exitCode }),
+                ...(hook.outcome === undefined ? {} : { outcome: hook.outcome }),
+                uuid: randomUUID(),
+                session_id: this.sessionId,
+            });
+            return;
+        }
+        if (event.type === 'failed') {
+            this.ensureTurn();
+            if (this.turnText.length === 0 &&
+                this.turnThinking.length === 0 &&
+                this.turnCalls.length === 0) {
+                this.turnText = event.message;
+                this.partialText(event.message);
+            }
+            this.flushAssistant();
+            this.writeSessionState('idle');
+        }
+    }
+    writeSessionState(state) {
+        if (this.sessionState === state)
+            return;
+        this.sessionState = state;
+        this.write({
+            type: 'system',
+            subtype: 'session_state_changed',
+            state,
+            uuid: randomUUID(),
+            session_id: this.sessionId,
+        });
+    }
+    ensureTurn() {
+        if (!this.turnActive)
+            this.startTurn();
+    }
+    startTurn() {
+        if (this.turnActive)
+            this.finishTurn();
+        this.turnId = randomUUID();
+        this.turnText = '';
+        this.turnThinking = [];
+        this.turnCalls = [];
+        this.turnUsage = emptyUsage();
+        this.turnActive = true;
+        this.assistantFlushed = false;
+        this.contentStarted = false;
+        this.textContentIndex = undefined;
+        this.activeThinkingIndex = undefined;
+        this.nextContentIndex = 0;
+        this.modelTurns += 1;
+        if (this.includePartialMessages) {
+            this.write({
+                type: 'stream_event',
+                event: {
+                    type: 'message_start',
+                    message: {
+                        id: this.turnId,
+                        type: 'message',
+                        role: 'assistant',
+                        model: this.info.model,
+                        content: [],
+                        stop_reason: null,
+                        stop_sequence: null,
+                        usage: { input_tokens: 0, output_tokens: 0 },
+                    },
+                },
+                parent_tool_use_id: null,
+                session_id: this.sessionId,
+            });
+        }
+    }
+    partialText(delta) {
+        if (!this.includePartialMessages)
+            return;
+        if (!this.contentStarted) {
+            this.contentStarted = true;
+            this.textContentIndex = this.nextContentIndex;
+            this.nextContentIndex += 1;
+            this.write({
+                type: 'stream_event',
+                event: {
+                    type: 'content_block_start',
+                    index: this.textContentIndex,
+                    content_block: { type: 'text', text: '' },
+                },
+                parent_tool_use_id: null,
+                session_id: this.sessionId,
+            });
+        }
+        this.write({
+            type: 'stream_event',
+            event: {
+                type: 'content_block_delta',
+                index: this.textContentIndex,
+                delta: { type: 'text_delta', text: delta },
+            },
+            parent_tool_use_id: null,
+            session_id: this.sessionId,
+        });
+    }
+    finishPartial() {
+        if (!this.includePartialMessages)
+            return;
+        if (this.contentStarted) {
+            this.write({
+                type: 'stream_event',
+                event: {
+                    type: 'content_block_stop',
+                    index: this.textContentIndex,
+                },
+                parent_tool_use_id: null,
+                session_id: this.sessionId,
+            });
+        }
+        for (const [toolIndex, call] of this.turnCalls.entries()) {
+            const index = this.nextContentIndex + toolIndex;
+            this.write({
+                type: 'stream_event',
+                event: {
+                    type: 'content_block_start',
+                    index,
+                    content_block: {
+                        type: 'tool_use',
+                        id: call.id,
+                        name: call.name,
+                        input: {},
+                    },
+                },
+                parent_tool_use_id: null,
+                session_id: this.sessionId,
+            });
+            this.write({
+                type: 'stream_event',
+                event: {
+                    type: 'content_block_delta',
+                    index,
+                    delta: {
+                        type: 'input_json_delta',
+                        partial_json: JSON.stringify(call.input),
+                    },
+                },
+                parent_tool_use_id: null,
+                session_id: this.sessionId,
+            });
+            this.write({
+                type: 'stream_event',
+                event: { type: 'content_block_stop', index },
+                parent_tool_use_id: null,
+                session_id: this.sessionId,
+            });
+        }
+        this.write({
+            type: 'stream_event',
+            event: {
+                type: 'message_delta',
+                delta: {
+                    stop_reason: this.turnCalls.length > 0 ? 'tool_use' : 'end_turn',
+                    stop_sequence: null,
+                },
+                usage: { output_tokens: this.turnUsage.outputTokens },
+            },
+            parent_tool_use_id: null,
+            session_id: this.sessionId,
+        });
+        this.write({
+            type: 'stream_event',
+            event: { type: 'message_stop' },
+            parent_tool_use_id: null,
+            session_id: this.sessionId,
+        });
+    }
+    flushAssistant() {
+        if (!this.turnActive || this.assistantFlushed)
+            return;
+        this.assistantFlushed = true;
+        this.finishPartial();
+        const content = [];
+        content.push(...this.turnThinking);
+        if (this.turnText.length > 0)
+            content.push({ type: 'text', text: this.turnText });
+        content.push(...this.turnCalls.map((call) => ({
+            type: 'tool_use',
+            id: call.id,
+            name: call.name,
+            input: call.input,
+        })));
+        this.write({
+            type: 'assistant',
+            message: {
+                id: this.turnId,
+                type: 'message',
+                role: 'assistant',
+                model: this.info.model,
+                content,
+                stop_reason: null,
+                stop_sequence: null,
+                usage: {
+                    input_tokens: this.turnUsage.inputTokens,
+                    output_tokens: this.turnUsage.outputTokens,
+                },
+            },
+            parent_tool_use_id: null,
+            session_id: this.sessionId,
+        });
+    }
+    finishTurn() {
+        this.flushAssistant();
+        this.turnActive = false;
+    }
+}
+//# sourceMappingURL=protocol.js.map