@oh-my-pi/pi-coding-agent 17.2.13 → 17.2.14

package/dist/types/config/settings-schema.d.ts

@@ -1026,6 +1026,16 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Instruct upstream providers to completely omit thinking summaries from responses (where supported)";
         };
     };
+    readonly externalThinking: {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "model";
+            readonly group: "Thinking";
+            readonly label: "External Thinking";
+            readonly description: "Use a private think tool and send reasoning effort off to GPT Responses models";
+        };
+    };
     readonly "model.loopGuard.enabled": {
         readonly type: "boolean";
         readonly default: true;

package/dist/types/session/agent-session-types.d.ts

@@ -138,6 +138,8 @@ export interface AgentSessionConfig {
     createMemoryTools?: () => Promise<AgentTool[]>;
     /** Creates the built-in `computer` tool for session-scoped runtime enablement (see {@link AgentSession.setComputerToolEnabled}). */
     createComputerTool?: () => Promise<AgentTool | null>;
+    /** Creates the private `think` scratchpad tool for runtime setting changes. */
+    createThinkTool?: () => Promise<AgentTool | null>;
     /** Creates the built-in `inspect_image` tool for session-scoped runtime enablement (see {@link AgentSession.setInspectImageMode}). */
     createInspectImageTool?: () => Promise<AgentTool | null>;
     /** Model registry for API key resolution and model discovery. */

package/dist/types/session/agent-session.d.ts

@@ -331,6 +331,8 @@ export declare class AgentSession {
      * tool (e.g. restricted child sessions have no factory).
      */
     setComputerToolEnabled(enabled: boolean): Promise<boolean>;
+    /** Applies the external-thinking setting to the private scratchpad tool immediately. */
+    setThinkToolEnabled(enabled: boolean): Promise<boolean>;
     /**
      * Session-scoped inspect_image mode (`/vision`). `auto` clears the override
      * and returns to the persisted `inspect_image.mode` setting; `on`/`off`

package/dist/types/session/session-tools.d.ts

@@ -43,6 +43,8 @@ interface SessionToolsOptions {
     toolRegistry?: Map<string, AgentTool>;
     createVibeTools?: () => AgentTool[];
     createComputerTool?: () => Promise<AgentTool | null>;
+    /** Creates the private `think` scratchpad tool for runtime setting changes. */
+    createThinkTool?: () => Promise<AgentTool | null>;
     /** Creates the built-in `inspect_image` tool for session-scoped runtime enablement (see {@link SessionTools.setInspectImageMode}). */
     createInspectImageTool?: () => Promise<AgentTool | null>;
     builtInToolNames?: Iterable<string>;
@@ -232,6 +234,15 @@ export declare class SessionTools {
      * tool (e.g. restricted child sessions have no factory).
      */
     setComputerToolEnabled(enabled: boolean): Promise<boolean>;
+    /**
+     * Session-scoped enable/disable for the private `think` scratchpad tool.
+     *
+     * Enabling constructs the tool once and refreshes the model's tool contract;
+     * disabling removes it from the active set while preserving its registry entry.
+     *
+     * @returns false when enabling was requested but this session cannot build the tool.
+     */
+    setThinkToolEnabled(enabled: boolean): Promise<boolean>;
     /** Current effective inspect_image state for `/vision status`. */
     inspectImageState(): {
         mode: InspectImageMode;

package/dist/types/tools/builtin-names.d.ts

@@ -1,7 +1,6 @@
 export declare const BUILTIN_TOOL_NAMES: readonly ["read", "bash", "edit", "ast_grep", "ast_edit", "ask", "debug", "eval", "github", "glob", "grep", "lsp", "inspect_image", "browser", "computer", "checkpoint", "rewind", "security_scan", "task", "hub", "todo", "web_search", "write", "memory_edit", "retain", "recall", "reflect", "learn", "manage_skill"];
 export type BuiltinToolName = (typeof BUILTIN_TOOL_NAMES)[number];
-/** Hidden built-ins: constructible and `--tools`-addressable, but never part of the default active set. */
-export declare const HIDDEN_TOOL_NAMES: readonly ["yield", "goal"];
+export declare const HIDDEN_TOOL_NAMES: readonly ["yield", "goal", "think"];
 export type HiddenToolName = (typeof HIDDEN_TOOL_NAMES)[number];
 /** Return the canonical tool name for current and legacy built-in tool IDs. */
 export declare function normalizeToolName(name: string): string;

package/dist/types/tools/index.d.ts

@@ -67,6 +67,7 @@ export * from "./report-tool-issue.js";
 export * from "./resolve.js";
 export * from "./review.js";
 export * from "./security-scan.js";
+export * from "./think.js";
 export * from "./todo.js";
 export * from "./tts.js";
 export * from "./vibe.js";

package/dist/types/tools/think.d.ts

@@ -0,0 +1,38 @@
+import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import { type Component } from "@oh-my-pi/pi-tui";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types.js";
+import { type Theme } from "../modes/theme/theme.js";
+declare const thinkSchema: import("@oh-my-pi/omptype").FluentType<{
+    thoughts: string;
+}, {
+    thoughts: string;
+}>;
+type ThinkParams = typeof thinkSchema.infer;
+export type ThinkRenderArgs = {
+    thoughts?: string;
+};
+export declare const thinkToolRenderer: {
+    inline: boolean;
+    renderCall(args: ThinkRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(): Component;
+};
+interface ThinkToolDetails {
+    recorded: true;
+}
+/** Records private intermediate reasoning while native GPT reasoning is disabled. */
+export declare class ThinkTool implements AgentTool<typeof thinkSchema, ThinkToolDetails> {
+    readonly name = "think";
+    readonly approval: "read";
+    readonly label = "Think";
+    readonly summary = "Record private intermediate reasoning before answering";
+    readonly description = "Use this private scratchpad to plan, derive, or check work before answering. Record only materially new reasoning. The user does not see this tool activity.";
+    readonly parameters: import("@oh-my-pi/omptype").FluentType<{
+        thoughts: string;
+    }, {
+        thoughts: string;
+    }>;
+    readonly strict = true;
+    readonly intent: "omit";
+    execute(_toolCallId: string, _params: ThinkParams): Promise<AgentToolResult<ThinkToolDetails>>;
+}
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "17.2.13",
+	"version": "17.2.14",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -50,18 +50,18 @@
 	},
 	"dependencies": {
 		"@babel/parser": "^7.29.7",
-		"@oh-my-pi/hashline": "17.2.13",
-		"@oh-my-pi/omp-stats": "17.2.13",
-		"@oh-my-pi/omptype": "17.2.13",
-		"@oh-my-pi/pi-agent-core": "17.2.13",
-		"@oh-my-pi/pi-ai": "17.2.13",
-		"@oh-my-pi/pi-catalog": "17.2.13",
-		"@oh-my-pi/pi-mnemopi": "17.2.13",
-		"@oh-my-pi/pi-natives": "17.2.13",
-		"@oh-my-pi/pi-tui": "17.2.13",
-		"@oh-my-pi/pi-utils": "17.2.13",
-		"@oh-my-pi/pi-wire": "17.2.13",
-		"@oh-my-pi/snapcompact": "17.2.13",
+		"@oh-my-pi/hashline": "17.2.14",
+		"@oh-my-pi/omp-stats": "17.2.14",
+		"@oh-my-pi/omptype": "17.2.14",
+		"@oh-my-pi/pi-agent-core": "17.2.14",
+		"@oh-my-pi/pi-ai": "17.2.14",
+		"@oh-my-pi/pi-catalog": "17.2.14",
+		"@oh-my-pi/pi-mnemopi": "17.2.14",
+		"@oh-my-pi/pi-natives": "17.2.14",
+		"@oh-my-pi/pi-tui": "17.2.14",
+		"@oh-my-pi/pi-utils": "17.2.14",
+		"@oh-my-pi/pi-wire": "17.2.14",
+		"@oh-my-pi/snapcompact": "17.2.14",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/api-logs": "^0.220.0",
 		"@opentelemetry/context-async-hooks": "^2.9.0",

package/src/cli/gallery-fixtures/agentic.ts

@@ -361,6 +361,22 @@ export const agenticFixtures: Record<string, GalleryFixture> = {
 		},
 	},
 
+	think: {
+		label: "Think",
+		// Streaming: scratchpad text still arriving.
+		streamingArgs: {
+			thoughts: "The retry loop re-reads the config after every failure — that explains the doubled latency.",
+		},
+		args: {
+			thoughts:
+				"The retry loop re-reads the config after every failure — that explains the doubled latency. Cache the parsed config outside the loop, then re-check the invalidation path before answering.",
+		},
+		result: {
+			content: [{ type: "text", text: "------" }],
+			details: { recorded: true },
+		},
+	},
+
 	hub_jobs: {
 		label: "Hub jobs",
 		renderer: "hub",

package/src/config/settings-schema.ts

@@ -1139,6 +1139,17 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	externalThinking: {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "model",
+			group: "Thinking",
+			label: "External Thinking",
+			description: "Use a private think tool and send reasoning effort off to GPT Responses models",
+		},
+	},
+
 	"model.loopGuard.enabled": {
 		type: "boolean",
 		default: true,

package/src/modes/controllers/selector-controller.ts

@@ -479,6 +479,11 @@ export class SelectorController {
 					this.ctx.showError(`Failed to apply vision mode: ${err}`);
 				});
 				break;
+			case "externalThinking":
+				void this.ctx.session.setThinkToolEnabled(value as boolean).catch(err => {
+					this.ctx.showError(`Failed to apply external thinking: ${err}`);
+				});
+				break;
 
 			case "autocompleteMaxVisible":
 				this.ctx.editor.setAutocompleteMaxVisible(typeof value === "number" ? value : Number(value));

package/src/prompts/system/system-prompt.md

@@ -101,6 +101,15 @@ Invalid args return the schema in the error — fix and retry
 TOOL POLICY
 ==============
 
+{{#has tools "think"}}
+# Reasoning
+`{{toolRefs.think}}` is your scratchpad and it is where your reasoning actually happens — whatever you do not write there, you have not worked out. Its content is private; the user never sees it.
+- MUST call `{{toolRefs.think}}` before the first action of a turn, and again before any step that is expensive to undo: an edit, a destructive command, a final answer.
+- Restate what is actually being asked and the constraints given. Split it into ordered sub-problems and solve each explicitly, writing the intermediate result instead of jumping to the conclusion. When a step splits into cases, enumerate them and resolve each.
+- Then check the work: verify each claim against the constraints, test one boundary or degenerate case, and look specifically for the error you would most plausibly have made. If a check fails, redo that step — NEVER patch the conclusion.
+- Call again only for materially new state: a tool result that changes the plan, a failed check, a sub-problem you had not opened. NEVER use it to narrate progress or restate what you already recorded.
+{{/has}}
+
 # General
 Use tools whenever they improve correctness, completeness, or grounding.
 - SHOULD resolve prerequisites before acting.

package/src/sdk.ts

@@ -3237,7 +3237,12 @@ async function createAgentSessionScoped(options: CreateAgentSessionOptions): Pro
 						});
 					}
 				}
-				return settingsAwareStreamFn(streamModel, context, streamOptions);
+				const externalThinking =
+					settings.get("externalThinking") && agent.state.tools.some(tool => tool.name === "think");
+				return settingsAwareStreamFn(streamModel, context, {
+					...streamOptions,
+					forceReasoningOff: externalThinking || streamOptions?.forceReasoningOff,
+				});
 			},
 			cursorExecHandlers,
 			getCursorTools: () => (toolSession.xdev ? listXdevTools(toolSession.xdev) : []),
@@ -3393,6 +3398,7 @@ async function createAgentSessionScoped(options: CreateAgentSessionOptions): Pro
 			createComputerTool: restrictToolNames
 				? undefined
 				: async () => (await BUILTIN_TOOLS.computer(toolSession)) ?? null,
+			createThinkTool: async () => (await HIDDEN_TOOLS.think(toolSession)) ?? null,
 			createInspectImageTool: restrictToolNames
 				? undefined
 				: async () => (await BUILTIN_TOOLS.inspect_image(toolSession)) ?? null,

package/src/session/agent-session-types.ts

@@ -164,6 +164,8 @@ export interface AgentSessionConfig {
 	createMemoryTools?: () => Promise<AgentTool[]>;
 	/** Creates the built-in `computer` tool for session-scoped runtime enablement (see {@link AgentSession.setComputerToolEnabled}). */
 	createComputerTool?: () => Promise<AgentTool | null>;
+	/** Creates the private `think` scratchpad tool for runtime setting changes. */
+	createThinkTool?: () => Promise<AgentTool | null>;
 	/** Creates the built-in `inspect_image` tool for session-scoped runtime enablement (see {@link AgentSession.setInspectImageMode}). */
 	createInspectImageTool?: () => Promise<AgentTool | null>;
 	/** Model registry for API key resolution and model discovery. */

package/src/session/agent-session.ts

@@ -1241,6 +1241,7 @@ export class AgentSession {
 			toolRegistry: config.toolRegistry,
 			createVibeTools: config.createVibeTools,
 			createComputerTool: config.createComputerTool,
+			createThinkTool: config.createThinkTool,
 			createInspectImageTool: config.createInspectImageTool,
 			builtInToolNames: config.builtInToolNames,
 			mcpManagerToolNames: config.mcpManagerToolNames,
@@ -4419,6 +4420,11 @@ export class AgentSession {
 		return this.#tools.setComputerToolEnabled(enabled);
 	}
 
+	/** Applies the external-thinking setting to the private scratchpad tool immediately. */
+	setThinkToolEnabled(enabled: boolean): Promise<boolean> {
+		return this.#tools.setThinkToolEnabled(enabled);
+	}
+
 	/**
 	 * Session-scoped inspect_image mode (`/vision`). `auto` clears the override
 	 * and returns to the persisted `inspect_image.mode` setting; `on`/`off`
@@ -5176,6 +5182,18 @@ export class AgentSession {
 
 		// Skip eager preludes when the user has already queued a directive
 		const hasPendingUserDirective = this.#toolChoiceQueue.inspect().includes("user-force");
+		const activeModel = this.agent.state.model;
+		const externalThinkingToolChoice =
+			!options?.synthetic &&
+			!hasPendingUserDirective &&
+			this.settings.get("externalThinking") &&
+			this.getEnabledToolNames().includes("think") &&
+			activeModel &&
+			(activeModel.api === "openai-responses" ||
+				activeModel.api === "azure-openai-responses" ||
+				activeModel.api === "openai-codex-responses")
+				? buildNamedToolChoice("think", activeModel)
+				: undefined;
 		const eagerTodoPrelude =
 			!options?.synthetic && !hasPendingUserDirective ? this.#todo.createEagerTodoPrelude(expandedText) : undefined;
 		const eagerTaskPrelude =
@@ -5193,6 +5211,12 @@ export class AgentSession {
 			: undefined;
 
 		const promptAttribution = options?.attribution ?? (options?.synthetic ? "agent" : "user");
+		if (externalThinkingToolChoice) {
+			this.#toolChoiceQueue.pushOnce(externalThinkingToolChoice, {
+				label: "external-thinking",
+				now: true,
+			});
+		}
 		const message = options?.synthetic
 			? { role: "developer" as const, content: userContent, attribution: promptAttribution, timestamp: Date.now() }
 			: { role: "user" as const, content: userContent, attribution: promptAttribution, timestamp: Date.now() };
@@ -5223,6 +5247,7 @@ export class AgentSession {
 			// Clean up residual eager-todo directive if the prompt never consumed it
 			// (e.g., compaction aborted, validation failed).
 			this.#toolChoiceQueue.removeByLabel("eager-todo");
+			this.#toolChoiceQueue.removeByLabel("external-thinking");
 		}
 		return true;
 	}

package/src/session/session-tools.ts

@@ -68,6 +68,8 @@ interface SessionToolsOptions {
 	toolRegistry?: Map<string, AgentTool>;
 	createVibeTools?: () => AgentTool[];
 	createComputerTool?: () => Promise<AgentTool | null>;
+	/** Creates the private `think` scratchpad tool for runtime setting changes. */
+	createThinkTool?: () => Promise<AgentTool | null>;
 	/** Creates the built-in `inspect_image` tool for session-scoped runtime enablement (see {@link SessionTools.setInspectImageMode}). */
 	createInspectImageTool?: () => Promise<AgentTool | null>;
 	builtInToolNames?: Iterable<string>;
@@ -184,6 +186,7 @@ export class SessionTools {
 	#toolRegistry: Map<string, AgentTool>;
 	#createVibeTools: (() => AgentTool[]) | undefined;
 	#createComputerTool: SessionToolsOptions["createComputerTool"];
+	#createThinkTool: SessionToolsOptions["createThinkTool"];
 	#createInspectImageTool: SessionToolsOptions["createInspectImageTool"];
 	#installedVibeToolNames = new Set<string>();
 	#builtInToolNames: Set<string>;
@@ -241,6 +244,7 @@ export class SessionTools {
 		this.#toolRegistry = options.toolRegistry ?? new Map();
 		this.#createVibeTools = options.createVibeTools;
 		this.#createComputerTool = options.createComputerTool;
+		this.#createThinkTool = options.createThinkTool;
 		this.#createInspectImageTool = options.createInspectImageTool;
 		this.#builtInToolNames = new Set(options.builtInToolNames ?? []);
 		this.#mcpManagerToolNames = new Set(options.mcpManagerToolNames ?? []);
@@ -1158,6 +1162,37 @@ export class SessionTools {
 		});
 	}
 
+	/**
+	 * Session-scoped enable/disable for the private `think` scratchpad tool.
+	 *
+	 * Enabling constructs the tool once and refreshes the model's tool contract;
+	 * disabling removes it from the active set while preserving its registry entry.
+	 *
+	 * @returns false when enabling was requested but this session cannot build the tool.
+	 */
+	setThinkToolEnabled(enabled: boolean): Promise<boolean> {
+		return this.runToolRegistryMutation(async () => {
+			const active = this.getEnabledToolNames();
+			if (!enabled) {
+				if (active.includes("think")) {
+					await this.#applyActiveToolsByName(active.filter(name => name !== "think"));
+				}
+				return true;
+			}
+			if (!this.#toolRegistry.has("think")) {
+				const tool = await this.#createThinkTool?.();
+				if (tool?.name !== "think") return false;
+				const wrapped = this.#wrapRuntimeTool(tool);
+				this.#toolRegistry.set(wrapped.name, wrapped);
+				this.#builtInToolNames.add(wrapped.name);
+			}
+			if (!active.includes("think")) {
+				await this.#applyActiveToolsByName([...active, "think"]);
+			}
+			return true;
+		});
+	}
+
 	/** Current effective inspect_image state for `/vision status`. */
 	inspectImageState(): { mode: InspectImageMode; active: boolean; model: string | undefined } {
 		const model = this.#host.model();

package/src/tools/builtin-names.ts

@@ -32,8 +32,7 @@ export const BUILTIN_TOOL_NAMES = [
 
 export type BuiltinToolName = (typeof BUILTIN_TOOL_NAMES)[number];
 
-/** Hidden built-ins: constructible and `--tools`-addressable, but never part of the default active set. */
-export const HIDDEN_TOOL_NAMES = ["yield", "goal"] as const;
+export const HIDDEN_TOOL_NAMES = ["yield", "goal", "think"] as const;
 
 export type HiddenToolName = (typeof HIDDEN_TOOL_NAMES)[number];
 

package/src/tools/index.ts

@@ -62,6 +62,7 @@ import { wrapToolWithMetaNotice } from "./output-meta";
 import { ReadTool } from "./read";
 import type { PlanProposalHandler } from "./resolve";
 import { SecurityScanTool } from "./security-scan";
+import { ThinkTool } from "./think";
 import { type TodoPhase, TodoTool } from "./todo";
 import { WriteTool } from "./write";
 import { isMountableUnderXdev, type XdevState } from "./xdev";
@@ -102,6 +103,7 @@ export * from "./report-tool-issue";
 export * from "./resolve";
 export * from "./review";
 export * from "./security-scan";
+export * from "./think";
 export * from "./todo";
 export * from "./tts";
 export * from "./vibe";
@@ -444,6 +446,7 @@ export const BUILTIN_TOOLS: Record<BuiltinToolName, ToolFactory> = {
 };
 
 export const HIDDEN_TOOLS: Record<HiddenToolName, ToolFactory> = {
+	think: () => new ThinkTool(),
 	yield: s => new YieldTool(s),
 	goal: s => new GoalTool(s),
 };
@@ -562,6 +565,9 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		if (session.settings.get("memory.backend") === "mnemopi" && !requestedTools.includes("memory_edit")) {
 			requestedTools.push("memory_edit");
 		}
+		if (session.settings.get("externalThinking") && !requestedTools.includes("think")) {
+			requestedTools.push("think");
+		}
 		// Auto-learn tools are gated by `autolearn.enabled` but, like the memory
 		// tools above, must also be force-included into an explicit requestedTools
 		// list so a restricted top-level session whose controller/guidance is
@@ -604,6 +610,7 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		if (name === "inspect_image") return isInspectImageToolActive(session);
 		if (name === "web_search") return session.settings.get("web_search.enabled");
 		if (name === "security_scan") return session.settings.get("security.enabled");
+		if (name === "think") return session.settings.get("externalThinking");
 		if (name === "ask") return session.settings.get("ask.enabled");
 		if (name === "browser") return session.settings.get("browser.enabled");
 		if (name === "computer") return session.settings.get("computer.enabled");
@@ -650,6 +657,7 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 					...Object.entries(BUILTIN_TOOLS)
 						.filter(([name]) => isToolAllowed(name))
 						.map(([name, factory]) => [name, factory] as const),
+					...(session.settings.get("externalThinking") ? ([["think", HIDDEN_TOOLS.think]] as const) : []),
 					...(includeYield ? ([["yield", HIDDEN_TOOLS.yield]] as const) : []),
 					...(goalModeActive ? ([["goal", HIDDEN_TOOLS.goal]] as const) : []),
 				];

package/src/tools/renderers.ts

@@ -27,6 +27,7 @@ import { inspectImageToolRenderer } from "./inspect-image-renderer";
 import { recallToolRenderer, reflectToolRenderer, retainToolRenderer } from "./memory-render";
 import { readToolRenderer } from "./read";
 import { resolveRenderer } from "./resolve";
+import { thinkToolRenderer } from "./think";
 import { todoToolRenderer } from "./todo";
 import { createVibeToolRenderer } from "./vibe";
 import { writeToolRenderer } from "./write";
@@ -115,6 +116,7 @@ export const toolRenderers: Record<string, ToolRenderer> = {
 	get task(): ToolRenderer {
 		return taskToolRenderer as ToolRenderer;
 	},
+	think: thinkToolRenderer as ToolRenderer,
 	todo: todoToolRenderer as ToolRenderer,
 	github: githubToolRenderer as ToolRenderer,
 	goal: goalToolRenderer as ToolRenderer,

package/src/tools/think.ts

@@ -0,0 +1,62 @@
+import { type } from "@oh-my-pi/omptype";
+import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import { type Component, Markdown } from "@oh-my-pi/pi-tui";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import { getMarkdownTheme, type Theme } from "../modes/theme/theme";
+
+const thinkSchema = type({
+	thoughts: type("string").describe("private scratchpad reasoning to retain before the next response"),
+	"+": "reject",
+}).describe("record private intermediate reasoning before answering");
+
+type ThinkParams = typeof thinkSchema.infer;
+
+export type ThinkRenderArgs = {
+	thoughts?: string;
+};
+
+export const thinkToolRenderer = {
+	inline: true,
+	renderCall(args: ThinkRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
+		const thoughts =
+			typeof args === "object" && args !== null && "thoughts" in args && typeof args.thoughts === "string"
+				? args.thoughts
+				: "";
+		return new Markdown(thoughts, 1, 0, getMarkdownTheme(), {
+			color: (text: string) => uiTheme.fg("thinkingText", text),
+			italic: true,
+		});
+	},
+	renderResult(): Component {
+		return undefined as unknown as Component;
+	},
+};
+
+interface ThinkToolDetails {
+	recorded: true;
+}
+
+/** Records private intermediate reasoning while native GPT reasoning is disabled. */
+export class ThinkTool implements AgentTool<typeof thinkSchema, ThinkToolDetails> {
+	readonly name = "think";
+	readonly approval = "read" as const;
+	readonly label = "Think";
+	readonly summary = "Record private intermediate reasoning before answering";
+	readonly description =
+		"Use this private scratchpad to plan, derive, or check work before answering. Record only materially new reasoning. The user does not see this tool activity.";
+	readonly parameters = thinkSchema;
+	readonly strict = true;
+	readonly intent = "omit" as const;
+
+	async execute(_toolCallId: string, _params: ThinkParams): Promise<AgentToolResult<ThinkToolDetails>> {
+		return {
+			content: [
+				{
+					type: "text",
+					text: "------",
+				},
+			],
+			details: { recorded: true },
+		};
+	}
+}