@oh-my-pi/pi-coding-agent 11.0.3 → 11.2.0

package/src/task/executor.ts

@@ -9,7 +9,7 @@ import type { Api, Model, ToolChoice } from "@oh-my-pi/pi-ai";
 import { logger, untilAborted } from "@oh-my-pi/pi-utils";
 import type { TSchema } from "@sinclair/typebox";
 import Ajv, { type ValidateFunction } from "ajv";
-import type { ModelRegistry } from "../config/model-registry";
+import { ModelRegistry } from "../config/model-registry";
 import { resolveModelOverride } from "../config/model-resolver";
 import { type PromptTemplate, renderPromptTemplate } from "../config/prompt-templates";
 import { Settings } from "../config/settings";
@@ -19,7 +19,7 @@ import { callTool } from "../mcp/client";
 import type { MCPManager } from "../mcp/manager";
 import submitReminderTemplate from "../prompts/system/subagent-submit-reminder.md" with { type: "text" };
 import subagentSystemPromptTemplate from "../prompts/system/subagent-system-prompt.md" with { type: "text" };
-import { createAgentSession, discoverAuthStorage, discoverModels } from "../sdk";
+import { createAgentSession, discoverAuthStorage } from "../sdk";
 import type { AgentSession, AgentSessionEvent } from "../session/agent-session";
 import type { AuthStorage } from "../session/auth-storage";
 import { SessionManager } from "../session/session-manager";
@@ -153,7 +153,6 @@ export interface ExecutorOptions {
 	description?: string;
 	index: number;
 	id: string;
-	context?: string;
 	modelOverride?: string | string[];
 	thinkingLevel?: ThinkingLevel;
 	outputSchema?: unknown;
@@ -374,7 +373,6 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 		index,
 		id,
 		worktree,
-		context,
 		modelOverride,
 		thinkingLevel,
 		outputSchema,
@@ -421,9 +419,6 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 		};
 	}
 
-	// Build full task with context
-	const fullTask = context ? `${context}\n\n${task}` : task;
-
 	// Set up artifact paths and write input file upfront if artifacts dir provided
 	let subtaskSessionFile: string | undefined;
 	if (options.artifactsDir) {
@@ -849,7 +844,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 			checkAbort();
 			const authStorage = options.authStorage ?? (await discoverAuthStorage());
 			checkAbort();
-			const modelRegistry = options.modelRegistry ?? discoverModels(authStorage);
+			const modelRegistry = options.modelRegistry ?? new ModelRegistry(authStorage);
 			checkAbort();
 
 			const { model, thinkingLevel: resolvedThinkingLevel } = resolveModelOverride(
@@ -905,7 +900,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 
 			session.sessionManager.appendSessionInit({
 				systemPrompt: session.agent.state.systemPrompt,
-				task: fullTask,
+				task,
 				tools: session.getAllToolNames(),
 				outputSchema,
 			});
@@ -994,7 +989,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				}
 			});
 
-			await session.prompt(fullTask);
+			await session.prompt(task);
 
 			const reminderToolChoice = buildSubmitResultToolChoice(session.model);
 

package/src/task/index.ts

@@ -35,7 +35,15 @@ import { AgentOutputManager } from "./output-manager";
 import { mapWithConcurrencyLimit } from "./parallel";
 import { renderCall, renderResult } from "./render";
 import { renderTemplate } from "./template";
-import { type AgentProgress, type SingleResult, type TaskParams, type TaskToolDetails, taskSchema } from "./types";
+import {
+	type AgentProgress,
+	type SingleResult,
+	type TaskParams,
+	type TaskSchema,
+	type TaskToolDetails,
+	taskSchema,
+	taskSchemaNoIsolation,
+} from "./types";
 import {
 	applyBaseline,
 	captureBaseline,
@@ -102,12 +110,13 @@ export { taskSchema } from "./types";
 /**
  * Build dynamic tool description listing available agents.
  */
-async function buildDescription(cwd: string, maxConcurrency: number): Promise<string> {
+async function buildDescription(cwd: string, maxConcurrency: number, isolationEnabled: boolean): Promise<string> {
 	const { agents } = await discoverAgents(cwd);
 
 	return renderPromptTemplate(taskDescriptionTemplate, {
 		agents,
 		MAX_CONCURRENCY: maxConcurrency,
+		isolationEnabled,
 	});
 }
 
@@ -121,20 +130,21 @@ async function buildDescription(cwd: string, maxConcurrency: number): Promise<st
  * Requires async initialization to discover available agents.
  * Use `TaskTool.create(session)` to instantiate.
  */
-export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, Theme> {
+export class TaskTool implements AgentTool<TaskSchema, TaskToolDetails, Theme> {
 	public readonly name = "task";
 	public readonly label = "Task";
-	public readonly description: string;
-	public readonly parameters = taskSchema;
+	public readonly parameters: TaskSchema;
 	public readonly renderCall = renderCall;
 	public readonly renderResult = renderResult;
 
-	private readonly session: ToolSession;
 	private readonly blockedAgent: string | undefined;
 
-	private constructor(session: ToolSession, description: string) {
-		this.session = session;
-		this.description = description;
+	private constructor(
+		private readonly session: ToolSession,
+		public readonly description: string,
+		isolationEnabled: boolean,
+	) {
+		this.parameters = isolationEnabled ? taskSchema : taskSchemaNoIsolation;
 		this.blockedAgent = $env.PI_BLOCKED_AGENT;
 	}
 
@@ -143,8 +153,9 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 	 */
 	public static async create(session: ToolSession): Promise<TaskTool> {
 		const maxConcurrency = session.settings.get("task.maxConcurrency");
-		const description = await buildDescription(session.cwd, maxConcurrency);
-		return new TaskTool(session, description);
+		const isolationEnabled = session.settings.get("task.isolation.enabled");
+		const description = await buildDescription(session.cwd, maxConcurrency, isolationEnabled);
+		return new TaskTool(session, description, isolationEnabled);
 	}
 
 	public async execute(
@@ -155,11 +166,29 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 	): Promise<AgentToolResult<TaskToolDetails>> {
 		const startTime = Date.now();
 		const { agents, projectAgentsDir } = await discoverAgents(this.session.cwd);
-		const { agent: agentName, context, schema: outputSchema, isolated } = params;
-		const isIsolated = isolated === true;
+		const { agent: agentName, context, schema: outputSchema } = params;
+		const isolationEnabled = this.session.settings.get("task.isolation.enabled");
+		const isolationRequested = "isolated" in params ? params.isolated === true : false;
+		const isIsolated = isolationEnabled && isolationRequested;
 		const maxConcurrency = this.session.settings.get("task.maxConcurrency");
 		const taskDepth = this.session.taskDepth ?? 0;
 
+		if (!isolationEnabled && "isolated" in params) {
+			return {
+				content: [
+					{
+						type: "text",
+						text: "Task isolation is disabled. Remove the isolated argument to run subagents.",
+					},
+				],
+				details: {
+					projectAgentsDir,
+					results: [],
+					totalDurationMs: 0,
+				},
+			};
+		}
+
 		// Validate agent exists
 		const agent = getAgent(agents, agentName);
 		if (!agent) {
@@ -426,7 +455,6 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 					agentSource: agent.source,
 					status: "pending",
 					task: t.task,
-					args: t.args,
 					recentTools: [],
 					recentOutput: [],
 					toolCount: 0,
@@ -447,7 +475,6 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 						description: task.description,
 						index,
 						id: task.id,
-						context: undefined, // Already prepended above
 						taskDepth,
 						modelOverride,
 						thinkingLevel: thinkingLevelOverride,
@@ -462,7 +489,6 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 						onProgress: progress => {
 							progressMap.set(index, {
 								...structuredClone(progress),
-								args: tasksWithSkills[index]?.args,
 							});
 							emitProgress();
 						},
@@ -493,7 +519,6 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 						description: task.description,
 						index,
 						id: task.id,
-						context: undefined, // Already prepended above
 						taskDepth,
 						modelOverride,
 						thinkingLevel: thinkingLevelOverride,
@@ -508,7 +533,6 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 						onProgress: progress => {
 							progressMap.set(index, {
 								...structuredClone(progress),
-								args: tasksWithSkills[index]?.args,
 							});
 							emitProgress();
 						},
@@ -564,10 +588,7 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 			// Fill in skipped tasks (undefined entries from abort) with placeholder results
 			const results: SingleResult[] = partialResults.map((result, index) => {
 				if (result !== undefined) {
-					return {
-						...result,
-						args: tasksWithSkills[index]?.args,
-					};
+					return result;
 				}
 				const task = tasksWithSkills[index];
 				return {
@@ -576,7 +597,6 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 					agent: agentName,
 					agentSource: agent.source,
 					task: task.task,
-					args: task.args,
 					description: task.description,
 					exitCode: 1,
 					output: "",

package/src/task/render.ts

@@ -354,25 +354,27 @@ function renderOutputSection(
 	return lines;
 }
 
-function formatArgsInline(args: Record<string, string>, _theme: Theme): string {
-	const entries = Object.entries(args);
-	if (entries.length === 0) return "No arguments";
+function renderTaskSection(
+	task: string,
+	continuePrefix: string,
+	expanded: boolean,
+	theme: Theme,
+	maxExpanded = 20,
+): string[] {
+	const lines: string[] = [];
+	const trimmed = task.trimEnd();
+	if (!expanded || !trimmed) return lines;
 
-	// Single variable: show inline as "Key: value" without tree structure
-	if (entries.length === 1) {
-		const [key, value] = entries[0];
-		const humanKey = humanizeKey(key);
-		const displayValue = `"${truncateToWidth(value, 32)}"`;
-		return `${humanKey}: ${displayValue}`;
+	lines.push(`${continuePrefix}${theme.fg("dim", "Task")}`);
+	const taskLines = trimmed.split("\n");
+	for (const line of taskLines.slice(0, maxExpanded)) {
+		lines.push(`${continuePrefix}  ${theme.fg("dim", truncateToWidth(line, 70))}`);
+	}
+	if (taskLines.length > maxExpanded) {
+		lines.push(`${continuePrefix}  ${theme.fg("dim", formatMoreItems(taskLines.length - maxExpanded, "line"))}`);
 	}
 
-	const pairs = entries.map(([key, value]) => `${key}=${truncateToWidth(value, 24)}`);
-	return `Args: ${pairs.join(", ")}`;
-}
-
-/** Convert snake_case or kebab-case to Title Case */
-function humanizeKey(key: string): string {
-	return key.replace(/[-_]/g, " ").replace(/\b\w/g, c => c.toUpperCase());
+	return lines;
 }
 
 function formatScalarInline(value: unknown, maxLen: number, _theme: Theme): string {
@@ -428,47 +430,6 @@ function formatOutputInline(data: unknown, theme: Theme, maxWidth = 80): string
 	return `Output: ${pairs.join(", ")}`;
 }
 
-function renderArgsSection(
-	args: Record<string, string> | undefined,
-	continuePrefix: string,
-	expanded: boolean,
-	theme: Theme,
-): string[] {
-	if (!args) return [];
-	// Filter out auto-injected id and description
-	const filteredArgs = Object.fromEntries(
-		Object.entries(args).filter(([key]) => key !== "id" && key !== "description"),
-	);
-	if (Object.keys(filteredArgs).length === 0) return [];
-	const lines: string[] = [];
-	const entries = Object.entries(filteredArgs);
-
-	if (!expanded) {
-		lines.push(`${continuePrefix}${theme.fg("dim", formatArgsInline(filteredArgs, theme))}`);
-		return lines;
-	}
-
-	// Single variable: show inline as "Key: value" without tree structure
-	if (entries.length === 1) {
-		const [key, value] = entries[0];
-		const humanKey = humanizeKey(key);
-		const displayValue = `"${truncateToWidth(value, 60)}"`;
-		lines.push(`${continuePrefix}${theme.fg("dim", `${humanKey}: ${displayValue}`)}`);
-		return lines;
-	}
-
-	lines.push(`${continuePrefix}${theme.fg("dim", "Args")}`);
-	const tree = renderJsonTreeLines(filteredArgs, theme, 4, 16);
-	for (const line of tree.lines) {
-		lines.push(`${continuePrefix}  ${line}`);
-	}
-	if (tree.truncated) {
-		lines.push(`${continuePrefix}  ${theme.fg("dim", "…")}`);
-	}
-
-	return lines;
-}
-
 /**
  * Render the tool call arguments.
  */
@@ -482,7 +443,7 @@ export function renderCall(args: TaskParams, theme: Theme): Component {
 	const branch = theme.fg("dim", theme.tree.branch);
 	const last = theme.fg("dim", theme.tree.last);
 	const vertical = theme.fg("dim", theme.tree.vertical);
-	const showIsolated = args.isolated === true;
+	const showIsolated = "isolated" in args && args.isolated === true;
 
 	if (hasContext) {
 		lines.push(` ${branch} ${theme.fg("dim", "Context")}`);
@@ -556,7 +517,7 @@ function renderAgentProgress(
 
 	lines.push(statusLine);
 
-	lines.push(...renderArgsSection(progress.args, continuePrefix, expanded, theme));
+	lines.push(...renderTaskSection(progress.task, continuePrefix, expanded, theme));
 
 	// Current tool (if running) or most recent completed tool
 	if (progress.status === "running") {
@@ -778,7 +739,8 @@ function renderAgentResult(result: SingleResult, isLast: boolean, expanded: bool
 	}
 
 	lines.push(statusLine);
-	lines.push(...renderArgsSection(result.args, continuePrefix, expanded, theme));
+
+	lines.push(...renderTaskSection(result.task, continuePrefix, expanded, theme));
 
 	// Check for review result (submit_result with review schema + report_finding)
 	const completeData = result.extractedToolData?.submit_result as Array<{ data: unknown }> | undefined;
@@ -810,6 +772,7 @@ function renderAgentResult(result: SingleResult, isLast: boolean, expanded: bool
 
 	// Check for extracted tool data with custom renderers (skip review tools)
 	let hasCustomRendering = false;
+	const deferredToolLines: string[] = [];
 	if (result.extractedToolData) {
 		for (const [toolName, dataArray] of Object.entries(result.extractedToolData)) {
 			// Skip review tools - handled above
@@ -817,20 +780,24 @@ function renderAgentResult(result: SingleResult, isLast: boolean, expanded: bool
 
 			const handler = subprocessToolRegistry.getHandler(toolName);
 			if (handler?.renderFinal && (dataArray as unknown[]).length > 0) {
-				hasCustomRendering = true;
+				const isTaskTool = toolName === "task";
 				const component = handler.renderFinal(dataArray as unknown[], theme, expanded);
-				lines.push(`${continuePrefix}${theme.fg("dim", `Tool: ${toolName}`)}`);
+				const target = isTaskTool ? deferredToolLines : lines;
+				if (!isTaskTool) {
+					hasCustomRendering = true;
+					target.push(`${continuePrefix}${theme.fg("dim", `Tool: ${toolName}`)}`);
+				}
 				if (component instanceof Text) {
 					// Prefix each line with continuePrefix
 					const text = component.getText();
 					for (const line of text.split("\n")) {
-						lines.push(`${continuePrefix}${line}`);
+						target.push(`${continuePrefix}${line}`);
 					}
 				} else if (component instanceof Container) {
 					// For containers, render each child
 					for (const child of (component as Container).children) {
 						if (child instanceof Text) {
-							lines.push(`${continuePrefix}${child.getText()}`);
+							target.push(`${continuePrefix}${child.getText()}`);
 						}
 					}
 				}
@@ -854,6 +821,10 @@ function renderAgentResult(result: SingleResult, isLast: boolean, expanded: bool
 		);
 	}
 
+	if (deferredToolLines.length > 0) {
+		lines.push(...deferredToolLines);
+	}
+
 	if (result.patchPath && !aborted && result.exitCode === 0) {
 		lines.push(`${continuePrefix}${theme.fg("dim", `Patch: ${result.patchPath}`)}`);
 	}
@@ -944,6 +915,38 @@ export function renderResult(
 	return new Text(indented.join("\n"), 0, 0);
 }
 
+function isTaskToolDetails(value: unknown): value is TaskToolDetails {
+	return (
+		Boolean(value) &&
+		typeof value === "object" &&
+		"results" in (value as TaskToolDetails) &&
+		Array.isArray((value as TaskToolDetails).results)
+	);
+}
+
+function renderNestedTaskResults(detailsList: TaskToolDetails[], expanded: boolean, theme: Theme): string[] {
+	const lines: string[] = [];
+	for (const details of detailsList) {
+		if (!details.results || details.results.length === 0) continue;
+		details.results.forEach((result, index) => {
+			const isLast = index === details.results.length - 1;
+			lines.push(...renderAgentResult(result, isLast, expanded, theme));
+		});
+	}
+	return lines;
+}
+
+subprocessToolRegistry.register<TaskToolDetails>("task", {
+	extractData: event => {
+		const details = event.result?.details;
+		return isTaskToolDetails(details) ? details : undefined;
+	},
+	renderFinal: (allData, theme, expanded) => {
+		const lines = renderNestedTaskResults(allData, expanded, theme);
+		return new Text(lines.join("\n"), 0, 0);
+	},
+});
+
 export const taskToolRenderer = {
 	renderCall,
 	renderResult,

package/src/task/template.ts

@@ -1,47 +1,30 @@
+import { renderPromptTemplate } from "../config/prompt-templates";
+import subagentUserPromptTemplate from "../prompts/system/subagent-user-prompt.md" with { type: "text" };
 import type { TaskItem } from "./types";
 
-type RenderResult = {
+interface RenderResult {
+	/** Full task text sent to the subagent */
 	task: string;
-	args: Record<string, string>;
 	id: string;
 	description: string;
 	skills?: string[];
-};
-
-export function renderTemplate(template: string, task: TaskItem): RenderResult {
-	const { id, description, args, skills } = task;
-
-	let usedPlaceholder = false;
-	const unknownArguments: string[] = [];
-	let renderedTask = template.replace(/\{\{(\w+)\}\}/g, (_match, key: string) => {
-		const value = args?.[key];
-		if (value) {
-			usedPlaceholder = true;
-			return value;
-		}
-		switch (key) {
-			case "id":
-				usedPlaceholder = true;
-				return id;
-			case "description":
-				usedPlaceholder = true;
-				return description;
-			default:
-				unknownArguments.push(key);
-				return `{{${key}}}`;
-		}
-	});
+}
 
-	if (unknownArguments.length > 0) {
-		throw new Error(`Task "${id}" has unknown arguments: ${unknownArguments.join(", ")}`);
-	}
+/**
+ * Build the full task text from shared context and per-task assignment.
+ *
+ * If context is provided, it is prepended with a separator.
+ */
+export function renderTemplate(context: string | undefined, task: TaskItem): RenderResult {
+	let { id, description, assignment, skills } = task;
+	assignment = assignment.trim();
+	context = context?.trim();
 
-	if (!usedPlaceholder) {
-		renderedTask += `\n----------------------\n# ${id}\n${description}`;
+	if (!context || !assignment) {
+		return { task: assignment || context!, id, description, skills };
 	}
 	return {
-		task: renderedTask,
-		args: { id, description, ...args },
+		task: renderPromptTemplate(subagentUserPromptTemplate, { context, assignment }),
 		id,
 		description,
 		skills,

package/src/task/types.ts

@@ -33,36 +33,65 @@ export const TASK_SUBAGENT_PROGRESS_CHANNEL = "task:subagent:progress";
 /** Single task item for parallel execution */
 export const taskItemSchema = Type.Object({
 	id: Type.String({
-		description: "Task ID, CamelCase, max 32 chars",
+		description: "CamelCase identifier, max 32 chars",
 		maxLength: 32,
 	}),
-	description: Type.String({ description: "Short description for display" }),
-	args: Type.Optional(
-		Type.Record(Type.String(), Type.String(), {
-			description: "Arguments to fill {{placeholders}} in context",
-		}),
-	),
+	description: Type.String({
+		description: "Short one-liner for UI display only — not seen by the subagent",
+	}),
+	assignment: Type.String({
+		description:
+			"Complete per-task instructions the subagent executes. Must follow the Target/Change/Edge Cases/Acceptance structure. Only include per-task deltas — shared background belongs in `context`.",
+	}),
 	skills: Type.Optional(
 		Type.Array(Type.String(), {
-			description: "Skill names to preload into the subagent system prompt",
+			description: "Skill names to preload into the subagent. Use only where it changes correctness.",
 		}),
 	),
 });
-
 export type TaskItem = Static<typeof taskItemSchema>;
 
-/** Task tool parameters */
-export const taskSchema = Type.Object({
-	agent: Type.String({ description: "Agent type for all tasks" }),
-	context: Type.String({ description: "Template with {{placeholders}} for args" }),
-	isolated: Type.Optional(Type.Boolean({ description: "Run in isolated git worktree" })),
-	schema: Type.Optional(
-		Type.Record(Type.String(), Type.Unknown(), { description: "JTD schema defining expected response structure" }),
-	),
-	tasks: Type.Array(taskItemSchema, { description: "Tasks to run in parallel" }),
-});
+const createTaskSchema = (options: { isolationEnabled: boolean }) => {
+	const properties = {
+		agent: Type.String({ description: "Agent type for all tasks in this batch" }),
+		context: Type.Optional(
+			Type.String({
+				description:
+					"Shared background prepended to every task's assignment. Put goal, non-goals, constraints, conventions, reference paths, API contracts, and global acceptance commands here once — instead of duplicating across assignments.",
+			}),
+		),
+		schema: Type.Optional(
+			Type.Record(Type.String(), Type.Unknown(), {
+				description:
+					"JTD schema defining expected response structure. Use typed properties. Output format belongs here — never in context or assignment.",
+			}),
+		),
+		tasks: Type.Array(taskItemSchema, {
+			description:
+				"Tasks to execute in parallel. Each must be small-scoped (3-5 files max) and self-contained given context + assignment.",
+		}),
+	};
+
+	if (options.isolationEnabled) {
+		return Type.Object({
+			...properties,
+			isolated: Type.Optional(
+				Type.Boolean({
+					description: "Run in isolated git worktree; returns patches. Use when tasks edit overlapping files.",
+				}),
+			),
+		});
+	}
+
+	return Type.Object(properties);
+};
+
+export const taskSchema = createTaskSchema({ isolationEnabled: true });
+export const taskSchemaNoIsolation = createTaskSchema({ isolationEnabled: false });
+
+export type TaskSchema = typeof taskSchema | typeof taskSchemaNoIsolation;
 
-export type TaskParams = Static<typeof taskSchema>;
+export type TaskParams = Static<TaskSchema>;
 
 /** A code review finding reported by the reviewer agent */
 export interface ReviewFinding {
@@ -110,7 +139,6 @@ export interface AgentProgress {
 	agentSource: AgentSource;
 	status: "pending" | "running" | "completed" | "failed" | "aborted";
 	task: string;
-	args?: Record<string, string>;
 	description?: string;
 	currentTool?: string;
 	currentToolArgs?: string;
@@ -132,7 +160,6 @@ export interface SingleResult {
 	agent: string;
 	agentSource: AgentSource;
 	task: string;
-	args?: Record<string, string>;
 	description?: string;
 	exitCode: number;
 	output: string;

package/src/tools/ask.ts

@@ -254,10 +254,8 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 	public readonly label = "Ask";
 	public readonly description: string;
 	public readonly parameters = askSchema;
-	private readonly session: ToolSession;
 
-	constructor(session: ToolSession) {
-		this.session = session;
+	constructor(private readonly session: ToolSession) {
 		this.description = renderPromptTemplate(askDescription);
 	}
 

package/src/tools/bash.ts

@@ -49,10 +49,7 @@ export class BashTool implements AgentTool<typeof bashSchema, BashToolDetails> {
 	public readonly parameters = bashSchema;
 	public readonly concurrency = "exclusive";
 
-	private readonly session: ToolSession;
-
-	constructor(session: ToolSession) {
-		this.session = session;
+	constructor(private readonly session: ToolSession) {
 		this.description = renderPromptTemplate(bashDescription);
 	}
 

package/src/tools/browser.ts

@@ -257,7 +257,6 @@ export class BrowserTool implements AgentTool<typeof browserSchema, BrowserToolD
 	public readonly label = "Puppeteer";
 	public readonly description: string;
 	public readonly parameters = browserSchema;
-	private readonly session: ToolSession;
 	private browser: Browser | null = null;
 	private page: Page | null = null;
 	private currentHeadless: boolean | null = null;
@@ -267,8 +266,7 @@ export class BrowserTool implements AgentTool<typeof browserSchema, BrowserToolD
 	private readonly elementCache = new Map<number, ElementHandle>();
 	private readonly patchedClients = new WeakSet<object>();
 
-	constructor(session: ToolSession) {
-		this.session = session;
+	constructor(private readonly session: ToolSession) {
 		this.description = renderPromptTemplate(browserDescription, {});
 	}
 
@@ -1033,10 +1031,10 @@ export class BrowserTool implements AgentTool<typeof browserSchema, BrowserToolD
 					const html = (await untilAborted(signal, () => page.content())) as string;
 					const url = page.url();
 					const virtualConsole = new VirtualConsole();
-					virtualConsole.on("jsdomError", error => {
-						if (error?.message?.includes("Could not parse CSS stylesheet")) return;
+					virtualConsole.on("jsdomError", err => {
+						if (err?.message?.includes("Could not parse CSS stylesheet")) return;
 						logger.debug("JSDOM error during readable extraction", {
-							error: error instanceof Error ? error.message : String(error),
+							error: err instanceof Error ? err.message : String(err),
 						});
 					});
 					const dom = new JSDOM(html, { url, virtualConsole });
@@ -1094,7 +1092,7 @@ export class BrowserTool implements AgentTool<typeof browserSchema, BrowserToolD
 					}
 
 					const mimeType = imageFormat === "png" ? "image/png" : "image/jpeg";
-					const base64 = buffer.toString("base64");
+					const base64 = buffer.toBase64();
 					let savedPath: string | undefined;
 					if (params.path) {
 						const resolved = resolveToCwd(params.path, this.session.cwd);