@oh-my-pi/pi-coding-agent 14.5.7 → 14.5.9

package/src/tools/bash.ts

@@ -222,15 +222,6 @@ function extractPartialBashEnv(partialJson: string | undefined): Record<string,
 	return Object.keys(env).length > 0 ? env : undefined;
 }
 
-function getBashEnvForDisplay(args: BashRenderArgs): Record<string, string> | undefined {
-	// During streaming, partial-json parsing often does not surface env values until the object closes.
-	// Recover them from the raw JSON buffer so the pending bash preview can show `NAME="..." cmd` immediately,
-	// instead of rendering only the command and making the env assignment appear at the very end.
-	const partialEnv = extractPartialBashEnv(args.__partialJson);
-	if (partialEnv && args.env) return { ...partialEnv, ...args.env };
-	return args.env ?? partialEnv;
-}
-
 function formatTimeoutClampNotice(requestedTimeoutSec: number, effectiveTimeoutSec: number): string | undefined {
 	return requestedTimeoutSec !== effectiveTimeoutSec
 		? `Timeout clamped to ${effectiveTimeoutSec}s (requested ${requestedTimeoutSec}s; allowed range ${TOOL_TIMEOUTS.bash.min}-${TOOL_TIMEOUTS.bash.max}s).`
@@ -688,8 +679,7 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 // =============================================================================
 // TUI Renderer
 // =============================================================================
-
-interface BashRenderArgs {
+export interface BashRenderArgs {
 	command?: string;
 	env?: Record<string, string>;
 	timeout?: number;
@@ -698,7 +688,7 @@ interface BashRenderArgs {
 	[key: string]: unknown;
 }
 
-interface BashRenderContext {
+export interface BashRenderContext {
 	/** Raw output text */
 	output?: string;
 	/** Whether output came from artifact storage */
@@ -711,7 +701,29 @@ interface BashRenderContext {
 	timeout?: number;
 }
 
-function formatBashCommand(args: BashRenderArgs): string {
+export interface ShellRendererConfig<TArgs> {
+	resolveTitle: (args: TArgs | undefined, options: RenderResultOptions) => string;
+	resolveCommand?: (args: TArgs | undefined) => string | undefined;
+	resolveCwd?: (args: TArgs | undefined) => string | undefined;
+	resolveEnv?: (args: TArgs | undefined) => Record<string, string> | undefined;
+}
+
+function getPartialJson<TArgs>(args: TArgs | undefined): string | undefined {
+	if (!args || typeof args !== "object" || !("__partialJson" in args)) return undefined;
+	const value = (args as { __partialJson?: unknown }).__partialJson;
+	return typeof value === "string" ? value : undefined;
+}
+
+export function getBashEnvForDisplay(args: BashRenderArgs): Record<string, string> | undefined {
+	// During streaming, partial-json parsing often does not surface env values until the object closes.
+	// Recover them from the raw JSON buffer so the pending bash preview can show `NAME="..." cmd` immediately,
+	// instead of rendering only the command and making the env assignment appear at the very end.
+	const partialEnv = extractPartialBashEnv(args.__partialJson);
+	if (partialEnv && args.env) return { ...partialEnv, ...args.env };
+	return args.env ?? partialEnv;
+}
+
+export function formatBashCommand(args: BashRenderArgs): string {
 	const command = replaceTabs(args.command || "…");
 	const prompt = "$";
 	const cwd = getProjectDir();
@@ -720,113 +732,135 @@ function formatBashCommand(args: BashRenderArgs): string {
 	return displayWorkdir ? `${prompt} cd ${displayWorkdir} && ${renderedCommand}` : `${prompt} ${renderedCommand}`;
 }
 
-export const bashToolRenderer = {
-	renderCall(args: BashRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
-		const cmdText = formatBashCommand(args);
-		const text = renderStatusLine({ icon: "pending", title: "Bash", description: cmdText }, uiTheme);
-		return new Text(text, 0, 0);
-	},
-
-	renderResult(
-		result: {
-			content: Array<{ type: string; text?: string }>;
-			details?: BashToolDetails;
-			isError?: boolean;
+function toBashRenderArgs<TArgs>(args: TArgs | undefined, config: ShellRendererConfig<TArgs>): BashRenderArgs {
+	return {
+		command: config.resolveCommand?.(args),
+		cwd: config.resolveCwd?.(args),
+		env: config.resolveEnv?.(args),
+		__partialJson: getPartialJson(args),
+	};
+}
+
+export function createShellRenderer<TArgs>(config: ShellRendererConfig<TArgs>) {
+	return {
+		renderCall(args: TArgs, options: RenderResultOptions, uiTheme: Theme): Component {
+			const renderArgs = toBashRenderArgs(args, config);
+			const cmdText = formatBashCommand(renderArgs);
+			const title = config.resolveTitle(args, options);
+			const text = renderStatusLine({ icon: "pending", title, description: cmdText }, uiTheme);
+			return new Text(text, 0, 0);
 		},
-		options: RenderResultOptions & { renderContext?: BashRenderContext },
-		uiTheme: Theme,
-		args?: BashRenderArgs,
-	): Component {
-		const cmdText = args ? formatBashCommand(args) : undefined;
-		const isError = result.isError === true;
-		const icon = options.isPartial ? "pending" : isError ? "error" : "success";
-		const header = renderStatusLine({ icon, title: "Bash" }, uiTheme);
-		const details = result.details;
-		const outputBlock = new CachedOutputBlock();
 
-		return {
-			render: (width: number): string[] => {
-				// REACTIVE: read mutable options at render time
-				const { renderContext } = options;
-				const expanded = renderContext?.expanded ?? options.expanded;
-				const previewLines = renderContext?.previewLines ?? BASH_DEFAULT_PREVIEW_LINES;
-
-				// Get output from context (preferred) or fall back to result content
-				const output = renderContext?.output ?? result.content?.find(c => c.type === "text")?.text ?? "";
-				const displayOutput = output.trimEnd();
-				const showingFullOutput = expanded && renderContext?.isFullOutput === true;
-
-				// Build truncation warning
-				const timeoutSeconds = details?.timeoutSeconds ?? renderContext?.timeout;
-				const requestedTimeoutSeconds = details?.requestedTimeoutSeconds;
-				const timeoutLabel =
-					typeof timeoutSeconds === "number"
-						? requestedTimeoutSeconds !== undefined && requestedTimeoutSeconds !== timeoutSeconds
-							? `Timeout: ${timeoutSeconds}s (requested ${requestedTimeoutSeconds}s clamped)`
-							: `Timeout: ${timeoutSeconds}s`
-						: undefined;
-				const timeoutLine =
-					timeoutLabel !== undefined
-						? uiTheme.fg("dim", `${uiTheme.format.bracketLeft}${timeoutLabel}${uiTheme.format.bracketRight}`)
-						: undefined;
-				let warningLine: string | undefined;
-				if (details?.meta?.truncation && !showingFullOutput) {
-					warningLine = formatStyledTruncationWarning(details.meta, uiTheme) ?? undefined;
-				}
+		renderResult(
+			result: {
+				content: Array<{ type: string; text?: string }>;
+				details?: BashToolDetails;
+				isError?: boolean;
+			},
+			options: RenderResultOptions & { renderContext?: BashRenderContext },
+			uiTheme: Theme,
+			args?: TArgs,
+		): Component {
+			const renderArgs = toBashRenderArgs(args, config);
+			const cmdText = args ? formatBashCommand(renderArgs) : undefined;
+			const isError = result.isError === true;
+			const icon = options.isPartial ? "pending" : isError ? "error" : "success";
+			const title = config.resolveTitle(args, options);
+			const header = renderStatusLine({ icon, title }, uiTheme);
+			const details = result.details;
+			const outputBlock = new CachedOutputBlock();
+
+			return {
+				render: (width: number): string[] => {
+					// REACTIVE: read mutable options at render time
+					const { renderContext } = options;
+					const expanded = renderContext?.expanded ?? options.expanded;
+					const previewLines = renderContext?.previewLines ?? BASH_DEFAULT_PREVIEW_LINES;
+
+					// Get output from context (preferred) or fall back to result content
+					const output = renderContext?.output ?? result.content?.find(c => c.type === "text")?.text ?? "";
+					const displayOutput = output.trimEnd();
+					const showingFullOutput = expanded && renderContext?.isFullOutput === true;
+
+					// Build truncation warning
+					const timeoutSeconds = details?.timeoutSeconds ?? renderContext?.timeout;
+					const requestedTimeoutSeconds = details?.requestedTimeoutSeconds;
+					const timeoutLabel =
+						typeof timeoutSeconds === "number"
+							? requestedTimeoutSeconds !== undefined && requestedTimeoutSeconds !== timeoutSeconds
+								? `Timeout: ${timeoutSeconds}s (requested ${requestedTimeoutSeconds}s clamped)`
+								: `Timeout: ${timeoutSeconds}s`
+							: undefined;
+					const timeoutLine =
+						timeoutLabel !== undefined
+							? uiTheme.fg("dim", `${uiTheme.format.bracketLeft}${timeoutLabel}${uiTheme.format.bracketRight}`)
+							: undefined;
+					let warningLine: string | undefined;
+					if (details?.meta?.truncation && !showingFullOutput) {
+						warningLine = formatStyledTruncationWarning(details.meta, uiTheme) ?? undefined;
+					}
 
-				const outputLines: string[] = [];
-				const hasOutput = displayOutput.trim().length > 0;
-				const rawOutputLines = displayOutput.split("\n");
-				const sixelLineMask =
-					TERMINAL.imageProtocol === ImageProtocol.Sixel ? getSixelLineMask(rawOutputLines) : undefined;
-				const hasSixelOutput = sixelLineMask?.some(Boolean) ?? false;
-				if (hasOutput) {
-					if (hasSixelOutput) {
-						outputLines.push(
-							...rawOutputLines.map((line, index) =>
-								sixelLineMask?.[index] ? line : uiTheme.fg("toolOutput", replaceTabs(line)),
-							),
-						);
-					} else if (expanded) {
-						outputLines.push(...rawOutputLines.map(line => uiTheme.fg("toolOutput", replaceTabs(line))));
-					} else {
-						const styledOutput = rawOutputLines
-							.map(line => uiTheme.fg("toolOutput", replaceTabs(line)))
-							.join("\n");
-						const textContent = styledOutput;
-						const result = truncateToVisualLines(textContent, previewLines, width);
-						if (result.skippedCount > 0) {
+					const outputLines: string[] = [];
+					const hasOutput = displayOutput.trim().length > 0;
+					const rawOutputLines = displayOutput.split("\n");
+					const sixelLineMask =
+						TERMINAL.imageProtocol === ImageProtocol.Sixel ? getSixelLineMask(rawOutputLines) : undefined;
+					const hasSixelOutput = sixelLineMask?.some(Boolean) ?? false;
+					if (hasOutput) {
+						if (hasSixelOutput) {
 							outputLines.push(
-								uiTheme.fg(
-									"dim",
-									`… (${result.skippedCount} earlier lines, showing ${result.visualLines.length} of ${result.skippedCount + result.visualLines.length}) (ctrl+o to expand)`,
+								...rawOutputLines.map((line, index) =>
+									sixelLineMask?.[index] ? line : uiTheme.fg("toolOutput", replaceTabs(line)),
 								),
 							);
+						} else if (expanded) {
+							outputLines.push(...rawOutputLines.map(line => uiTheme.fg("toolOutput", replaceTabs(line))));
+						} else {
+							const styledOutput = rawOutputLines
+								.map(line => uiTheme.fg("toolOutput", replaceTabs(line)))
+								.join("\n");
+							const textContent = styledOutput;
+							const result = truncateToVisualLines(textContent, previewLines, width);
+							if (result.skippedCount > 0) {
+								outputLines.push(
+									uiTheme.fg(
+										"dim",
+										`… (${result.skippedCount} earlier lines, showing ${result.visualLines.length} of ${result.skippedCount + result.visualLines.length}) (ctrl+o to expand)`,
+									),
+								);
+							}
+							outputLines.push(...result.visualLines);
 						}
-						outputLines.push(...result.visualLines);
 					}
-				}
-				if (timeoutLine) outputLines.push(timeoutLine);
-				if (warningLine) outputLines.push(warningLine);
-
-				return outputBlock.render(
-					{
-						header,
-						state: options.isPartial ? "pending" : isError ? "error" : "success",
-						sections: [
-							{ lines: cmdText ? [uiTheme.fg("dim", cmdText)] : [] },
-							{ label: uiTheme.fg("toolTitle", "Output"), lines: outputLines },
-						],
-						width,
-					},
-					uiTheme,
-				);
-			},
-			invalidate: () => {
-				outputBlock.invalidate();
-			},
-		};
-	},
-	mergeCallAndResult: true,
-	inline: true,
-};
+					if (timeoutLine) outputLines.push(timeoutLine);
+					if (warningLine) outputLines.push(warningLine);
+
+					return outputBlock.render(
+						{
+							header,
+							state: options.isPartial ? "pending" : isError ? "error" : "success",
+							sections: [
+								{ lines: cmdText ? [uiTheme.fg("dim", cmdText)] : [] },
+								{ label: uiTheme.fg("toolTitle", "Output"), lines: outputLines },
+							],
+							width,
+						},
+						uiTheme,
+					);
+				},
+				invalidate: () => {
+					outputBlock.invalidate();
+				},
+			};
+		},
+		mergeCallAndResult: true,
+		inline: true,
+	};
+}
+
+export const bashToolRenderer = createShellRenderer<BashRenderArgs>({
+	resolveTitle: () => "Bash",
+	resolveCommand: args => args?.command,
+	resolveCwd: args => args?.cwd,
+	resolveEnv: args => args?.env,
+});

package/src/tools/debug.ts

@@ -52,85 +52,72 @@ import { toolResult } from "./tool-result";
 import { clampTimeout } from "./tool-timeouts";
 
 const debugSchema = Type.Object({
-	action: StringEnum(
-		[
-			"launch",
-			"attach",
-			"set_breakpoint",
-			"remove_breakpoint",
-			"set_instruction_breakpoint",
-			"remove_instruction_breakpoint",
-			"data_breakpoint_info",
-			"set_data_breakpoint",
-			"remove_data_breakpoint",
-			"continue",
-			"step_over",
-			"step_in",
-			"step_out",
-			"pause",
-			"evaluate",
-			"stack_trace",
-			"threads",
-			"scopes",
-			"variables",
-			"disassemble",
-			"read_memory",
-			"write_memory",
-			"modules",
-			"loaded_sources",
-			"custom_request",
-			"output",
-			"terminate",
-			"sessions",
-		],
-		{ description: "dap debugger action" },
-	),
-	program: Type.Optional(Type.String({ description: "program path", examples: ["./my_app", "src/main.py"] })),
-	args: Type.Optional(Type.Array(Type.String(), { description: "program arguments", examples: [["--verbose"]] })),
-	adapter: Type.Optional(
-		Type.String({ description: "debugger adapter", examples: ["gdb", "lldb-dap", "debugpy", "dlv"] }),
-	),
-	cwd: Type.Optional(Type.String({ description: "working directory", examples: ["src/"] })),
-	file: Type.Optional(Type.String({ description: "source file", examples: ["src/main.c"] })),
-	line: Type.Optional(Type.Number({ description: "source line", examples: [42] })),
-	function: Type.Optional(Type.String({ description: "function name", examples: ["main", "handle_request"] })),
-	name: Type.Optional(Type.String({ description: "variable or data name", examples: ["counter", "buffer"] })),
-	condition: Type.Optional(Type.String({ description: "breakpoint condition", examples: ["i == 10", "x > 0"] })),
-	hit_condition: Type.Optional(Type.String({ description: "hit condition" })),
-	expression: Type.Optional(Type.String({ description: "expression to evaluate", examples: ["x + 1", "obj.field"] })),
+	action: StringEnum([
+		"launch",
+		"attach",
+		"set_breakpoint",
+		"remove_breakpoint",
+		"set_instruction_breakpoint",
+		"remove_instruction_breakpoint",
+		"data_breakpoint_info",
+		"set_data_breakpoint",
+		"remove_data_breakpoint",
+		"continue",
+		"step_over",
+		"step_in",
+		"step_out",
+		"pause",
+		"evaluate",
+		"stack_trace",
+		"threads",
+		"scopes",
+		"variables",
+		"disassemble",
+		"read_memory",
+		"write_memory",
+		"modules",
+		"loaded_sources",
+		"custom_request",
+		"output",
+		"terminate",
+		"sessions",
+	]),
+	program: Type.Optional(Type.String({ description: "program path" })),
+	args: Type.Optional(Type.Array(Type.String(), { description: "program arguments" })),
+	adapter: Type.Optional(Type.String({ description: "debugger adapter (gdb, lldb-dap, debugpy, dlv)" })),
+	cwd: Type.Optional(Type.String()),
+	file: Type.Optional(Type.String({ description: "source file" })),
+	line: Type.Optional(Type.Number({ description: "source line" })),
+	function: Type.Optional(Type.String({ description: "function name" })),
+	name: Type.Optional(Type.String({ description: "variable or data name" })),
+	condition: Type.Optional(Type.String({ description: "breakpoint condition" })),
+	hit_condition: Type.Optional(Type.String()),
+	expression: Type.Optional(Type.String({ description: "expression to evaluate" })),
 	context: Type.Optional(
-		Type.String({ description: "evaluate context", examples: ["watch", "repl", "hover", "variables", "clipboard"] }),
+		Type.String({ description: "evaluate context: watch | repl | hover | variables | clipboard" }),
 	),
-	frame_id: Type.Optional(Type.Number({ description: "stack frame id" })),
+	frame_id: Type.Optional(Type.Number()),
 	scope_id: Type.Optional(Type.Number({ description: "scope variables reference" })),
 	variable_ref: Type.Optional(Type.Number({ description: "variable reference" })),
-	pid: Type.Optional(Type.Number({ description: "process id for attach", examples: [12345] })),
-	port: Type.Optional(Type.Number({ description: "remote attach port", examples: [4711] })),
-	host: Type.Optional(Type.String({ description: "remote attach host", examples: ["127.0.0.1"] })),
+	pid: Type.Optional(Type.Number({ description: "process id for attach" })),
+	port: Type.Optional(Type.Number({ description: "remote attach port" })),
+	host: Type.Optional(Type.String({ description: "remote attach host" })),
 	levels: Type.Optional(Type.Number({ description: "max stack frames" })),
-	memory_reference: Type.Optional(
-		Type.String({ description: "memory reference or address", examples: ["0x7ffd1234"] }),
-	),
-	instruction_reference: Type.Optional(Type.String({ description: "instruction address or reference" })),
-	instruction_count: Type.Optional(Type.Number({ description: "instructions to disassemble" })),
-	instruction_offset: Type.Optional(Type.Number({ description: "instruction offset" })),
+	memory_reference: Type.Optional(Type.String({ description: "memory reference or address" })),
+	instruction_reference: Type.Optional(Type.String()),
+	instruction_count: Type.Optional(Type.Number()),
+	instruction_offset: Type.Optional(Type.Number()),
 	count: Type.Optional(Type.Number({ description: "bytes to read" })),
 	data: Type.Optional(Type.String({ description: "base64 memory payload" })),
 	data_id: Type.Optional(Type.String({ description: "data breakpoint id" })),
-	access_type: Type.Optional(
-		StringEnum(["read", "write", "readWrite"], { description: "data breakpoint access type" }),
-	),
+	access_type: Type.Optional(StringEnum(["read", "write", "readWrite"])),
 	command: Type.Optional(Type.String({ description: "custom dap request command" })),
-	arguments: Type.Optional(
-		Type.Record(Type.String(), Type.Any(), {
-			description: "custom request arguments",
-		}),
-	),
-	offset: Type.Optional(Type.Number({ description: "memory or instruction offset" })),
-	resolve_symbols: Type.Optional(Type.Boolean({ description: "resolve symbols during disassembly" })),
-	allow_partial: Type.Optional(Type.Boolean({ description: "allow partial writes" })),
-	start_module: Type.Optional(Type.Number({ description: "modules start index" })),
-	module_count: Type.Optional(Type.Number({ description: "max modules to fetch" })),
+	arguments: Type.Optional(Type.Record(Type.String(), Type.Any(), { description: "custom request arguments" })),
+	offset: Type.Optional(Type.Number()),
+	resolve_symbols: Type.Optional(Type.Boolean()),
+	allow_partial: Type.Optional(Type.Boolean()),
+	start_module: Type.Optional(Type.Number()),
+	module_count: Type.Optional(Type.Number()),
 	timeout: Type.Optional(Type.Number({ description: "per-request timeout seconds" })),
 });
 

package/src/tools/index.ts

@@ -37,6 +37,7 @@ import { NotebookTool } from "./notebook";
 import { wrapToolWithMetaNotice } from "./output-meta";
 import { PythonTool } from "./python";
 import { ReadTool } from "./read";
+import { RecipeTool } from "./recipe";
 import { RenderMermaidTool } from "./render-mermaid";
 import { createReportToolIssueTool, isAutoQaEnabled } from "./report-tool-issue";
 import { ResolveTool } from "./resolve";
@@ -75,6 +76,7 @@ export * from "./job";
 export * from "./notebook";
 export * from "./python";
 export * from "./read";
+export * from "./recipe";
 export * from "./render-mermaid";
 export * from "./report-tool-issue";
 export * from "./resolve";
@@ -224,6 +226,7 @@ export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
 	rewind: RewindTool.createIf,
 	task: TaskTool.create,
 	job: JobTool.createIf,
+	recipe: RecipeTool.createIf,
 	irc: IrcTool.createIf,
 	todo_write: s => new TodoWriteTool(s),
 	web_search: s => new WebSearchTool(s),
@@ -370,6 +373,13 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		) {
 			requestedTools.push("ast_edit");
 		}
+		if (
+			requestedTools.includes("bash") &&
+			!requestedTools.includes("recipe") &&
+			session.settings.get("recipe.enabled")
+		) {
+			requestedTools.push("recipe");
+		}
 	}
 	const allTools: Record<string, ToolFactory> = { ...BUILTIN_TOOLS, ...HIDDEN_TOOLS };
 	const isToolAllowed = (name: string) => {
@@ -392,6 +402,7 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		if (name === "browser") return session.settings.get("browser.enabled");
 		if (name === "checkpoint" || name === "rewind") return session.settings.get("checkpoint.enabled");
 		if (name === "irc") return session.settings.get("irc.enabled");
+		if (name === "recipe") return session.settings.get("recipe.enabled");
 		if (name === "task") {
 			const maxDepth = session.settings.get("task.maxRecursionDepth") ?? 2;
 			const currentDepth = session.taskDepth ?? 0;

package/src/tools/recipe/index.ts

@@ -0,0 +1,80 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import type { Component } from "@oh-my-pi/pi-tui";
+import { prompt } from "@oh-my-pi/pi-utils";
+import { type Static, Type } from "@sinclair/typebox";
+import type { RenderResultOptions } from "../../extensibility/custom-tools/types";
+import type { Theme } from "../../modes/theme/theme";
+import recipeDescription from "../../prompts/tools/recipe.md" with { type: "text" };
+import type { ToolSession } from "..";
+import { type BashRenderContext, BashTool, type BashToolDetails } from "../bash";
+import { createRecipeToolRenderer, type RecipeRenderArgs } from "./render";
+import { buildPromptModel, type DetectedRunner, resolveCommand } from "./runner";
+import { RUNNERS } from "./runners";
+
+const recipeSchema = Type.Object({
+	op: Type.String({
+		description: 'task name and args, e.g. "test" or "build --release"',
+		examples: ["test", "build --release", "pkg:test --watch"],
+	}),
+});
+
+type RecipeParams = Static<typeof recipeSchema>;
+
+type RecipeRenderResult = {
+	content: Array<{ type: string; text?: string }>;
+	details?: BashToolDetails;
+	isError?: boolean;
+};
+
+export class RecipeTool implements AgentTool<typeof recipeSchema, BashToolDetails, Theme> {
+	readonly name = "recipe";
+	readonly label = "Run";
+	readonly description: string;
+	readonly parameters = recipeSchema;
+	readonly strict = true;
+	readonly concurrency = "exclusive";
+	readonly mergeCallAndResult = true;
+	readonly inline = true;
+	readonly renderCall: (args: RecipeRenderArgs, options: RenderResultOptions, uiTheme: Theme) => Component;
+	readonly renderResult: (
+		result: RecipeRenderResult,
+		options: RenderResultOptions & { renderContext?: BashRenderContext },
+		uiTheme: Theme,
+		args?: RecipeRenderArgs,
+	) => Component;
+
+	readonly #bash: BashTool;
+	readonly #runners: DetectedRunner[];
+
+	constructor(session: ToolSession, runners: DetectedRunner[]) {
+		this.#runners = runners;
+		this.#bash = new BashTool(session);
+		this.description = prompt.render(recipeDescription, buildPromptModel(runners));
+		const renderer = createRecipeToolRenderer(runners);
+		this.renderCall = renderer.renderCall;
+		this.renderResult = renderer.renderResult;
+	}
+
+	static async createIf(session: ToolSession): Promise<RecipeTool | null> {
+		if (!session.settings.get("recipe.enabled")) return null;
+		const detected = (await Promise.all(RUNNERS.map(runner => runner.detect(session.cwd)))).filter(
+			(runner): runner is DetectedRunner => runner !== null && runner.tasks.length > 0,
+		);
+		if (detected.length === 0) return null;
+		return new RecipeTool(session, detected);
+	}
+
+	async execute(
+		toolCallId: string,
+		{ op }: RecipeParams,
+		signal?: AbortSignal,
+		onUpdate?: AgentToolUpdateCallback<BashToolDetails>,
+		ctx?: AgentToolContext,
+	): Promise<AgentToolResult<BashToolDetails>> {
+		const { command, cwd } = resolveCommand(op, this.#runners);
+		return await this.#bash.execute(toolCallId, { command, cwd }, signal, onUpdate, ctx);
+	}
+}
+
+export * from "./runner";
+export { tasksFromCargoMetadata } from "./runners/cargo";

package/src/tools/recipe/render.ts

@@ -0,0 +1,19 @@
+import { createShellRenderer } from "../bash";
+import type { DetectedRunner } from "./runner";
+import { commandFromOp, cwdFromOp, titleFromOp } from "./runner";
+
+export interface RecipeRenderArgs {
+	op?: string;
+	__partialJson?: string;
+	[key: string]: unknown;
+}
+
+export function createRecipeToolRenderer(runners: DetectedRunner[]) {
+	return createShellRenderer<RecipeRenderArgs>({
+		resolveTitle: args => titleFromOp(args?.op, runners),
+		resolveCommand: args => commandFromOp(args?.op, runners),
+		resolveCwd: args => cwdFromOp(args?.op, runners),
+	});
+}
+
+export const recipeToolRenderer = createRecipeToolRenderer([]);