@narumitw/pi-subagents 0.49.2 → 0.51.0

package/src/timeout-checkpoint.ts

@@ -0,0 +1,305 @@
+import { redactPrivateText } from "./context.js";
+import { DEFAULT_MAX_CONTEXT_BYTES, truncateUtf8 } from "./limits.js";
+
+export const TIMEOUT_CHECKPOINT_VERSION = "pi-subagents:checkpoint:v1" as const;
+export const TURN_TERMINATION_VERSION = "pi-subagents:termination:v1" as const;
+
+const DEFAULT_CHECKPOINT_BYTES = 16 * 1024;
+const MAX_ITEMS = 10;
+const MAX_ITEM_BYTES = 2 * 1024;
+const MAX_PENDING_TOOLS = 50;
+const MUTATING_TOOLS = new Set(["bash", "edit", "write"]);
+const FILE_TOOLS = new Set(["edit", "write"]);
+
+export type TurnTerminationReason =
+	| "work_timeout"
+	| "idle_timeout"
+	| "turn_limit"
+	| "tool_call_limit"
+	| "orchestration_timeout";
+
+export interface CompletedToolEvidence {
+	toolName: string;
+	output: string;
+	isError: boolean;
+}
+
+export interface TimeoutCheckpoint {
+	version: typeof TIMEOUT_CHECKPOINT_VERSION;
+	task: string;
+	partialOutput?: string;
+	assistantNotes: string[];
+	completedTools: CompletedToolEvidence[];
+	changedFiles: string[];
+	sideEffectsMayHaveOccurred: boolean;
+	truncated: boolean;
+}
+
+export interface TurnFinalizationReport {
+	attempted: boolean;
+	status: "completed" | "failed" | "timed_out" | "skipped";
+	durationMs: number;
+	error?: string;
+}
+
+export interface TurnTerminationReport {
+	version: typeof TURN_TERMINATION_VERSION;
+	reason: TurnTerminationReason;
+	limit: number;
+	checkpoint: TimeoutCheckpoint;
+	finalization: TurnFinalizationReport;
+}
+
+export interface TimeoutProgressJournalOptions {
+	maxBytes?: number;
+}
+
+interface PendingToolCall {
+	name: string;
+	path?: string;
+}
+
+export class TimeoutProgressJournal {
+	private readonly assistantNotes: string[] = [];
+	private readonly completedTools: CompletedToolEvidence[] = [];
+	private readonly changedFiles = new Set<string>();
+	private readonly pendingTools = new Map<string, PendingToolCall>();
+	private readonly maxBytes: number;
+	private sideEffectsMayHaveOccurred = false;
+	private truncated = false;
+
+	constructor(options: TimeoutProgressJournalOptions = {}) {
+		const requested = options.maxBytes ?? DEFAULT_CHECKPOINT_BYTES;
+		if (
+			!Number.isSafeInteger(requested) ||
+			requested < 512 ||
+			requested > DEFAULT_MAX_CONTEXT_BYTES
+		) {
+			throw new Error(
+				`Timeout checkpoint limit must be an integer between 512 and ${DEFAULT_MAX_CONTEXT_BYTES}`,
+			);
+		}
+		this.maxBytes = requested;
+	}
+
+	recordAssistantText(text: string): void {
+		const bounded = boundedPrivate(text, MAX_ITEM_BYTES);
+		if (!bounded) return;
+		this.assistantNotes.push(bounded);
+		this.trimItems(this.assistantNotes);
+	}
+
+	recordToolCall(id: string, name: string, args: Record<string, unknown> = {}): void {
+		const toolName = boundedPrivate(name, 256);
+		if (!toolName) return;
+		const path = toolPath(args);
+		this.pendingTools.set(id, { name: toolName, path });
+		while (this.pendingTools.size > MAX_PENDING_TOOLS) {
+			const oldest = this.pendingTools.keys().next().value;
+			if (typeof oldest !== "string") break;
+			this.pendingTools.delete(oldest);
+			this.truncated = true;
+		}
+		if (MUTATING_TOOLS.has(toolName)) this.sideEffectsMayHaveOccurred = true;
+	}
+
+	recordToolResult(
+		id: string,
+		name: string,
+		result: { content?: unknown; isError?: unknown },
+	): void {
+		const pending = this.pendingTools.get(id);
+		this.pendingTools.delete(id);
+		const toolName = boundedPrivate(pending?.name || name, 256);
+		if (!toolName) return;
+		if (pending?.path && FILE_TOOLS.has(toolName)) this.changedFiles.add(pending.path);
+		const output = boundedPrivate(textContent(result.content), MAX_ITEM_BYTES);
+		this.completedTools.push({
+			toolName,
+			output: output || "(no text output)",
+			isError: result.isError === true,
+		});
+		this.trimItems(this.completedTools);
+	}
+
+	checkpoint(task: string, partialOutput?: string): TimeoutCheckpoint {
+		const checkpoint: TimeoutCheckpoint = {
+			version: TIMEOUT_CHECKPOINT_VERSION,
+			task: boundedPrivate(task, 4 * 1024),
+			partialOutput: partialOutput ? boundedPrivate(partialOutput, 4 * 1024) : undefined,
+			assistantNotes: [...this.assistantNotes],
+			completedTools: this.completedTools.map((item) => ({ ...item })),
+			changedFiles: [...this.changedFiles].slice(-MAX_ITEMS),
+			sideEffectsMayHaveOccurred: this.sideEffectsMayHaveOccurred,
+			truncated: this.truncated || this.changedFiles.size > MAX_ITEMS,
+		};
+		return fitCheckpoint(checkpoint, this.maxBytes);
+	}
+
+	private trimItems(items: unknown[]): void {
+		if (items.length <= MAX_ITEMS) return;
+		items.splice(0, items.length - MAX_ITEMS);
+		this.truncated = true;
+	}
+}
+
+export function formatTurnTerminationMessage(
+	reason: TurnTerminationReason,
+	limit: number,
+	prefix = "Subagent",
+): string {
+	switch (reason) {
+		case "work_timeout":
+			return `${prefix} timed out after ${limit}ms`;
+		case "orchestration_timeout":
+			return `${prefix} orchestration deadline expired after ${limit}ms`;
+		case "idle_timeout":
+			return `${prefix} made no completed progress for ${limit}ms`;
+		case "turn_limit":
+			return `${prefix} reached the ${limit}-turn limit before producing a final answer`;
+		case "tool_call_limit":
+			return `${prefix} exceeded the ${limit}-tool-call limit`;
+	}
+}
+
+export function copyTurnTerminationReport(report: TurnTerminationReport): TurnTerminationReport {
+	return {
+		...report,
+		checkpoint: {
+			...report.checkpoint,
+			assistantNotes: [...report.checkpoint.assistantNotes],
+			completedTools: report.checkpoint.completedTools.map((item) => ({ ...item })),
+			changedFiles: [...report.checkpoint.changedFiles],
+		},
+		finalization: { ...report.finalization },
+	};
+}
+
+export function formatTimeoutCheckpoint(checkpoint: TimeoutCheckpoint): string {
+	const sections = [
+		checkpoint.partialOutput ? `Partial output:\n${checkpoint.partialOutput}` : undefined,
+		checkpoint.assistantNotes.length > 0
+			? `Assistant checkpoints:\n${checkpoint.assistantNotes.map((note) => `- ${note}`).join("\n")}`
+			: undefined,
+		checkpoint.completedTools.length > 0
+			? `Completed tool evidence:\n${checkpoint.completedTools
+					.map((item) => `- ${item.toolName}${item.isError ? " (error)" : ""}: ${item.output}`)
+					.join("\n")}`
+			: undefined,
+		checkpoint.changedFiles.length > 0
+			? `Changed files: ${checkpoint.changedFiles.join(", ")}`
+			: undefined,
+		checkpoint.sideEffectsMayHaveOccurred
+			? "Side effects may have occurred before termination."
+			: undefined,
+		checkpoint.truncated ? "Checkpoint evidence was truncated." : undefined,
+	].filter((value): value is string => Boolean(value));
+	return truncateUtf8(
+		sections.join("\n\n") || "No completed evidence was captured.",
+		DEFAULT_MAX_CONTEXT_BYTES,
+	).text;
+}
+
+export function journalMessages(
+	journal: TimeoutProgressJournal,
+	messages: readonly unknown[],
+): void {
+	for (const message of messages) {
+		if (!message || typeof message !== "object" || Array.isArray(message)) continue;
+		const value = message as Record<string, unknown>;
+		if (value.role === "assistant" && Array.isArray(value.content)) {
+			for (const part of value.content) {
+				if (!part || typeof part !== "object" || Array.isArray(part)) continue;
+				const item = part as Record<string, unknown>;
+				if (item.type === "text" && typeof item.text === "string") {
+					journal.recordAssistantText(item.text);
+				} else if (
+					item.type === "toolCall" &&
+					typeof item.id === "string" &&
+					typeof item.name === "string"
+				) {
+					journal.recordToolCall(
+						item.id,
+						item.name,
+						isRecord(item.arguments) ? item.arguments : {},
+					);
+				}
+			}
+		} else if (value.role === "toolResult") {
+			journal.recordToolResult(
+				typeof value.toolCallId === "string" ? value.toolCallId : "",
+				typeof value.toolName === "string" ? value.toolName : "tool",
+				{ content: value.content, isError: value.isError },
+			);
+		}
+	}
+}
+
+function fitCheckpoint(checkpoint: TimeoutCheckpoint, maxBytes: number): TimeoutCheckpoint {
+	const copy: TimeoutCheckpoint = {
+		...checkpoint,
+		assistantNotes: [...checkpoint.assistantNotes],
+		completedTools: checkpoint.completedTools.map((item) => ({ ...item })),
+		changedFiles: [...checkpoint.changedFiles],
+	};
+	while (serializedBytes(copy) > maxBytes) {
+		copy.truncated = true;
+		if (copy.assistantNotes.length > 0) copy.assistantNotes.shift();
+		else if (copy.completedTools.length > 0) copy.completedTools.shift();
+		else if (copy.changedFiles.length > 0) copy.changedFiles.shift();
+		else if (copy.partialOutput) {
+			copy.partialOutput =
+				shrinkCheckpointText(copy.partialOutput, Math.floor(maxBytes / 4), 128) || undefined;
+		} else if (copy.task) {
+			copy.task = shrinkCheckpointText(copy.task, Math.floor(maxBytes / 8), 64);
+		} else break;
+	}
+	return copy;
+}
+
+function shrinkCheckpointText(
+	value: string,
+	preferredMaxBytes: number,
+	minimumBytes: number,
+): string {
+	const currentBytes = Buffer.byteLength(value, "utf8");
+	if (currentBytes <= minimumBytes) return "";
+	const nextMaxBytes = Math.min(
+		currentBytes - 1,
+		preferredMaxBytes,
+		Math.max(minimumBytes, Math.floor(currentBytes / 2)),
+	);
+	return truncateUtf8(value, nextMaxBytes).text;
+}
+
+function serializedBytes(value: unknown): number {
+	return Buffer.byteLength(JSON.stringify(value), "utf8");
+}
+
+function boundedPrivate(value: string, maxBytes: number): string {
+	return truncateUtf8(redactPrivateText(value).trim(), maxBytes).text;
+}
+
+function textContent(value: unknown): string {
+	if (typeof value === "string") return value;
+	if (!Array.isArray(value)) return "";
+	return value
+		.flatMap((part) => {
+			if (!part || typeof part !== "object" || Array.isArray(part)) return [];
+			const item = part as Record<string, unknown>;
+			return item.type === "text" && typeof item.text === "string" ? [item.text] : [];
+		})
+		.join("\n");
+}
+
+function toolPath(args: Record<string, unknown>): string | undefined {
+	for (const key of ["path", "file_path"]) {
+		const value = args[key];
+		if (typeof value === "string" && value.trim()) return boundedPrivate(value, 1024);
+	}
+	return undefined;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}

package/src/timeout-finalization.ts

@@ -0,0 +1,75 @@
+import { redactPrivateText } from "./context.js";
+import { DEFAULT_MAX_CONTEXT_BYTES, truncateUtf8 } from "./limits.js";
+import { appendResultInstruction, type SubagentResultFormat } from "./result-contract.js";
+import type { RecentActivityItem } from "./runner.js";
+import {
+	formatTimeoutCheckpoint,
+	type TimeoutCheckpoint,
+	type TurnTerminationReason,
+} from "./timeout-checkpoint.js";
+
+export const DEFAULT_TIMEOUT_FINALIZATION_MS = 45_000;
+
+export interface TimeoutFinalizationEvidence {
+	task: string;
+	partialOutput?: string;
+	recentActivity?: readonly RecentActivityItem[];
+	checkpoint?: TimeoutCheckpoint;
+	terminationReason?: TurnTerminationReason;
+	resultFormat?: SubagentResultFormat;
+}
+
+export function resolveTimeoutFinalizationMs(workTimeoutMs: number, override?: number): number {
+	const requested = override ?? Math.min(workTimeoutMs, DEFAULT_TIMEOUT_FINALIZATION_MS);
+	if (!Number.isFinite(requested) || requested < 1) {
+		throw new Error("Timeout finalization deadline must be a positive finite number");
+	}
+	return Math.min(Math.floor(requested), DEFAULT_TIMEOUT_FINALIZATION_MS);
+}
+
+export function buildTimeoutFinalizationPrompt(
+	evidence: TimeoutFinalizationEvidence,
+	maxBytes = DEFAULT_MAX_CONTEXT_BYTES,
+): string {
+	const activity = (evidence.recentActivity ?? [])
+		.slice(-10)
+		.map((item) =>
+			item.type === "text"
+				? `- Assistant note: ${redactPrivateText(item.text)}`
+				: `- Tool activity: ${redactPrivateText(item.name)}`,
+		)
+		.join("\n");
+	const prompt = [
+		terminationHeading(evidence.terminationReason),
+		"Do not continue investigating, call tools, modify files, or retry the original task.",
+		"Return a concise summary of only verified findings and completed evidence already available.",
+		"Explicitly label unfinished or unverified areas.",
+		`Original task:\n${redactPrivateText(evidence.task)}`,
+		evidence.partialOutput
+			? `Partial assistant output:\n${redactPrivateText(evidence.partialOutput)}`
+			: "Partial assistant output: (none)",
+		evidence.checkpoint
+			? `Deterministic progress checkpoint:\n${formatTimeoutCheckpoint(evidence.checkpoint)}`
+			: undefined,
+		activity ? `Recent bounded activity:\n${activity}` : "Recent bounded activity: (none)",
+	]
+		.filter((value): value is string => Boolean(value))
+		.join("\n\n");
+	return truncateUtf8(appendResultInstruction(prompt, evidence.resultFormat, maxBytes), maxBytes)
+		.text;
+}
+
+function terminationHeading(reason: TurnTerminationReason | undefined): string {
+	switch (reason) {
+		case "idle_timeout":
+			return "The idle deadline expired and the active work was aborted.";
+		case "turn_limit":
+			return "The assistant-turn budget was exhausted and the active work was aborted.";
+		case "tool_call_limit":
+			return "The tool-call budget was exhausted and the active work was aborted.";
+		case "orchestration_timeout":
+			return "The orchestration deadline expired and the active work was aborted.";
+		default:
+			return "Work deadline expired and the active work was aborted.";
+	}
+}

package/src/transport-types.ts

@@ -0,0 +1,68 @@
+import type { SubagentThinkingLevel } from "./agents.js";
+
+export const PI_SUBAGENTS_RPC_PROTOCOL = "pi-subagents:v1" as const;
+
+export type EffectiveSubagentTransportKind = "subprocess" | "in-process" | "rpc";
+
+export type TransportProgressPhase =
+	| "queued"
+	| "starting"
+	| "ready"
+	| "accepted"
+	| "running"
+	| "finalizing"
+	| "retrying"
+	| "compacting"
+	| "settled"
+	| "failed"
+	| "interrupted";
+
+export interface TransportUsage {
+	input: number;
+	output: number;
+	cacheRead: number;
+	cacheWrite: number;
+	totalTokens: number;
+	cost: number;
+	turns: number;
+}
+
+export interface TransportTiming {
+	queuedAt?: number;
+	startedAt?: number;
+	transportStartedAt?: number;
+	readyAt?: number;
+	promptAcceptedAt?: number;
+	firstActivityAt?: number;
+	settledAt?: number;
+	completionDeliveredAt?: number;
+}
+
+export interface TransportTelemetry {
+	transport?: EffectiveSubagentTransportKind;
+	selectionReason?: string;
+	protocol?: typeof PI_SUBAGENTS_RPC_PROTOCOL;
+	phase: TransportProgressPhase;
+	queuePosition?: number;
+	updatedAt: number;
+	timing: TransportTiming;
+	provider?: string;
+	model?: string;
+	thinkingLevel?: SubagentThinkingLevel;
+	usage?: TransportUsage;
+	failurePhase?: TransportProgressPhase;
+}
+
+export type TransportProgressCallback = (progress: TransportTelemetry) => void;
+
+export function emptyTransportUsage(): TransportUsage {
+	return {
+		input: 0,
+		output: 0,
+		cacheRead: 0,
+		cacheWrite: 0,
+		totalTokens: 0,
+		cost: 0,
+		turns: 0,
+	};
+}

package/src/transport-ui.ts

@@ -0,0 +1,169 @@
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import type { SubagentTransportKind } from "./agents.js";
+import { safeTerminalLine as safeTerminalText } from "./safe-text.js";
+import { inspectStatefulTransportSettings, updateStatefulTransportSetting } from "./settings.js";
+import type { StatefulSubagentRuntimeStatus } from "./stateful.js";
+
+const TRANSPORT_OPTIONS: Array<{
+	value: SubagentTransportKind;
+	label: string;
+	description: string;
+}> = [
+	{
+		value: "subprocess",
+		label: "Fresh subprocess",
+		description: "Compatibility path with a fresh isolated Pi process for every turn.",
+	},
+	{
+		value: "in-process",
+		label: "In process",
+		description:
+			"Lowest follow-up overhead for built-in tools, with shared memory and crash boundary.",
+	},
+	{
+		value: "rpc",
+		label: "Persistent RPC process",
+		description: "Retain native history in one isolated Pi process per active retained agent.",
+	},
+	{
+		value: "auto",
+		label: "Automatic",
+		description:
+			"Read-only built-ins use in-process, write-capable built-ins use RPC, and custom tools use subprocess.",
+	},
+];
+
+export interface TransportUiRuntime {
+	getRuntimeStatus(): StatefulSubagentRuntimeStatus;
+}
+
+export function transportSettingsScreen(runtime: TransportUiRuntime) {
+	const configured = inspectStatefulTransportSettings();
+	const current = runtime.getRuntimeStatus();
+	return {
+		kind: "actions" as const,
+		title: configured.error ? "Detached Transport · Read only" : "Detached Transport",
+		lines: [
+			`Current session: ${transportLabel(current.transport)}`,
+			`Configured after reload: ${transportLabel(configured.value)} (${configured.source})`,
+			"Transport isolation is not a filesystem or network sandbox.",
+			"RPC v1 disables child extensions and supports built-in Pi tools only.",
+			...(configured.error
+				? [
+						`Settings cannot be edited: ${safeTerminalText(configured.error)}`,
+						`Repair ${safeTerminalText(configured.path)} and retry.`,
+					]
+				: []),
+		],
+		items: [
+			...(configured.error
+				? []
+				: TRANSPORT_OPTIONS.map((option) => ({
+						id: option.value,
+						label: option.label,
+						description: option.description,
+						action: "set-transport" as const,
+					}))),
+			{ id: "back", label: "Back", action: "back" as const },
+		],
+		hint: "back" as const,
+	};
+}
+
+export async function applyTransportSetting(
+	value: string,
+	ctx: ExtensionCommandContext,
+	runtime: TransportUiRuntime,
+	signal: AbortSignal,
+	isCurrent: () => boolean,
+) {
+	if (!isTransport(value)) return { kind: "rejected" as const };
+	const before = inspectStatefulTransportSettings();
+	if (before.error) return { kind: "rejected" as const };
+	if (value === before.value) return { kind: "stay" as const };
+	const status = runtime.getRuntimeStatus();
+	if (status.retainedAgents > 0) {
+		ctx.ui.notify(
+			`Cannot change transport while ${status.retainedAgents} detached agent${status.retainedAgents === 1 ? " is" : "s are"} retained. Clear Current agents first.`,
+			"warning",
+		);
+		return { kind: "rejected" as const };
+	}
+	const option = TRANSPORT_OPTIONS.find((candidate) => candidate.value === value);
+	const confirmed = await ctx.ui.confirm(
+		`Use ${transportLabel(value)} after reload?`,
+		`${option?.description ?? ""}\n\nThis saves the setting but does not reload Pi automatically.`,
+		{ signal },
+	);
+	if (signal.aborted || !isCurrent()) return { kind: "close" as const };
+	if (!confirmed) return { kind: "rejected" as const };
+	const after = inspectStatefulTransportSettings();
+	if (after.error || after.value !== before.value || after.source !== before.source) {
+		ctx.ui.notify("Transport settings changed while confirming; review again.", "warning");
+		return { kind: "rejected" as const };
+	}
+	if (runtime.getRuntimeStatus().retainedAgents > 0) {
+		ctx.ui.notify(
+			"Detached agents appeared while confirming; clear them before changing transport.",
+			"warning",
+		);
+		return { kind: "rejected" as const };
+	}
+	try {
+		updateStatefulTransportSetting(value);
+		ctx.ui.notify(`Saved ${transportLabel(value)}. Run /reload when ready.`, "info");
+		return { kind: "stay" as const };
+	} catch (error) {
+		ctx.ui.notify(
+			`Transport was not saved; the previous setting remains: ${safeTerminalText(error instanceof Error ? error.message : String(error))}`,
+			"error",
+		);
+		return { kind: "rejected" as const };
+	}
+}
+
+export function responsivenessSetupScreen(runtime: TransportUiRuntime) {
+	const current = runtime.getRuntimeStatus();
+	const configured = inspectStatefulTransportSettings();
+	return {
+		kind: "actions" as const,
+		title: "Responsiveness Setup",
+		lines: [
+			`Current transport: ${transportLabel(current.transport)}`,
+			`Configured transport: ${transportLabel(configured.value)}`,
+			"Transport, completion delivery, and thinking defaults are separate explicit choices.",
+			"Use Automatic to reduce retained follow-up startup while keeping custom-tool compatibility.",
+		],
+		items: [
+			{
+				id: "auto",
+				label: "Preview Automatic transport",
+				description: "Choose a deterministic transport before each retained agent starts",
+				action: "set-transport" as const,
+			},
+			{ id: "transport", label: "Compare all transports", to: "transport" as const },
+			{
+				id: "completion",
+				label: "Completion delivery",
+				description: "Choose separately whether an idle root resumes for synthesis",
+				to: "settings" as const,
+			},
+			{
+				id: "thinking",
+				label: "Thinking profiles",
+				description: "Preview explicit Fast, Balanced, or Deep per-agent defaults",
+				to: "execution-profiles" as const,
+			},
+			{ id: "back", label: "Back", action: "back" as const },
+		],
+		hint: "back" as const,
+	};
+}
+
+export function transportLabel(value: SubagentTransportKind): string {
+	return TRANSPORT_OPTIONS.find((option) => option.value === value)?.label ?? value;
+}
+
+function isTransport(value: string): value is SubagentTransportKind {
+	return ["subprocess", "in-process", "rpc", "auto"].includes(value);
+}

package/src/transport.ts

@@ -1,8 +1,14 @@
 import type { ManagedAgent, TurnOutcome } from "./registry.js";
+import type { TransportProgressCallback } from "./transport-types.js";
 
 export interface SubagentTransport {
-	readonly kind: "subprocess" | "in-process" | "fake";
-	runTurn(agent: ManagedAgent, task: string, signal: AbortSignal): Promise<TurnOutcome>;
+	readonly kind: "subprocess" | "in-process" | "rpc" | "auto" | "fake";
+	runTurn(
+		agent: ManagedAgent,
+		task: string,
+		signal: AbortSignal,
+		onProgress?: TransportProgressCallback,
+	): Promise<TurnOutcome>;
 	release?(agent: ManagedAgent): Promise<void>;
 	shutdown?(): Promise<void>;
 }
@@ -11,6 +17,7 @@ export type AgentTurnRunner = (
 	agent: ManagedAgent,
 	task: string,
 	signal: AbortSignal,
+	onProgress?: TransportProgressCallback,
 ) => Promise<TurnOutcome>;
 
 export class FunctionTransport implements SubagentTransport {
@@ -18,8 +25,13 @@ export class FunctionTransport implements SubagentTransport {
 
 	constructor(private readonly runner: AgentTurnRunner) {}
 
-	runTurn(agent: ManagedAgent, task: string, signal: AbortSignal): Promise<TurnOutcome> {
-		return this.runner(agent, task, signal);
+	runTurn(
+		agent: ManagedAgent,
+		task: string,
+		signal: AbortSignal,
+		onProgress?: TransportProgressCallback,
+	): Promise<TurnOutcome> {
+		return this.runner(agent, task, signal, onProgress);
 	}
 }