@xopcai/xopc 0.0.222 → 0.0.224

package/dist/src/agent/orchestration/agent-run-supervisor.js

@@ -0,0 +1,49 @@
+//#region src/agent/orchestration/agent-run-supervisor.ts
+/** Minimal run-level coordination: root cancellation and per-attempt deadline planning. */
+var AgentRunSupervisor = class {
+	deadlineAtMs;
+	signal;
+	controller = new AbortController();
+	timeout;
+	forwardParentAbort;
+	timeoutMs;
+	minimumFallbackMs;
+	parentSignal;
+	constructor(options) {
+		this.timeoutMs = options.timeoutMs;
+		this.minimumFallbackMs = options.minimumFallbackMs ?? 5e3;
+		this.deadlineAtMs = options.deadlineAtMs ?? Date.now() + options.timeoutMs;
+		this.parentSignal = options.parentSignal;
+		this.signal = this.controller.signal;
+		this.forwardParentAbort = () => this.controller.abort(this.parentSignal?.reason);
+		if (this.parentSignal?.aborted) this.forwardParentAbort();
+		else this.parentSignal?.addEventListener("abort", this.forwardParentAbort, { once: true });
+		this.timeout = setTimeout(() => this.controller.abort(/* @__PURE__ */ new Error("Agent run deadline expired")), Math.max(0, this.deadlineAtMs - Date.now()));
+	}
+	planModelAttempt(isFallback) {
+		if (this.signal.aborted) return {
+			ok: false,
+			reason: "Agent run aborted"
+		};
+		const remainingMs = this.deadlineAtMs - Date.now();
+		if (remainingMs <= 0) return {
+			ok: false,
+			reason: "Agent run deadline expired before the next model attempt"
+		};
+		if (isFallback && remainingMs < this.minimumFallbackMs) return {
+			ok: false,
+			reason: "Agent run deadline left too little time for a fallback model attempt"
+		};
+		return {
+			ok: true,
+			remainingMs,
+			timeoutMs: Math.max(1, Math.min(this.timeoutMs, remainingMs))
+		};
+	}
+	dispose() {
+		clearTimeout(this.timeout);
+		this.parentSignal?.removeEventListener("abort", this.forwardParentAbort);
+	}
+};
+//#endregion
+export { AgentRunSupervisor };

package/dist/src/agent/orchestration/agent-turn-policy.d.ts

@@ -0,0 +1,18 @@
+import type { AfterToolCallContext, BeforeToolCallContext, BeforeToolCallResult, ShouldStopAfterTurnContext } from '@earendil-works/pi-agent-core';
+export interface AgentTurnPolicy {
+    reset(): void;
+    beforeToolCall(context: BeforeToolCallContext, signal?: AbortSignal): Promise<BeforeToolCallResult | undefined>;
+    afterToolCall(context: AfterToolCallContext): Promise<undefined>;
+    shouldStopAfterTurn(context: ShouldStopAfterTurnContext): boolean;
+}
+export interface AgentTurnPolicyOptions {
+    maxTurns?: number;
+    maxToolFailures?: number;
+    resolveToolLimit?: (toolName: string, args: unknown) => {
+        id: string;
+        maxCalls: number;
+    } | undefined;
+    authorizeToolCall?: (context: BeforeToolCallContext, signal?: AbortSignal) => Promise<BeforeToolCallResult | undefined>;
+}
+/** One user-visible run policy. A fresh instance is created for every embedded run. */
+export declare function createAgentTurnPolicy(options: AgentTurnPolicyOptions): AgentTurnPolicy;

package/dist/src/agent/orchestration/agent-turn-policy.js

@@ -0,0 +1,36 @@
+//#region src/agent/orchestration/agent-turn-policy.ts
+function assistantMessageCount(messages) {
+	return messages.filter((message) => message.role === "assistant").length;
+}
+/** One user-visible run policy. A fresh instance is created for every embedded run. */
+function createAgentTurnPolicy(options) {
+	const toolCalls = /* @__PURE__ */ new Map();
+	let toolFailures = 0;
+	return {
+		reset() {
+			toolCalls.clear();
+			toolFailures = 0;
+		},
+		async beforeToolCall(context, signal) {
+			const limit = options.resolveToolLimit?.(context.toolCall.name, context.args);
+			if (limit) {
+				const count = (toolCalls.get(limit.id) ?? 0) + 1;
+				toolCalls.set(limit.id, count);
+				if (count > limit.maxCalls) return {
+					block: true,
+					terminate: true,
+					reason: `${limit.id} exceeded its per-turn call limit.`
+				};
+			}
+			return options.authorizeToolCall?.(context, signal);
+		},
+		async afterToolCall(context) {
+			if (context.isError) toolFailures += 1;
+		},
+		shouldStopAfterTurn(context) {
+			return Boolean(options.maxTurns && assistantMessageCount(context.newMessages) >= options.maxTurns || options.maxToolFailures && toolFailures >= options.maxToolFailures);
+		}
+	};
+}
+//#endregion
+export { createAgentTurnPolicy };

package/dist/src/agent/orchestration/llm-turn-retry.d.ts

@@ -6,6 +6,8 @@
  */
 import type { Agent, AgentMessage } from '@earendil-works/pi-agent-core';
 export declare function isTransientLlmErrorMessage(message: string): boolean;
+export type LlmFailureKind = 'transient_network' | 'context_overflow' | 'aborted' | 'permanent';
+export declare function classifyLlmFailure(message: string): LlmFailureKind;
 export declare function getLastAssistantMessage(messages: AgentMessage[]): AgentMessage | undefined;
 /** Raw provider/LLM error from the last failed assistant message, if any. */
 export declare function getAssistantTurnErrorMessage(agent: Agent): string | undefined;
@@ -20,6 +22,9 @@ export declare function stripTrailingErrorAssistantMessages(messages: AgentMessa
 export interface RetryTransientTurnOptions {
     /** Extra turns after a failed assistant message (default 2). */
     maxContinues?: number;
+    /** Initial deterministic backoff. Each later retry doubles it. */
+    baseDelayMs?: number;
+    signal?: AbortSignal;
     sessionKey: string;
     log: {
         warn: (obj: Record<string, unknown>, msg: string) => void;

package/dist/src/agent/orchestration/llm-turn-retry.js

@@ -1,3 +1,4 @@
+import { isContextOverflowError } from "./context-overflow.js";
 //#region src/agent/orchestration/llm-turn-retry.ts
 const TRANSIENT_LLM_ERROR_SUBSTRINGS = [
 	"fetch failed",
@@ -16,6 +17,13 @@ function isTransientLlmErrorMessage(message) {
 	const lower = message.toLowerCase();
 	return TRANSIENT_LLM_ERROR_SUBSTRINGS.some((s) => lower.includes(s));
 }
+function classifyLlmFailure(message) {
+	const normalized = message.trim().toLowerCase();
+	if (normalized === "aborted" || normalized.includes("aborterror")) return "aborted";
+	if (isContextOverflowError(message)) return "context_overflow";
+	if (isTransientLlmErrorMessage(message)) return "transient_network";
+	return "permanent";
+}
 function getLastAssistantMessage(messages) {
 	for (let i = messages.length - 1; i >= 0; i--) if (messages[i].role === "assistant") return messages[i];
 }
@@ -56,32 +64,54 @@ function stripTrailingErrorAssistantMessages(messages) {
 	}
 	return out;
 }
+async function waitForRetryDelay(delayMs, signal) {
+	signal?.throwIfAborted();
+	if (delayMs <= 0) return;
+	await new Promise((resolve, reject) => {
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(signal?.reason ?? new DOMException("Aborted", "AbortError"));
+		};
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, delayMs);
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
 /**
 * After waitForIdle(), call this to optionally re-run the last user turn when the
 * assistant message only contains a transient provider/network error.
 */
 async function maybeRetryTurnAfterTransientLlmFailure(agent, options) {
 	const maxContinues = options.maxContinues ?? 2;
+	const baseDelayMs = Math.max(0, options.baseDelayMs ?? 300);
 	let continues = 0;
 	while (continues < maxContinues) {
 		const last = getLastAssistantMessage(agent.state.messages);
 		if (!last) return;
 		if (last.stopReason !== "error") return;
 		const errMsg = String(last.errorMessage || "");
-		if (!isTransientLlmErrorMessage(errMsg)) {
+		const failureKind = classifyLlmFailure(errMsg);
+		if (failureKind !== "transient_network") {
 			options.log.warn({
 				sessionKey: options.sessionKey,
-				errorMessage: errMsg
+				errorMessage: errMsg,
+				failureKind
 			}, "Assistant turn ended with error (not retrying as transient)");
 			return;
 		}
 		continues += 1;
+		const retryDelayMs = baseDelayMs * 2 ** (continues - 1);
 		options.log.warn({
 			sessionKey: options.sessionKey,
 			errorMessage: errMsg,
+			failureKind,
 			continueAttempt: continues,
-			maxContinues
+			maxContinues,
+			retryDelayMs
 		}, "LLM request failed with a transient network error; retrying the same turn. If this persists, check outbound HTTPS to the provider API and HTTP(S)_PROXY.");
+		await waitForRetryDelay(retryDelayMs, options.signal);
 		const trimmed = stripTrailingErrorAssistantMessages(agent.state.messages);
 		agent.state.messages = trimmed;
 		await agent.continue();
@@ -89,4 +119,4 @@ async function maybeRetryTurnAfterTransientLlmFailure(agent, options) {
 	}
 }
 //#endregion
-export { getAssistantTurnErrorMessage, getLastAssistantMessage, isAssistantTurnAborted, isAssistantTurnFailed, isTransientLlmErrorMessage, maybeRetryTurnAfterTransientLlmFailure, stripTrailingErrorAssistantMessages };
+export { classifyLlmFailure, getAssistantTurnErrorMessage, getLastAssistantMessage, isAssistantTurnAborted, isAssistantTurnFailed, isTransientLlmErrorMessage, maybeRetryTurnAfterTransientLlmFailure, stripTrailingErrorAssistantMessages };

package/dist/src/agent/orchestration/run-agent-turn-with-timeout.d.ts

@@ -10,6 +10,15 @@ export declare const MIN_AGENT_TURN_TIMEOUT_MS = 60000;
 export declare const MAX_AGENT_TURN_TIMEOUT_MS: number;
 /** Default per-turn timeout (30 minutes). */
 export declare const DEFAULT_AGENT_TURN_TIMEOUT_MS: number;
+export declare const DEFAULT_AGENT_ABORT_GRACE_MS = 5000;
+export declare class AgentTurnUnsettledError extends Error {
+    readonly timeoutMs: number;
+    readonly abortGraceMs: number;
+    constructor(timeoutMs: number, abortGraceMs: number);
+}
+export declare function isAgentTurnUnsettledError(err: unknown): err is AgentTurnUnsettledError;
 export declare function resolveAgentTurnTimeoutMs(config?: Config, sessionKey?: string): number;
 export declare function isAgentTurnTimeoutError(err: unknown): boolean;
-export declare function runAgentTurnWithTimeout(agent: Agent, runTurn: () => Promise<void>, timeoutMs: number): Promise<void>;
+export declare function runAgentTurnWithTimeout(agent: Agent, runTurn: () => Promise<void>, timeoutMs: number, options?: {
+    abortGraceMs?: number;
+}): Promise<void>;

package/dist/src/agent/orchestration/run-agent-turn-with-timeout.js

@@ -6,6 +6,18 @@ const MIN_AGENT_TURN_TIMEOUT_MS = 6e4;
 const MAX_AGENT_TURN_TIMEOUT_MS = 14400 * 1e3;
 /** Default per-turn timeout (30 minutes). */
 const DEFAULT_AGENT_TURN_TIMEOUT_MS = 1800 * 1e3;
+const DEFAULT_AGENT_ABORT_GRACE_MS = 5e3;
+var AgentTurnUnsettledError = class extends Error {
+	constructor(timeoutMs, abortGraceMs) {
+		super(`Agent turn timed out after ${timeoutMs / 1e3}s and did not settle within ${abortGraceMs / 1e3}s`);
+		this.timeoutMs = timeoutMs;
+		this.abortGraceMs = abortGraceMs;
+		this.name = "AgentTurnUnsettledError";
+	}
+};
+function isAgentTurnUnsettledError(err) {
+	return err instanceof AgentTurnUnsettledError;
+}
 function resolveAgentTurnTimeoutMs(config, sessionKey) {
 	if (!config) return DEFAULT_AGENT_TURN_TIMEOUT_MS;
 	const configured = resolveEffectiveAgentManifestForSession(config, sessionKey).runtime?.timeoutMs;
@@ -15,22 +27,31 @@ function resolveAgentTurnTimeoutMs(config, sessionKey) {
 function isAgentTurnTimeoutError(err) {
 	return err instanceof Error && err.message.startsWith("Agent turn timed out after");
 }
-async function runAgentTurnWithTimeout(agent, runTurn, timeoutMs) {
+async function runAgentTurnWithTimeout(agent, runTurn, timeoutMs, options = {}) {
 	let timeoutId;
 	const timeoutPromise = new Promise((_, reject) => {
 		timeoutId = setTimeout(() => reject(/* @__PURE__ */ new Error(`Agent turn timed out after ${timeoutMs / 1e3}s`)), timeoutMs);
 	});
+	const runTurnPromise = Promise.resolve().then(runTurn);
 	try {
-		await Promise.race([runTurn().finally(() => {
+		await Promise.race([runTurnPromise.finally(() => {
 			if (timeoutId !== void 0) clearTimeout(timeoutId);
 		}), timeoutPromise]);
 	} catch (err) {
 		if (isAgentTurnTimeoutError(err)) {
 			agent.abort();
-			await agent.waitForIdle();
+			const abortGraceMs = options.abortGraceMs ?? 5e3;
+			let graceTimer;
+			try {
+				await Promise.race([Promise.allSettled([runTurnPromise, agent.waitForIdle()]), new Promise((_, reject) => {
+					graceTimer = setTimeout(() => reject(new AgentTurnUnsettledError(timeoutMs, abortGraceMs)), abortGraceMs);
+				})]);
+			} finally {
+				if (graceTimer !== void 0) clearTimeout(graceTimer);
+			}
 		}
 		throw err;
 	}
 }
 //#endregion
-export { DEFAULT_AGENT_TURN_TIMEOUT_MS, MAX_AGENT_TURN_TIMEOUT_MS, MIN_AGENT_TURN_TIMEOUT_MS, isAgentTurnTimeoutError, resolveAgentTurnTimeoutMs, runAgentTurnWithTimeout };
+export { AgentTurnUnsettledError, DEFAULT_AGENT_ABORT_GRACE_MS, DEFAULT_AGENT_TURN_TIMEOUT_MS, MAX_AGENT_TURN_TIMEOUT_MS, MIN_AGENT_TURN_TIMEOUT_MS, isAgentTurnTimeoutError, isAgentTurnUnsettledError, resolveAgentTurnTimeoutMs, runAgentTurnWithTimeout };

package/dist/src/agent/service/async-queue.d.ts

@@ -3,15 +3,28 @@
  *
  * Replaces the ad-hoc `eventQueue + resolveWaiting` single-slot pattern that
  * the streaming direct turn used to manage run events. The previous pattern was
- * lossy if two pushes landed before the single waiter resumed; this queue keeps
- * the buffer growing until consumed, and closes cleanly so the iterator drains.
+ * lossy if two pushes landed before the single waiter resumed; this queue buffers
+ * until consumed, supports an explicit bound, and drains cleanly on close.
  */
+export interface AsyncQueueOptions<T> {
+    /** Maximum buffer size. Lossy events are evicted; critical-only overflow fails fast. */
+    maxBuffered?: number;
+    isDroppable?: (value: T) => boolean;
+}
+export declare class AsyncQueueOverflowError extends Error {
+    readonly maxBuffered: number;
+    constructor(maxBuffered: number);
+}
 export declare class AsyncQueue<T> implements AsyncIterable<T> {
+    private readonly options;
     private readonly buffer;
     private readonly waiters;
     private closed;
+    private dropped;
+    constructor(options?: AsyncQueueOptions<T>);
     /** Push a value to the queue. No-op when the queue is closed. */
-    push(value: T): void;
+    push(value: T): boolean;
+    get droppedCount(): number;
     /** Close the queue. Pending iterators drain any buffered values and then complete. */
     close(): void;
     /** True if the queue is closed and the internal buffer is drained. */

package/dist/src/agent/service/async-queue.js

@@ -1,25 +1,43 @@
 //#region src/agent/service/async-queue.ts
-/**
-* Async FIFO queue with `for await` support.
-*
-* Replaces the ad-hoc `eventQueue + resolveWaiting` single-slot pattern that
-* the streaming direct turn used to manage run events. The previous pattern was
-* lossy if two pushes landed before the single waiter resumed; this queue keeps
-* the buffer growing until consumed, and closes cleanly so the iterator drains.
-*/
+var AsyncQueueOverflowError = class extends Error {
+	constructor(maxBuffered) {
+		super(`Async queue exceeded its ${maxBuffered}-event buffer`);
+		this.maxBuffered = maxBuffered;
+		this.name = "AsyncQueueOverflowError";
+	}
+};
 var AsyncQueue = class {
 	buffer = [];
 	waiters = [];
 	closed = false;
+	dropped = 0;
+	constructor(options = {}) {
+		this.options = options;
+	}
 	/** Push a value to the queue. No-op when the queue is closed. */
 	push(value) {
-		if (this.closed) return;
+		if (this.closed) return false;
 		const waiter = this.waiters.shift();
 		if (waiter) {
 			waiter(value);
-			return;
+			return true;
+		}
+		const maxBuffered = this.options.maxBuffered;
+		if (maxBuffered && this.buffer.length >= maxBuffered) {
+			const droppableIndex = this.options.isDroppable ? this.buffer.findIndex(this.options.isDroppable) : -1;
+			if (droppableIndex >= 0) {
+				this.buffer.splice(droppableIndex, 1);
+				this.dropped += 1;
+			} else if (this.options.isDroppable?.(value)) {
+				this.dropped += 1;
+				return false;
+			} else throw new AsyncQueueOverflowError(maxBuffered);
 		}
 		this.buffer.push(value);
+		return true;
+	}
+	get droppedCount() {
+		return this.dropped;
 	}
 	/** Close the queue. Pending iterators drain any buffered values and then complete. */
 	close() {
@@ -48,4 +66,4 @@ var AsyncQueue = class {
 };
 const CLOSE_SENTINEL = Symbol("AsyncQueue.close");
 //#endregion
-export { AsyncQueue };
+export { AsyncQueue, AsyncQueueOverflowError };

package/dist/src/agent/service/process-direct-streaming.js

@@ -11,9 +11,16 @@ import { isVoiceLikeAttachment, mergeVoiceTranscriptsIntoUserText } from "../../
 import { applyReasoningVisibility } from "../streaming/reasoning-visibility.js";
 import { isSessionSourceBinding, summarizeSourceContext } from "../source-context/types.js";
 import { injectSourceContextsIntoUserMessage } from "../source-context/injector.js";
-import { AsyncQueue } from "./async-queue.js";
+import { AsyncQueue, AsyncQueueOverflowError } from "./async-queue.js";
 import { hydratePerTurnState, runDirectAgentTurn, tryRunSlashCommand } from "./direct-turn-helpers.js";
 //#region src/agent/service/process-direct-streaming.ts
+const MAX_BUFFERED_STREAM_EVENTS = 512;
+const LOSSY_STREAM_EVENT_TYPES = new Set([
+	"message_update",
+	"tool_execution_update",
+	"progress",
+	"review_delta"
+]);
 function isReviewOutput(value) {
 	return !!value && typeof value === "object" && !Array.isArray(value) && value.type === "review";
 }
@@ -118,7 +125,10 @@ async function* runProcessDirectStreaming(deps, input) {
 	const sessionKey = input.sessionKey ?? "agent:main:main";
 	const { channel, chatId } = await deps.resolveSessionEndpoint(sessionKey);
 	const context = deps.initDirectStreamingSession(sessionKey, channel, chatId, input.origin);
-	const queue = new AsyncQueue();
+	const queue = new AsyncQueue({
+		maxBuffered: MAX_BUFFERED_STREAM_EVENTS,
+		isDroppable: (event) => LOSSY_STREAM_EVENT_TYPES.has(event.type)
+	});
 	let reasoningLevel = channel === "webchat" ? resolveConfiguredActivityDetailDefault(deps.getConfig()) : "stream";
 	const pushVisible = (event) => {
 		const visible = channel === "webchat" ? event : applyReasoningVisibility(event, reasoningLevel);
@@ -144,6 +154,7 @@ async function* runProcessDirectStreaming(deps, input) {
 	let ranSlashCommand = false;
 	let mergedUserText = input.content;
 	let webchatSlashReceipt;
+	let streamOverflowed = false;
 	let slashCommandMetadata;
 	const slashTraceRows = [];
 	const taskPromise = (async () => {
@@ -301,12 +312,24 @@ async function* runProcessDirectStreaming(deps, input) {
 				clearPendingTranscriptUserMessage(sessionKey, pendingUserMessage);
 			}
 		} catch (err) {
-			if (!abortHandled) pushVisible({
+			if (err instanceof AsyncQueueOverflowError) {
+				streamOverflowed = true;
+				await abortEmbeddedRun(sessionKey).catch(() => false);
+				deps.log.warn({
+					err,
+					sessionKey,
+					maxBuffered: err.maxBuffered
+				}, "Aborted agent stream because the consumer could not keep up with critical events");
+			} else if (!abortHandled) pushVisible({
 				type: "error",
 				content: formatStreamError(err instanceof Error ? err.message : String(err))
 			});
 		} finally {
-			if (!userAborted && channel === "webchat") try {
+			if (queue.droppedCount > 0) deps.log.warn({
+				sessionKey,
+				droppedEvents: queue.droppedCount
+			}, "Coalesced stream progress events because the consumer fell behind");
+			if (!userAborted && !streamOverflowed && channel === "webchat") try {
 				const ttsAudioEvent = await deps.maybeEmitWebchatTts(sessionKey, inboundVoice);
 				if (ttsAudioEvent) queue.push(ttsAudioEvent);
 			} catch (ttsErr) {

package/dist/src/agent/service.js

@@ -602,6 +602,7 @@ var AgentService = class {
 			workspaceDir,
 			transcriptRuntime: params.transcriptRuntime,
 			timeoutMs: resolveAgentTurnTimeoutMs(this.effectiveAppConfig(), params.parentSessionKey),
+			turnPolicy: this.agentManager.createAgentTurnPolicy(params.parentSessionKey),
 			abortSignal: params.abortSignal,
 			onEvent: params.onEvent
 		}));

package/dist/src/agent/tools/exec-command.d.ts

@@ -9,6 +9,8 @@ export interface ExecCommandDetails {
     truncated: boolean;
     truncatedBy?: 'lines' | 'bytes' | null;
     outputBytes: number;
+    totalOutputBytes: number;
+    captureTruncated: boolean;
     stdout: string;
     stderr: string;
     aggregatedOutput: string;

package/dist/src/agent/tools/exec-command.js

@@ -25,6 +25,45 @@ function commandStatus(exitCode, timedOut) {
 	if (exitCode === 0) return "success";
 	return "failed";
 }
+function appendBoundedTail(current, chunk, maxChars) {
+	const combined = current + chunk;
+	if (combined.length <= maxChars) return {
+		value: combined,
+		truncated: false
+	};
+	return {
+		value: combined.slice(-maxChars),
+		truncated: true
+	};
+}
+function terminateProcessTree(proc) {
+	if (!proc.pid) return;
+	if (process.platform === "win32") {
+		const killer = spawn("taskkill", [
+			"/pid",
+			String(proc.pid),
+			"/t",
+			"/f"
+		], {
+			stdio: "ignore",
+			windowsHide: true
+		});
+		killer.once("error", () => {
+			try {
+				proc.kill("SIGKILL");
+			} catch {}
+		});
+		killer.unref();
+		return;
+	}
+	try {
+		process.kill(-proc.pid, "SIGKILL");
+		return;
+	} catch {}
+	try {
+		proc.kill("SIGKILL");
+	} catch {}
+}
 function commandFailureHint(details) {
 	if (details.status === "success") return void 0;
 	if (details.status === "timed_out") return "The command timed out. Re-run a narrower command, increase timeoutMs if the long run is expected, or inspect partial output before retrying.";
@@ -36,6 +75,7 @@ function formatOutputForModel(details, maxOutputChars) {
 	let prefix = "";
 	if (details.timedOut) prefix += `Command timed out after ${Math.round(details.durationMs / 1e3)}s\n`;
 	if (details.exitCode !== 0 && details.exitCode != null) prefix += `Command exited with code ${details.exitCode}\n`;
+	if (details.captureTruncated) prefix += `Earlier command output was discarded after ${formatSize(details.totalOutputBytes)}; showing the latest captured output.\n`;
 	const truncation = truncateTail(details.aggregatedOutput, { maxBytes: Math.min(maxOutputChars, DEFAULT_MAX_OUTPUT_CHARS) });
 	let text = `${prefix}${truncation.content}`.trimEnd();
 	if (!text) text = "(no output)";
@@ -78,6 +118,8 @@ function createExecCommandTool(workspaceCwd, options) {
 					timedOut: false,
 					truncated: false,
 					outputBytes: 0,
+					totalOutputBytes: 0,
+					captureTruncated: false,
 					stdout: "",
 					stderr: "cmd is required",
 					aggregatedOutput: "cmd is required",
@@ -106,6 +148,8 @@ function createExecCommandTool(workspaceCwd, options) {
 						timedOut: false,
 						truncated: false,
 						outputBytes: Buffer.byteLength(text),
+						totalOutputBytes: Buffer.byteLength(text),
+						captureTruncated: false,
 						stdout: "",
 						stderr: text,
 						aggregatedOutput: text,
@@ -120,11 +164,14 @@ function createExecCommandTool(workspaceCwd, options) {
 			let stdout = "";
 			let stderr = "";
 			let aggregatedOutput = "";
+			let totalOutputBytes = 0;
+			let captureTruncated = false;
 			let timedOut = false;
 			let settled = false;
 			return new Promise((resolveTool) => {
 				const proc = spawn(command, [], {
 					shell: true,
+					detached: process.platform !== "win32",
 					cwd: policy.effectiveCwd,
 					env: {
 						...runtimeEnv,
@@ -134,9 +181,19 @@ function createExecCommandTool(workspaceCwd, options) {
 				const publishDelta = (stream, raw) => {
 					const text = raw.toString();
 					if (!text) return;
-					if (stream === "stdout") stdout += text;
-					else stderr += text;
-					aggregatedOutput += text;
+					totalOutputBytes += Buffer.byteLength(text);
+					if (stream === "stdout") {
+						const next = appendBoundedTail(stdout, text, maxOutputChars);
+						stdout = next.value;
+						captureTruncated ||= next.truncated;
+					} else {
+						const next = appendBoundedTail(stderr, text, maxOutputChars);
+						stderr = next.value;
+						captureTruncated ||= next.truncated;
+					}
+					const nextAggregate = appendBoundedTail(aggregatedOutput, text, maxOutputChars);
+					aggregatedOutput = nextAggregate.value;
+					captureTruncated ||= nextAggregate.truncated;
 					const delta = text.length > STREAM_DELTA_MAX_CHARS ? `${text.slice(0, STREAM_DELTA_MAX_CHARS)}\n[stream delta truncated]` : text;
 					onUpdate?.({
 						content: [],
@@ -155,8 +212,12 @@ function createExecCommandTool(workspaceCwd, options) {
 					clearTimeout(timeout);
 					signal?.removeEventListener("abort", abort);
 					if (errorText) {
-						stderr += errorText;
-						aggregatedOutput += errorText;
+						totalOutputBytes += Buffer.byteLength(errorText);
+						const nextStderr = appendBoundedTail(stderr, errorText, maxOutputChars);
+						stderr = nextStderr.value;
+						const nextAggregate = appendBoundedTail(aggregatedOutput, errorText, maxOutputChars);
+						aggregatedOutput = nextAggregate.value;
+						captureTruncated ||= nextStderr.truncated || nextAggregate.truncated;
 					}
 					const durationMs = Date.now() - startTime;
 					const baseDetails = {
@@ -168,6 +229,8 @@ function createExecCommandTool(workspaceCwd, options) {
 						timedOut,
 						truncated: false,
 						outputBytes: Buffer.byteLength(aggregatedOutput),
+						totalOutputBytes,
+						captureTruncated,
 						stdout,
 						stderr,
 						aggregatedOutput
@@ -190,11 +253,11 @@ function createExecCommandTool(workspaceCwd, options) {
 				};
 				const abort = () => {
 					timedOut = true;
-					proc.kill("SIGKILL");
+					terminateProcessTree(proc);
 				};
 				const timeout = setTimeout(() => {
 					timedOut = true;
-					proc.kill("SIGKILL");
+					terminateProcessTree(proc);
 				}, timeoutMs);
 				if (signal?.aborted) abort();
 				else signal?.addEventListener("abort", abort, { once: true });

package/dist/src/auth/oauth/index.js

@@ -8,8 +8,8 @@ import { init_kimi_coding, kimiCodingOAuthProvider } from "./kimi-coding.js";
 import { init_minimax_cn, minimaxCnOAuthProvider } from "./minimax-cn.js";
 import { init_minimax, minimaxOAuthProvider } from "./minimax.js";
 import { init_openai_codex, loginOpenAICodex, openaiCodexOAuthProvider, refreshOpenAICodexToken } from "./openai-codex.js";
-import { init_xopc_cloud, xopcCloudOAuthProvider } from "./xopc-cloud.js";
-import { OAUTH_PROVIDER_DEFINITIONS, getOAuthProviderDefinition, getOAuthProviderIds, getOAuthProviderInterfaces, init_registry, isOAuthOnlyProvider } from "./registry.js";
+import { init_xopc_cloud, xopcCloudOAuthProvider, xopcTunnelOAuthProvider } from "./xopc-cloud.js";
+import { OAUTH_PROVIDER_DEFINITIONS, getModelOAuthProviderIds, getOAuthProviderDefinition, getOAuthProviderIds, getOAuthProviderInterfaces, init_registry, isOAuthOnlyProvider } from "./registry.js";
 //#region src/auth/oauth/index.ts
 init_anthropic();
 init_minimax();
@@ -22,4 +22,4 @@ init_openai_codex();
 init_xopc_cloud();
 init_registry();
 //#endregion
-export { OAUTH_PROVIDER_DEFINITIONS, anthropicOAuthProvider, getOAuthProviderDefinition, getOAuthProviderIds, getOAuthProviderInterfaces, githubCopilotOAuthProvider, antigravityOAuthProvider as googleAntigravityOAuthProvider, geminiCliOAuthProvider as googleGeminiCliOAuthProvider, isOAuthOnlyProvider, kimiCodingOAuthProvider, loginAnthropic, loginAntigravity, loginGeminiCli, loginOpenAICodex, minimaxCnOAuthProvider, minimaxOAuthProvider, openaiCodexOAuthProvider, refreshAnthropicToken, refreshAntigravityToken, refreshGoogleCloudToken, refreshOpenAICodexToken, xopcCloudOAuthProvider };
+export { OAUTH_PROVIDER_DEFINITIONS, anthropicOAuthProvider, getModelOAuthProviderIds, getOAuthProviderDefinition, getOAuthProviderIds, getOAuthProviderInterfaces, githubCopilotOAuthProvider, antigravityOAuthProvider as googleAntigravityOAuthProvider, geminiCliOAuthProvider as googleGeminiCliOAuthProvider, isOAuthOnlyProvider, kimiCodingOAuthProvider, loginAnthropic, loginAntigravity, loginGeminiCli, loginOpenAICodex, minimaxCnOAuthProvider, minimaxOAuthProvider, openaiCodexOAuthProvider, refreshAnthropicToken, refreshAntigravityToken, refreshGoogleCloudToken, refreshOpenAICodexToken, xopcCloudOAuthProvider, xopcTunnelOAuthProvider };

package/dist/src/auth/oauth/registry.d.ts

@@ -2,6 +2,7 @@ import type { OAuthProviderInterface } from './types.js';
 export interface OAuthProviderDefinition {
     displayName: string;
     oauthOnly?: boolean;
+    purpose: 'models' | 'tunnel';
     provider: OAuthProviderInterface;
     profileId: string;
     urlPrompt: string;
@@ -10,4 +11,5 @@ export declare const OAUTH_PROVIDER_DEFINITIONS: Readonly<Record<string, OAuthPr
 export declare function getOAuthProviderDefinition(provider: string): OAuthProviderDefinition | undefined;
 export declare function getOAuthProviderInterfaces(): Record<string, OAuthProviderInterface>;
 export declare function getOAuthProviderIds(): string[];
+export declare function getModelOAuthProviderIds(): string[];
 export declare function isOAuthOnlyProvider(provider: string): boolean;