pi-ui-extend 0.1.46 → 0.1.48

package/dist/app/rendering/tool-block-renderer.js

@@ -88,7 +88,10 @@ export function renderToolBlock(entry, rule, width, colors, options = {}) {
 }
 function renderCollapsedPreviewLines(entry, body, rule, width, target, color, colors, hasLspDiagnostics, showGutter) {
     const preview = previewBodyText(body, rule.direction, rule.previewLines);
-    const allPreviewLines = renderToolBodyLines(preview.text, width, target, color, entry.bodyStyle, colors, undefined, entry.bodyWrap, hasLspDiagnostics, entry.bodyLineStyles, entry.preserveAnsi, showGutter, { rawLineOffset: preview.rawLineOffset, bodyEndsAfterText: !preview.omittedAfter });
+    // bodyLineStyles is aligned to entry.expandedText (args block prefix + output), but the
+    // collapsed body here is the raw output only. Applying bodyLineStyles would misalign and
+    // incorrectly dim the first N output lines, so we do not pass it to the collapsed preview.
+    const allPreviewLines = renderToolBodyLines(preview.text, width, target, color, entry.bodyStyle, colors, undefined, entry.bodyWrap, hasLspDiagnostics, undefined, entry.preserveAnsi, showGutter, { rawLineOffset: preview.rawLineOffset, bodyEndsAfterText: !preview.omittedAfter });
     const overflow = preview.omittedBefore || preview.omittedAfter || allPreviewLines.length > rule.previewLines;
     if (!overflow)
         return allPreviewLines;

package/dist/app/session/tabs-controller.d.ts

@@ -107,6 +107,7 @@ export declare class AppTabsController {
     private observeRuntimeForTab;
     private shouldSyncTabFromRuntimeEvent;
     private shouldScheduleDelayedSyncForRuntimeEvent;
+    private shouldInvalidateCachedViewForRuntimeEvent;
     private scheduleDelayedRuntimeSync;
     private clearRuntimeRefreshTimers;
     private clearHistoryReloadTimers;

package/dist/app/session/tabs-controller.js

@@ -641,8 +641,7 @@ export class AppTabsController {
         void this.saveTabs();
         this.scheduleTabPrewarm();
         const cachedView = this.sessionViewsByTabId.get(target.id);
-        const cachedViewNeedsHistoryReload = this.tabIdsNeedingHistoryReload.has(target.id)
-            && this.sessionActivity(targetRuntime.session) !== "running";
+        const cachedViewNeedsHistoryReload = this.tabIdsNeedingHistoryReload.has(target.id);
         if (cachedView && this.host.restoreSessionView && !cachedViewNeedsHistoryReload) {
             this.host.restoreSessionView(cachedView);
             this.restoreDeferredUserMessages(target.id);
@@ -883,9 +882,11 @@ export class AppTabsController {
             return;
         existing?.unsubscribe();
         const unsubscribe = runtime.session.subscribe((event) => {
+            if (this.shouldInvalidateCachedViewForRuntimeEvent(event)) {
+                this.tabIdsNeedingHistoryReload.add(tabId);
+            }
             if (this.shouldScheduleDelayedSyncForRuntimeEvent(event)) {
                 this.scheduleDelayedRuntimeSync(tabId, runtime);
-                this.tabIdsNeedingHistoryReload.add(tabId);
             }
             if (!this.shouldSyncTabFromRuntimeEvent(event))
                 return;
@@ -905,6 +906,17 @@ export class AppTabsController {
             || event.type === "turn_end"
             || event.type === "compaction_end";
     }
+    shouldInvalidateCachedViewForRuntimeEvent(event) {
+        return event.type === "message_start"
+            || event.type === "message_update"
+            || event.type === "message_end"
+            || event.type === "tool_execution_start"
+            || event.type === "tool_execution_update"
+            || event.type === "tool_execution_end"
+            || event.type === "agent_end"
+            || event.type === "turn_end"
+            || event.type === "compaction_end";
+    }
     scheduleDelayedRuntimeSync(tabId, runtime) {
         this.clearRuntimeRefreshTimers(tabId);
         for (const delayMs of [0, 100, 500, 1500, 3000]) {

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

@@ -0,0 +1,154 @@
+/**
+ * WORKAROUND for @earendil-works/pi-ai bug: the Codex / OpenAI Responses API
+ * 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.
+ *
+ * The fix must run at the WebSocket.send layer, not at before_provider_request:
+ * pi's openai-codex-responses provider uses a websocket-cached transport that
+ * rebuilds the body into a delta AFTER the before_provider_request hook, so the
+ * hook never sees the bytes actually sent. This module wraps
+ * WebSocket.prototype.send once and strips `content` from every non-message
+ * input item of each `response.create` frame, on the exact bytes leaving the
+ * socket. The before_provider_request hook is kept as a secondary guard for the
+ * SSE-fallback transport (full body, no delta).
+ *
+ * Remove this whole module once an upstream pi-ai release carries the fix.
+ */
+type ExtensionAPI = any;
+
+type ProviderRequestEvent = {
+	payload?: unknown;
+};
+
+type ProviderRequestContext = {
+	cwd?: string;
+	model?: unknown;
+};
+
+installWireStripper();
+
+/**
+ * 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);
+					const result = stripContentFromWireFrame(parsed);
+					if (result) {
+						outgoing = JSON.stringify(result.frame);
+					}
+				} 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
+	}
+}
+
+/**
+ * If `frame` is a Codex `response.create` carrying an `input` (or `messages`)
+ * array, return the cleaned frame (content stripped from every non-message
+ * item) plus a tally of how many items were stripped. Returns `undefined`
+ * when nothing matched (caller forwards the original frame untouched). The
+ * returned `frame` is a clean Codex payload with no extra fields.
+ */
+export function stripContentFromWireFrame(frame: unknown): { frame: Record<string, unknown>; stripped: number } | undefined {
+	if (!isRecord(frame) || frame.type !== "response.create") return undefined;
+	const field = Array.isArray(frame.input) ? "input" : Array.isArray(frame.messages) ? "messages" : null;
+	if (!field) return undefined;
+
+	const list = frame[field] as unknown[];
+	let stripped = 0;
+	let changed = false;
+	const next = new Array(list.length);
+	for (let i = 0; i < list.length; i++) {
+		const item = list[i];
+		// Only items with an explicit `type` that is NOT "message" can carry a
+		// spurious `content`. Role-based messages (no `type`) and typed
+		// messages (`type:"message"`) legitimately hold content — leave them.
+		if (
+			isRecord(item) &&
+			typeof item.type === "string" &&
+			item.type !== "message" &&
+			Object.prototype.hasOwnProperty.call(item, "content")
+		) {
+			const { content: _drop, ...rest } = item;
+			next[i] = rest;
+			stripped++;
+			changed = true;
+		} else {
+			next[i] = item;
+		}
+	}
+	if (!changed) return undefined;
+	return { frame: { ...frame, [field]: next }, stripped };
+}
+
+export default function codexReasoningFix(pi: ExtensionAPI): void {
+	pi.on("before_provider_request", async (event: ProviderRequestEvent, _ctx: ProviderRequestContext) => {
+		const result = stripReasoningContentFromPayload(event.payload);
+		return result === event.payload ? undefined : result;
+	});
+}
+
+/**
+ * Strip spurious `content` from non-message items in a full payload. Secondary
+ * guard for the SSE-fallback / non-websocket path. Same rule as the wire
+ * stripper; exported for unit testing.
+ */
+export function stripReasoningContentFromPayload(payload: unknown): unknown {
+	if (!isRecord(payload)) return payload;
+	const inputList = Array.isArray(payload.input) ? payload.input : undefined;
+	const messagesList = Array.isArray(payload.messages) ? payload.messages : undefined;
+	const field = inputList ? "input" : messagesList ? "messages" : undefined;
+	const list = inputList ?? messagesList;
+	if (!field || !list) return payload;
+
+	let changed = false;
+	const next = new Array(list.length);
+	for (let i = 0; i < list.length; i++) {
+		const item = list[i];
+		if (
+			isRecord(item) &&
+			typeof item.type === "string" &&
+			item.type !== "message" &&
+			Object.prototype.hasOwnProperty.call(item, "content")
+		) {
+			const { content: _drop, ...rest } = item;
+			next[i] = rest;
+			changed = true;
+		} else {
+			next[i] = item;
+		}
+	}
+	if (!changed) return payload;
+	return { ...payload, [field]: next };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}

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

@@ -123,12 +123,28 @@ function appendTextToContent(content: unknown, text: string): unknown {
 
 function appendDcpControlToMessages(messages: unknown, text: string): unknown {
 	if (!Array.isArray(messages)) return messages
-	const existingIndex = messages.findIndex((message: any) =>
-		message?.role === "system" || message?.role === "developer"
-	)
 	const block = `${DCP_PROVIDER_CONTROL_HEADER}\n${text}`
-	if (existingIndex >= 0) {
-		return messages.map((message: any, index) => index === existingIndex
+
+	// Keep DCP's volatile ID map at the tail of the provider context instead of
+	// mutating the stable system/developer prefix. Prefix cache reuse is much
+	// better when only the newest transcript item changes on each request.
+	let targetIndex = -1
+	for (let index = messages.length - 1; index >= 0; index--) {
+		const message = messages[index] as any
+		if (!message || typeof message !== "object") continue
+		if (message.role === "system" || message.role === "developer") continue
+		targetIndex = index
+		break
+	}
+
+	if (targetIndex < 0) {
+		targetIndex = messages.findIndex((message: any) =>
+			message?.role === "system" || message?.role === "developer"
+		)
+	}
+
+	if (targetIndex >= 0) {
+		return messages.map((message: any, index) => index === targetIndex
 			? { ...message, content: appendTextToContent(message.content, block) }
 			: message)
 	}
@@ -155,10 +171,6 @@ function appendDcpControlToProviderPayload(payload: unknown, text: string): unkn
 	if (!payload || typeof payload !== "object") return payload
 	const record = payload as Record<string, unknown>
 
-	if ("system" in record) {
-		return { ...record, system: appendDcpControlToAnthropicSystem(record.system, text) }
-	}
-
 	if (Array.isArray(record.input)) {
 		return { ...record, input: appendDcpControlToMessages(record.input, text) }
 	}
@@ -167,6 +179,10 @@ function appendDcpControlToProviderPayload(payload: unknown, text: string): unkn
 		return { ...record, messages: appendDcpControlToMessages(record.messages, text) }
 	}
 
+	if ("system" in record) {
+		return { ...record, system: appendDcpControlToAnthropicSystem(record.system, text) }
+	}
+
 	if (record.config && typeof record.config === "object") {
 		const config = record.config as Record<string, unknown>
 		return {

package/external/pi-tools-suite/src/dcp/pruner-message-ids.ts

@@ -46,27 +46,87 @@ function priorityForMessage(tokenEstimate: number, config: DcpConfig | undefined
   return "low";
 }
 
-function controlLineForMessageId(id: string, state: DcpState): string {
-  const meta = state.messageMetaSnapshot.get(id);
-  if (!meta) return `- ${id}`;
-
-  const details: string[] = [meta.role];
-  if (meta.blockId !== undefined) details.push(`block=b${meta.blockId}`);
-  if (meta.toolName) details.push(`tool=${meta.toolName}`);
-  if (meta.priority) details.push(`priority=${meta.priority}`);
-  return `- ${id}: ${details.join(", ")}`;
+function messageIdIndex(id: string): number | undefined {
+  const match = /^m(\d+)$/.exec(id);
+  if (!match) return undefined;
+  const index = Number.parseInt(match[1]!, 10);
+  return Number.isFinite(index) ? index : undefined;
+}
+
+function summarizeMessageIds(ids: string[]): string {
+  if (ids.length === 0) return "none";
+
+  const ranges: string[] = [];
+  let start = ids[0]!;
+  let previous = ids[0]!;
+  let previousIndex = messageIdIndex(previous);
+
+  const flush = () => {
+    const startIndex = messageIdIndex(start);
+    const endIndex = messageIdIndex(previous);
+    if (
+      startIndex !== undefined &&
+      endIndex !== undefined &&
+      endIndex - startIndex >= 2
+    ) {
+      ranges.push(`${start}..${previous}`);
+    } else if (start === previous) {
+      ranges.push(start);
+    } else {
+      ranges.push(start, previous);
+    }
+  };
+
+  for (let i = 1; i < ids.length; i++) {
+    const id = ids[i]!;
+    const index = messageIdIndex(id);
+    if (previousIndex !== undefined && index === previousIndex + 1) {
+      previous = id;
+      previousIndex = index;
+      continue;
+    }
+
+    flush();
+    start = id;
+    previous = id;
+    previousIndex = index;
+  }
+
+  flush();
+  return ranges.join(", ");
+}
+
+function compactPriorityHint(ids: string[], state: DcpState): string | undefined {
+  const high: string[] = [];
+  const medium: string[] = [];
+  const blocks: string[] = [];
+
+  for (const id of ids) {
+    const meta = state.messageMetaSnapshot.get(id);
+    if (!meta) continue;
+    if (meta.priority === "high") high.push(id);
+    else if (meta.priority === "medium") medium.push(id);
+    if (meta.blockId !== undefined) blocks.push(`${id}=b${meta.blockId}`);
+  }
+
+  const parts: string[] = [];
+  if (high.length > 0) parts.push(`high=${summarizeMessageIds(high)}`);
+  if (medium.length > 0) parts.push(`medium=${summarizeMessageIds(medium)}`);
+  if (blocks.length > 0) parts.push(`blocks=${blocks.join(",")}`);
+  return parts.length > 0 ? `Hints: ${parts.join("; ")}` : undefined;
 }
 
 export function buildMessageIdControlText(state: DcpState): string | undefined {
   const ids = [...state.messageIdSnapshot.keys()];
   if (ids.length === 0) return undefined;
 
+  const hint = compactPriorityHint(ids, state);
+
   return [
     "<dcp-message-ids>",
-    "DCP metadata for the preceding conversation messages. These IDs are model-visible but UI-hidden control data.",
-    "Use only these current IDs with the compress tool; do not quote or output this metadata.",
-    `Current raw message IDs: ${ids.join(", ")}`,
-    ...ids.map((id) => controlLineForMessageId(id, state)),
+    "DCP metadata for the preceding conversation messages. IDs follow current message order; use only these IDs with compress; do not quote/output.",
+    `Current raw message IDs: ${summarizeMessageIds(ids)}${ids.length > 2 ? ` (${ids.length} messages)` : ""}`,
+    ...(hint ? [hint] : []),
     "</dcp-message-ids>",
   ].join("\n");
 }

package/external/pi-tools-suite/src/index.ts

@@ -10,6 +10,7 @@ type ExtensionModule = {
 };
 
 const MODULES: Array<{ name: string; load: () => Promise<ExtensionModule> }> = [
+	{ name: "codex-reasoning-fix", load: () => import("./codex-reasoning-fix/index") },
 	{ name: "coding-discipline", load: () => import("./coding-discipline/index") },
 	{ name: "ast-grep", load: () => import("./ast-grep/index") },
 	{ name: "async-subagents", load: () => import("./async-subagents/index") },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-ui-extend",
-  "version": "0.1.46",
+  "version": "0.1.48",
   "private": false,
   "type": "module",
   "bin": {