@oh-my-pi/pi-coding-agent 5.4.2 → 5.6.7

package/src/core/tools/renderers.ts

@@ -17,6 +17,7 @@ import { lsToolRenderer } from "./ls";
 import { lspToolRenderer } from "./lsp/render";
 import { notebookToolRenderer } from "./notebook";
 import { outputToolRenderer } from "./output";
+import { pythonToolRenderer } from "./python";
 import { readToolRenderer } from "./read";
 import { sshToolRenderer } from "./ssh";
 import { taskToolRenderer } from "./task/render";
@@ -41,6 +42,7 @@ type ToolRenderer = {
 export const toolRenderers: Record<string, ToolRenderer> = {
 	ask: askToolRenderer as ToolRenderer,
 	bash: bashToolRenderer as ToolRenderer,
+	python: pythonToolRenderer as ToolRenderer,
 	calc: calculatorToolRenderer as ToolRenderer,
 	edit: editToolRenderer as ToolRenderer,
 	find: findToolRenderer as ToolRenderer,

package/src/core/tools/schema-validation.test.ts

@@ -378,6 +378,7 @@ describe("tool schema validation (post-sanitization)", () => {
 			"lsp",
 			"notebook",
 			"output",
+			"python",
 			"read",
 			"task",
 			"todo_write",

package/src/core/tools/task/executor.ts

@@ -10,6 +10,9 @@ import type { EventBus } from "../../event-bus";
 import { callTool } from "../../mcp/client";
 import type { MCPManager } from "../../mcp/manager";
 import type { ModelRegistry } from "../../model-registry";
+import { checkPythonKernelAvailability } from "../../python-kernel";
+import type { ToolSession } from "..";
+import { createPythonTool } from "../python";
 import { ensureArtifactsDir, getArtifactPaths } from "./artifacts";
 import { resolveModelPattern } from "./model-resolver";
 import { subprocessToolRegistry } from "./subprocess-tool-registry";
@@ -26,6 +29,8 @@ import {
 import type {
 	MCPToolCallRequest,
 	MCPToolMetadata,
+	PythonToolCallCancel,
+	PythonToolCallRequest,
 	SubagentWorkerRequest,
 	SubagentWorkerResponse,
 } from "./worker-protocol";
@@ -52,7 +57,12 @@ export interface ExecutorOptions {
 	mcpManager?: MCPManager;
 	authStorage?: AuthStorage;
 	modelRegistry?: ModelRegistry;
-	settingsManager?: { serialize: () => import("../../settings-manager").Settings };
+	settingsManager?: {
+		serialize: () => import("../../settings-manager").Settings;
+		getPythonToolMode?: () => "ipy-only" | "bash-only" | "both";
+		getPythonKernelMode?: () => "session" | "per-call";
+		getPythonSharedGateway?: () => boolean;
+	};
 }
 
 /**
@@ -269,14 +279,34 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 		}
 	}
 
+	const pythonToolMode = options.settingsManager?.getPythonToolMode?.() ?? "ipy-only";
+	if (toolNames?.includes("exec")) {
+		const expanded = toolNames.filter((name) => name !== "exec");
+		if (pythonToolMode === "bash-only") {
+			expanded.push("bash");
+		} else if (pythonToolMode === "ipy-only") {
+			expanded.push("python");
+		} else {
+			expanded.push("python", "bash");
+		}
+		toolNames = Array.from(new Set(expanded));
+	}
+
 	const serializedSettings = options.settingsManager?.serialize();
 	const availableModels = options.modelRegistry?.getAvailable().map((model) => `${model.provider}/${model.id}`);
 
 	// Resolve and add model
 	const resolvedModel = await resolveModelPattern(modelOverride || agent.model, availableModels, serializedSettings);
-	const sessionFile = subtaskSessionFile ?? options.sessionFile ?? null;
+	const sessionFile = subtaskSessionFile ?? null;
 	const spawnsEnv = agent.spawns === undefined ? "" : agent.spawns === "*" ? "*" : agent.spawns.join(",");
 
+	const pythonToolRequested = toolNames === undefined || toolNames.includes("python");
+	let pythonProxyEnabled = pythonToolRequested && pythonToolMode !== "bash-only";
+	if (pythonProxyEnabled) {
+		const availability = await checkPythonKernelAvailability(cwd);
+		pythonProxyEnabled = availability.ok;
+	}
+
 	let worker: Worker;
 	try {
 		worker = new Worker(new URL("./worker.ts", import.meta.url), { type: "module" });
@@ -311,6 +341,49 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	let finalize: ((message: Extract<SubagentWorkerResponse, { type: "done" }>) => void) | null = null;
 	const listenerController = new AbortController();
 	const listenerSignal = listenerController.signal;
+	const withTimeout = async <T>(promise: Promise<T>, timeoutMs?: number): Promise<T> => {
+		if (timeoutMs === undefined) return promise;
+		let timeoutId: ReturnType<typeof setTimeout> | undefined;
+		try {
+			return await Promise.race([
+				promise,
+				new Promise<T>((_resolve, reject) => {
+					timeoutId = setTimeout(() => {
+						reject(new Error(`Tool call timed out after ${timeoutMs}ms`));
+					}, timeoutMs);
+				}),
+			]);
+		} finally {
+			if (timeoutId) clearTimeout(timeoutId);
+		}
+	};
+
+	const combineSignals = (signals: Array<AbortSignal | undefined>): AbortSignal | undefined => {
+		const filtered = signals.filter((value): value is AbortSignal => Boolean(value));
+		if (filtered.length === 0) return undefined;
+		if (filtered.length === 1) return filtered[0];
+		return AbortSignal.any(filtered);
+	};
+
+	const createTimeoutSignal = (timeoutMs?: number): AbortSignal | undefined => {
+		if (typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+			return undefined;
+		}
+		return AbortSignal.timeout(timeoutMs);
+	};
+
+	const pythonSessionFile = sessionFile ?? `subtask:${taskId}`;
+	const pythonToolSession: ToolSession = {
+		cwd,
+		hasUI: false,
+		enableLsp: false,
+		getSessionFile: () => pythonSessionFile,
+		getSessionSpawns: () => spawnsEnv,
+		settings: options.settingsManager as ToolSession["settings"],
+		settingsManager: options.settingsManager,
+	};
+	const pythonTool = pythonProxyEnabled ? createPythonTool(pythonToolSession) : null;
+	const pythonCallControllers = new Map<string, AbortController>();
 
 	// Accumulate usage incrementally from message_end events (no memory for streaming events)
 	const accumulatedUsage = {
@@ -360,6 +433,10 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 		if (resolved) return;
 		abortSent = true;
 		abortReason = reason;
+		for (const controller of pythonCallControllers.values()) {
+			controller.abort();
+		}
+		pythonCallControllers.clear();
 		const abortMessage: SubagentWorkerRequest = { type: "abort" };
 		try {
 			worker.postMessage(abortMessage);
@@ -606,6 +683,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 			serializedModels: options.modelRegistry?.serialize(),
 			serializedSettings,
 			mcpTools: options.mcpManager ? extractMCPToolMetadata(options.mcpManager) : undefined,
+			pythonToolProxy: pythonProxyEnabled,
 		},
 	};
 
@@ -642,7 +720,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				if (!parsed) throw new Error(`Invalid MCP tool name: ${request.toolName}`);
 				const connection = mcpManager.getConnection(parsed.serverName);
 				if (!connection) throw new Error(`MCP server not connected: ${parsed.serverName}`);
-				const result = await callTool(connection, parsed.toolName, request.params);
+				const result = await withTimeout(callTool(connection, parsed.toolName, request.params), request.timeoutMs);
 				worker.postMessage({
 					type: "mcp_tool_result",
 					callId: request.callId,
@@ -657,6 +735,63 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 			}
 		};
 
+		const getPythonCallTimeoutMs = (params: { timeout?: number }): number | undefined => {
+			const timeout = params.timeout;
+			if (typeof timeout === "number" && Number.isFinite(timeout) && timeout > 0) {
+				return Math.max(1000, Math.round(timeout * 1000) + 1000);
+			}
+			return undefined;
+		};
+
+		const handlePythonCall = async (request: PythonToolCallRequest) => {
+			if (!pythonTool) {
+				worker.postMessage({
+					type: "python_tool_result",
+					callId: request.callId,
+					error: "Python proxy not available",
+				});
+				return;
+			}
+			const callController = new AbortController();
+			pythonCallControllers.set(request.callId, callController);
+			const timeoutMs = getPythonCallTimeoutMs(request.params as { timeout?: number });
+			const timeoutSignal = createTimeoutSignal(timeoutMs);
+			const combinedSignal = combineSignals([signal, callController.signal, timeoutSignal]);
+			try {
+				const result = await pythonTool.execute(
+					request.callId,
+					request.params as { code: string; timeout?: number; workdir?: string; reset?: boolean },
+					combinedSignal,
+				);
+				worker.postMessage({
+					type: "python_tool_result",
+					callId: request.callId,
+					result: { content: result.content ?? [], details: result.details },
+				});
+			} catch (error) {
+				const message =
+					timeoutSignal?.aborted && timeoutMs !== undefined
+						? `Python tool call timed out after ${timeoutMs}ms`
+						: error instanceof Error
+							? error.message
+							: String(error);
+				worker.postMessage({
+					type: "python_tool_result",
+					callId: request.callId,
+					error: message,
+				});
+			} finally {
+				pythonCallControllers.delete(request.callId);
+			}
+		};
+
+		const handlePythonCancel = (request: PythonToolCallCancel) => {
+			const controller = pythonCallControllers.get(request.callId);
+			if (controller) {
+				controller.abort();
+			}
+		};
+
 		const onMessage = (event: WorkerMessageEvent<SubagentWorkerResponse>) => {
 			const message = event.data;
 			if (!message || resolved) return;
@@ -664,6 +799,14 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				handleMCPCall(message as MCPToolCallRequest);
 				return;
 			}
+			if (message.type === "python_tool_call") {
+				handlePythonCall(message as PythonToolCallRequest);
+				return;
+			}
+			if (message.type === "python_tool_cancel") {
+				handlePythonCancel(message as PythonToolCallCancel);
+				return;
+			}
 			if (message.type === "event") {
 				try {
 					processEvent(message.event);

package/src/core/tools/task/worker-protocol.ts

@@ -24,6 +24,7 @@ export interface MCPToolCallRequest {
 	callId: string;
 	toolName: string;
 	params: Record<string, unknown>;
+	timeoutMs?: number;
 }
 
 /**
@@ -39,6 +40,30 @@ export interface MCPToolCallResponse {
 	error?: string;
 }
 
+export interface PythonToolCallRequest {
+	type: "python_tool_call";
+	callId: string;
+	params: Record<string, unknown>;
+	timeoutMs?: number;
+}
+
+export interface PythonToolCallResponse {
+	type: "python_tool_result";
+	callId: string;
+	result?: {
+		content: Array<{ type: string; text?: string; [key: string]: unknown }>;
+		details?: unknown;
+		isError?: boolean;
+	};
+	error?: string;
+}
+
+export interface PythonToolCallCancel {
+	type: "python_tool_cancel";
+	callId: string;
+	reason?: string;
+}
+
 export interface SubagentWorkerStartPayload {
 	cwd: string;
 	task: string;
@@ -54,14 +79,19 @@ export interface SubagentWorkerStartPayload {
 	serializedModels?: SerializedModelRegistry;
 	serializedSettings?: Settings;
 	mcpTools?: MCPToolMetadata[];
+	pythonToolProxy?: boolean;
 }
 
 export type SubagentWorkerRequest =
 	| { type: "start"; payload: SubagentWorkerStartPayload }
 	| { type: "abort" }
-	| MCPToolCallResponse;
+	| MCPToolCallResponse
+	| PythonToolCallResponse
+	| PythonToolCallCancel;
 
 export type SubagentWorkerResponse =
 	| { type: "event"; event: AgentEvent }
 	| { type: "done"; exitCode: number; durationMs: number; error?: string; aborted?: boolean }
-	| MCPToolCallRequest;
+	| MCPToolCallRequest
+	| PythonToolCallRequest
+	| PythonToolCallCancel;

package/src/core/tools/task/worker.ts

@@ -19,15 +19,18 @@ import type { TSchema } from "@sinclair/typebox";
 import type { AgentSessionEvent } from "../../agent-session";
 import { AuthStorage } from "../../auth-storage";
 import type { CustomTool } from "../../custom-tools/types";
+import { logger } from "../../logger";
 import { ModelRegistry } from "../../model-registry";
 import { parseModelPattern, parseModelString } from "../../model-resolver";
 import { createAgentSession, discoverAuthStorage, discoverModels } from "../../sdk";
 import { SessionManager } from "../../session-manager";
 import { SettingsManager } from "../../settings-manager";
 import { untilAborted } from "../../utils";
+import { getPythonToolDescription, type PythonToolDetails, type PythonToolParams, pythonSchema } from "../python";
 import type {
 	MCPToolCallResponse,
 	MCPToolMetadata,
+	PythonToolCallResponse,
 	SubagentWorkerRequest,
 	SubagentWorkerResponse,
 	SubagentWorkerStartPayload,
@@ -49,14 +52,26 @@ interface PendingMCPCall {
 	timeoutId: ReturnType<typeof setTimeout>;
 }
 
+interface PendingPythonCall {
+	resolve: (result: PythonToolCallResponse["result"]) => void;
+	reject: (error: Error) => void;
+	timeoutId?: ReturnType<typeof setTimeout>;
+}
+
 const pendingMCPCalls = new Map<string, PendingMCPCall>();
+const pendingPythonCalls = new Map<string, PendingPythonCall>();
 const MCP_CALL_TIMEOUT_MS = 60_000;
 let mcpCallIdCounter = 0;
+let pythonCallIdCounter = 0;
 
 function generateMCPCallId(): string {
 	return `mcp_${Date.now()}_${++mcpCallIdCounter}`;
 }
 
+function generatePythonCallId(): string {
+	return `python_${Date.now()}_${++pythonCallIdCounter}`;
+}
+
 function callMCPToolViaParent(
 	toolName: string,
 	params: Record<string, unknown>,
@@ -80,14 +95,16 @@ function callMCPToolViaParent(
 			pendingMCPCalls.delete(callId);
 		};
 
-		signal?.addEventListener(
-			"abort",
-			() => {
-				cleanup();
-				reject(new Error("Aborted"));
-			},
-			{ once: true },
-		);
+		if (typeof signal?.addEventListener === "function") {
+			signal.addEventListener(
+				"abort",
+				() => {
+					cleanup();
+					reject(new Error("Aborted"));
+				},
+				{ once: true },
+			);
+		}
 
 		pendingMCPCalls.set(callId, {
 			resolve: (result) => {
@@ -106,6 +123,72 @@ function callMCPToolViaParent(
 			callId,
 			toolName,
 			params,
+			timeoutMs,
+		} as SubagentWorkerResponse);
+	});
+}
+
+function callPythonToolViaParent(
+	params: PythonToolParams,
+	signal?: AbortSignal,
+	timeoutMs?: number,
+): Promise<PythonToolCallResponse["result"]> {
+	return new Promise((resolve, reject) => {
+		const callId = generatePythonCallId();
+		if (signal?.aborted) {
+			reject(new Error("Aborted"));
+			return;
+		}
+
+		const sendCancel = (reason: string) => {
+			postMessageSafe({ type: "python_tool_cancel", callId, reason } as SubagentWorkerResponse);
+		};
+
+		const timeoutId =
+			typeof timeoutMs === "number" && Number.isFinite(timeoutMs)
+				? setTimeout(() => {
+						pendingPythonCalls.delete(callId);
+						sendCancel(`Python call timed out after ${timeoutMs}ms`);
+						reject(new Error(`Python call timed out after ${timeoutMs}ms`));
+					}, timeoutMs)
+				: undefined;
+
+		const cleanup = () => {
+			if (timeoutId) {
+				clearTimeout(timeoutId);
+			}
+			pendingPythonCalls.delete(callId);
+		};
+
+		if (typeof signal?.addEventListener === "function") {
+			signal.addEventListener(
+				"abort",
+				() => {
+					cleanup();
+					sendCancel("Aborted");
+					reject(new Error("Aborted"));
+				},
+				{ once: true },
+			);
+		}
+
+		pendingPythonCalls.set(callId, {
+			resolve: (result) => {
+				cleanup();
+				resolve(result ?? { content: [] });
+			},
+			reject: (error) => {
+				cleanup();
+				reject(error);
+			},
+			timeoutId,
+		});
+
+		postMessageSafe({
+			type: "python_tool_call",
+			callId,
+			params,
+			timeoutMs,
 		} as SubagentWorkerResponse);
 	});
 }
@@ -120,6 +203,32 @@ function handleMCPToolResult(response: MCPToolCallResponse): void {
 	}
 }
 
+function handlePythonToolResult(response: PythonToolCallResponse): void {
+	const pending = pendingPythonCalls.get(response.callId);
+	if (!pending) return;
+	if (response.error) {
+		pending.reject(new Error(response.error));
+	} else {
+		pending.resolve(response.result);
+	}
+}
+
+function rejectPendingCalls(reason: string): void {
+	const error = new Error(reason);
+	const mcpCalls = Array.from(pendingMCPCalls.values());
+	const pythonCalls = Array.from(pendingPythonCalls.values());
+	pendingMCPCalls.clear();
+	pendingPythonCalls.clear();
+	for (const pending of mcpCalls) {
+		clearTimeout(pending.timeoutId);
+		pending.reject(error);
+	}
+	for (const pending of pythonCalls) {
+		clearTimeout(pending.timeoutId);
+		pending.reject(error);
+	}
+}
+
 function createMCPProxyTool(metadata: MCPToolMetadata): CustomTool<TSchema> {
 	return {
 		name: metadata.name,
@@ -157,6 +266,36 @@ function createMCPProxyTool(metadata: MCPToolMetadata): CustomTool<TSchema> {
 	};
 }
 
+function getPythonCallTimeoutMs(params: PythonToolParams): number | undefined {
+	const timeout = params.timeout;
+	if (typeof timeout === "number" && Number.isFinite(timeout) && timeout > 0) {
+		return Math.max(1000, Math.round(timeout * 1000) + 1000);
+	}
+	return undefined;
+}
+
+function createPythonProxyTool(): CustomTool<typeof pythonSchema> {
+	return {
+		name: "python",
+		label: "Python",
+		description: getPythonToolDescription(),
+		parameters: pythonSchema,
+		execute: async (_toolCallId, params, _onUpdate, _ctx, signal) => {
+			const timeoutMs = getPythonCallTimeoutMs(params as PythonToolParams);
+			const result = await callPythonToolViaParent(params as PythonToolParams, signal, timeoutMs);
+			return {
+				content:
+					result?.content?.map((c) =>
+						c.type === "text"
+							? { type: "text" as const, text: c.text ?? "" }
+							: { type: "text" as const, text: JSON.stringify(c) },
+					) ?? [],
+				details: result?.details as PythonToolDetails | undefined,
+			};
+		},
+	};
+}
+
 interface WorkerMessageEvent<T> {
 	data: T;
 }
@@ -284,8 +423,12 @@ async function runTask(runState: RunState, payload: SubagentWorkerStartPayload):
 			checkAbort();
 		}
 
-		// Create MCP proxy tools if provided
-		const mcpProxyTools = payload.mcpTools?.map(createMCPProxyTool) ?? [];
+		// Create MCP/python proxy tools if provided
+		const mcpProxyTools: CustomTool<TSchema>[] = payload.mcpTools?.map(createMCPProxyTool) ?? [];
+		const pythonProxyTools: CustomTool<TSchema>[] = payload.pythonToolProxy
+			? [createPythonProxyTool() as unknown as CustomTool<TSchema>]
+			: [];
+		const proxyTools = [...mcpProxyTools, ...pythonProxyTools];
 
 		// Resolve model override (equivalent to CLI's parseModelPattern with --model)
 		const { model, thinkingLevel: modelThinkingLevel } = resolveModelOverride(payload.model, modelRegistry);
@@ -325,8 +468,8 @@ async function runTask(runState: RunState, payload: SubagentWorkerStartPayload):
 			enableLsp: payload.enableLsp ?? true,
 			// Disable local MCP discovery if using proxy tools
 			enableMCP: !payload.mcpTools,
-			// Add MCP proxy tools
-			customTools: mcpProxyTools.length > 0 ? mcpProxyTools : undefined,
+			// Add proxy tools
+			customTools: proxyTools.length > 0 ? proxyTools : undefined,
 		});
 
 		runState.session = session;
@@ -349,17 +492,24 @@ async function runTask(runState: RunState, payload: SubagentWorkerStartPayload):
 				{
 					sendMessage: (message, options) => {
 						session.sendCustomMessage(message, options).catch((e) => {
-							console.error(`Extension sendMessage failed: ${e instanceof Error ? e.message : String(e)}`);
+							logger.error("Extension sendMessage failed", {
+								error: e instanceof Error ? e.message : String(e),
+							});
 						});
 					},
 					sendUserMessage: (content, options) => {
 						session.sendUserMessage(content, options).catch((e) => {
-							console.error(`Extension sendUserMessage failed: ${e instanceof Error ? e.message : String(e)}`);
+							logger.error("Extension sendUserMessage failed", {
+								error: e instanceof Error ? e.message : String(e),
+							});
 						});
 					},
 					appendEntry: (customType, data) => {
 						session.sessionManager.appendCustomEntry(customType, data);
 					},
+					setLabel: (targetId, label) => {
+						session.sessionManager.appendLabelChange(targetId, label);
+					},
 					getActiveTools: () => session.getActiveToolNames(),
 					getAllTools: () => session.getAllToolNames(),
 					setActiveTools: (toolNames: string[]) => session.setActiveToolsByName(toolNames),
@@ -379,10 +529,19 @@ async function runTask(runState: RunState, payload: SubagentWorkerStartPayload):
 					abort: () => session.abort(),
 					hasPendingMessages: () => session.queuedMessageCount > 0,
 					shutdown: () => {},
+					getContextUsage: () => session.getContextUsage(),
+					compact: async (instructionsOrOptions) => {
+						const instructions = typeof instructionsOrOptions === "string" ? instructionsOrOptions : undefined;
+						const options =
+							instructionsOrOptions && typeof instructionsOrOptions === "object"
+								? instructionsOrOptions
+								: undefined;
+						await session.compact(instructions, options);
+					},
 				},
 			);
 			extensionRunner.onError((err) => {
-				console.error(`Extension error (${err.extensionPath}): ${err.error}`);
+				logger.error("Extension error", { path: err.extensionPath, error: err.error });
 			});
 			await extensionRunner.emit({ type: "session_start" });
 		}
@@ -444,6 +603,7 @@ Call complete now.`;
 		}
 
 		sessionAbortController.abort();
+		rejectPendingCalls("Worker finished");
 
 		if (runState.unsubscribe) {
 			try {
@@ -485,8 +645,10 @@ function handleAbort(): void {
 	const runState = activeRun;
 	if (!runState) {
 		pendingAbort = true;
+		rejectPendingCalls("Aborted");
 		return;
 	}
+	rejectPendingCalls("Aborted");
 	runState.abortController.abort();
 	if (runState.session) {
 		void runState.session.abort();
@@ -556,6 +718,11 @@ globalThis.addEventListener("message", (event: WorkerMessageEvent<SubagentWorker
 		return;
 	}
 
+	if (message.type === "python_tool_result") {
+		handlePythonToolResult(message);
+		return;
+	}
+
 	if (message.type === "start") {
 		// Only allow one task per worker
 		if (activeRun) return;

package/src/index.ts

@@ -5,6 +5,7 @@
 export { StringEnum } from "@oh-my-pi/pi-ai";
 // Re-export TUI components for custom tool rendering
 export { Container, Markdown, Spacer, Text } from "@oh-my-pi/pi-tui";
+export { getAgentDir, VERSION } from "./config";
 export {
 	AgentSession,
 	type AgentSessionConfig,
@@ -82,6 +83,8 @@ export type {
 	ExtensionShortcut,
 	ExtensionUIContext,
 	ExtensionUIDialogOptions,
+	InputEvent,
+	InputEventResult,
 	KeybindingsManager,
 	LoadExtensionsResult,
 	MessageRenderer,
@@ -107,6 +110,7 @@ export {
 } from "./core/extensions/index";
 // Hook system types (legacy re-export)
 export type * from "./core/hooks/index";
+export { formatKeyHint, formatKeyHints } from "./core/keybindings";
 // Logging
 export { type Logger, logger } from "./core/logger";
 export { convertToLlm } from "./core/messages";
@@ -205,6 +209,7 @@ export {
 	type LsOperations,
 	type LsToolDetails,
 	type LsToolOptions,
+	type PythonToolDetails,
 	type ReadToolDetails,
 	type TruncationOptions,
 	type TruncationResult,
@@ -269,3 +274,4 @@ export {
 	Theme,
 	type ThemeColor,
 } from "./modes/interactive/theme/theme";
+export { getShellConfig } from "./utils/shell";