pi-openai-codex-compat 0.0.7-alpha.0 → 0.0.8

package/extensions/openai-codex-compat/codex-stream.ts

@@ -141,11 +141,6 @@ function appendCustomInput(
   return delta;
 }
 
-function responseItems(value: unknown): JsonRecord[] {
-  if (!Array.isArray(value)) return [];
-  return value.filter(isObject);
-}
-
 function itemContentText(item: JsonRecord): string {
   if (!Array.isArray(item.content)) return "";
   return item.content
@@ -209,7 +204,8 @@ export async function processCodexStream(
 ): Promise<void> {
   let terminal = false;
   const slots = new Map<number, OutputSlot>();
-  const reasoningById = new Map<string, ThinkingContent>();
+  const completedOutputItems = new Set<string>();
+  const completedToolCallContentIndexes = new Set<number>();
   const applyMessagePhaseStopReason = (item: JsonRecord): void => {
     if (item.type === "message" && item["phase"] === "final_answer") {
       output.stopReason = "stop";
@@ -318,6 +314,80 @@ export async function processCodexStream(
   const slotFor = (index: number, item: JsonRecord): OutputSlot | undefined =>
     slots.get(index) ?? createSlot(index, item);
 
+  const outputItemKey = (index: number, item: JsonRecord): string => {
+    if (typeof item.id === "string") return `id:${item.id}`;
+    if (typeof item["call_id"] === "string") {
+      return `call:${String(item.type)}:${item["call_id"]}`;
+    }
+    return `index:${String(index)}:${String(item.type)}`;
+  };
+
+  const completeOutputItem = (index: number, item: JsonRecord): void => {
+    const key = outputItemKey(index, item);
+    if (completedOutputItems.has(key)) return;
+    completedOutputItems.add(key);
+    applyMessagePhaseStopReason(item);
+    const slot = slotFor(index, item);
+    if (item.type === "reasoning" && slot?.type === "thinking") {
+      slot.block.thinking = reasoningText(item) || slot.block.thinking;
+      slot.block.thinkingSignature = JSON.stringify(item);
+      stream.push({
+        type: "thinking_end",
+        contentIndex: slot.contentIndex,
+        content: slot.block.thinking,
+        partial: output,
+      });
+      trackCompleted(slot);
+      slots.delete(index);
+    } else if (item.type === "message" && slot?.type === "text") {
+      slot.block.text = itemContentText(item);
+      if (typeof item.id === "string") {
+        slot.block.textSignature = encodeTextSignature(item.id, item["phase"]);
+      }
+      stream.push({
+        type: "text_end",
+        contentIndex: slot.contentIndex,
+        content: slot.block.text,
+        partial: output,
+      });
+      trackCompleted(slot);
+      slots.delete(index);
+    } else if (
+      item.type === "function_call" &&
+      slot?.type === "toolCall" &&
+      slot.block.partialJson !== undefined
+    ) {
+      slot.block.name = piToolCallName(item);
+      const argumentsJson =
+        typeof item.arguments === "string" ? item.arguments : slot.block.partialJson || "{}";
+      slot.block.arguments = parseStreamingJson(argumentsJson);
+      delete slot.block.partialJson;
+      stream.push({
+        type: "toolcall_end",
+        contentIndex: slot.contentIndex,
+        toolCall: slot.block,
+        partial: output,
+      });
+      trackCompleted(slot);
+      completedToolCallContentIndexes.add(slot.contentIndex);
+      slots.delete(index);
+    } else if (item.type === "custom_tool_call" && slot?.type === "toolCall") {
+      slot.block.name = piToolCallName(item);
+      const input = typeof item["input"] === "string" ? item["input"] : customInput(slot.block);
+      pushToolDelta(slot, appendCustomInput(slot.block, input, true));
+      delete slot.block.customInput;
+      stream.push({
+        type: "toolcall_end",
+        contentIndex: slot.contentIndex,
+        toolCall: slot.block,
+        partial: output,
+      });
+      trackCompleted(slot);
+      completedToolCallContentIndexes.add(slot.contentIndex);
+      slots.delete(index);
+    }
+  };
+
   const finalize = (response: JsonRecord): void => {
     terminal = true;
     if (typeof response.id === "string") output.responseId = response.id;
@@ -350,18 +420,6 @@ export async function processCodexStream(
       output.usage,
       typeof response.service_tier === "string" ? response.service_tier : undefined,
     );
-    for (const item of responseItems(response["output"])) {
-      if (item.type !== "reasoning" || typeof item.id !== "string") continue;
-      const block = reasoningById.get(item.id);
-      if (!block?.thinkingSignature || typeof item.encrypted_content !== "string") continue;
-      const stored = JSON.parse(block.thinkingSignature) as JsonRecord;
-      if (typeof stored.encrypted_content !== "string") {
-        block.thinkingSignature = JSON.stringify({
-          ...stored,
-          encrypted_content: item.encrypted_content,
-        });
-      }
-    }
     const status = normalizeCodexStatus(response["status"]);
     const incompleteDetails = isObject(response["incomplete_details"])
       ? response["incomplete_details"]
@@ -376,7 +434,12 @@ export async function processCodexStream(
     output.stopReason = mappedStop.stopReason;
     if (mappedStop.errorMessage === undefined) delete output.errorMessage;
     else output.errorMessage = mappedStop.errorMessage;
-    if (output.stopReason === "stop" && output.content.some((block) => block.type === "toolCall")) {
+    if (
+      output.stopReason === "stop" &&
+      [...completedToolCallContentIndexes].some(
+        (contentIndex) => output.content[contentIndex]?.type === "toolCall",
+      )
+    ) {
       output.stopReason = "toolUse";
     }
   };
@@ -455,66 +518,7 @@ export async function processCodexStream(
       if (!slot || typeof event["input"] !== "string") continue;
       pushToolDelta(slot, appendCustomInput(slot.block, event["input"], true));
     } else if (event.type === "response.output_item.done" && isObject(event.item)) {
-      const item = event.item;
-      applyMessagePhaseStopReason(item);
-      const slot = slotFor(index, item);
-      if (item.type === "reasoning" && slot?.type === "thinking") {
-        slot.block.thinking = reasoningText(item) || slot.block.thinking;
-        slot.block.thinkingSignature = JSON.stringify(item);
-        if (typeof item.id === "string") reasoningById.set(item.id, slot.block);
-        stream.push({
-          type: "thinking_end",
-          contentIndex: slot.contentIndex,
-          content: slot.block.thinking,
-          partial: output,
-        });
-        trackCompleted(slot);
-        slots.delete(index);
-      } else if (item.type === "message" && slot?.type === "text") {
-        slot.block.text = itemContentText(item);
-        if (typeof item.id === "string") {
-          slot.block.textSignature = encodeTextSignature(item.id, item["phase"]);
-        }
-        stream.push({
-          type: "text_end",
-          contentIndex: slot.contentIndex,
-          content: slot.block.text,
-          partial: output,
-        });
-        trackCompleted(slot);
-        slots.delete(index);
-      } else if (
-        item.type === "function_call" &&
-        slot?.type === "toolCall" &&
-        slot.block.partialJson !== undefined
-      ) {
-        slot.block.name = piToolCallName(item);
-        const argumentsJson =
-          typeof item.arguments === "string" ? item.arguments : slot.block.partialJson || "{}";
-        slot.block.arguments = parseStreamingJson(argumentsJson);
-        delete slot.block.partialJson;
-        stream.push({
-          type: "toolcall_end",
-          contentIndex: slot.contentIndex,
-          toolCall: slot.block,
-          partial: output,
-        });
-        trackCompleted(slot);
-        slots.delete(index);
-      } else if (item.type === "custom_tool_call" && slot?.type === "toolCall") {
-        slot.block.name = piToolCallName(item);
-        const input = typeof item["input"] === "string" ? item["input"] : customInput(slot.block);
-        pushToolDelta(slot, appendCustomInput(slot.block, input, true));
-        delete slot.block.customInput;
-        stream.push({
-          type: "toolcall_end",
-          contentIndex: slot.contentIndex,
-          toolCall: slot.block,
-          partial: output,
-        });
-        trackCompleted(slot);
-        slots.delete(index);
-      }
+      completeOutputItem(index, event.item);
     } else if (
       (event.type === "response.completed" || event.type === "response.incomplete") &&
       isObject(event.response)

package/extensions/openai-codex-compat/codex-transport.ts

@@ -1910,16 +1910,6 @@ async function* requestWebSocket(
           responseCompleted = true;
         }
         if (typeof event.response.id === "string") responseId = event.response.id;
-        if (Array.isArray(event.response["output"])) {
-          const terminalItems = event.response["output"].filter(isObject);
-          if (terminalItems.length > 0) {
-            responseItems.splice(
-              0,
-              responseItems.length,
-              ...terminalItems.map((item) => structuredClone(item)),
-            );
-          }
-        }
       }
       const normalized = normalizeEvent(event);
       if (!normalized) continue;

package/extensions/openai-codex-compat/compaction-checkpoint.ts

@@ -25,11 +25,17 @@ import { convertResponsesMessages } from "./vendor/pi-ai/openai-responses-serial
 export const CHECKPOINT_ENTRY_TYPE = "openai-codex-compat-remote-compaction";
 export const CHECKPOINT_FORMAT_VERSION = 1;
 
+export type CompactionDecision = {
+  reason: "manual" | "threshold" | "overflow" | "provider-boundary";
+  willRetry: boolean;
+};
+
 export type CheckpointData = {
   kind: typeof CHECKPOINT_ENTRY_TYPE;
   version: typeof CHECKPOINT_FORMAT_VERSION;
   modelId: string;
   history: ResponsesItem[];
+  compactionDecision?: CompactionDecision;
 };
 
 export type CheckpointSearch =
@@ -180,11 +186,31 @@ export function parseCheckpoint(value: unknown): CheckpointData | undefined {
     return undefined;
   }
 
+  const rawDecision = value["compactionDecision"];
+  let compactionDecision: CompactionDecision | undefined;
+  if (rawDecision !== undefined) {
+    if (
+      !isObject(rawDecision) ||
+      (rawDecision["reason"] !== "manual" &&
+        rawDecision["reason"] !== "threshold" &&
+        rawDecision["reason"] !== "overflow" &&
+        rawDecision["reason"] !== "provider-boundary") ||
+      typeof rawDecision["willRetry"] !== "boolean"
+    ) {
+      return undefined;
+    }
+    compactionDecision = {
+      reason: rawDecision["reason"],
+      willRetry: rawDecision["willRetry"],
+    };
+  }
+
   return {
     kind: CHECKPOINT_ENTRY_TYPE,
     version: CHECKPOINT_FORMAT_VERSION,
     modelId: value.modelId,
     history,
+    ...(compactionDecision ? { compactionDecision } : {}),
   };
 }
 
@@ -229,6 +255,7 @@ export function checkpointData(
   inputHistory: readonly ResponsesItem[],
   compactionItem: ResponsesItem,
   postCompactionTail: readonly ResponsesItem[] = [],
+  compactionDecision?: CompactionDecision,
 ): CheckpointData {
   return {
     kind: CHECKPOINT_ENTRY_TYPE,
@@ -238,6 +265,7 @@ export function checkpointData(
       ...installCompactionItem(inputHistory, compactionItem),
       ...postCompactionTail.map((item) => structuredClone(item)),
     ],
+    ...(compactionDecision ? { compactionDecision: { ...compactionDecision } } : {}),
   };
 }
 

package/extensions/openai-codex-compat/config.ts

@@ -20,6 +20,8 @@ export interface CodexCompatConfig {
   responsesLite: boolean;
   /** Replace Pi's active edit and write tools with the extension's apply_patch tool. */
   applyPatch: boolean;
+  /** Show exact model-facing apply_patch feedback while its TUI result is collapsed. */
+  applyPatchDebug: boolean;
   /** Select the shared background surface for extension-owned Codex tools. */
   toolBackground: CodexToolBackground;
   /** Expose the standalone Codex image-generation namespace tool. */
@@ -44,6 +46,7 @@ export const CONFIG_ENVIRONMENT_VARIABLES = {
   fastMode: `${ENV_PREFIX}FAST_MODE`,
   responsesLite: `${ENV_PREFIX}RESPONSES_LITE`,
   applyPatch: `${ENV_PREFIX}APPLY_PATCH`,
+  applyPatchDebug: `${ENV_PREFIX}APPLY_PATCH_DEBUG`,
   toolBackground: `${ENV_PREFIX}TOOL_BACKGROUND`,
   imageGeneration: `${ENV_PREFIX}IMAGE_GENERATION`,
   imageDetail: `${ENV_PREFIX}IMAGE_DETAIL`,
@@ -59,6 +62,7 @@ export type ConfigLayer = {
   fastMode?: boolean;
   responsesLite?: boolean;
   applyPatch?: boolean;
+  applyPatchDebug?: boolean;
   toolBackground?: CodexToolBackground;
   imageGeneration?: boolean;
   imageDetail?: ImageDetail;
@@ -75,6 +79,7 @@ export const DEFAULT_CONFIG: CodexCompatConfig = {
   fastMode: false,
   responsesLite: false,
   applyPatch: true,
+  applyPatchDebug: false,
   toolBackground: "subtle",
   imageGeneration: true,
   imageDetail: "auto",
@@ -152,6 +157,12 @@ export function parseEnvironmentConfig(environment: Environment = process.env):
   const applyPatch = environmentBoolean(environment, CONFIG_ENVIRONMENT_VARIABLES.applyPatch);
   if (applyPatch !== undefined) layer.applyPatch = applyPatch;
 
+  const applyPatchDebug = environmentBoolean(
+    environment,
+    CONFIG_ENVIRONMENT_VARIABLES.applyPatchDebug,
+  );
+  if (applyPatchDebug !== undefined) layer.applyPatchDebug = applyPatchDebug;
+
   const toolBackground = environmentEnum(
     environment,
     CONFIG_ENVIRONMENT_VARIABLES.toolBackground,
@@ -239,6 +250,9 @@ export function parseConfig(value: unknown): ConfigLayer {
   const applyPatch = value["applyPatch"];
   if (typeof applyPatch === "boolean") layer.applyPatch = applyPatch;
 
+  const applyPatchDebug = value["applyPatchDebug"];
+  if (typeof applyPatchDebug === "boolean") layer.applyPatchDebug = applyPatchDebug;
+
   const toolBackground = value["toolBackground"];
   if (
     typeof toolBackground === "string" &&
@@ -318,6 +332,9 @@ export function resolveConfig(
     ...(typeof merged.fastMode === "boolean" ? { fastMode: merged.fastMode } : {}),
     ...(typeof merged.responsesLite === "boolean" ? { responsesLite: merged.responsesLite } : {}),
     ...(typeof merged.applyPatch === "boolean" ? { applyPatch: merged.applyPatch } : {}),
+    ...(typeof merged.applyPatchDebug === "boolean"
+      ? { applyPatchDebug: merged.applyPatchDebug }
+      : {}),
     ...(merged.toolBackground ? { toolBackground: merged.toolBackground } : {}),
     ...(typeof merged.imageGeneration === "boolean"
       ? { imageGeneration: merged.imageGeneration }
@@ -363,6 +380,7 @@ export function configLayer(config: CodexCompatConfig): ConfigLayer {
     fastMode: config.fastMode,
     responsesLite: config.responsesLite,
     applyPatch: config.applyPatch,
+    applyPatchDebug: config.applyPatchDebug,
     toolBackground: config.toolBackground,
     imageGeneration: config.imageGeneration,
     imageDetail: config.imageDetail,

package/extensions/openai-codex-compat/footer.ts

@@ -4,7 +4,7 @@ import {
   type ExtensionContext,
   type ReadonlyFooterDataProvider,
 } from "@earendil-works/pi-coding-agent";
-import type { Component, TUI } from "@earendil-works/pi-tui";
+import type { Component } from "@earendil-works/pi-tui";
 import type { CodexCompatConfig } from "./config.ts";
 import { isCodexModel } from "./request-options.ts";
 
@@ -74,16 +74,15 @@ function footerSession(ctx: ExtensionContext, resolveConfig: ConfigResolver): Fo
 
 class CodexFooter implements Component {
   private readonly footer: FooterComponent;
-  private readonly unsubscribe: () => void;
 
   constructor(
-    tui: TUI,
     footerData: ReadonlyFooterDataProvider,
     ctx: ExtensionContext,
     resolveConfig: ConfigResolver,
   ) {
     this.footer = new FooterComponent(footerSession(ctx, resolveConfig), footerData);
-    this.unsubscribe = footerData.onBranchChange(() => tui.requestRender());
+    // Pi does not expose its live auto-compaction state to extension footers.
+    this.footer.setAutoCompactEnabled(false);
   }
 
   render(width: number): string[] {
@@ -95,14 +94,11 @@ class CodexFooter implements Component {
   }
 
   dispose(): void {
-    this.unsubscribe();
     this.footer.dispose();
   }
 }
 
 export function installCodexFooter(ctx: ExtensionContext, resolveConfig: ConfigResolver): void {
   if (ctx.mode !== "tui") return;
-  ctx.ui.setFooter(
-    (tui, _theme, footerData) => new CodexFooter(tui, footerData, ctx, resolveConfig),
-  );
+  ctx.ui.setFooter((_tui, _theme, footerData) => new CodexFooter(footerData, ctx, resolveConfig));
 }

package/extensions/openai-codex-compat/index.ts

@@ -32,6 +32,7 @@ function settingsSummary(ctx: ExtensionContext, config: CodexCompatConfig): stri
     `reasoning mode: ${config.reasoningMode}`,
     `Codex tool background: ${config.toolBackground}`,
     `apply_patch: ${config.applyPatch ? "on" : "off"}`,
+    `apply_patch debug output: ${config.applyPatchDebug ? "on" : "off"}`,
     `image_gen.imagegen: ${config.imageGeneration ? "on" : "off"}`,
     `image result detail: ${config.imageDetail}`,
     `web.run: ${config.webRun ? "on" : "off"}`,
@@ -51,6 +52,8 @@ export default function registerOpenAICodexCompat(pi: ExtensionAPI): void {
     return activeConfig;
   };
   const resolveToolBackground = () => activeConfig?.toolBackground ?? DEFAULT_CONFIG.toolBackground;
+  const resolveApplyPatchDebug = () =>
+    activeConfig?.applyPatchDebug ?? DEFAULT_CONFIG.applyPatchDebug;
 
   pi.on("session_start", (event, ctx) => {
     activeConfig = loadConfig(ctx.cwd, ctx.isProjectTrusted());
@@ -60,7 +63,7 @@ export default function registerOpenAICodexCompat(pi: ExtensionAPI): void {
     }
   });
 
-  registerCodexTools(pi, resolveConfig, resolveToolBackground);
+  registerCodexTools(pi, resolveConfig, resolveToolBackground, resolveApplyPatchDebug);
   registerCodexThreadLineage(pi);
   const codexProvider = registerCodexProvider(pi, resolveConfig);
   registerCodexRequestOptions(pi, resolveConfig);

package/extensions/openai-codex-compat/remote-compaction.ts

@@ -188,6 +188,10 @@ export default function registerRemoteCompaction(
         template,
         priority: config.fastMode,
         compactionMetadata: compactionMetadata(event.reason),
+        compactionDecision: {
+          reason: event.reason,
+          willRetry: event.willRetry,
+        },
       });
 
       return {

package/extensions/openai-codex-compat/settings-pane.ts

@@ -34,6 +34,7 @@ type SettingId =
   | "reasoningMode"
   | "toolBackground"
   | "applyPatch"
+  | "applyPatchDebug"
   | "imageGeneration"
   | "imageDetail"
   | "webRun"
@@ -108,6 +109,13 @@ export function settingItems(
       currentValue: toggleValue(config.applyPatch),
       values: ["off", "on"],
     },
+    {
+      id: "applyPatchDebug",
+      label: "apply_patch debug output",
+      description: "Show exact model feedback while apply_patch output is collapsed.",
+      currentValue: toggleValue(config.applyPatchDebug),
+      values: ["off", "on"],
+    },
     {
       id: "imageGeneration",
       label: "image_gen.imagegen tool",
@@ -185,6 +193,8 @@ export function settingPatch(id: string, value: string): ConfigLayer | undefined
       return undefined;
     case "applyPatch":
       return value === "on" || value === "off" ? { applyPatch: value === "on" } : undefined;
+    case "applyPatchDebug":
+      return value === "on" || value === "off" ? { applyPatchDebug: value === "on" } : undefined;
     case "imageGeneration":
       return value === "on" || value === "off" ? { imageGeneration: value === "on" } : undefined;
     case "imageDetail":
@@ -214,6 +224,7 @@ function applySettingPatch(config: CodexCompatConfig, patch: ConfigLayer): Codex
   if (typeof patch.fastMode === "boolean") next.fastMode = patch.fastMode;
   if (typeof patch.responsesLite === "boolean") next.responsesLite = patch.responsesLite;
   if (typeof patch.applyPatch === "boolean") next.applyPatch = patch.applyPatch;
+  if (typeof patch.applyPatchDebug === "boolean") next.applyPatchDebug = patch.applyPatchDebug;
   if (patch.toolBackground) next.toolBackground = patch.toolBackground;
   if (typeof patch.imageGeneration === "boolean") {
     next.imageGeneration = patch.imageGeneration;

package/extensions/openai-codex-compat/tools.ts

@@ -63,8 +63,9 @@ export default function registerCodexTools(
   pi: ExtensionAPI,
   resolveConfig: ConfigResolver,
   resolveToolBackground: CodexToolBackgroundResolver = () => DEFAULT_CONFIG.toolBackground,
+  resolveApplyPatchDebug: () => boolean = () => DEFAULT_CONFIG.applyPatchDebug,
 ): void {
-  registerApplyPatch(pi, resolveToolBackground);
+  registerApplyPatch(pi, resolveToolBackground, resolveApplyPatchDebug);
   registerImageGeneration(pi, resolveConfig, resolveToolBackground);
   registerWebRun(pi, resolveConfig, resolveToolBackground);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-openai-codex-compat",
-  "version": "0.0.7-alpha.0",
+  "version": "0.0.8",
   "description": "OpenAI Codex compatibility for Pi with native compaction, fast mode, and Codex-optimized capabilities",
   "keywords": [
     "pi-package"
@@ -21,6 +21,7 @@
   },
   "files": [
     "extensions",
+    "APPLY_PATCH_INSTRUCTION_FEEDBACK.md",
     "README.md",
     "CHANGELOG.md",
     "LICENSE",
@@ -38,15 +39,19 @@
     "lint": "oxlint",
     "lint:fix": "oxlint --fix"
   },
+  "dependencies": {
+    "@2h2d/tree-sitter-wasms": "0.2.1",
+    "web-tree-sitter": "0.26.11"
+  },
   "devDependencies": {
     "@earendil-works/pi-ai": "0.84.1",
     "@earendil-works/pi-coding-agent": "0.84.1",
     "@earendil-works/pi-tui": "0.84.1",
     "@types/node": "22.20.1",
-    "oxfmt": "0.60.0",
-    "oxlint": "1.75.0",
+    "oxfmt": "0.62.0",
+    "oxlint": "1.77.0",
     "oxlint-tsgolint": "7.0.2001",
-    "typebox": "1.3.7",
+    "typebox": "1.3.11",
     "typescript": "7.0.2"
   },
   "peerDependencies": {