@oh-my-pi/pi-coding-agent 15.10.11 → 15.10.12

package/src/modes/rpc/rpc-subagents.ts

@@ -0,0 +1,265 @@
+import * as fs from "node:fs/promises";
+import { isEnoent } from "@oh-my-pi/pi-utils";
+import type { FileEntry, SessionMessageEntry } from "../../session/session-manager";
+import { parseSessionEntries } from "../../session/session-manager";
+import {
+	type AgentProgress,
+	type SubagentEventPayload,
+	type SubagentLifecyclePayload,
+	type SubagentProgressPayload,
+	TASK_SUBAGENT_EVENT_CHANNEL,
+	TASK_SUBAGENT_LIFECYCLE_CHANNEL,
+	TASK_SUBAGENT_PROGRESS_CHANNEL,
+} from "../../task";
+import type { EventBus } from "../../utils/event-bus";
+import type {
+	RpcSubagentEventFrame,
+	RpcSubagentFrame,
+	RpcSubagentMessagesResult,
+	RpcSubagentSnapshot,
+	RpcSubagentSubscriptionLevel,
+} from "./rpc-types";
+
+export interface RpcSubagentTranscriptSelector {
+	subagentId?: string;
+	sessionFile?: string;
+	fromByte?: number;
+}
+
+type RpcSubagentOutput = (frame: RpcSubagentFrame) => void;
+
+const MAX_RETAINED_TRANSCRIPT_REFERENCES = 256;
+
+function isSessionMessageEntry(entry: FileEntry): entry is SessionMessageEntry {
+	return entry.type === "message";
+}
+
+function statusFromLifecycle(status: SubagentLifecyclePayload["status"]): AgentProgress["status"] {
+	return status === "started" ? "running" : status;
+}
+
+function isTerminalLifecycleStatus(status: SubagentLifecyclePayload["status"]): boolean {
+	return status !== "started";
+}
+
+function hasSameOwner(
+	payload: Pick<SubagentLifecyclePayload | SubagentProgressPayload, "parentToolCallId" | "sessionFile">,
+	snapshot: RpcSubagentSnapshot,
+): boolean {
+	if (payload.parentToolCallId !== undefined && snapshot.parentToolCallId !== undefined) {
+		return payload.parentToolCallId === snapshot.parentToolCallId;
+	}
+	if (payload.sessionFile !== undefined && snapshot.sessionFile !== undefined) {
+		return payload.sessionFile === snapshot.sessionFile;
+	}
+	return true;
+}
+
+function addPruned(set: Set<string>, value: string, maxSize: number): void {
+	set.delete(value);
+	set.add(value);
+	while (set.size > maxSize) {
+		const oldest = set.keys().next();
+		if (oldest.done) break;
+		set.delete(oldest.value);
+	}
+}
+
+export async function readRpcSubagentTranscript(sessionFile: string, fromByte = 0): Promise<RpcSubagentMessagesResult> {
+	let startByte = Number.isFinite(fromByte) ? Math.max(0, Math.trunc(fromByte)) : 0;
+	const file = Bun.file(sessionFile);
+	let size: number;
+	try {
+		({ size } = await fs.stat(sessionFile));
+	} catch (err) {
+		if (!isEnoent(err)) throw err;
+		return {
+			sessionFile,
+			fromByte: startByte,
+			nextByte: startByte,
+			reset: false,
+			entries: [],
+			messages: [],
+		};
+	}
+	let reset = false;
+	if (startByte > size) {
+		startByte = 0;
+		reset = true;
+	}
+
+	const text = startByte >= size ? "" : await file.slice(startByte).text();
+	const lastNewline = text.lastIndexOf("\n");
+	const completeText = lastNewline >= 0 ? text.slice(0, lastNewline + 1) : "";
+	const entries = completeText.length > 0 ? parseSessionEntries(completeText) : [];
+	const nextByte = startByte + Buffer.byteLength(completeText, "utf8");
+
+	return {
+		sessionFile,
+		fromByte: startByte,
+		nextByte,
+		reset,
+		entries,
+		messages: entries.filter(isSessionMessageEntry).map(entry => entry.message),
+	};
+}
+
+export class RpcSubagentRegistry {
+	#subagents = new Map<string, RpcSubagentSnapshot>();
+	#transcriptSessionFilesBySubagentId = new Map<string, string>();
+	#staleSubagentIds = new Set<string>();
+	#unsubscribers: Array<() => void> = [];
+	#output: RpcSubagentOutput;
+	#subscriptionLevel: RpcSubagentSubscriptionLevel = "off";
+
+	constructor(eventBus: EventBus, output: RpcSubagentOutput) {
+		this.#output = output;
+		this.#unsubscribers.push(
+			eventBus.on(TASK_SUBAGENT_LIFECYCLE_CHANNEL, data => {
+				this.handleLifecycle(data as SubagentLifecyclePayload);
+			}),
+			eventBus.on(TASK_SUBAGENT_PROGRESS_CHANNEL, data => {
+				this.handleProgress(data as SubagentProgressPayload);
+			}),
+			eventBus.on(TASK_SUBAGENT_EVENT_CHANNEL, data => {
+				this.handleEvent(data as SubagentEventPayload);
+			}),
+		);
+	}
+
+	dispose(): void {
+		for (const unsubscribe of this.#unsubscribers) unsubscribe();
+		this.#unsubscribers = [];
+		this.#subagents.clear();
+		this.#transcriptSessionFilesBySubagentId.clear();
+		this.#staleSubagentIds.clear();
+	}
+
+	clear(): void {
+		for (const subagentId of this.#subagents.keys()) {
+			addPruned(this.#staleSubagentIds, subagentId, MAX_RETAINED_TRANSCRIPT_REFERENCES);
+		}
+		for (const subagentId of this.#transcriptSessionFilesBySubagentId.keys()) {
+			addPruned(this.#staleSubagentIds, subagentId, MAX_RETAINED_TRANSCRIPT_REFERENCES);
+		}
+		this.#subagents.clear();
+		this.#transcriptSessionFilesBySubagentId.clear();
+	}
+
+	setSubscriptionLevel(level: RpcSubagentSubscriptionLevel): void {
+		this.#subscriptionLevel = level;
+	}
+
+	getSubscriptionLevel(): RpcSubagentSubscriptionLevel {
+		return this.#subscriptionLevel;
+	}
+
+	getSubagents(): RpcSubagentSnapshot[] {
+		return [...this.#subagents.values()].sort((a, b) => a.index - b.index || a.id.localeCompare(b.id));
+	}
+
+	#rememberTranscriptSession(subagentId: string, sessionFile: string | undefined): void {
+		if (!sessionFile) return;
+		this.#transcriptSessionFilesBySubagentId.delete(subagentId);
+		this.#transcriptSessionFilesBySubagentId.set(subagentId, sessionFile);
+		while (this.#transcriptSessionFilesBySubagentId.size > MAX_RETAINED_TRANSCRIPT_REFERENCES) {
+			const oldest = this.#transcriptSessionFilesBySubagentId.keys().next();
+			if (oldest.done) break;
+			this.#transcriptSessionFilesBySubagentId.delete(oldest.value);
+		}
+	}
+
+	#hasTranscriptSessionFile(sessionFile: string): boolean {
+		for (const snapshot of this.#subagents.values()) {
+			if (snapshot.sessionFile === sessionFile) return true;
+		}
+		for (const transcriptSessionFile of this.#transcriptSessionFilesBySubagentId.values()) {
+			if (transcriptSessionFile === sessionFile) return true;
+		}
+		return false;
+	}
+
+	handleLifecycle(payload: SubagentLifecyclePayload): void {
+		const existing = this.#subagents.get(payload.id);
+		if (existing && !hasSameOwner(payload, existing)) return;
+		if (!existing && payload.status !== "started") return;
+		if (payload.status === "started") {
+			this.#staleSubagentIds.delete(payload.id);
+		}
+		const sessionFile = payload.sessionFile ?? existing?.sessionFile;
+		const snapshot: RpcSubagentSnapshot = {
+			id: payload.id,
+			index: payload.index,
+			agent: payload.agent,
+			agentSource: payload.agentSource,
+			description: payload.description ?? existing?.description,
+			status: statusFromLifecycle(payload.status),
+			task: existing?.task,
+			assignment: existing?.assignment,
+			sessionFile,
+			parentToolCallId: payload.parentToolCallId ?? existing?.parentToolCallId,
+			lastUpdate: Date.now(),
+			progress: existing?.progress,
+		};
+		this.#rememberTranscriptSession(payload.id, sessionFile);
+		if (isTerminalLifecycleStatus(payload.status)) {
+			this.#subagents.delete(payload.id);
+		} else {
+			this.#subagents.set(payload.id, snapshot);
+		}
+		if (this.#subscriptionLevel !== "off") {
+			this.#output({ type: "subagent_lifecycle", payload });
+		}
+	}
+
+	handleProgress(payload: SubagentProgressPayload): void {
+		const progress = payload.progress;
+		if (this.#staleSubagentIds.has(progress.id)) return;
+		const existing = this.#subagents.get(progress.id);
+		if (!existing) return;
+		if (!hasSameOwner(payload, existing)) return;
+		const sessionFile = payload.sessionFile ?? existing?.sessionFile;
+		this.#rememberTranscriptSession(progress.id, sessionFile);
+		this.#subagents.set(progress.id, {
+			id: progress.id,
+			index: payload.index,
+			agent: payload.agent,
+			agentSource: payload.agentSource,
+			description: progress.description ?? existing?.description,
+			status: progress.status,
+			task: payload.task,
+			assignment: payload.assignment,
+			sessionFile,
+			lastUpdate: Date.now(),
+			parentToolCallId: payload.parentToolCallId ?? existing?.parentToolCallId,
+			progress,
+		});
+		if (this.#subscriptionLevel !== "off") {
+			this.#output({ type: "subagent_progress", payload });
+		}
+	}
+
+	handleEvent(payload: SubagentEventPayload): void {
+		if (this.#staleSubagentIds.has(payload.id)) return;
+		if (this.#subscriptionLevel !== "events") return;
+		this.#output({ type: "subagent_event", payload } satisfies RpcSubagentEventFrame);
+	}
+
+	resolveSessionFile(selector: RpcSubagentTranscriptSelector): string {
+		if (selector.subagentId) {
+			const snapshot = this.#subagents.get(selector.subagentId);
+			const sessionFile = snapshot?.sessionFile ?? this.#transcriptSessionFilesBySubagentId.get(selector.subagentId);
+			if (!sessionFile) {
+				throw new Error(`Unknown subagent or session file unavailable: ${selector.subagentId}`);
+			}
+			return sessionFile;
+		}
+
+		if (selector.sessionFile) {
+			if (this.#hasTranscriptSessionFile(selector.sessionFile)) return selector.sessionFile;
+			throw new Error("Unknown subagent session file");
+		}
+
+		throw new Error("get_subagent_messages requires subagentId or sessionFile");
+	}
+}

package/src/modes/rpc/rpc-types.ts

@@ -9,7 +9,14 @@ import type { CompactionResult } from "@oh-my-pi/pi-agent-core/compaction";
 import type { Effort, ImageContent, Model } from "@oh-my-pi/pi-ai";
 import type { BashResult } from "../../exec/bash-executor";
 import type { ContextUsage } from "../../extensibility/extensions/types";
-import type { SessionStats } from "../../session/agent-session";
+import type { AgentSessionEvent, SessionStats } from "../../session/agent-session";
+import type { FileEntry } from "../../session/session-manager";
+import type {
+	AgentProgress,
+	SubagentEventPayload,
+	SubagentLifecyclePayload,
+	SubagentProgressPayload,
+} from "../../task";
 import type { TodoPhase } from "../../tools/todo";
 
 // ============================================================================
@@ -30,6 +37,9 @@ export type RpcCommand =
 	| { id?: string; type: "set_todos"; phases: TodoPhase[] }
 	| { id?: string; type: "set_host_tools"; tools: RpcHostToolDefinition[] }
 	| { id?: string; type: "set_host_uri_schemes"; schemes: RpcHostUriSchemeDefinition[] }
+	| { id?: string; type: "set_subagent_subscription"; level: RpcSubagentSubscriptionLevel }
+	| { id?: string; type: "get_subagents" }
+	| { id?: string; type: "get_subagent_messages"; subagentId?: string; sessionFile?: string; fromByte?: number }
 
 	// Model
 	| { id?: string; type: "set_model"; provider: string; modelId: string }
@@ -104,6 +114,32 @@ export interface RpcHandoffResult {
 	savedPath?: string;
 }
 
+export type RpcSubagentSubscriptionLevel = "off" | "progress" | "events";
+
+export interface RpcSubagentSnapshot {
+	id: string;
+	index: number;
+	agent: string;
+	agentSource: AgentProgress["agentSource"];
+	description?: string;
+	status: AgentProgress["status"];
+	task?: string;
+	assignment?: string;
+	sessionFile?: string;
+	lastUpdate: number;
+	progress?: AgentProgress;
+	parentToolCallId?: string;
+}
+
+export interface RpcSubagentMessagesResult {
+	sessionFile: string;
+	fromByte: number;
+	nextByte: number;
+	reset: boolean;
+	entries: FileEntry[];
+	messages: AgentMessage[];
+}
+
 // ============================================================================
 // RPC Responses (stdout)
 // ============================================================================
@@ -123,6 +159,27 @@ export type RpcResponse =
 	| { id?: string; type: "response"; command: "set_todos"; success: true; data: { todoPhases: TodoPhase[] } }
 	| { id?: string; type: "response"; command: "set_host_tools"; success: true; data: { toolNames: string[] } }
 	| { id?: string; type: "response"; command: "set_host_uri_schemes"; success: true; data: { schemes: string[] } }
+	| {
+			id?: string;
+			type: "response";
+			command: "set_subagent_subscription";
+			success: true;
+			data: { level: RpcSubagentSubscriptionLevel };
+	  }
+	| {
+			id?: string;
+			type: "response";
+			command: "get_subagents";
+			success: true;
+			data: { subagents: RpcSubagentSnapshot[] };
+	  }
+	| {
+			id?: string;
+			type: "response";
+			command: "get_subagent_messages";
+			success: true;
+			data: RpcSubagentMessagesResult;
+	  }
 
 	// Model
 	| {
@@ -212,6 +269,29 @@ export type RpcResponse =
 	// Error response (any command can fail)
 	| { id?: string; type: "response"; command: string; success: false; error: string };
 
+// ============================================================================
+// Subagent Events (stdout)
+// ============================================================================
+
+export interface RpcSubagentLifecycleFrame {
+	type: "subagent_lifecycle";
+	payload: SubagentLifecyclePayload;
+}
+
+export interface RpcSubagentProgressFrame {
+	type: "subagent_progress";
+	payload: SubagentProgressPayload;
+}
+
+export interface RpcSubagentEventFrame {
+	type: "subagent_event";
+	payload: SubagentEventPayload;
+}
+
+export type RpcSubagentFrame = RpcSubagentLifecycleFrame | RpcSubagentProgressFrame | RpcSubagentEventFrame;
+
+export type RpcSessionEventFrame = AgentSessionEvent | RpcSubagentFrame;
+
 // ============================================================================
 // Extension UI Events (stdout)
 // ============================================================================

package/src/modes/setup-wizard/index.ts

@@ -65,9 +65,15 @@ export async function markSetupWizardComplete(
 	await settings.flush();
 }
 
+export interface RunSetupWizardOptions {
+	markComplete?: boolean;
+	playWelcomeIntro?: boolean;
+}
+
 export async function runSetupWizard(
 	ctx: InteractiveModeContext,
 	scenes: readonly SetupScene[] = ALL_SCENES,
+	options: RunSetupWizardOptions = {},
 ): Promise<void> {
 	if (scenes.length === 0) return;
 	const component = new SetupWizardComponent(ctx, scenes);
@@ -79,11 +85,15 @@ export async function runSetupWizard(
 	});
 	try {
 		await component.run();
-		await markSetupWizardComplete(ctx.settings);
+		if (options.markComplete !== false) {
+			await markSetupWizardComplete(ctx.settings);
+		}
 	} finally {
 		component.dispose();
 		ctx.ui.setFocus(component);
 		overlay.hide();
 	}
-	ctx.playWelcomeIntro();
+	if (options.playWelcomeIntro !== false) {
+		ctx.playWelcomeIntro();
+	}
 }

package/src/modes/setup-wizard/lazy.ts

@@ -0,0 +1,16 @@
+import type { InteractiveModeContext } from "../types";
+
+export async function runProviderSetupWizard(ctx: InteractiveModeContext): Promise<void> {
+	// Keep the full setup wizard behind the existing cold-start boundary; a static
+	// import here would load provider/OAuth/search/theme setup deps on every TUI startup.
+	const { ALL_SCENES, runSetupWizard } = await import("./index");
+	const providersScene = ALL_SCENES.find(scene => scene.id === "providers");
+	if (!providersScene) {
+		ctx.showError("Provider setup is unavailable.");
+		return;
+	}
+	await runSetupWizard(ctx, [providersScene], {
+		markComplete: false,
+		playWelcomeIntro: false,
+	});
+}

package/src/modes/types.ts

@@ -99,6 +99,7 @@ export interface InteractiveModeContext {
 	historyStorage?: HistoryStorage;
 	mcpManager?: MCPManager;
 	lspServers?: LspStartupServerInfo[];
+	titleSystemPrompt?: string;
 
 	// State
 	isInitialized: boolean;
@@ -288,6 +289,7 @@ export interface InteractiveModeContext {
 	handleResumeSession(sessionPath: string): Promise<void>;
 	handleSessionDeleteCommand(): Promise<void>;
 	showOAuthSelector(mode: "login" | "logout", providerId?: string): Promise<void>;
+	showProviderSetup(): Promise<void>;
 	showHookConfirm(title: string, message: string): Promise<boolean>;
 	showDebugSelector(): Promise<void>;
 	showSessionObserver(): void;

package/src/sdk.ts

@@ -89,7 +89,7 @@ import type { HindsightSessionState } from "./hindsight/state";
 import { LocalProtocolHandler, type LocalProtocolOptions } from "./internal-urls";
 import { LSP_STARTUP_EVENT_CHANNEL, type LspStartupEvent } from "./lsp/startup-events";
 import { discoverAndLoadMCPTools, MCPManager, type MCPToolsLoadResult } from "./mcp";
-import { resolveMemoryBackend } from "./memory-backend";
+import { createSessionMemoryRuntimeContext, resolveMemoryBackend } from "./memory-backend";
 import type { MnemopiSessionState } from "./mnemopi/state";
 import asyncResultTemplate from "./prompts/tools/async-result.md" with { type: "text" };
 import lateDiagnosticTemplate from "./prompts/tools/lsp-late-diagnostic.md" with { type: "text" };
@@ -99,6 +99,7 @@ import {
 	deobfuscateSessionContext,
 	loadSecrets,
 	obfuscateMessages,
+	obfuscateProviderContext,
 	SecretObfuscator,
 } from "./secrets";
 import { AgentSession } from "./session/agent-session";
@@ -134,6 +135,7 @@ import {
 	parseThinkingLevel,
 	resolveProvisionalAutoLevel,
 	resolveThinkingLevelForModel,
+	shouldDisableReasoning,
 	toReasoningEffort,
 } from "./thinking";
 import { countToolsForAutoDiscovery, resolveEffectiveToolDiscoveryMode } from "./tool-discovery/mode";
@@ -1791,6 +1793,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			cwd,
 			sessionManager,
 			modelRegistry,
+			() => (hasSession ? createSessionMemoryRuntimeContext(session, agentDir, cwd) : undefined),
 		);
 
 		credentialDisabledTarget = extensionRunner;
@@ -2138,6 +2141,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			if (!obfuscator?.hasSecrets()) return converted;
 			return obfuscateMessages(obfuscator, converted);
 		};
+
 		const transformContext = async (messages: AgentMessage[], _signal?: AbortSignal) => {
 			const withContext = await extensionRunner.emitContext(messages);
 			return wrapSteeringForModel(withContext);
@@ -2173,6 +2177,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				systemPrompt,
 				model,
 				thinkingLevel: toReasoningEffort(effectiveThinkingLevel),
+				disableReasoning: shouldDisableReasoning(effectiveThinkingLevel),
 				tools: initialTools,
 			},
 			convertToLlm: convertToLlmFinal,
@@ -2181,6 +2186,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			sessionId: providerSessionId,
 			promptCacheKey: options.providerPromptCacheKey,
 			transformContext,
+			transformProviderContext: obfuscator ? context => obfuscateProviderContext(obfuscator, context) : undefined,
 			steeringMode: settings.get("steeringMode") ?? "one-at-a-time",
 			followUpMode: settings.get("followUpMode") ?? "one-at-a-time",
 			interruptMode: settings.get("interruptMode") ?? "immediate",
@@ -2267,6 +2273,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			thinkingLevel: autoThinking ? AUTO_THINKING : effectiveThinkingLevel,
 			sessionManager,
 			settings,
+			autoApprove: options.autoApprove,
 			evalKernelOwnerId,
 			// Defined only for top-level sessions (creation is gated above).
 			// AgentSession uses this to decide whether it may dispose the global

package/src/secrets/index.ts

@@ -4,7 +4,14 @@ import { YAML } from "bun";
 import type { SecretEntry } from "./obfuscator";
 import { compileSecretRegex } from "./regex";
 
-export { deobfuscateSessionContext, obfuscateMessages, type SecretEntry, SecretObfuscator } from "./obfuscator";
+export {
+	deobfuscateSessionContext,
+	obfuscateMessages,
+	obfuscateProviderContext,
+	obfuscateProviderTools,
+	type SecretEntry,
+	SecretObfuscator,
+} from "./obfuscator";
 
 /**
  * Load secrets from project-local and global secrets.yml files.

package/src/secrets/obfuscator.ts

@@ -1,4 +1,5 @@
-import type { Message, TextContent } from "@oh-my-pi/pi-ai";
+import type { Context, Message, Tool } from "@oh-my-pi/pi-ai";
+import { toolWireSchema } from "@oh-my-pi/pi-ai/utils/schema";
 import type { SessionContext } from "../session/session-manager";
 import { compileSecretRegex } from "./regex";
 
@@ -184,6 +185,12 @@ export class SecretObfuscator {
 		return deepWalkStrings(obj, s => this.deobfuscate(s));
 	}
 
+	/** Deep-walk an object, obfuscating all string values. */
+	obfuscateObject<T>(obj: T): T {
+		if (!this.#hasAny) return obj;
+		return deepWalkStrings(obj, s => this.obfuscate(s));
+	}
+
 	/** Find the obfuscate index for a known secret value. */
 	#findObfuscateIndex(secret: string): number | undefined {
 		// Check plain mappings first
@@ -211,25 +218,34 @@ export function deobfuscateSessionContext(
 // Message obfuscation (outbound to LLM)
 // ═══════════════════════════════════════════════════════════════════════════
 
-/** Obfuscate all text content in LLM messages (for outbound interception). */
+/** Obfuscate all string content in LLM messages (for outbound interception). */
 export function obfuscateMessages(obfuscator: SecretObfuscator, messages: Message[]): Message[] {
-	return messages.map(msg => {
-		if (!Array.isArray(msg.content)) return msg;
+	return obfuscator.obfuscateObject(messages);
+}
 
-		let changed = false;
-		const content = msg.content.map(block => {
-			if (block.type === "text") {
-				const obfuscated = obfuscator.obfuscate(block.text);
-				if (obfuscated !== block.text) {
-					changed = true;
-					return { ...block, text: obfuscated } as TextContent;
-				}
-			}
-			return block;
-		});
+/** Obfuscate provider request context without walking live tool schema instances. */
+export function obfuscateProviderContext(obfuscator: SecretObfuscator | undefined, context: Context): Context {
+	if (!obfuscator?.hasSecrets()) return context;
+	return {
+		...context,
+		systemPrompt: obfuscator.obfuscateObject(context.systemPrompt),
+		messages: obfuscator.obfuscateObject(context.messages),
+		tools: obfuscateProviderTools(obfuscator, context.tools),
+	};
+}
 
-		return changed ? ({ ...msg, content } as typeof msg) : msg;
-	});
+/** Convert tool schemas to wire JSON Schema before obfuscating provider-visible strings. */
+export function obfuscateProviderTools(
+	obfuscator: SecretObfuscator | undefined,
+	tools: Tool[] | undefined,
+): Tool[] | undefined {
+	if (!tools || !obfuscator?.hasSecrets()) return tools;
+	return tools.map(tool => ({
+		...tool,
+		description: obfuscator.obfuscate(tool.description),
+		parameters: obfuscator.obfuscateObject(toolWireSchema(tool)),
+		customFormat: tool.customFormat ? obfuscator.obfuscateObject(tool.customFormat) : undefined,
+	}));
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -262,7 +278,7 @@ function deepWalkStrings<T>(obj: T, transform: (s: string) => string): T {
 		});
 		return (changed ? result : obj) as unknown as T;
 	}
-	if (obj !== null && typeof obj === "object") {
+	if (obj !== null && typeof obj === "object" && isPlainRecord(obj)) {
 		let changed = false;
 		const result: Record<string, unknown> = {};
 		for (const key of Object.keys(obj)) {
@@ -275,3 +291,8 @@ function deepWalkStrings<T>(obj: T, transform: (s: string) => string): T {
 	}
 	return obj;
 }
+
+function isPlainRecord(obj: object): obj is Record<string, unknown> {
+	const prototype = Object.getPrototypeOf(obj);
+	return prototype === Object.prototype || prototype === null;
+}