@oh-my-pi/pi-coding-agent 4.2.0 → 4.2.2

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

@@ -5,7 +5,11 @@
  */
 
 import type { AgentEvent } from "@oh-my-pi/pi-agent-core";
+import type { AuthStorage } from "../../auth-storage";
 import type { EventBus } from "../../event-bus";
+import { callTool } from "../../mcp/client";
+import type { MCPManager } from "../../mcp/manager";
+import type { ModelRegistry } from "../../model-registry";
 import { ensureArtifactsDir, getArtifactPaths } from "./artifacts";
 import { resolveModelPattern } from "./model-resolver";
 import { subprocessToolRegistry } from "./subprocess-tool-registry";
@@ -18,7 +22,12 @@ import {
 	TASK_SUBAGENT_EVENT_CHANNEL,
 	TASK_SUBAGENT_PROGRESS_CHANNEL,
 } from "./types";
-import type { SubagentWorkerRequest, SubagentWorkerResponse } from "./worker-protocol";
+import type {
+	MCPToolCallRequest,
+	MCPToolMetadata,
+	SubagentWorkerRequest,
+	SubagentWorkerResponse,
+} from "./worker-protocol";
 
 /** Options for worker execution */
 export interface ExecutorOptions {
@@ -31,12 +40,16 @@ export interface ExecutorOptions {
 	context?: string;
 	modelOverride?: string;
 	outputSchema?: unknown;
+	enableLsp?: boolean;
 	signal?: AbortSignal;
 	onProgress?: (progress: AgentProgress) => void;
 	sessionFile?: string | null;
 	persistArtifacts?: boolean;
 	artifactsDir?: string;
 	eventBus?: EventBus;
+	mcpManager?: MCPManager;
+	authStorage?: AuthStorage;
+	modelRegistry?: ModelRegistry;
 }
 
 /**
@@ -133,11 +146,45 @@ function getUsageTokens(usage: unknown): number {
 	return input + output + cacheRead + cacheWrite;
 }
 
+/**
+ * Parse MCP tool name to extract server and tool names.
+ * Format: mcp_<serverName>_<toolName>
+ * Note: Uses lastIndexOf to handle server names with underscores.
+ */
+function parseMCPToolName(fullName: string): { serverName: string; toolName: string } | undefined {
+	if (!fullName.startsWith("mcp_")) return undefined;
+	const rest = fullName.slice(4);
+	const underscoreIndex = rest.lastIndexOf("_");
+	if (underscoreIndex === -1) return undefined;
+	return {
+		serverName: rest.slice(0, underscoreIndex),
+		toolName: rest.slice(underscoreIndex + 1),
+	};
+}
+
+/**
+ * Extract MCP tool metadata from MCPManager for passing to worker.
+ */
+function extractMCPToolMetadata(mcpManager: MCPManager): MCPToolMetadata[] {
+	return mcpManager.getTools().map((tool) => {
+		const parsed = parseMCPToolName(tool.name);
+		return {
+			name: tool.name,
+			label: tool.label ?? tool.name,
+			description: tool.description ?? "",
+			parameters: tool.parameters,
+			serverName: parsed?.serverName ?? "",
+			mcpToolName: parsed?.toolName ?? "",
+		};
+	});
+}
+
 /**
  * Run a single agent in a worker.
  */
 export async function runSubprocess(options: ExecutorOptions): Promise<SingleResult> {
-	const { cwd, agent, task, index, taskId, context, modelOverride, outputSchema, signal, onProgress } = options;
+	const { cwd, agent, task, index, taskId, context, modelOverride, outputSchema, enableLsp, signal, onProgress } =
+		options;
 	const startTime = Date.now();
 
 	// Initialize progress
@@ -208,7 +255,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	}
 
 	// Resolve and add model
-	const resolvedModel = resolveModelPattern(modelOverride || agent.model);
+	const resolvedModel = await resolveModelPattern(modelOverride || agent.model);
 	const sessionFile = subtaskSessionFile ?? options.sessionFile ?? null;
 	const spawnsEnv = agent.spawns === undefined ? "" : agent.spawns === "*" ? "*" : agent.spawns.join(",");
 
@@ -535,6 +582,10 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 			outputSchema,
 			sessionFile,
 			spawnsEnv,
+			enableLsp,
+			serializedAuth: options.authStorage?.serialize(),
+			serializedModels: options.modelRegistry?.serialize(),
+			mcpTools: options.mcpManager ? extractMCPToolMetadata(options.mcpManager) : undefined,
 		},
 	};
 
@@ -556,9 +607,43 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 			cleanup();
 			resolve(message);
 		};
+		const handleMCPCall = async (request: MCPToolCallRequest) => {
+			const mcpManager = options.mcpManager;
+			if (!mcpManager) {
+				worker.postMessage({
+					type: "mcp_tool_result",
+					callId: request.callId,
+					error: "MCP not available",
+				});
+				return;
+			}
+			try {
+				const parsed = parseMCPToolName(request.toolName);
+				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);
+				worker.postMessage({
+					type: "mcp_tool_result",
+					callId: request.callId,
+					result: { content: result.content ?? [], isError: result.isError },
+				});
+			} catch (error) {
+				worker.postMessage({
+					type: "mcp_tool_result",
+					callId: request.callId,
+					error: error instanceof Error ? error.message : String(error),
+				});
+			}
+		};
+
 		const onMessage = (event: WorkerMessageEvent<SubagentWorkerResponse>) => {
 			const message = event.data;
 			if (!message || resolved) return;
+			if (message.type === "mcp_tool_call") {
+				handleMCPCall(message as MCPToolCallRequest);
+				return;
+			}
 			if (message.type === "event") {
 				try {
 					processEvent(message.event);

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

@@ -349,12 +349,16 @@ export async function createTaskTool(
 							sessionFile,
 							persistArtifacts: !!artifactsDir,
 							artifactsDir: effectiveArtifactsDir,
+							enableLsp: false,
 							signal,
 							eventBus: undefined,
 							onProgress: (progress) => {
 								progressMap.set(index, structuredClone(progress));
 								emitProgress();
 							},
+							authStorage: session.authStorage,
+							modelRegistry: session.modelRegistry,
+							mcpManager: session.mcpManager,
 						});
 					},
 					signal,

package/src/core/tools/task/model-resolver.ts

@@ -12,7 +12,7 @@
  */
 
 import { type Settings, settingsCapability } from "../../../capability/settings";
-import { loadSync } from "../../../discovery";
+import { loadCapability } from "../../../discovery";
 import { resolveOmpCommand } from "./omp-command";
 
 /** Cache for available models (provider/modelId format) */
@@ -79,8 +79,8 @@ export function clearModelCache(): void {
 /**
  * Load model roles from settings files using capability API.
  */
-function loadModelRoles(): Record<string, string> {
-	const result = loadSync<Settings>(settingsCapability.id, { cwd: process.cwd() });
+async function loadModelRoles(): Promise<Record<string, string>> {
+	const result = await loadCapability<Settings>(settingsCapability.id, { cwd: process.cwd() });
 
 	// Merge all settings, prioritizing first (highest priority)
 	let modelRoles: Record<string, string> = {};
@@ -99,8 +99,8 @@ function loadModelRoles(): Record<string, string> {
  * Looks up the role in settings.modelRoles and returns the configured model.
  * Returns undefined if the role isn't configured.
  */
-function resolveOmpAlias(role: string, availableModels: string[]): string | undefined {
-	const roles = loadModelRoles();
+async function resolveOmpAlias(role: string, availableModels: string[]): Promise<string | undefined> {
+	const roles = await loadModelRoles();
 
 	// Look up role in settings (case-insensitive)
 	const configured = roles[role] || roles[role.toLowerCase()];
@@ -127,7 +127,10 @@ function getModelId(fullModel: string): string {
  * @param pattern - Model pattern to resolve
  * @param availableModels - Optional pre-fetched list of available models (in provider/modelId format)
  */
-export function resolveModelPattern(pattern: string | undefined, availableModels?: string[]): string | undefined {
+export async function resolveModelPattern(
+	pattern: string | undefined,
+	availableModels?: string[],
+): Promise<string | undefined> {
 	if (!pattern || pattern === "default") {
 		return undefined;
 	}
@@ -149,7 +152,7 @@ export function resolveModelPattern(pattern: string | undefined, availableModels
 		const lower = p.toLowerCase();
 		if (lower.startsWith("omp/") || lower.startsWith("pi/")) {
 			const role = lower.startsWith("omp/") ? p.slice(4) : p.slice(3);
-			const resolved = resolveOmpAlias(role, models);
+			const resolved = await resolveOmpAlias(role, models);
 			if (resolved) return resolved;
 			continue; // Role not configured, try next pattern
 		}

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

@@ -1,4 +1,42 @@
 import type { AgentEvent } from "@oh-my-pi/pi-agent-core";
+import type { SerializedAuthStorage } from "../../auth-storage";
+import type { SerializedModelRegistry } from "../../model-registry";
+
+/**
+ * MCP tool metadata passed from parent to worker for proxy tool creation.
+ */
+export interface MCPToolMetadata {
+	name: string;
+	label: string;
+	description: string;
+	parameters: unknown;
+	serverName: string;
+	mcpToolName: string;
+	timeoutMs?: number;
+}
+
+/**
+ * Worker -> Parent: request to execute an MCP tool via parent's connection.
+ */
+export interface MCPToolCallRequest {
+	type: "mcp_tool_call";
+	callId: string;
+	toolName: string;
+	params: Record<string, unknown>;
+}
+
+/**
+ * Parent -> Worker: result of an MCP tool call.
+ */
+export interface MCPToolCallResponse {
+	type: "mcp_tool_result";
+	callId: string;
+	result?: {
+		content: Array<{ type: string; text?: string; [key: string]: unknown }>;
+		isError?: boolean;
+	};
+	error?: string;
+}
 
 export interface SubagentWorkerStartPayload {
 	cwd: string;
@@ -7,12 +45,20 @@ export interface SubagentWorkerStartPayload {
 	model?: string;
 	toolNames?: string[];
 	outputSchema?: unknown;
+	enableLsp?: boolean;
 	sessionFile?: string | null;
 	spawnsEnv?: string;
+	serializedAuth?: SerializedAuthStorage;
+	serializedModels?: SerializedModelRegistry;
+	mcpTools?: MCPToolMetadata[];
 }
 
-export type SubagentWorkerRequest = { type: "start"; payload: SubagentWorkerStartPayload } | { type: "abort" };
+export type SubagentWorkerRequest =
+	| { type: "start"; payload: SubagentWorkerStartPayload }
+	| { type: "abort" }
+	| MCPToolCallResponse;
 
 export type SubagentWorkerResponse =
 	| { type: "event"; event: AgentEvent }
-	| { type: "done"; exitCode: number; durationMs: number; error?: string; aborted?: boolean };
+	| { type: "done"; exitCode: number; durationMs: number; error?: string; aborted?: boolean }
+	| MCPToolCallRequest;

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

@@ -15,12 +15,22 @@
 
 import type { AgentEvent, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Api, Model } from "@oh-my-pi/pi-ai";
+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 { ModelRegistry } from "../../model-registry";
 import { parseModelPattern, parseModelString } from "../../model-resolver";
 import { createAgentSession, discoverAuthStorage, discoverModels } from "../../sdk";
 import { SessionManager } from "../../session-manager";
 import { untilAborted } from "../../utils";
-import type { SubagentWorkerRequest, SubagentWorkerResponse, SubagentWorkerStartPayload } from "./worker-protocol";
+import type {
+	MCPToolCallResponse,
+	MCPToolMetadata,
+	SubagentWorkerRequest,
+	SubagentWorkerResponse,
+	SubagentWorkerStartPayload,
+} from "./worker-protocol";
 
 type PostMessageFn = (message: SubagentWorkerResponse) => void;
 
@@ -32,6 +42,120 @@ const postMessageSafe: PostMessageFn = (message) => {
 	}
 };
 
+interface PendingMCPCall {
+	resolve: (result: MCPToolCallResponse["result"]) => void;
+	reject: (error: Error) => void;
+	timeoutId: ReturnType<typeof setTimeout>;
+}
+
+const pendingMCPCalls = new Map<string, PendingMCPCall>();
+const MCP_CALL_TIMEOUT_MS = 60_000;
+let mcpCallIdCounter = 0;
+
+function generateMCPCallId(): string {
+	return `mcp_${Date.now()}_${++mcpCallIdCounter}`;
+}
+
+function callMCPToolViaParent(
+	toolName: string,
+	params: Record<string, unknown>,
+	signal?: AbortSignal,
+	timeoutMs = MCP_CALL_TIMEOUT_MS,
+): Promise<{ content: Array<{ type: string; text?: string; [key: string]: unknown }>; isError?: boolean }> {
+	return new Promise((resolve, reject) => {
+		const callId = generateMCPCallId();
+		if (signal?.aborted) {
+			reject(new Error("Aborted"));
+			return;
+		}
+
+		const timeoutId = setTimeout(() => {
+			pendingMCPCalls.delete(callId);
+			reject(new Error(`MCP call timed out after ${timeoutMs}ms`));
+		}, timeoutMs);
+
+		const cleanup = () => {
+			clearTimeout(timeoutId);
+			pendingMCPCalls.delete(callId);
+		};
+
+		signal?.addEventListener(
+			"abort",
+			() => {
+				cleanup();
+				reject(new Error("Aborted"));
+			},
+			{ once: true },
+		);
+
+		pendingMCPCalls.set(callId, {
+			resolve: (result) => {
+				cleanup();
+				resolve(result ?? { content: [] });
+			},
+			reject: (error) => {
+				cleanup();
+				reject(error);
+			},
+			timeoutId,
+		});
+
+		postMessageSafe({
+			type: "mcp_tool_call",
+			callId,
+			toolName,
+			params,
+		} as SubagentWorkerResponse);
+	});
+}
+
+function handleMCPToolResult(response: MCPToolCallResponse): void {
+	const pending = pendingMCPCalls.get(response.callId);
+	if (!pending) return;
+	if (response.error) {
+		pending.reject(new Error(response.error));
+	} else {
+		pending.resolve(response.result);
+	}
+}
+
+function createMCPProxyTool(metadata: MCPToolMetadata): CustomTool<TSchema> {
+	return {
+		name: metadata.name,
+		label: metadata.label,
+		description: metadata.description,
+		parameters: metadata.parameters as TSchema,
+		execute: async (_toolCallId, params, _onUpdate, _ctx, signal) => {
+			try {
+				const result = await callMCPToolViaParent(
+					metadata.name,
+					params as Record<string, unknown>,
+					signal,
+					metadata.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: { serverName: metadata.serverName, mcpToolName: metadata.mcpToolName, isError: result.isError },
+				};
+			} catch (error) {
+				return {
+					content: [
+						{
+							type: "text" as const,
+							text: `MCP error: ${error instanceof Error ? error.message : String(error)}`,
+						},
+					],
+					details: { serverName: metadata.serverName, mcpToolName: metadata.mcpToolName, isError: true },
+				};
+			}
+		},
+	};
+}
+
 interface WorkerMessageEvent<T> {
 	data: T;
 }
@@ -145,11 +269,22 @@ async function runTask(runState: RunState, payload: SubagentWorkerStartPayload):
 		// Set working directory (CLI does this implicitly)
 		process.chdir(payload.cwd);
 
-		// Discover auth and models (equivalent to CLI's discoverAuthStorage/discoverModels)
-		const authStorage = await discoverAuthStorage();
-		checkAbort();
-		const modelRegistry = await discoverModels(authStorage);
-		checkAbort();
+		// Use serialized auth/models if provided, otherwise discover from disk
+		let authStorage: AuthStorage;
+		let modelRegistry: ModelRegistry;
+
+		if (payload.serializedAuth && payload.serializedModels) {
+			authStorage = AuthStorage.fromSerialized(payload.serializedAuth);
+			modelRegistry = ModelRegistry.fromSerialized(payload.serializedModels, authStorage);
+		} else {
+			authStorage = await discoverAuthStorage();
+			checkAbort();
+			modelRegistry = await discoverModels(authStorage);
+			checkAbort();
+		}
+
+		// Create MCP proxy tools if provided
+		const mcpProxyTools = payload.mcpTools?.map(createMCPProxyTool) ?? [];
 
 		// Resolve model override (equivalent to CLI's parseModelPattern with --model)
 		const { model, thinkingLevel } = resolveModelOverride(payload.model, modelRegistry);
@@ -180,6 +315,11 @@ async function runTask(runState: RunState, payload: SubagentWorkerStartPayload):
 			hasUI: false,
 			// Pass spawn restrictions to nested tasks
 			spawns: payload.spawnsEnv,
+			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,
 		});
 
 		runState.session = session;
@@ -394,7 +534,7 @@ self.addEventListener("messageerror", () => {
 	reportFatal("Failed to deserialize parent message");
 });
 
-// Message handler - receives start/abort commands from parent
+// Message handler - receives start/abort/mcp_tool_result commands from parent
 globalThis.addEventListener("message", (event: WorkerMessageEvent<SubagentWorkerRequest>) => {
 	const message = event.data;
 	if (!message) return;
@@ -404,6 +544,11 @@ globalThis.addEventListener("message", (event: WorkerMessageEvent<SubagentWorker
 		return;
 	}
 
+	if (message.type === "mcp_tool_result") {
+		handleMCPToolResult(message);
+		return;
+	}
+
 	if (message.type === "start") {
 		// Only allow one task per worker
 		if (activeRun) return;

package/src/core/tools/write.ts

@@ -8,7 +8,7 @@ import type { RenderResultOptions } from "../custom-tools/types";
 import { renderPromptTemplate } from "../prompt-templates";
 import type { ToolSession } from "../sdk";
 import { untilAborted } from "../utils";
-import { createLspWritethrough, type FileDiagnosticsResult } from "./lsp/index";
+import { createLspWritethrough, type FileDiagnosticsResult, writethroughNoop } from "./lsp/index";
 import { resolveToCwd } from "./path-utils";
 import { formatDiagnostics, replaceTabs, shortenPath } from "./render-utils";
 
@@ -23,9 +23,12 @@ export interface WriteToolDetails {
 }
 
 export function createWriteTool(session: ToolSession): AgentTool<typeof writeSchema, WriteToolDetails> {
-	const enableFormat = session.settings?.getLspFormatOnWrite() ?? true;
-	const enableDiagnostics = session.settings?.getLspDiagnosticsOnWrite() ?? true;
-	const writethrough = createLspWritethrough(session.cwd, { enableFormat, enableDiagnostics });
+	const enableLsp = session.enableLsp ?? true;
+	const enableFormat = enableLsp ? (session.settings?.getLspFormatOnWrite() ?? true) : false;
+	const enableDiagnostics = enableLsp ? (session.settings?.getLspDiagnosticsOnWrite() ?? true) : false;
+	const writethrough = enableLsp
+		? createLspWritethrough(session.cwd, { enableFormat, enableDiagnostics })
+		: writethroughNoop;
 	return {
 		name: "write",
 		label: "Write",

package/src/discovery/agents-md.ts

@@ -8,6 +8,7 @@
 
 import { dirname, join, sep } from "node:path";
 import { type ContextFile, contextFileCapability } from "../capability/context-file";
+import { readFile } from "../capability/fs";
 import { registerProvider } from "../capability/index";
 import type { LoadContext, LoadResult } from "../capability/types";
 import { calculateDepth, createSourceMeta } from "./helpers";
@@ -19,7 +20,7 @@ const MAX_DEPTH = 20; // Prevent walking up excessively far from cwd
 /**
  * Load standalone AGENTS.md files.
  */
-function loadAgentsMd(ctx: LoadContext): LoadResult<ContextFile> {
+async function loadAgentsMd(ctx: LoadContext): Promise<LoadResult<ContextFile>> {
 	const items: ContextFile[] = [];
 	const warnings: string[] = [];
 
@@ -29,30 +30,23 @@ function loadAgentsMd(ctx: LoadContext): LoadResult<ContextFile> {
 
 	while (depth < MAX_DEPTH) {
 		const candidate = join(current, "AGENTS.md");
+		const content = await readFile(candidate);
 
-		if (ctx.fs.isFile(candidate)) {
-			// Skip if it's inside a config directory (handled by other providers)
+		if (content !== null) {
 			const parent = dirname(candidate);
 			const baseName = parent.split(sep).pop() ?? "";
 
-			// Skip if inside .codex, .gemini, or other config dirs
 			if (!baseName.startsWith(".")) {
-				const content = ctx.fs.readFile(candidate);
+				const fileDir = dirname(candidate);
+				const calculatedDepth = calculateDepth(ctx.cwd, fileDir, sep);
 
-				if (content === null) {
-					warnings.push(`Failed to read: ${candidate}`);
-				} else {
-					const fileDir = dirname(candidate);
-					const calculatedDepth = calculateDepth(ctx.cwd, fileDir, sep);
-
-					items.push({
-						path: candidate,
-						content,
-						level: "project",
-						depth: calculatedDepth,
-						_source: createSourceMeta(PROVIDER_ID, candidate, "project"),
-					});
-				}
+				items.push({
+					path: candidate,
+					content,
+					level: "project",
+					depth: calculatedDepth,
+					_source: createSourceMeta(PROVIDER_ID, candidate, "project"),
+				});
 			}
 		}