package/cli-wrapper.cjs000644 0000011543 3560116604 012212 0ustar00000000 000000 #!/usr/bin/env node // Fallback launcher for the claude wrapper package (name in ./package.json). // // Normally the postinstall script copies the native binary over bin/claude.exe, // so this file is never invoked. It exists for environments where postinstall // doesn't run (--ignore-scripts) — users can run `node cli-wrapper.cjs` directly // and pay the Node-process overhead as the price. const { spawnSync } = require('child_process') const { arch, constants } = require('os') const path = require('path') // Replaced at build time via sed. Keep the literals below as markers. // Platform detection + PLATFORMS map is duplicated in install.cjs — keep in sync. const PACKAGE_PREFIX = '@anthropic-ai/claude-code' const BINARY_NAME = 'claude' const WRAPPER_NAME = require('./package.json').name const PLATFORMS = { 'darwin-arm64': { pkg: PACKAGE_PREFIX + '-darwin-arm64', bin: BINARY_NAME }, 'darwin-x64': { pkg: PACKAGE_PREFIX + '-darwin-x64', bin: BINARY_NAME }, 'linux-x64': { pkg: PACKAGE_PREFIX + '-linux-x64', bin: BINARY_NAME }, 'linux-arm64': { pkg: PACKAGE_PREFIX + '-linux-arm64', bin: BINARY_NAME }, 'linux-x64-musl': { pkg: PACKAGE_PREFIX + '-linux-x64-musl', bin: BINARY_NAME, }, 'linux-arm64-musl': { pkg: PACKAGE_PREFIX + '-linux-arm64-musl', bin: BINARY_NAME, }, 'linux-arm64-android': { pkg: PACKAGE_PREFIX + '-linux-arm64-android', bin: BINARY_NAME, }, 'linux-x64-android': { pkg: PACKAGE_PREFIX + '-linux-x64-android', bin: BINARY_NAME, }, 'freebsd-x64': { pkg: PACKAGE_PREFIX + '-freebsd-x64', bin: BINARY_NAME }, 'freebsd-arm64': { pkg: PACKAGE_PREFIX + '-freebsd-arm64', bin: BINARY_NAME }, 'win32-x64': { pkg: PACKAGE_PREFIX + '-win32-x64', bin: BINARY_NAME + '.exe', }, 'win32-arm64': { pkg: PACKAGE_PREFIX + '-win32-arm64', bin: BINARY_NAME + '.exe', }, } function detectMusl() { if (process.platform !== 'linux') { return false } const report = typeof process.report?.getReport === 'function' ? process.report.getReport() : null return report != null && report.header?.glibcVersionRuntime === undefined } function getPlatformKey() { const platform = process.platform let cpu = arch() if (platform === 'android') { return 'linux-' + cpu + '-android' } if (platform === 'linux') { return 'linux-' + cpu + (detectMusl() ? '-musl' : '') } // Rosetta 2: an x64 Node on Apple Silicon reports arch()==='x64'. Prefer the // native arm64 binary — the x64 build needs AVX, which Rosetta doesn't emulate. if (platform === 'darwin' && cpu === 'x64') { const r = spawnSync('sysctl', ['-n', 'sysctl.proc_translated'], { encoding: 'utf8', }) if (r.stdout?.trim() === '1') { cpu = 'arm64' } } return platform + '-' + cpu } function getBinaryPath() { const platformKey = getPlatformKey() const info = PLATFORMS[platformKey] if (!info) { console.error( `[${WRAPPER_NAME}] Unsupported platform: ${process.platform} ${arch()}. Supported: ${Object.keys(PLATFORMS).join(', ')}`, ) process.exit(1) } const optionalDeps = require('./package.json').optionalDependencies || {} if (!optionalDeps[info.pkg]) { console.error( `[${WRAPPER_NAME}] Native binaries for ${platformKey} are not available on this release channel.`, ) console.error( ` Available: ${Object.keys(optionalDeps) .map(p => p.replace(PACKAGE_PREFIX + '-', '')) .join(', ')}`, ) process.exit(1) } try { const pkgDir = path.dirname(require.resolve(info.pkg + '/package.json')) return path.join(pkgDir, info.bin) } catch { console.error( `[${WRAPPER_NAME}] Could not find native binary package "${info.pkg}".`, ) if (platformKey === 'darwin-arm64' && arch() === 'x64') { console.error( ' You are running x64 Node under Rosetta 2 on Apple Silicon. npm only', ) console.error( ' installed the darwin-x64 binary, which requires AVX (not emulated by', ) console.error(' Rosetta). Install arm64 Node and reinstall.') } else { console.error(' Try reinstalling with: npm install') } process.exit(1) } } function main() { const binaryPath = getBinaryPath() const result = spawnSync(binaryPath, process.argv.slice(2), { stdio: 'inherit', env: { ...process.env, CLAUDE_CODE_INSTALLED_VIA_NPM_WRAPPER: '1' }, }) if (result.error) { console.error( `[${WRAPPER_NAME}] Failed to execute native binary at ` + binaryPath, ) console.error(' ' + result.error.message) process.exit(1) } if (result.signal) { // Node.js ignores some signals (e.g. SIGPIPE → SIG_IGN), so re-raising is // unreliable. Exit with the POSIX convention 128+signum instead. const signum = constants.signals[result.signal] ?? 0 process.exit(128 + signum) } else { process.exit(result.status ?? 1) } } main() package/install.cjs000644 0000015772 3560116604 011443 0ustar00000000 000000 #!/usr/bin/env node // Postinstall for the claude wrapper package (name in ./package.json). // // Detects the platform, finds the matching native binary from optionalDependencies, // and copies it over the bin/claude.exe placeholder. After this runs, `claude` execs // the native binary directly — no Node.js process stays resident. // // If the native package isn't present (--omit=optional), prints instructions and // leaves the placeholder stub in place. cli-wrapper.cjs (same directory) can be // invoked manually as a fallback that keeps working via require.resolve + spawn. // // Platform detection + PLATFORMS map is duplicated in cli-wrapper.cjs — keep in sync. const { spawnSync } = require('child_process') const { copyFileSync, linkSync, unlinkSync, chmodSync, readFileSync, writeFileSync, statSync, } = require('fs') const { arch } = require('os') const path = require('path') // Replaced at build time via sed. Keep the literals below as markers. const PACKAGE_PREFIX = '@anthropic-ai/claude-code' const BINARY_NAME = 'claude' const WRAPPER_NAME = require('./package.json').name const PLATFORMS = { 'darwin-arm64': { pkg: PACKAGE_PREFIX + '-darwin-arm64', bin: BINARY_NAME }, 'darwin-x64': { pkg: PACKAGE_PREFIX + '-darwin-x64', bin: BINARY_NAME }, 'linux-x64': { pkg: PACKAGE_PREFIX + '-linux-x64', bin: BINARY_NAME }, 'linux-arm64': { pkg: PACKAGE_PREFIX + '-linux-arm64', bin: BINARY_NAME }, 'linux-x64-musl': { pkg: PACKAGE_PREFIX + '-linux-x64-musl', bin: BINARY_NAME, }, 'linux-arm64-musl': { pkg: PACKAGE_PREFIX + '-linux-arm64-musl', bin: BINARY_NAME, }, 'linux-arm64-android': { pkg: PACKAGE_PREFIX + '-linux-arm64-android', bin: BINARY_NAME, }, 'linux-x64-android': { pkg: PACKAGE_PREFIX + '-linux-x64-android', bin: BINARY_NAME, }, 'freebsd-x64': { pkg: PACKAGE_PREFIX + '-freebsd-x64', bin: BINARY_NAME }, 'freebsd-arm64': { pkg: PACKAGE_PREFIX + '-freebsd-arm64', bin: BINARY_NAME }, 'win32-x64': { pkg: PACKAGE_PREFIX + '-win32-x64', bin: BINARY_NAME + '.exe', }, 'win32-arm64': { pkg: PACKAGE_PREFIX + '-win32-arm64', bin: BINARY_NAME + '.exe', }, } function detectMusl() { if (process.platform !== 'linux') { return false } // process.report is available in Node ≥12; glibcVersionRuntime is absent on musl. // Faster than spawning `ldd` and avoids the ENOENT→musl false positive when ldd // isn't on PATH (minimal containers). const report = typeof process.report?.getReport === 'function' ? process.report.getReport() : null return report != null && report.header?.glibcVersionRuntime === undefined } function getPlatformKey() { const platform = process.platform let cpu = arch() if (platform === 'android') { return 'linux-' + cpu + '-android' } if (platform === 'linux') { return 'linux-' + cpu + (detectMusl() ? '-musl' : '') } // Rosetta 2: an x64 Node on Apple Silicon reports arch()==='x64'. Prefer the // native arm64 binary — the x64 build needs AVX, which Rosetta doesn't emulate. if (platform === 'darwin' && cpu === 'x64') { const r = spawnSync('sysctl', ['-n', 'sysctl.proc_translated'], { encoding: 'utf8', }) if (r.stdout?.trim() === '1') { cpu = 'arm64' } } return platform + '-' + cpu } function placeBinary(src, dest) { // Try hardlink first (instant, zero extra disk for a ~500MB binary; src and // dest are both under node_modules/ so same-filesystem is the common case). // We attempt the link BEFORE touching dest — if src is missing (partial // extraction) the first linkSync throws ENOENT and the fallback stub stays. try { linkSync(src, dest) } catch (err) { if (err.code === 'EEXIST') { // Read the stub before unlinking so we can restore it if both link and // copy fail (ENOSPC, NFS error mid-500MB-copy). Only read if dest is // stub-sized — on re-install dest is the ~500MB binary. const stub = statSync(dest).size < 4096 ? readFileSync(dest) : null unlinkSync(dest) try { linkSync(src, dest) } catch { try { copyFileSync(src, dest) } catch (copyErr) { if (stub) { try { writeFileSync(dest, stub, { mode: 0o755 }) } catch { // Do nothing } } throw copyErr } } } else if (err.code === 'EXDEV' || err.code === 'EPERM') { // Cross-device or no-link-perms — copyFileSync overwrites existing dest. copyFileSync(src, dest) } else { throw err } } if (process.platform !== 'win32') { chmodSync(dest, 0o755) } } function main() { const platformKey = getPlatformKey() const info = PLATFORMS[platformKey] if (!info) { console.error( `[${WRAPPER_NAME} postinstall] Unsupported platform: ${process.platform} ${arch()}`, ) console.error(` Supported: ${Object.keys(PLATFORMS).join(', ')}`) return } const optionalDeps = require('./package.json').optionalDependencies || {} if (!optionalDeps[info.pkg]) { console.error( `[${WRAPPER_NAME} postinstall] Native binaries for ${platformKey} are not available on this release channel.`, ) console.error( ` Available: ${Object.keys(optionalDeps) .map(p => p.replace(PACKAGE_PREFIX + '-', '')) .join(', ')}`, ) return } let src try { const pkgDir = path.dirname(require.resolve(info.pkg + '/package.json')) src = path.join(pkgDir, info.bin) } catch { console.error( `[${WRAPPER_NAME} postinstall] Native package "${info.pkg}" not found.`, ) if (platformKey === 'darwin-arm64' && arch() === 'x64') { console.error( ' You are running x64 Node under Rosetta 2 on Apple Silicon. npm only', ) console.error( ' installed the darwin-x64 binary, which requires AVX (not emulated by', ) console.error( ' Rosetta). Install arm64 Node and reinstall — e.g. via nvm:', ) console.error( ' arch -arm64 zsh -c "nvm install --lts && npm i -g ' + WRAPPER_NAME + '"', ) return } console.error( ' This happens with --omit=optional or when the download failed.', ) console.error( ' The `claude` command will print instructions when invoked.', ) console.error(' Fallback: node ' + path.join(__dirname, 'cli-wrapper.cjs')) return } // Always write to bin/claude.exe — the package.json bin field points here. // The .exe extension + no-shebang stub makes npm's cmd-shim (generated at // install time, before postinstall) emit a direct exec on Windows; Unix // ignores the extension. Same pattern as Bun's npm package. const dest = path.join(__dirname, 'bin', 'claude.exe') try { placeBinary(src, dest) } catch (err) { console.error( `[${WRAPPER_NAME} postinstall] Failed to place binary: ${err.message}`, ) console.error(' Fallback: node ' + path.join(__dirname, 'cli-wrapper.cjs')) process.exitCode = 1 } } main() package/bin/claude.exe000644 0000000764 3560116604 011777 0ustar00000000 000000 echo "Error: claude native binary not installed." >&2 echo "" >&2 echo "Either postinstall did not run (--ignore-scripts, some pnpm configs)" >&2 echo "or the platform-native optional dependency was not downloaded" >&2 echo "(--omit=optional)." >&2 echo "" >&2 echo "Run the postinstall manually (adjust path for local vs global install):" >&2 echo " node node_modules/@anthropic-ai/claude-code/install.cjs" >&2 echo "" >&2 echo "Or reinstall without --ignore-scripts / --omit=optional." >&2 exit 1 package/package.json000644 0000002704 3560116604 011551 0ustar00000000 000000 { "name": "@anthropic-ai/claude-code", "version": "2.1.178", "bin": { "claude": "bin/claude.exe" }, "scripts": { "postinstall": "node install.cjs", "prepare": "node -e \"if (!process.env.AUTHORIZED) { console.error('ERROR: Direct publishing is not allowed.\\nPlease see the release workflow documentation to publish this package.'); process.exit(1); }\"" }, "engines": { "node": ">=18.0.0" }, "type": "module", "author": "Anthropic ", "license": "SEE LICENSE IN README.md", "description": "Use Claude, Anthropic's AI assistant, right from your terminal. Claude can understand your codebase, edit files, run terminal commands, and handle entire workflows for you.", "homepage": "https://github.com/anthropics/claude-code", "bugs": { "url": "https://github.com/anthropics/claude-code/issues" }, "dependencies": {}, "optionalDependencies": { "@anthropic-ai/claude-code-darwin-arm64": "2.1.178", "@anthropic-ai/claude-code-darwin-x64": "2.1.178", "@anthropic-ai/claude-code-linux-x64": "2.1.178", "@anthropic-ai/claude-code-linux-arm64": "2.1.178", "@anthropic-ai/claude-code-linux-x64-musl": "2.1.178", "@anthropic-ai/claude-code-linux-arm64-musl": "2.1.178", "@anthropic-ai/claude-code-win32-x64": "2.1.178", "@anthropic-ai/claude-code-win32-arm64": "2.1.178" }, "files": [ "bin/claude.exe", "install.cjs", "cli-wrapper.cjs", "sdk-tools.d.ts" ] } package/LICENSE.md000644 0000000223 3560116604 010661 0ustar00000000 000000 © Anthropic PBC. All rights reserved. Use is subject to the Legal Agreements outlined here: https://code.claude.com/docs/en/legal-and-compliance. package/README.md000644 0000003765 3560116604 010552 0ustar00000000 000000 # Claude Code ![](https://img.shields.io/badge/Node.js-18%2B-brightgreen?style=flat-square) [![npm]](https://www.npmjs.com/package/@anthropic-ai/claude-code) [npm]: https://img.shields.io/npm/v/@anthropic-ai/claude-code.svg?style=flat-square Claude Code is an agentic coding tool that lives in your terminal, understands your codebase, and helps you code faster by executing routine tasks, explaining complex code, and handling git workflows -- all through natural language commands. Use it in your terminal, IDE, or tag @claude on Github. **Learn more at [Claude Code Homepage](https://claude.com/product/claude-code)** | [Documentation](https://code.claude.com/docs/en/overview) ## Get started 1. Install Claude Code: ```sh npm install -g @anthropic-ai/claude-code ``` 2. Navigate to your project directory and run `claude`. ## Reporting Bugs We welcome your feedback. Use the `/bug` command to report issues directly within Claude Code, or file a [GitHub issue](https://github.com/anthropics/claude-code/issues). ## Connect on Discord Join the [Claude Developers Discord](https://anthropic.com/discord) to connect with other developers using Claude Code. Get help, share feedback, and discuss your projects with the community. ## Data collection, usage, and retention When you use Claude Code, we collect feedback, which includes usage data (such as code acceptance or rejections), associated conversation data, and user feedback submitted via the `/bug` command. ### How we use your data See our [data usage policies](https://code.claude.com/docs/en/data-usage). ### Privacy safeguards We have implemented several safeguards to protect your data, including limited retention periods for sensitive information and restricted access to user session data. For full details, please review our [Commercial Terms of Service](https://www.anthropic.com/legal/commercial-terms) and [Privacy Policy](https://www.anthropic.com/legal/privacy). package/sdk-tools.d.ts000644 0000407200 3560116604 011774 0ustar00000000 000000 /* eslint-disable */ /** * This file was automatically generated by json-schema-to-typescript. * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file, * and run json-schema-to-typescript to regenerate this file. */ /** * JSON Schema definitions for Claude CLI tool inputs */ export type ToolInputSchemas = | AgentInput | BashInput | TaskOutputInput | ExitPlanModeInput | FileEditInput | FileReadInput | FileWriteInput | GlobInput | GrepInput | TaskStopInput | ListMcpResourcesInput | McpInput | NotebookEditInput | ReadMcpResourceInput | TodoWriteInput | WebFetchInput | WebSearchInput | AskUserQuestionInput | ProjectsInput | EnterPlanModeInput | TaskCreateInput | TaskGetInput | TaskUpdateInput | TaskListInput | REPLInput | WorkflowInput | CronCreateInput | CronDeleteInput | CronListInput | ScheduleWakeupInput | RemoteTriggerInput | ShowOnboardingRolePickerInput | MonitorInput | ArtifactInput | PushNotificationInput | EnterWorktreeInput | ExitWorktreeInput | ToolOutputSchemas; export type ToolOutputSchemas = | AgentOutput | BashOutput | ExitPlanModeOutput | FileEditOutput | FileReadOutput | FileWriteOutput | GlobOutput | GrepOutput | TaskStopOutput | ListMcpResourcesOutput | McpOutput | NotebookEditOutput | ReadMcpResourceOutput | TodoWriteOutput | WebFetchOutput | WebSearchOutput | AskUserQuestionOutput | EnterWorktreeOutput | ExitWorktreeOutput | TaskCreateOutput | TaskGetOutput | TaskUpdateOutput | TaskListOutput | ArtifactOutput | RemoteTriggerOutput | ShowOnboardingRolePickerOutput | ScheduleWakeupOutput | MonitorOutput | EnterPlanModeOutput | REPLOutput | WorkflowOutput | CronCreateOutput | CronDeleteOutput | CronListOutput | PushNotificationOutput | ProjectsOutput; export type AgentOutput = | { agentId: string; agentType?: string; content: { type: "text"; text: string; }[]; resolvedModel?: string; totalToolUseCount: number; totalDurationMs: number; totalTokens: number; usage: { input_tokens: number; output_tokens: number; cache_creation_input_tokens: number | null; cache_read_input_tokens: number | null; server_tool_use: { web_search_requests: number; web_fetch_requests: number; } | null; service_tier: ("standard" | "priority" | "batch") | null; cache_creation: { ephemeral_1h_input_tokens: number; ephemeral_5m_input_tokens: number; } | null; }; toolStats?: { readCount: number; searchCount: number; bashCount: number; editFileCount: number; linesAdded: number; linesRemoved: number; otherToolCount: number; }; status: "completed"; prompt: string; } | { status: "async_launched"; /** * The ID of the async agent */ agentId: string; /** * The description of the task */ description: string; /** * Model the spawn resolved (may differ from the requested one) */ resolvedModel?: string; /** * The prompt for the agent */ prompt: string; /** * Path to the output file for checking agent progress */ outputFile: string; /** * Whether the calling agent has Read/Bash tools to check progress */ canReadOutputFile?: boolean; } | { status: "remote_launched"; /** * The ID of the remote agent task */ taskId: string; /** * The URL of the cloud session */ sessionUrl: string; /** * The description of the task */ description: string; /** * The prompt for the agent */ prompt: string; /** * Path to the output file for checking agent progress */ outputFile: string; }; export type FileReadOutput = | { type: "text"; file: { /** * The path to the file that was read */ filePath: string; /** * The content of the file */ content: string; /** * Number of lines in the returned content */ numLines: number; /** * The starting line number */ startLine: number; /** * Total number of lines in the file */ totalLines: number; /** * True when a whole-file read was auto-paginated because it exceeded the token cap (the content is a partial first page). A programmatic signal for internal consumers; survives output reconstruction (unlike the render-time banner). */ truncatedByTokenCap?: boolean; }; } | { type: "image"; file: { /** * Base64-encoded image data */ base64: string; /** * The MIME type of the image */ type: "image/jpeg" | "image/png" | "image/gif" | "image/webp"; /** * Original file size in bytes */ originalSize: number; /** * Image dimension info for coordinate mapping */ dimensions?: { /** * Original image width in pixels */ originalWidth?: number; /** * Original image height in pixels */ originalHeight?: number; /** * Displayed image width in pixels (after resizing) */ displayWidth?: number; /** * Displayed image height in pixels (after resizing) */ displayHeight?: number; }; }; } | { type: "notebook"; file: { /** * The path to the notebook file */ filePath: string; /** * Array of notebook cells */ cells: unknown[]; }; } | { type: "pdf"; file: { /** * The path to the PDF file */ filePath: string; /** * Base64-encoded PDF data */ base64: string; /** * Original file size in bytes */ originalSize: number; }; } | { type: "parts"; file: { /** * The path to the PDF file */ filePath: string; /** * Original file size in bytes */ originalSize: number; /** * Number of pages extracted */ count: number; /** * Directory containing extracted page images */ outputDir: string; }; } | { type: "file_unchanged"; file: { /** * The path to the file */ filePath: string; }; }; export type ListMcpResourcesOutput = { /** * Resource URI */ uri: string; /** * Resource name */ name: string; /** * MIME type of the resource */ mimeType?: string; /** * Resource description */ description?: string; /** * Server that provides this resource */ server: string; }[]; /** * MCP tool execution result */ export type McpOutput = | string | { type: string; [k: string]: unknown; }[] | { [k: string]: unknown; }; export type ProjectsOutput = | { method: "project_info"; notice?: string; name: string; description: string; instructions: string; docs: { path: string; created_at: string | null; }[]; files?: { path: string; file_kind: string; created_at: string | null; }[]; sync_sources?: { type: string | null; config: { [k: string]: unknown; }; }[]; knowledge: { knowledge_size: number; max_knowledge_size: number; search_threshold: number | null; rag_active: boolean; remaining_budget: number | null; }; } | { method: "project_read"; notice?: string; path: string; file_kind?: string; content?: string; local_file?: string; created_at: string | null; } | { method: "project_search"; notice?: string; rag: boolean; hits?: { name?: string; doc_uuid?: string; text?: string; }[]; docs?: string[]; } | { method: "project_write"; notice?: string; path: string; doc_uuid: string; replaced: boolean; knowledge: { knowledge_size: number; max_knowledge_size: number; search_threshold: number | null; rag_active: boolean; remaining_budget: number | null; }; } | { method: "project_delete"; notice?: string; path: string; deleted: boolean; }; export interface AgentInput { /** * A short (3-5 word) description of the task */ description: string; /** * The task for the agent to perform */ prompt: string; /** * The type of specialized agent to use for this task */ subagent_type?: string; /** * Optional model override for this agent. Takes precedence over the agent definition's model frontmatter. If omitted, uses the agent definition's model, or inherits from the parent. Ignored for subagent_type: "fork" — forks always inherit the parent model. */ model?: "sonnet" | "opus" | "haiku" | "fable"; /** * Set to true to run this agent in the background. You will be notified when it completes. */ run_in_background?: boolean; /** * Name for the spawned agent. Makes it addressable via SendMessage({to: name}) while running. */ name?: string; /** * Deprecated; ignored. The session has a single implicit team. */ team_name?: string; /** * Permission mode for spawned teammate (e.g., "plan" to require plan approval). */ mode?: "acceptEdits" | "auto" | "bypassPermissions" | "default" | "dontAsk" | "plan"; /** * Isolation mode. "worktree" creates a temporary git worktree so the agent works on an isolated copy of the repo. "remote" launches the agent in a remote cloud environment (always runs in background; availability is gated). */ isolation?: "worktree" | "remote"; } export interface BashInput { /** * The command to execute */ command: string; /** * Optional timeout in milliseconds (max 600000) */ timeout?: number; /** * Clear, concise description of what this command does in active voice. Never use words like "complex" or "risk" in the description - just describe what it does. * * For simple commands (git, npm, standard CLI tools), keep it brief (5-10 words): * - ls → "List files in current directory" * - git status → "Show working tree status" * - npm install → "Install package dependencies" * * For commands that are harder to parse at a glance (piped commands, obscure flags, etc.), add enough context to clarify what it does: * - find . -name "*.tmp" -exec rm {} \; → "Find and delete all .tmp files recursively" * - git reset --hard origin/main → "Discard all local changes and match remote main" * - curl -s url | jq '.data[]' → "Fetch JSON from URL and extract data array elements" */ description?: string; /** * Set to true to run this command in the background. */ run_in_background?: boolean; /** * Set this to true to dangerously override sandbox mode and run commands without sandboxing. */ dangerouslyDisableSandbox?: boolean; } export interface TaskOutputInput { /** * The task ID to get output from */ task_id: string; /** * Whether to wait for completion */ block: boolean; /** * Max wait time in ms */ timeout: number; } export interface ExitPlanModeInput { /** * Prompt-based permissions needed to implement the plan. These describe categories of actions rather than specific commands. */ allowedPrompts?: { /** * The tool this prompt applies to */ tool: "Bash"; /** * Semantic description of the action, e.g. "run tests", "install dependencies" */ prompt: string; }[]; [k: string]: unknown; } export interface FileEditInput { /** * The absolute path to the file to modify */ file_path: string; /** * The text to replace */ old_string: string; /** * The text to replace it with (must be different from old_string) */ new_string: string; /** * Replace all occurrences of old_string (default false) */ replace_all?: boolean; } export interface FileReadInput { /** * The absolute path to the file to read */ file_path: string; /** * The line number to start reading from. Only provide if the file is too large to read at once */ offset?: number; /** * The number of lines to read. Only provide if the file is too large to read at once. */ limit?: number; /** * Page range for PDF files (e.g., "1-5", "3", "10-20"). Only applicable to PDF files. Maximum 20 pages per request. */ pages?: string; } export interface FileWriteInput { /** * The absolute path to the file to write (must be absolute, not relative) */ file_path: string; /** * The content to write to the file */ content: string; } export interface GlobInput { /** * The glob pattern to match files against */ pattern: string; /** * The directory to search in. If not specified, the current working directory will be used. IMPORTANT: Omit this field to use the default directory. DO NOT enter "undefined" or "null" - simply omit it for the default behavior. Must be a valid directory path if provided. */ path?: string; } export interface GrepInput { /** * The regular expression pattern to search for in file contents */ pattern: string; /** * File or directory to search in (rg PATH). Defaults to current working directory. */ path?: string; /** * Glob pattern to filter files (e.g. "*.js", "*.{ts,tsx}") - maps to rg --glob */ glob?: string; /** * Output mode: "content" shows matching lines (supports -A/-B/-C context, -n line numbers, head_limit), "files_with_matches" shows file paths (supports head_limit), "count" shows match counts (supports head_limit). Defaults to "files_with_matches". */ output_mode?: "content" | "files_with_matches" | "count"; /** * Number of lines to show before each match (rg -B). Requires output_mode: "content", ignored otherwise. */ "-B"?: number; /** * Number of lines to show after each match (rg -A). Requires output_mode: "content", ignored otherwise. */ "-A"?: number; /** * Alias for context. */ "-C"?: number; /** * Number of lines to show before and after each match (rg -C). Requires output_mode: "content", ignored otherwise. */ context?: number; /** * Show line numbers in output (rg -n). Requires output_mode: "content", ignored otherwise. Defaults to true. */ "-n"?: boolean; /** * Case insensitive search (rg -i) */ "-i"?: boolean; /** * Print only the matched (non-empty) parts of each matching line, one match per output line (rg -o / --only-matching). Requires output_mode: "content", ignored otherwise. Defaults to false. */ "-o"?: boolean; /** * File type to search (rg --type). Common types: js, py, rust, go, java, etc. More efficient than include for standard file types. */ type?: string; /** * Limit output to first N lines/entries, equivalent to "| head -N". Works across all output modes: content (limits output lines), files_with_matches (limits file paths), count (limits count entries). Defaults to 250 when unspecified. Pass 0 for unlimited (use sparingly — large result sets waste context). */ head_limit?: number; /** * Skip first N lines/entries before applying head_limit, equivalent to "| tail -n +N | head -N". Works across all output modes. Defaults to 0. */ offset?: number; /** * Enable multiline mode where . matches newlines and patterns can span lines (rg -U --multiline-dotall). Default: false. */ multiline?: boolean; } export interface TaskStopInput { /** * The ID of the background task to stop */ task_id?: string; /** * Deprecated: use task_id instead */ shell_id?: string; } export interface ListMcpResourcesInput { /** * Optional server name to filter resources by */ server?: string; } export interface McpInput { [k: string]: unknown; } export interface NotebookEditInput { /** * The absolute path to the Jupyter notebook file to edit (must be absolute, not relative) */ notebook_path: string; /** * The ID of the cell to edit. When inserting a new cell, the new cell will be inserted after the cell with this ID, or at the beginning if not specified. */ cell_id?: string; /** * The new source for the cell */ new_source: string; /** * The type of the cell (code or markdown). If not specified, it defaults to the current cell type. If using edit_mode=insert, this is required. */ cell_type?: "code" | "markdown"; /** * The type of edit to make (replace, insert, delete). Defaults to replace. */ edit_mode?: "replace" | "insert" | "delete"; } export interface ReadMcpResourceInput { /** * The MCP server name */ server: string; /** * The resource URI to read */ uri: string; } export interface TodoWriteInput { /** * The updated todo list */ todos: { content: string; status: "pending" | "in_progress" | "completed"; activeForm: string; }[]; } export interface WebFetchInput { /** * The URL to fetch content from */ url: string; /** * The prompt to run on the fetched content */ prompt: string; } export interface WebSearchInput { /** * The search query to use */ query: string; /** * Only include search results from these domains */ allowed_domains?: string[]; /** * Never include search results from these domains */ blocked_domains?: string[]; } export interface AskUserQuestionInput { /** * Questions to ask the user (1-4 questions) * * @minItems 1 * @maxItems 4 */ questions: | [ { /** * The complete question to ask the user. Should be clear, specific, and end with a question mark. Example: "Which library should we use for date formatting?" If multiSelect is true, phrase it accordingly, e.g. "Which features do you want to enable?" */ question: string; /** * Very short label displayed as a chip/tag (max 12 chars). Examples: "Auth method", "Library", "Approach". */ header: string; /** * The available choices for this question. Must have 2-4 options. Each option should be a distinct, mutually exclusive choice (unless multiSelect is enabled). There should be no 'Other' option, that will be provided automatically. * * @minItems 2 * @maxItems 4 */ options: | [ { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; } ] | [ { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; } ] | [ { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; } ]; /** * Set to true to allow the user to select multiple options instead of just one. Use when choices are not mutually exclusive. */ multiSelect: boolean; } ] | [ { /** * The complete question to ask the user. Should be clear, specific, and end with a question mark. Example: "Which library should we use for date formatting?" If multiSelect is true, phrase it accordingly, e.g. "Which features do you want to enable?" */ question: string; /** * Very short label displayed as a chip/tag (max 12 chars). Examples: "Auth method", "Library", "Approach". */ header: string; /** * The available choices for this question. Must have 2-4 options. Each option should be a distinct, mutually exclusive choice (unless multiSelect is enabled). There should be no 'Other' option, that will be provided automatically. * * @minItems 2 * @maxItems 4 */ options: | [ { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; } ] | [ { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; } ] | [ { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; } ]; /** * Set to true to allow the user to select multiple options instead of just one. Use when choices are not mutually exclusive. */ multiSelect: boolean; }, { /** * The complete question to ask the user. Should be clear, specific, and end with a question mark. Example: "Which library should we use for date formatting?" If multiSelect is true, phrase it accordingly, e.g. "Which features do you want to enable?" */ question: string; /** * Very short label displayed as a chip/tag (max 12 chars). Examples: "Auth method", "Library", "Approach". */ header: string; /** * The available choices for this question. Must have 2-4 options. Each option should be a distinct, mutually exclusive choice (unless multiSelect is enabled). There should be no 'Other' option, that will be provided automatically. * * @minItems 2 * @maxItems 4 */ options: | [ { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; } ] | [ { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; } ] | [ { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; } ]; /** * Set to true to allow the user to select multiple options instead of just one. Use when choices are not mutually exclusive. */ multiSelect: boolean; } ] | [ { /** * The complete question to ask the user. Should be clear, specific, and end with a question mark. Example: "Which library should we use for date formatting?" If multiSelect is true, phrase it accordingly, e.g. "Which features do you want to enable?" */ question: string; /** * Very short label displayed as a chip/tag (max 12 chars). Examples: "Auth method", "Library", "Approach". */ header: string; /** * The available choices for this question. Must have 2-4 options. Each option should be a distinct, mutually exclusive choice (unless multiSelect is enabled). There should be no 'Other' option, that will be provided automatically. * * @minItems 2 * @maxItems 4 */ options: | [ { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; } ] | [ { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; } ] | [ { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; } ]; /** * Set to true to allow the user to select multiple options instead of just one. Use when choices are not mutually exclusive. */ multiSelect: boolean; }, { /** * The complete question to ask the user. Should be clear, specific, and end with a question mark. Example: "Which library should we use for date formatting?" If multiSelect is true, phrase it accordingly, e.g. "Which features do you want to enable?" */ question: string; /** * Very short label displayed as a chip/tag (max 12 chars). Examples: "Auth method", "Library", "Approach". */ header: string; /** * The available choices for this question. Must have 2-4 options. Each option should be a distinct, mutually exclusive choice (unless multiSelect is enabled). There should be no 'Other' option, that will be provided automatically. * * @minItems 2 * @maxItems 4 */ options: | [ { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; } ] | [ { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; } ] | [ { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; } ]; /** * Set to true to allow the user to select multiple options instead of just one. Use when choices are not mutually exclusive. */ multiSelect: boolean; }, { /** * The complete question to ask the user. Should be clear, specific, and end with a question mark. Example: "Which library should we use for date formatting?" If multiSelect is true, phrase it accordingly, e.g. "Which features do you want to enable?" */ question: string; /** * Very short label displayed as a chip/tag (max 12 chars). Examples: "Auth method", "Library", "Approach". */ header: string; /** * The available choices for this question. Must have 2-4 options. Each option should be a distinct, mutually exclusive choice (unless multiSelect is enabled). There should be no 'Other' option, that will be provided automatically. * * @minItems 2 * @maxItems 4 */ options: | [ { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; } ] | [ { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; } ] | [ { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; } ]; /** * Set to true to allow the user to select multiple options instead of just one. Use when choices are not mutually exclusive. */ multiSelect: boolean; } ] | [ { /** * The complete question to ask the user. Should be clear, specific, and end with a question mark. Example: "Which library should we use for date formatting?" If multiSelect is true, phrase it accordingly, e.g. "Which features do you want to enable?" */ question: string; /** * Very short label displayed as a chip/tag (max 12 chars). Examples: "Auth method", "Library", "Approach". */ header: string; /** * The available choices for this question. Must have 2-4 options. Each option should be a distinct, mutually exclusive choice (unless multiSelect is enabled). There should be no 'Other' option, that will be provided automatically. * * @minItems 2 * @maxItems 4 */ options: | [ { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; } ] | [ { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; } ] | [ { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; } ]; /** * Set to true to allow the user to select multiple options instead of just one. Use when choices are not mutually exclusive. */ multiSelect: boolean; }, { /** * The complete question to ask the user. Should be clear, specific, and end with a question mark. Example: "Which library should we use for date formatting?" If multiSelect is true, phrase it accordingly, e.g. "Which features do you want to enable?" */ question: string; /** * Very short label displayed as a chip/tag (max 12 chars). Examples: "Auth method", "Library", "Approach". */ header: string; /** * The available choices for this question. Must have 2-4 options. Each option should be a distinct, mutually exclusive choice (unless multiSelect is enabled). There should be no 'Other' option, that will be provided automatically. * * @minItems 2 * @maxItems 4 */ options: | [ { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; } ] | [ { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; } ] | [ { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; } ]; /** * Set to true to allow the user to select multiple options instead of just one. Use when choices are not mutually exclusive. */ multiSelect: boolean; }, { /** * The complete question to ask the user. Should be clear, specific, and end with a question mark. Example: "Which library should we use for date formatting?" If multiSelect is true, phrase it accordingly, e.g. "Which features do you want to enable?" */ question: string; /** * Very short label displayed as a chip/tag (max 12 chars). Examples: "Auth method", "Library", "Approach". */ header: string; /** * The available choices for this question. Must have 2-4 options. Each option should be a distinct, mutually exclusive choice (unless multiSelect is enabled). There should be no 'Other' option, that will be provided automatically. * * @minItems 2 * @maxItems 4 */ options: | [ { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; } ] | [ { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; } ] | [ { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; } ]; /** * Set to true to allow the user to select multiple options instead of just one. Use when choices are not mutually exclusive. */ multiSelect: boolean; }, { /** * The complete question to ask the user. Should be clear, specific, and end with a question mark. Example: "Which library should we use for date formatting?" If multiSelect is true, phrase it accordingly, e.g. "Which features do you want to enable?" */ question: string; /** * Very short label displayed as a chip/tag (max 12 chars). Examples: "Auth method", "Library", "Approach". */ header: string; /** * The available choices for this question. Must have 2-4 options. Each option should be a distinct, mutually exclusive choice (unless multiSelect is enabled). There should be no 'Other' option, that will be provided automatically. * * @minItems 2 * @maxItems 4 */ options: | [ { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; } ] | [ { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; } ] | [ { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; } ]; /** * Set to true to allow the user to select multiple options instead of just one. Use when choices are not mutually exclusive. */ multiSelect: boolean; } ]; /** * User answers collected by the permission component */ answers?: { [k: string]: string; }; /** * Optional per-question annotations from the user (e.g., notes on preview selections). Keyed by question text. */ annotations?: { [k: string]: { /** * The preview content of the selected option, if the question used previews. */ preview?: string; /** * Free-text notes the user added to their selection. */ notes?: string; }; }; /** * Optional metadata for tracking and analytics purposes. Not displayed to user. */ metadata?: { /** * Optional identifier for the source of this question (e.g., "remember" for /remember command). Used for analytics tracking. */ source?: string; }; } export interface ProjectsInput { method: "project_info" | "project_read" | "project_search" | "project_write" | "project_delete"; /** * project_read/project_write/project_delete: doc path. project_write: an existing path is replaced in place; a new bare filename (no "/") is namespaced to "claude/". */ path?: string; /** * project_write: inline doc text. Mutually exclusive with local_path. Use local_path for anything you have on disk. */ content?: string; /** * project_write: a file inside the working directory to upload. The tool reads, encodes, and uploads directly — contents never enter your context. Mutually exclusive with content. */ local_path?: string; /** * project_write: bypass the chat-injection budget guard. Set only when the write is genuinely worth degrading chat to retrieval mode for everyone in the project. */ force?: boolean; /** * project_search: knowledge-base query */ query?: string; /** * project_search: number of hits (default 5) */ n?: number; } export interface EnterPlanModeInput {} export interface TaskCreateInput { /** * A brief title for the task */ subject: string; /** * What needs to be done */ description: string; /** * Present continuous form shown in spinner when in_progress (e.g., "Running tests") */ activeForm?: string; /** * Arbitrary metadata to attach to the task */ metadata?: { [k: string]: unknown; }; } export interface TaskGetInput { /** * The ID of the task to retrieve */ taskId: string; } export interface TaskUpdateInput { /** * The ID of the task to update */ taskId: string; /** * New subject for the task */ subject?: string; /** * New description for the task */ description?: string; /** * Present continuous form shown in spinner when in_progress (e.g., "Running tests") */ activeForm?: string; /** * New status for the task */ status?: ("pending" | "in_progress" | "completed") | "deleted"; /** * Task IDs that this task blocks */ addBlocks?: string[]; /** * Task IDs that block this task */ addBlockedBy?: string[]; /** * New owner for the task */ owner?: string; /** * Metadata keys to merge into the task. Set a key to null to delete it. */ metadata?: { [k: string]: unknown; }; } export interface TaskListInput {} export interface REPLInput { /** * JavaScript code to execute. Supports top-level await. State persists across calls. */ code: string; /** * Clear, concise description of what this script does in active voice (5-10 words). E.g. "Trace upgrade message to its GrowthBook flag" */ description?: string; /** * Optional timeout in milliseconds (default 30000, max 600000) */ timeout?: number; } export interface WorkflowInput { /** * Self-contained workflow script. Must begin with `export const meta = { name, description, phases }` (pure literal, no computed values) followed by the script body using agent()/parallel()/pipeline()/phase(). */ script?: string; /** * Name of a predefined workflow (built-in or from .claude/workflows/). Resolves to a self-contained script. */ name?: string; /** * Ignored — set the workflow description in the script's `meta` block. */ description?: string; /** * Ignored — set the workflow title in the script's `meta` block. */ title?: string; /** * Optional input value exposed to the script as the global `args`, verbatim. Pass arrays/objects as actual JSON values, NOT as a JSON-encoded string — a stringified list breaks `args.filter`/`args.map` in the script. Use for parameterized named workflows (e.g. a research question). */ args?: { [k: string]: unknown; }; /** * Path to a workflow script file on disk. Every Workflow invocation persists its script under the session directory and returns the path in the tool result. To iterate, edit that file with Write/Edit and re-invoke Workflow with the same `scriptPath` instead of re-sending the full script. Takes precedence over `script` and `name`. */ scriptPath?: string; /** * Run ID of a prior Workflow invocation to resume from. Completed agent() calls with unchanged (prompt, opts) return their cached results instantly; only edited or new calls re-run. Same-session only. Stop the prior run first (TaskStop) before resuming. */ resumeFromRunId?: string; } export interface CronCreateInput { /** * Standard 5-field cron expression in local time: "M H DoM Mon DoW" (e.g. "* /5 * * * *" = every 5 minutes, "30 14 28 2 *" = Feb 28 at 2:30pm local once). */ cron: string; /** * The prompt to enqueue at each fire time. */ prompt: string; /** * true (default) = fire on every cron match until deleted or auto-expired after 7 days. false = fire once at the next match, then auto-delete. Use false for "remind me at X" one-shot requests with pinned minute/hour/dom/month. */ recurring?: boolean; /** * true = persist to .claude/scheduled_tasks.json and survive restarts. false (default) = in-memory only, dies when this Claude session ends. Use true only when the user asks the task to survive across sessions. */ durable?: boolean; } export interface CronDeleteInput { /** * Job ID returned by CronCreate. */ id: string; } export interface CronListInput {} export interface ScheduleWakeupInput { /** * Seconds from now to wake up. Clamped to [60, 3600] by the runtime. */ delaySeconds: number; /** * One short sentence explaining the chosen delay. Goes to telemetry and is shown to the user. Be specific. */ reason: string; /** * The /loop input to fire on wake-up. Pass the same /loop input verbatim each turn so the next firing re-enters the skill and continues the loop. For autonomous /loop (no user prompt), pass the literal sentinel `<>` instead (the dynamic-pacing variant, not the CronCreate-mode `<>`). */ prompt: string; } export interface RemoteTriggerInput { action: "list" | "get" | "create" | "update" | "run"; /** * Required for get, update, and run */ trigger_id?: string; /** * Required for create and update; optional for run */ body?: { [k: string]: unknown; }; } export interface ShowOnboardingRolePickerInput {} export interface MonitorInput { /** * Short human-readable description of what you are monitoring (shown in notifications). */ description: string; /** * Kill the monitor after this deadline. Default 300000ms, max 3600000ms. Ignored when persistent is true. */ timeout_ms: number; /** * Run for the lifetime of the session (no timeout). Use for session-length watches like PR monitoring or log tails. Stop with TaskStop. */ persistent: boolean; /** * Shell command or script. Each stdout line is an event; exit ends the watch. */ command: string; } export interface ArtifactInput { /** * Path to an .html or .md file to render. Use a short, distinctive basename — it is the fallback title if the HTML has no . */ file_path: string; /** * Browser-tab icon: one or two emoji (e.g. "📊"). No markup. Keep stable across redeploys; change only on a hard topic pivot. */ favicon: string; /** * Short human-readable name for this version (e.g. "fixed-background"). Shown in the version picker instead of the raw version id. */ label?: string; /** * Existing artifact URL to redeploy to. Pass when the user gives you a URL for an artifact not published in this session; omit for new artifacts or same-session redeploys. Must be an artifact the user owns. */ url?: string; } export interface PushNotificationInput { /** * The notification body. Keep it under 200 characters; mobile OSes truncate. */ message: string; status: "proactive"; } export interface EnterWorktreeInput { /** * Optional name for a new worktree. Each "/"-separated segment may contain only letters, digits, dots, underscores, and dashes; max 64 chars total. A random name is generated if not provided. Mutually exclusive with `path`. */ name?: string; /** * Path to an existing worktree of the current repository to switch into instead of creating a new one. Must appear in `git worktree list` for the current repo. Mutually exclusive with `name`. */ path?: string; } export interface ExitWorktreeInput { /** * "keep" leaves the worktree and branch on disk; "remove" deletes both. */ action: "keep" | "remove"; /** * Required true when action is "remove" and the worktree has uncommitted files or unmerged commits. The tool will refuse and list them otherwise. */ discard_changes?: boolean; } export interface BashOutput { /** * The standard output of the command */ stdout: string; /** * The standard error output of the command */ stderr: string; /** * Path to raw output file for large MCP tool outputs */ rawOutputPath?: string; /** * Whether the command was interrupted */ interrupted: boolean; /** * Flag to indicate if stdout contains image data */ isImage?: boolean; /** * ID of the background task if command is running in background */ backgroundTaskId?: string; /** * True if the user manually backgrounded the command with Ctrl+B */ backgroundedByUser?: boolean; /** * True if assistant-mode auto-backgrounded a long-running blocking command */ assistantAutoBackgrounded?: boolean; /** * Flag to indicate if sandbox mode was overridden */ dangerouslyDisableSandbox?: boolean; /** * Semantic interpretation for non-error exit codes with special meaning */ returnCodeInterpretation?: string; /** * Whether the command is expected to produce no output on success */ noOutputExpected?: boolean; /** * Structured content blocks */ structuredContent?: unknown[]; /** * Path to the persisted full output in tool-results dir (set when output is too large for inline) */ persistedOutputPath?: string; /** * Total size of the output in bytes (set when output is too large for inline) */ persistedOutputSize?: number; /** * Model-facing note listing readFileState entries whose mtime bumped during this command (set when WRITE_COMMAND_MARKERS matches) */ staleReadFileStateHint?: string; /** * Model-facing system-reminder appended when a gh command reports a GitHub API rate-limit error */ ghRateLimitHint?: string; /** * @internal Structured classification of git/gh operations detected in this command (commit/push/merge/rebase/PR). Client-facing — lets clients render git activity without re-parsing stdout; not surfaced to the model. */ gitOperation?: { commit?: { sha: string; kind: "committed" | "amended" | "cherry-picked"; }; push?: { branch: string; }; branch?: { ref: string; action: "merged" | "rebased"; }; pr?: { number: number; url?: string; action: | "created" | "edited" | "merged" | "commented" | "closed" | "ready" | "draft" | "auto-merge-enabled" | "auto-merge-disabled"; }; }; } export interface ExitPlanModeOutput { /** * The plan that was presented to the user */ plan: string | null; isAgent: boolean; /** * The file path where the plan was saved */ filePath?: string; /** * Whether the Agent tool is available in the current context */ hasTaskTool?: boolean; /** * True when the user edited the plan (CCR web UI or Ctrl+G); determines whether the plan is echoed back in tool_result */ planWasEdited?: boolean; /** * When true, the teammate has sent a plan approval request to the team leader */ awaitingLeaderApproval?: boolean; /** * Unique identifier for the plan approval request */ requestId?: string; } export interface FileEditOutput { /** * The file path that was edited */ filePath: string; /** * The original string that was replaced */ oldString: string; /** * The new string that replaced it */ newString: string; /** * The original file contents before editing */ originalFile: string | null; /** * Diff patch showing the changes */ structuredPatch: { oldStart: number; oldLines: number; newStart: number; newLines: number; lines: string[]; }[]; /** * Whether the user modified the proposed changes */ userModified: boolean; /** * Whether all occurrences were replaced */ replaceAll: boolean; gitDiff?: { filename: string; status: "modified" | "added"; additions: number; deletions: number; changes: number; patch: string; /** * GitHub owner/repo when available */ repository?: string | null; }; } export interface FileWriteOutput { /** * Whether a new file was created or an existing file was updated */ type: "create" | "update"; /** * The path to the file that was written */ filePath: string; /** * The content that was written to the file */ content: string; /** * Diff patch showing the changes */ structuredPatch: { oldStart: number; oldLines: number; newStart: number; newLines: number; lines: string[]; }[]; /** * The original file content before the write (null for new files) */ originalFile: string | null; gitDiff?: { filename: string; status: "modified" | "added"; additions: number; deletions: number; changes: number; patch: string; /** * GitHub owner/repo when available */ repository?: string | null; }; /** * True when the user edited the proposed content in the permission dialog before accepting */ userModified?: boolean; } export interface GlobOutput { /** * Time taken to execute the search in milliseconds */ durationMs: number; /** * Total number of files found */ numFiles: number; /** * Array of file paths that match the pattern */ filenames: string[]; /** * Whether results were truncated (limited to 100 files) */ truncated: boolean; } export interface GrepOutput { mode?: "content" | "files_with_matches" | "count"; numFiles: number; filenames: string[]; content?: string; numLines?: number; numMatches?: number; appliedLimit?: number; appliedOffset?: number; } export interface TaskStopOutput { /** * Status message about the operation */ message: string; /** * The ID of the task that was stopped */ task_id: string; /** * The type of the task that was stopped */ task_type: string; /** * The command or description of the stopped task */ command?: string; } export interface NotebookEditOutput { /** * The new source code that was written to the cell */ new_source: string; /** * The ID of the cell that was edited */ cell_id?: string; /** * The type of the cell */ cell_type: "code" | "markdown"; /** * The programming language of the notebook */ language: string; /** * The edit mode that was used */ edit_mode: string; /** * Error message if the operation failed */ error?: string; /** * The path to the notebook file */ notebook_path: string; /** * The original notebook content before modification */ original_file: string; /** * The updated notebook content after modification */ updated_file: string; } export interface ReadMcpResourceOutput { contents: { /** * Resource URI */ uri: string; /** * MIME type of the content */ mimeType?: string; /** * Text content of the resource */ text?: string; /** * Path where binary blob content was saved */ blobSavedTo?: string; }[]; /** * Human-readable error when the server could not read the resource */ error?: string; } export interface TodoWriteOutput { /** * The todo list before the update */ oldTodos: { content: string; status: "pending" | "in_progress" | "completed"; activeForm: string; }[]; /** * The todo list after the update */ newTodos: { content: string; status: "pending" | "in_progress" | "completed"; activeForm: string; }[]; } export interface WebFetchOutput { /** * Size of the fetched content in bytes */ bytes: number; /** * HTTP response code */ code: number; /** * HTTP response code text */ codeText: string; /** * Processed result from applying the prompt to the content */ result: string; /** * Time taken to fetch and process the content */ durationMs: number; /** * The URL that was fetched */ url: string; artifactRead?: { slug: string; ver: string; }; } export interface WebSearchOutput { /** * The search query that was executed */ query: string; /** * Search results and/or text commentary from the model */ results: ( | { /** * ID of the tool use */ tool_use_id: string; /** * Array of search hits */ content: { /** * The title of the search result */ title: string; /** * The URL of the search result */ url: string; }[]; } | string )[]; /** * Time taken to complete the search operation */ durationSeconds: number; /** * Number of web searches performed */ searchCount?: number; } export interface AskUserQuestionOutput { /** * The questions that were asked */ questions: { /** * The complete question to ask the user. Should be clear, specific, and end with a question mark. Example: "Which library should we use for date formatting?" If multiSelect is true, phrase it accordingly, e.g. "Which features do you want to enable?" */ question: string; /** * Very short label displayed as a chip/tag (max 12 chars). Examples: "Auth method", "Library", "Approach". */ header: string; /** * The available choices for this question. Must have 2-4 options. Each option should be a distinct, mutually exclusive choice (unless multiSelect is enabled). There should be no 'Other' option, that will be provided automatically. * * @minItems 2 * @maxItems 4 */ options: | [ { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; } ] | [ { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; } ] | [ { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; }, { /** * The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice. */ label: string; /** * Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications. */ description: string; /** * Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format. */ preview?: string; } ]; /** * Set to true to allow the user to select multiple options instead of just one. Use when choices are not mutually exclusive. */ multiSelect: boolean; }[]; /** * The answers provided by the user (question text -> answer string; multi-select answers are comma-separated) */ answers: { [k: string]: string; }; /** * Freeform text the user typed instead of selecting a structured option */ response?: string; /** * Optional per-question annotations from the user (e.g., notes on preview selections). Keyed by question text. */ annotations?: { [k: string]: { /** * The preview content of the selected option, if the question used previews. */ preview?: string; /** * Free-text notes the user added to their selection. */ notes?: string; }; }; } export interface EnterWorktreeOutput { worktreePath: string; worktreeBranch?: string; message: string; } export interface ExitWorktreeOutput { action: "keep" | "remove"; originalCwd: string; worktreePath: string; worktreeBranch?: string; tmuxSessionName?: string; discardedFiles?: number; discardedCommits?: number; message: string; } export interface TaskCreateOutput { task: { id: string; subject: string; }; } export interface TaskGetOutput { task: { id: string; subject: string; description: string; status: "pending" | "in_progress" | "completed"; blocks: string[]; blockedBy: string[]; } | null; } export interface TaskUpdateOutput { success: boolean; taskId: string; updatedFields: string[]; error?: string; statusChange?: { from: string; to: string; }; } export interface TaskListOutput { tasks: { id: string; subject: string; status: "pending" | "in_progress" | "completed"; owner?: string; blockedBy: string[]; }[]; } export interface ArtifactOutput { url: string; path: string; title?: string; version?: string; mcpDropped?: string; } export interface RemoteTriggerOutput { status: number; json: string; summary?: string; } export interface ShowOnboardingRolePickerOutput { role?: string; dismissed?: boolean; } export interface ScheduleWakeupOutput { /** * Epoch ms timestamp when the next wakeup will fire */ scheduledFor: number; /** * Actual delay used after clamping to runtime bounds */ clampedDelaySeconds: number; /** * True if the requested delaySeconds was outside [60, 3600] */ wasClamped: boolean; } export interface MonitorOutput { /** * ID of the background monitor task. */ taskId: string; /** * Timeout deadline in milliseconds (0 when persistent). */ timeoutMs: number; /** * No timeout — runs until TaskStop or session end. */ persistent?: boolean; } export interface EnterPlanModeOutput { /** * Confirmation that plan mode was entered */ message: string; } export interface REPLOutput { /** * The code that was executed */ code: string; /** * Return value from the code execution */ result: { [k: string]: unknown; }; /** * Captured console.log output */ stdout: string; /** * Captured console.error output */ stderr: string; /** * Error message if execution failed */ error?: string; /** * Names of tools registered during this execution */ registeredTools?: string[]; /** * Images returned by inner Read calls — surfaced as image content blocks */ images?: { base64: string; mediaType: string; }[]; /** * PDFs returned by inner Read calls — surfaced as document content blocks */ documents?: { base64: string; }[]; } export interface WorkflowOutput { status: "async_launched" | "remote_launched"; taskId: string; /** * TaskType of the registered background task — 'local_workflow' for in-process runs, 'remote_agent' when remote:true dispatches to CCR. Set on all new writes; absent only on transcripts written before this field existed. */ taskType?: "local_workflow" | "remote_agent"; /** * meta.name from the workflow script — same value as task_started.workflow_name. Set on all new writes; absent only on transcripts written before this field existed. */ workflowName?: string; /** * Local workflow run identifier for resumeFromRunId. Absent for remote_launched (the CCR session URL is the resume handle there) and on transcripts written before this field existed. */ runId?: string; summary?: string; /** * Directory where subagent transcripts are written during execution */ transcriptDir?: string; /** * Path to the persisted workflow script for this invocation. Editable via Write/Edit; pass back as `scriptPath` to re-run without resending the script. */ scriptPath?: string; /** * CCR session URL when status is remote_launched */ sessionUrl?: string; /** * Non-blocking heads-up (e.g. local git state diverges from the pushed branch the cloud session will clone) */ warning?: string; /** * Set if syntax check failed */ error?: string; } export interface CronCreateOutput { id: string; humanSchedule: string; recurring: boolean; durable?: boolean; } export interface CronDeleteOutput { id: string; } export interface CronListOutput { jobs: { id: string; cron: string; humanSchedule: string; prompt: string; recurring?: boolean; durable?: boolean; }[]; } export interface PushNotificationOutput { message: string; pushSent?: boolean; localSent?: boolean; disabledReason?: "config_off" | "user_present" | "no_transport"; idleSec?: number; hasFocus?: boolean; /** * ISO timestamp captured at tool execution on the emitting process. Optional — resumed sessions replay pre-sentAt outputs verbatim. */ sentAt?: string; } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������