pi-ui-extend 0.1.56 → 0.1.59

package/external/pi-tools-suite/docs/dcp-emergency-current-turn.md

@@ -0,0 +1,102 @@
+# Spec: DCP emergency current-turn pruning
+
+## Type
+
+Change.
+
+## Goal
+
+Prevent one long active user turn from exhausting the provider context when an
+active compression block already covers all older turns and the normal range
+and message candidate detectors therefore return nothing.
+
+## Scope
+
+- Emergency context reminders without a normal candidate.
+- Persisted emergency-pressure and provider-exposure state.
+- Emergency-only same-turn message candidates for old large tool results.
+- Deterministic placeholder pruning when reminders are ignored or usage reaches
+  the hard emergency threshold.
+- Bounded private diagnostics for the decision and pruning result.
+
+## Non-goals
+
+- Summarising the unfinished active turn as one broad range.
+- Changing normal multi-turn candidate or auto-compress behavior.
+- Setting normal `autoToolPruning.keepRecentTurns` to zero.
+- Mutating the raw session transcript; pruning affects provider context only.
+
+## Behavior
+
+1. Above the model-specific emergency threshold, DCP emits and re-applies a
+   context reminder even when normal candidates are absent.
+2. Emergency-only message suggestions may select old, large, complete
+   assistant tool-call/result pairs from the active turn.
+3. The newest configured number of complete pairs, results not yet included in
+   an accepted provider request, user messages, protected tools/files/tags, and messages
+   covered by compression blocks are never emergency candidates.
+4. If emergency pressure persists beyond patience, or reaches the configured
+   hard context percentage, DCP replaces eligible result bodies with the
+   existing pruning placeholder. It processes deterministic oldest-first
+   candidates and stops once the target recovery budget is met.
+5. The emergency counter resets only after pressure drops below the emergency
+   threshold, a successful compression/prune, a context-window change, or a
+   session reset.
+
+## Contracts
+
+The shared DCP config gains `strategies.emergencyCurrentTurnPruning` with an
+enable flag for same-turn candidates/lossy pruning, hard and target context percentages, patience, recent-pair count,
+minimum output size, suggestion cap, and extra protected tools. Missing config
+uses safe defaults. Emergency reminders remain active when lossy pruning is
+disabled. Sidecars accept missing new fields for backward
+compatibility.
+
+Diagnostics use distinct events:
+
+- `context.strong_nudge_without_candidate`
+- `compress.auto_blocked_no_candidate`
+- `prune.emergency_current_turn`
+
+## Invariants
+
+- User messages are never selected or pruned.
+- Tool-call/result structural pairs remain valid because only result content is
+  replaced.
+- A new result is not pruned before an accepted provider request included it.
+- The newest complete pairs and all configured/protected data survive.
+- Pruning is deterministic, idempotently accounted, and stops at its budget.
+
+## Related files
+
+- `src/dcp/index.ts`
+- `src/dcp/pruner-emergency.ts`
+- `src/dcp/pruner-candidates.ts`
+- `src/dcp/pruner-tools.ts`
+- `src/dcp/config.ts`
+- `src/dcp/state.ts`
+- `test/compress-pruner.test.ts`
+- `test/dcp-state-serialization.test.ts`
+- `test/dcp-config.test.ts`
+
+## Verification
+
+Focused regression and safety tests, full suite tests, headless smoke, root
+`npm run check`, SDK-pin check, `git diff --check`, and a headless one-turn
+reproduction that confirms estimated provider-visible tokens fall before the
+model limit.
+
+## Risks / unknowns
+
+Token recovery is estimated from message text, so the exact provider token
+count can differ. The hard fallback therefore targets a margin below the
+model-specific emergency threshold instead of an exact token boundary.
+
+## Evidence
+
+- Confirmed by current code: normal candidate detectors protect at least the
+  latest user turn; reminders and auto-compress are candidate-gated.
+- Confirmed by regression test: an active block plus one long turn produces no
+  normal candidate at emergency pressure.
+- Intended behavior: emergency candidate selection, persistence, fallback, and
+  diagnostics described above.

package/external/pi-tools-suite/src/antigravity-auth/payload.ts

@@ -314,7 +314,7 @@ function convertTools(tools?: Tool[]): Array<{ functionDeclarations: unknown[] }
 function reasoningLevel(options?: SimpleStreamOptions): "minimal" | "low" | "medium" | "high" | undefined {
 	const reasoning = options?.reasoning;
 	if (!reasoning) return undefined;
-	if (reasoning === "xhigh") return "high";
+	if (reasoning === "xhigh" || reasoning === "max") return "high";
 	return reasoning;
 }
 

package/external/pi-tools-suite/src/async-subagents/core/spawn.ts

@@ -26,7 +26,6 @@ const AGENT_TIMEOUT_EXIT_CODE = 124;
 const AGENT_TIMEOUT_KILL_GRACE_MS = 5_000;
 const AGENT_SETTLED_TERMINATE_GRACE_MS = 50;
 const AGENT_SETTLED_COMPLETION_FALLBACK_MS = 1_000;
-const AGENT_END_BACKCOMPAT_SETTLE_FALLBACK_MS = 100;
 const EXIT_STDIO_FLUSH_GRACE_MS = 10;
 
 export function shouldPersistSubagentSessions(env: NodeJS.ProcessEnv = process.env): boolean {
@@ -145,7 +144,6 @@ export function spawnAgent(
 	let timeoutKillTimer: NodeJS.Timeout | undefined;
 	let agentSettledKillTimer: NodeJS.Timeout | undefined;
 	let agentSettledCompletionFallbackTimer: NodeJS.Timeout | undefined;
-	let agentEndBackcompatFallbackTimer: NodeJS.Timeout | undefined;
 	let exitFinalizationTimer: NodeJS.Timeout | undefined;
 	const suppressedRpcEventCounts = new Map<string, number>();
 
@@ -157,7 +155,6 @@ export function spawnAgent(
 		if (timeoutKillTimer) clearTimeout(timeoutKillTimer);
 		if (agentSettledKillTimer) clearTimeout(agentSettledKillTimer);
 		if (agentSettledCompletionFallbackTimer) clearTimeout(agentSettledCompletionFallbackTimer);
-		if (agentEndBackcompatFallbackTimer) clearTimeout(agentEndBackcompatFallbackTimer);
 		if (exitFinalizationTimer) clearTimeout(exitFinalizationTimer);
 		if (!fs.existsSync(agentDir)) {
 			onComplete?.({
@@ -220,10 +217,6 @@ export function spawnAgent(
 	};
 
 	const scheduleAgentSettledTermination = () => {
-		if (agentEndBackcompatFallbackTimer) {
-			clearTimeout(agentEndBackcompatFallbackTimer);
-			agentEndBackcompatFallbackTimer = undefined;
-		}
 		if (agentSettledKillTimer) return;
 		agentSettledKillTimer = setTimeout(() => {
 			agentSettledKillTimer = undefined;
@@ -250,21 +243,6 @@ export function spawnAgent(
 		agentSettledCompletionFallbackTimer.unref?.();
 	};
 
-	const clearAgentEndBackcompatFallback = () => {
-		if (!agentEndBackcompatFallbackTimer) return;
-		clearTimeout(agentEndBackcompatFallbackTimer);
-		agentEndBackcompatFallbackTimer = undefined;
-	};
-
-	const scheduleAgentEndBackcompatFallback = () => {
-		if (agentEndBackcompatFallbackTimer || agentSettledKillTimer) return;
-		agentEndBackcompatFallbackTimer = setTimeout(() => {
-			agentEndBackcompatFallbackTimer = undefined;
-			scheduleAgentSettledTermination();
-		}, AGENT_END_BACKCOMPAT_SETTLE_FALLBACK_MS);
-		agentEndBackcompatFallbackTimer.unref?.();
-	};
-
 	const timeoutMs = options.timeoutMs ?? DEFAULT_AGENT_TIMEOUT_MS;
 	if (timeoutMs > 0) {
 		timeoutTimer = setTimeout(() => {
@@ -305,15 +283,6 @@ export function spawnAgent(
 		}
 		try {
 			const event = JSON.parse(line) as RpcEventRecord;
-			if (
-				event.type === "agent_start"
-				|| event.type === "message_start"
-				|| event.type === "tool_execution_start"
-				|| event.type === "compaction_start"
-				|| event.type === "auto_retry_start"
-			) {
-				clearAgentEndBackcompatFallback();
-			}
 			const storedEvent = compactRpcEventForTranscript(event, Buffer.byteLength(line, "utf8"));
 			if (storedEvent) transcriptStream.write(serializeJsonLine(storedEvent));
 			onRpcEvent?.(event);
@@ -340,7 +309,6 @@ export function spawnAgent(
 				const result = extractAgentEndResult(event);
 				if (result.trim())
 					fs.writeFileSync(path.join(agentDir, "result.md"), result, "utf-8");
-				scheduleAgentEndBackcompatFallback();
 			}
 			if (event.type === "agent_settled") {
 				scheduleAgentSettledTermination();
@@ -368,7 +336,6 @@ export function spawnAgent(
 					lastAgentEndError = "Sub-agent produced an oversized agent_end RPC event before a final result could be captured.";
 					fs.writeFileSync(path.join(agentDir, "result.md"), lastAgentEndError, "utf-8");
 				}
-				scheduleAgentEndBackcompatFallback();
 				return true;
 			}
 			return false;

package/external/pi-tools-suite/src/async-subagents/core/tool-guard.ts

@@ -1,5 +1,5 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { ignoreStaleExtensionContextError } from "../../context-usage";
+import { ignoreStaleExtensionContextError } from "../../context-usage.js";
 
 export const SUBAGENT_DENIED_TOOLS = new Set([
 	"question",

package/external/pi-tools-suite/src/codex-reasoning-fix/index.ts

@@ -3,29 +3,16 @@
  * rejects HTTP 400 `Unknown parameter: 'input[N].content'` when non-message
  * items (reasoning, function_call_output) carry a spurious `content` field.
  *
- * Root cause is in pi-ai's `convertResponsesMessages`, which pushes replayed
- * items verbatim including a stray `content` placeholder. The upstream fix is
- * uncommitted in pi-mono and never shipped, so every released pi-ai version
- * (incl. 0.79.10) is affected.
+ * Stray fields can come from replayed pi-ai items or from another extension
+ * that modifies the provider payload. The sanitizer therefore must be the
+ * LAST `before_provider_request` handler registered by pi-tools-suite.
  *
- * The fix must run at the transport layer because the provider has TWO paths:
+ * In pi-ai >= 0.80.6 the final `before_provider_request` payload feeds both the
+ * WebSocket delta builder and the zstd-compressed SSE fallback body. Running the
+ * sanitizer last therefore covers both transports without mutating global
+ * `fetch` or `WebSocket.prototype.send`.
  *
- *  1. WebSocket-cached path (normal): `buildCachedWebSocketRequestBody` rebuilds
- *     the body into a DELTA after `before_provider_request`, so the hook never
- *     sees the bytes actually sent. We wrap `WebSocket.prototype.send` once and
- *     strip `content` from every non-message input item of each
- *     `response.create` frame, on the exact bytes leaving the socket.
- *
- *  2. SSE/fetch fallback path: once a websocket attempt fails (common at large
- *     context — full body, ~100+ input items), the transport records an SSE
- *     fallback for the session and every subsequent request goes through a plain
- *     `fetch()` POST with the FULL body (`bodyJson`). The `before_provider_request`
- *     hook should clean this, but in practice it does not reliably catch every
- *     offending item, so we also wrap `globalThis.fetch` once and strip the same
- *     spurious `content` from the request body on the exact bytes leaving the
- *     HTTP client.
- *
- * The `before_provider_request` hook is kept as a third secondary guard.
+ * Module registration order is part of this workaround's correctness.
  *
  * Remove this whole module once an upstream pi-ai release carries the fix.
  */
@@ -40,12 +27,9 @@ type ProviderRequestContext = {
 	model?: unknown;
 };
 
-installWireStripper();
-installFetchStripper();
-
 /**
  * Strip spurious `content` from any object that carries an `input` or
- * `messages` array. Shared core for the wire-frame, fetch, and hook paths.
+ * `messages` array. Shared core for payload sanitization.
  * Returns the cleaned object plus a tally only when something changed;
  * otherwise `undefined` (caller forwards the original untouched).
  */
@@ -87,101 +71,10 @@ function isSpuriousContentItem(item: unknown): boolean {
 	);
 }
 
-/**
- * Wrap `WebSocket.prototype.send` once. For each `response.create` frame, strip
- * the offending `content` from non-message input items and forward the cleaned
- * frame. Forwards the original untouched on any parse/rewrite failure so the
- * transport never breaks.
- */
-function installWireStripper(): void {
-	try {
-		const WS = (globalThis as { WebSocket?: typeof WebSocket }).WebSocket;
-		if (!WS?.prototype) return;
-		const proto = WS.prototype as { send?: unknown };
-		if (typeof proto.send !== "function") return;
-		const original = proto.send as (data: unknown) => void;
-		if ((original as unknown as { __codexFixWrapped?: boolean }).__codexFixWrapped) return;
-
-		const wrapped = function (this: unknown, data: unknown): void {
-			let outgoing = data;
-			if (typeof data === "string") {
-				try {
-					const parsed = JSON.parse(data);
-					if (isRecord(parsed) && parsed.type === "response.create") {
-						const result = stripCarrier(parsed);
-						if (result) {
-							outgoing = JSON.stringify(result.obj);
-						}
-					}
-				} catch {
-					// Non-JSON or malformed: forward untouched.
-				}
-			}
-			return original.call(this, outgoing);
-		};
-		(wrapped as unknown as { __codexFixWrapped?: boolean }).__codexFixWrapped = true;
-		proto.send = wrapped;
-	} catch {
-		// best-effort; never break on setup
-	}
-}
-
-/**
- * Wrap `globalThis.fetch` once. For JSON POST bodies carrying an `input` or
- * `messages` array (Codex / OpenAI Responses shape), strip the spurious
- * `content` from non-message items before the request leaves the HTTP client.
- * This closes the SSE-fallback path that the WebSocket wrapper cannot see.
- * Forwards the original request untouched on any non-matching/parse failure.
- */
-function installFetchStripper(): void {
-	try {
-		const g = globalThis as { fetch?: typeof fetch };
-		const original = g.fetch;
-		if (typeof original !== "function") return;
-		if ((original as unknown as { __codexFixWrapped?: boolean }).__codexFixWrapped) return;
-
-		const wrapped = function fetchStripper(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
-			const nextInit = stripFetchInit(init);
-			return original.call(this, input, nextInit ?? init);
-		};
-		(wrapped as unknown as { __codexFixWrapped?: boolean }).__codexFixWrapped = true;
-		g.fetch = wrapped as typeof fetch;
-	} catch {
-		// best-effort; never break on setup
-	}
-}
-
-/**
- * If `init` carries a JSON body shaped like a Responses request, return a new
- * `init` with the stripped body. Returns `undefined` when nothing matched so
- * the caller forwards the original `init` untouched.
- */
-export function stripFetchInit(init: RequestInit | undefined): RequestInit | undefined {
-	if (!init || typeof init.body !== "string") return undefined;
-	try {
-		const parsed = JSON.parse(init.body);
-		const result = stripCarrier(parsed);
-		if (!result) return undefined;
-		return { ...init, body: JSON.stringify(result.obj) };
-	} catch {
-		return undefined;
-	}
-}
-
-/**
- * If `frame` is a Codex `response.create` carrying an `input` (or `messages`)
- * array, return the cleaned frame plus a tally of stripped items. Returns
- * `undefined` when nothing matched (caller forwards the original frame
- * untouched). Exported for unit testing.
- */
-export function stripContentFromWireFrame(frame: unknown): { frame: Record<string, unknown>; stripped: number } | undefined {
-	if (!isRecord(frame) || frame.type !== "response.create") return undefined;
-	const result = stripCarrier(frame);
-	if (!result) return undefined;
-	return { frame: result.obj, stripped: result.stripped };
-}
-
 export default function codexReasoningFix(pi: ExtensionAPI): void {
+	// src/index.ts deliberately registers this module last. A later payload
+	// modifier could otherwise reintroduce invalid content after sanitization,
+	// and transport encoding happens after this hook.
 	pi.on("before_provider_request", async (event: ProviderRequestEvent, _ctx: ProviderRequestContext) => {
 		const result = stripReasoningContentFromPayload(event.payload);
 		return result === event.payload ? undefined : result;
@@ -189,8 +82,7 @@ export default function codexReasoningFix(pi: ExtensionAPI): void {
 }
 
 /**
- * Strip spurious `content` from non-message items in a full payload. Secondary
- * guard for the SSE-fallback / non-websocket path. Returns the same reference
+ * Strip spurious `content` from non-message items in a full payload. Returns the same reference
  * when nothing changed; exported for unit testing.
  */
 export function stripReasoningContentFromPayload(payload: unknown): unknown {

package/external/pi-tools-suite/src/dcp/config.ts

@@ -85,6 +85,23 @@ export interface DcpConfig {
       readLikeTurns: number
       protectedTools: string[]
     }
+    emergencyCurrentTurnPruning: {
+      /** Enable same-turn candidates and lossy fallback pruning; emergency reminders remain active. */
+      enabled: boolean
+      /** Prune immediately at or above this model-independent context fraction. */
+      hardContextPercent: number
+      /** Recover enough estimated tokens to reach this fraction or a margin below the model emergency threshold. */
+      targetContextPercent: number
+      /** Emergency reminders allowed before pruning even below hardContextPercent. */
+      patience: number
+      /** Newest complete assistant tool-call/result pairs that are never selected. */
+      keepRecentToolPairs: number
+      /** Ignore small results whose replacement would recover little context. */
+      minOutputTokens: number
+      /** Maximum emergency same-turn message candidates shown in a reminder. */
+      maxSuggestions: number
+      protectedTools: string[]
+    }
   }
   protectedFilePatterns: string[]
   pruneNotification: "off" | "minimal" | "detailed"
@@ -178,6 +195,16 @@ const DEFAULT_CONFIG: DcpConfig = {
       readLikeTurns: 3,
       protectedTools: [],
     },
+    emergencyCurrentTurnPruning: {
+      enabled: true,
+      hardContextPercent: 0.82,
+      targetContextPercent: 0.70,
+      patience: 2,
+      keepRecentToolPairs: 8,
+      minOutputTokens: 500,
+      maxSuggestions: 8,
+      protectedTools: [],
+    },
   },
   protectedFilePatterns: [],
   pruneNotification: "detailed",

package/external/pi-tools-suite/src/dcp/debug-log.ts

@@ -128,6 +128,8 @@ export function summarizeDcpState(state: DcpState): Record<string, unknown> {
     },
     inactiveBlocksTail: inactiveBlocks,
     prunedTools: state.prunedToolIds.size,
+    providerSeenTools: state.providerSeenToolIds.size,
+    consecutiveEmergencyPasses: state.consecutiveIgnoredStrongNudges,
     nudgeAnchors: state.nudgeAnchors.map((anchor) => ({
       id: anchor.id,
       type: anchor.type,
@@ -232,4 +234,3 @@ export function writeDcpDebugLog(
 export function dcpDebugLogDrain(): Promise<void> {
   return logWriteChain
 }
-