feat: add write_stdin tool for interactive terminal support

This commit implements the interactive terminal feature from the terminal
integration specification (plans/extract-terminal-integration.md).

Changes:
- Add write_stdin to toolNames in packages/types/src/tool.ts
- Create write_stdin native tool schema in src/core/prompts/tools/native-tools/
- Create WriteStdinTool handler in src/core/tools/
- Add ProcessManager to track running processes by session_id
- Modify ExecuteCommandTool to register processes when still running
- Add write_stdin to tool routing in presentAssistantMessage.ts
- Add write_stdin to NativeToolCallParser for streaming support
- Add tests for ProcessManager

The write_stdin tool enables the LLM to:
- Send input to running terminal processes (y/n prompts, passwords)
- Send control characters like Ctrl+C (\x03)
- Poll for new output from long-running processes

When execute_command starts a process that's still running after the
yield time, it registers the process with ProcessManager and returns
a session_id. The LLM can then use write_stdin with that session_id
to interact with the process.

Author: hannesrudolph

packages/types/src/tool.ts

@@ -16,6 +16,7 @@ export type ToolGroup = z.infer<typeof toolGroupsSchema>
 
 export const toolNames = [
 	"execute_command",
+	"write_stdin",
 	"read_file",
 	"read_command_output",
 	"write_to_file",

src/core/assistant-message/NativeToolCallParser.ts

@@ -400,6 +400,17 @@ export class NativeToolCallParser {
 				}
 				break
 
+			case "write_stdin":
+				if (partialArgs.session_id !== undefined) {
+					nativeArgs = {
+						session_id: partialArgs.session_id,
+						chars: partialArgs.chars,
+						yield_time_ms: partialArgs.yield_time_ms,
+						max_output_tokens: partialArgs.max_output_tokens,
+					}
+				}
+				break
+
 			case "write_to_file":
 				if (partialArgs.path || partialArgs.content) {
 					nativeArgs = {
@@ -687,6 +698,17 @@ export class NativeToolCallParser {
 					}
 					break
 
+				case "write_stdin":
+					if (args.session_id !== undefined) {
+						nativeArgs = {
+							session_id: args.session_id,
+							chars: args.chars,
+							yield_time_ms: args.yield_time_ms,
+							max_output_tokens: args.max_output_tokens,
+						} as NativeArgsFor<TName>
+					}
+					break
+
 				case "apply_diff":
 					if (args.path !== undefined && args.diff !== undefined) {
 						nativeArgs = {

src/core/assistant-message/presentAssistantMessage.ts

@@ -26,6 +26,7 @@ import { applyPatchTool } from "../tools/ApplyPatchTool"
 import { searchFilesTool } from "../tools/SearchFilesTool"
 import { browserActionTool } from "../tools/BrowserActionTool"
 import { executeCommandTool } from "../tools/ExecuteCommandTool"
+import { writeStdinTool } from "../tools/WriteStdinTool"
 import { useMcpToolTool } from "../tools/UseMcpToolTool"
 import { accessMcpResourceTool } from "../tools/accessMcpResourceTool"
 import { askFollowupQuestionTool } from "../tools/AskFollowupQuestionTool"
@@ -856,6 +857,13 @@ export async function presentAssistantMessage(cline: Task) {
 						pushToolResult,
 					})
 					break
+				case "write_stdin":
+					await writeStdinTool.handle(cline, block as ToolUse<"write_stdin">, {
+						askApproval,
+						handleError,
+						pushToolResult,
+					})
+					break
 				case "use_mcp_tool":
 					await useMcpToolTool.handle(cline, block as ToolUse<"use_mcp_tool">, {
 						askApproval,

src/core/prompts/tools/native-tools/index.ts

@@ -20,6 +20,7 @@ import edit_file from "./edit_file"
 import searchFiles from "./search_files"
 import switchMode from "./switch_mode"
 import updateTodoList from "./update_todo_list"
+import writeStdin from "./write_stdin"
 import writeToFile from "./write_to_file"
 
 export { getMcpServerTools } from "./mcp_server"
@@ -75,6 +76,7 @@ export function getNativeTools(options: NativeToolsOptions = {}): OpenAI.Chat.Ch
 		searchFiles,
 		switchMode,
 		updateTodoList,
+		writeStdin,
 		writeToFile,
 	] satisfies OpenAI.Chat.ChatCompletionTool[]
 }

src/core/prompts/tools/native-tools/write_stdin.ts

@@ -0,0 +1,87 @@
+import type OpenAI from "openai"
+
+/**
+ * Native tool definition for write_stdin.
+ *
+ * This tool allows the LLM to write characters to an existing terminal session
+ * and receive the resulting output. It enables interactive terminal workflows
+ * where the LLM can respond to prompts, provide input to running processes,
+ * and monitor long-running commands.
+ */
+
+const WRITE_STDIN_DESCRIPTION = `Writes characters to an existing exec session and returns recent output.
+
+Use this tool when:
+1. A command started with execute_command is still running and waiting for input
+2. You need to respond to an interactive prompt (e.g., "Press y to continue", password prompts)
+3. You want to poll a long-running process for new output without sending input
+
+The session_id is returned by execute_command when a process is still running.
+
+Parameters:
+- session_id: (required) Identifier of the running exec session (returned by execute_command)
+- chars: (optional) Characters to write to stdin. Use empty string or omit to just poll for output.
+- yield_time_ms: (optional) Milliseconds to wait for output after writing (default: 250, min: 250, max: 30000)
+- max_output_tokens: (optional) Maximum tokens to return in the response
+
+Common use cases:
+- Sending 'y' or 'n' to confirmation prompts
+- Providing input to interactive CLI tools
+- Sending Ctrl+C (\\x03) to terminate a process
+- Polling for output from a long-running process
+
+Example: Responding to a confirmation prompt
+{ "session_id": 1234, "chars": "y\\n" }
+
+Example: Sending Ctrl+C to stop a process
+{ "session_id": 1234, "chars": "\\x03" }
+
+Example: Polling for new output (no input)
+{ "session_id": 1234, "chars": "", "yield_time_ms": 2000 }
+
+Example: Providing password (note: prefer non-interactive approaches when possible)
+{ "session_id": 1234, "chars": "password\\n" }`
+
+const SESSION_ID_DESCRIPTION = `Identifier of the running exec session (returned by execute_command when a process is still running)`
+
+const CHARS_DESCRIPTION = `Characters to write to stdin. May be empty to just poll for output. Supports escape sequences like \\n (newline) and \\x03 (Ctrl+C).`
+
+const YIELD_TIME_MS_DESCRIPTION = `Milliseconds to wait for output after writing (default: 250, range: 250-30000). Use higher values when expecting delayed output.`
+
+const MAX_OUTPUT_TOKENS_DESCRIPTION = `Maximum tokens to return in the response. Excess output will be truncated with head/tail preservation.`
+
+export default {
+	type: "function",
+	function: {
+		name: "write_stdin",
+		description: WRITE_STDIN_DESCRIPTION,
+		// Note: strict mode is intentionally disabled for this tool.
+		// With strict: true, OpenAI requires ALL properties to be in the 'required' array,
+		// which forces the LLM to always provide explicit values (even null) for optional params.
+		// This creates verbose tool calls and poor UX. By disabling strict mode, the LLM can
+		// omit optional parameters entirely, making the tool easier to use.
+		parameters: {
+			type: "object",
+			properties: {
+				session_id: {
+					type: "number",
+					description: SESSION_ID_DESCRIPTION,
+				},
+				chars: {
+					type: "string",
+					description: CHARS_DESCRIPTION,
+				},
+				yield_time_ms: {
+					type: "number",
+					description: YIELD_TIME_MS_DESCRIPTION,
+				},
+				max_output_tokens: {
+					type: "number",
+					description: MAX_OUTPUT_TOKENS_DESCRIPTION,
+				},
+			},
+			required: ["session_id"],
+			additionalProperties: false,
+		},
+	},
+} satisfies OpenAI.Chat.ChatCompletionTool

src/core/tools/ExecuteCommandTool.ts

@@ -16,6 +16,7 @@ import { ExitCodeDetails, RooTerminalCallbacks, RooTerminalProcess } from "../..
 import { TerminalRegistry } from "../../integrations/terminal/TerminalRegistry"
 import { Terminal } from "../../integrations/terminal/Terminal"
 import { OutputInterceptor } from "../../integrations/terminal/OutputInterceptor"
+import { ProcessManager } from "../../integrations/terminal/ProcessManager"
 import { Package } from "../../shared/package"
 import { t } from "../../i18n"
 import { getTaskDirectoryPath } from "../../utils/storage"
@@ -423,12 +424,31 @@ export async function executeCommandInTerminal(
 			`Command executed in terminal within working directory '${currentWorkingDir}'. ${exitStatus}\nOutput:\n${result}`,
 		]
 	} else {
+		// Process is still running - register it with ProcessManager for write_stdin interaction
+		let sessionId: number | undefined
+		const currentProcess = terminal.process
+
+		if (currentProcess) {
+			try {
+				const processManager = ProcessManager.getInstance()
+				sessionId = processManager.registerProcess(terminal, currentProcess, task.taskId, command)
+			} catch (error) {
+				console.warn(`[ExecuteCommandTool] Failed to register process: ${error}`)
+			}
+		}
+
+		const sessionInfo =
+			sessionId !== undefined
+				? `\nSession ID: ${sessionId} - Use write_stdin tool with this session_id to send input to the process.`
+				: ""
+
 		return [
 			false,
 			[
 				`Command is still running in terminal ${workingDir ? ` from '${workingDir.toPosix()}'` : ""}.`,
 				result.length > 0 ? `Here's the output so far:\n${result}\n` : "\n",
 				"You will be updated on the terminal status and new output in the future.",
+				sessionInfo,
 			].join("\n"),
 		]
 	}