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

package/extensions/openai-codex-compat/apply-patch-render.ts

@@ -40,14 +40,79 @@ type ApplyPatchResult = {
   details?: unknown;
 };
 
+export type ApplyPatchDebugResolver = () => boolean;
+
+class ApplyPatchTitleComponent implements Component {
+  private readonly text = new Text("", 0, 0);
+  private readonly theme: Theme;
+  private readonly resolveDebug: ApplyPatchDebugResolver;
+
+  constructor(theme: Theme, resolveDebug: ApplyPatchDebugResolver) {
+    this.theme = theme;
+    this.resolveDebug = resolveDebug;
+  }
+
+  render(width: number): string[] {
+    const title = this.resolveDebug() ? "apply_patch (debug)" : "apply_patch";
+    this.text.setText(this.theme.fg("toolTitle", this.theme.bold(title)));
+    return this.text.render(width);
+  }
+
+  invalidate(): void {
+    this.text.invalidate();
+  }
+}
+
+function modelFeedback(result: ApplyPatchResult): string | undefined {
+  const text = result.content.flatMap((item) =>
+    item.type === "text" && typeof item.text === "string" ? [item.text] : [],
+  );
+  return text.length > 0 ? text.join("\n") : undefined;
+}
+
+class ApplyPatchResultComponent implements Component {
+  private readonly ordinary: Component;
+  private readonly feedback: Container | undefined;
+  private readonly expanded: boolean;
+  private readonly resolveDebug: ApplyPatchDebugResolver;
+
+  constructor(
+    ordinary: Component,
+    result: ApplyPatchResult,
+    expanded: boolean,
+    resolveDebug: ApplyPatchDebugResolver,
+  ) {
+    this.ordinary = ordinary;
+    this.expanded = expanded;
+    this.resolveDebug = resolveDebug;
+    const feedback = modelFeedback(result);
+    if (feedback !== undefined) {
+      this.feedback = new Container();
+      this.feedback.addChild(new Text(feedback, 0, 0));
+    }
+  }
+
+  render(width: number): string[] {
+    return !this.expanded && this.resolveDebug() && this.feedback
+      ? this.feedback.render(width)
+      : this.ordinary.render(width);
+  }
+
+  invalidate(): void {
+    this.ordinary.invalidate();
+    this.feedback?.invalidate();
+  }
+}
+
 export function renderApplyPatchCall(
   args: ApplyPatchArgs,
   theme: Theme,
   context: ApplyPatchRenderContext,
   resolveBackground: CodexToolBackgroundResolver = () => DEFAULT_CONFIG.toolBackground,
+  resolveDebug: ApplyPatchDebugResolver = () => DEFAULT_CONFIG.applyPatchDebug,
 ): Component {
   const container = new Container();
-  container.addChild(new Text(theme.fg("toolTitle", theme.bold("apply_patch")), 0, 0));
+  container.addChild(new ApplyPatchTitleComponent(theme, resolveDebug));
 
   if (context.isPartial) {
     const state = context.state;
@@ -96,23 +161,20 @@ export function renderApplyPatchResult(
   theme: Theme,
   context: ApplyPatchRenderContext,
   resolveBackground: CodexToolBackgroundResolver = () => DEFAULT_CONFIG.toolBackground,
+  resolveDebug: ApplyPatchDebugResolver = () => DEFAULT_CONFIG.applyPatchDebug,
 ): Component {
   if (options.isPartial) return new Container();
 
   const details = isApplyPatchDetails(result.details) ? result.details : undefined;
-  const preview = isApplyPatchDetails(context.state.preview) ? context.state.preview : undefined;
-  const renderDetails =
-    details?.status === "failed" && preview
-      ? {
-          ...preview,
-          status: "failed" as const,
-          ...(details.error !== undefined ? { error: details.error } : {}),
-        }
-      : details;
-
-  if (renderDetails) {
+
+  if (details) {
     return new CodexToolSurfaceComponent(
-      new ApplyPatchDiffComponent(renderDetails, theme, context.cwd, context.expanded),
+      new ApplyPatchResultComponent(
+        new ApplyPatchDiffComponent(details, theme, context.cwd, context.expanded),
+        result,
+        context.expanded,
+        resolveDebug,
+      ),
       theme,
       {
         background: resolveBackground,
@@ -124,10 +186,14 @@ export function renderApplyPatchResult(
   }
   const text = context.isError ? theme.bold(theme.fg("error", "✘ Failed to apply patch")) : "";
   if (!text) return new Container();
-  return new CodexToolSurfaceComponent(new Text(text, 0, 0), theme, {
-    background: resolveBackground,
-    status: "error",
-    top: false,
-    bottom: true,
-  });
+  return new CodexToolSurfaceComponent(
+    new ApplyPatchResultComponent(new Text(text, 0, 0), result, context.expanded, resolveDebug),
+    theme,
+    {
+      background: resolveBackground,
+      status: "error",
+      top: false,
+      bottom: true,
+    },
+  );
 }

package/extensions/openai-codex-compat/apply-patch.ts

@@ -7,14 +7,30 @@ import {
   applyPatch,
   type ApplyPatchDetails,
   ApplyPatchExecutionError,
+  ApplyPatchInputError,
+  ApplyPatchVerificationError,
+  formatApplyPatchFailureSummary,
   formatApplyPatchModelOutput,
   formatApplyPatchSummary,
 } from "./apply-patch-engine.ts";
-import { renderApplyPatchCall, renderApplyPatchResult } from "./apply-patch-render.ts";
+import {
+  type ApplyPatchDebugResolver,
+  renderApplyPatchCall,
+  renderApplyPatchResult,
+} from "./apply-patch-render.ts";
 
 export {
   applyPatch,
   type ApplyPatchDetails,
+  type ApplyPatchExecutionFilesystem,
+  type ApplyPatchExecutionHooks,
+  type ApplyPatchFailureDetails,
+  type ApplyPatchInstructionDetails,
+  type ApplyPatchInstructionEffect,
+  type ApplyPatchInstructionReason,
+  type ApplyPatchInstructionReasonCode,
+  type ApplyPatchInstructionStatus,
+  type ApplyPatchFinalPathState,
   type AppliedPatchChange,
   ApplyPatchExecutionError,
   ApplyPatchInputError,
@@ -27,6 +43,7 @@ export {
   parsePatchDocument,
   previewPatch,
 } from "./apply-patch-engine.ts";
+export type { FormatterMatchFailureDetails } from "./apply-patch-matcher.ts";
 
 export const APPLY_PATCH_TOOL_NAME = "apply_patch";
 export const APPLY_PATCH_INPUT_PROPERTY = "patch";
@@ -57,6 +74,7 @@ eof_line: "*** End of File" LF
 export default function registerApplyPatch(
   pi: ExtensionAPI,
   resolveToolBackground: CodexToolBackgroundResolver = () => DEFAULT_CONFIG.toolBackground,
+  resolveDebug: ApplyPatchDebugResolver = () => DEFAULT_CONFIG.applyPatchDebug,
 ): void {
   const failedDetails = new Map<string, ApplyPatchDetails>();
 
@@ -115,7 +133,7 @@ export default function registerApplyPatch(
               text: formatApplyPatchModelOutput(
                 0,
                 executionDurationMs(),
-                formatApplyPatchSummary(details),
+                formatApplyPatchSummary(details, ctx.cwd),
               ),
             },
           ],
@@ -125,17 +143,35 @@ export default function registerApplyPatch(
         if (error instanceof ApplyPatchExecutionError) {
           failedDetails.set(toolCallId, error.details);
           throw new Error(
-            formatApplyPatchModelOutput(1, executionDurationMs(), `${error.message}\n`),
+            formatApplyPatchModelOutput(
+              1,
+              executionDurationMs(),
+              formatApplyPatchFailureSummary(error.details, ctx.cwd),
+            ),
           );
         }
+        if (error instanceof ApplyPatchVerificationError) {
+          failedDetails.set(toolCallId, error.details);
+          throw new Error(formatApplyPatchFailureSummary(error.details, ctx.cwd));
+        } else if (error instanceof ApplyPatchInputError && error.details) {
+          failedDetails.set(toolCallId, error.details);
+          throw new Error(formatApplyPatchFailureSummary(error.details, ctx.cwd));
+        }
         throw error;
       }
     },
     renderCall(args, theme, context) {
-      return renderApplyPatchCall(args, theme, context, resolveToolBackground);
+      return renderApplyPatchCall(args, theme, context, resolveToolBackground, resolveDebug);
     },
     renderResult(result, options, theme, context) {
-      return renderApplyPatchResult(result, options, theme, context, resolveToolBackground);
+      return renderApplyPatchResult(
+        result,
+        options,
+        theme,
+        context,
+        resolveToolBackground,
+        resolveDebug,
+      );
     },
   });
 }

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

@@ -9,6 +9,7 @@ import {
   clampThinkingLevel,
   createAssistantMessageEventStream,
   type AssistantMessage,
+  type AssistantMessageDiagnostic,
   type AssistantMessageEventStream,
   type Context,
   type Model,
@@ -28,6 +29,7 @@ import {
   providerHistory,
   searchCheckpoint,
   type CheckpointData,
+  type CompactionDecision,
   type GrammarToolInputProperties,
 } from "./compaction-checkpoint.ts";
 import {
@@ -113,6 +115,7 @@ type ActiveAgentTurn = {
   turnId: string;
   startedAtUnixMs: number;
   turnState: CodexTurnState;
+  pendingPostToolDisposition?: CodexPostToolDisposition;
 };
 
 type CodexCompat = {
@@ -126,6 +129,32 @@ type CodexTerminalState = {
   response?: JsonRecord;
 };
 
+type CodexAttemptCapture = {
+  streamedItems: ResponsesItem[];
+  streamedToolCallIndexes: Set<number>;
+  streamedCompletedToolCallIndexes: Set<number>;
+};
+
+type CodexToolCallAssessment = {
+  completedCount: number;
+  discardedPartialCount: number;
+  hasCompletedCalls: boolean;
+};
+
+type CodexPostToolDisposition = {
+  callIds: string[];
+  response?: JsonRecord;
+  retryAttempt: number;
+  terminalType: "response.incomplete" | "response.failed";
+  type: "error" | "retry";
+};
+
+type CodexResponseDecision =
+  | "continue_no_tools"
+  | "retry_original_input"
+  | "return_terminal"
+  | "return_tool_use";
+
 export type CodexResponseRetryPolicy = {
   maxRetries: number;
   baseDelayMs: number;
@@ -187,27 +216,100 @@ function nativeOverrideRequired(
   );
 }
 
+function isToolCallItem(item: ResponsesItem): boolean {
+  return item.type === "function_call" || item.type === "custom_tool_call";
+}
+
+function eventOutputIndex(event: JsonRecord): number {
+  return typeof event["output_index"] === "number" ? event["output_index"] : 0;
+}
+
+function assessAttemptToolCalls(
+  items: readonly ResponsesItem[],
+  capture: CodexAttemptCapture,
+): CodexToolCallAssessment {
+  const completedCount = items.filter(isToolCallItem).length;
+  const discardedPartialCount = [...capture.streamedToolCallIndexes].filter(
+    (index) => !capture.streamedCompletedToolCallIndexes.has(index),
+  ).length;
+  return {
+    completedCount,
+    discardedPartialCount,
+    hasCompletedCalls: completedCount > 0,
+  };
+}
+
+function outputItemTypeCounts(items: readonly ResponsesItem[]): Record<string, number> {
+  const counts: Record<string, number> = {};
+  for (const item of items) {
+    const type = item.type ?? "message";
+    counts[type] = (counts[type] ?? 0) + 1;
+  }
+  return counts;
+}
+
+function responseDecisionDiagnostic(options: {
+  attempt: number;
+  attemptItems: readonly ResponsesItem[];
+  capture: CodexAttemptCapture;
+  decision: CodexResponseDecision;
+  incompleteReason?: string;
+  postToolDisposition?: "continue" | "error" | "retry";
+  terminalState: CodexTerminalState;
+  toolCalls: CodexToolCallAssessment;
+}): AssistantMessageDiagnostic | undefined {
+  const endTurn =
+    typeof options.terminalState.response?.["end_turn"] === "boolean"
+      ? options.terminalState.response["end_turn"]
+      : undefined;
+  const nontrivial =
+    options.attempt > 1 ||
+    options.terminalState.type !== "response.completed" ||
+    endTurn === false ||
+    options.capture.streamedToolCallIndexes.size > 0;
+  if (!nontrivial) return undefined;
+
+  return {
+    type: "codex_response_decision",
+    timestamp: Date.now(),
+    details: {
+      attempt: options.attempt,
+      terminalType: options.terminalState.type ?? "missing",
+      ...(options.incompleteReason ? { incompleteReason: options.incompleteReason } : {}),
+      ...(endTurn === undefined ? {} : { endTurn }),
+      outputItemTypes: outputItemTypeCounts(options.attemptItems),
+      streamedCallsStarted: options.capture.streamedToolCallIndexes.size,
+      streamedCallsDone: options.capture.streamedCompletedToolCallIndexes.size,
+      returnedCalls: options.toolCalls.completedCount,
+      discardedPartialCalls: options.toolCalls.discardedPartialCount,
+      ...(options.postToolDisposition ? { postToolDisposition: options.postToolDisposition } : {}),
+      decision: options.decision,
+    },
+  };
+}
+
 function captureRawEvents(
   events: AsyncIterable<JsonRecord>,
-  items: ResponsesItem[],
+  capture: CodexAttemptCapture,
   terminalState?: CodexTerminalState,
 ): AsyncIterable<JsonRecord> {
   return {
     async *[Symbol.asyncIterator]() {
       for await (const event of events) {
-        if (event.type === "response.output_item.done" && isResponsesItem(event.item)) {
-          items.push(structuredClone(event.item));
-        }
         if (
-          (event.type === "response.completed" ||
-            event.type === "response.incomplete" ||
-            event.type === "response.failed") &&
-          isObject(event.response) &&
-          Array.isArray(event.response["output"])
+          event.type === "response.output_item.added" &&
+          isResponsesItem(event.item) &&
+          isToolCallItem(event.item)
         ) {
-          const terminalItems = event.response["output"].filter(isResponsesItem);
-          if (terminalItems.length > 0) {
-            items.splice(0, items.length, ...terminalItems.map((item) => structuredClone(item)));
+          capture.streamedToolCallIndexes.add(eventOutputIndex(event));
+        }
+        if (event.type === "response.output_item.done" && isResponsesItem(event.item)) {
+          const item = structuredClone(event.item);
+          capture.streamedItems.push(item);
+          if (isToolCallItem(item)) {
+            const index = eventOutputIndex(event);
+            capture.streamedToolCallIndexes.add(index);
+            capture.streamedCompletedToolCallIndexes.add(index);
           }
         }
         if (
@@ -310,6 +412,48 @@ function retryableResponseFailure(response: JsonRecord | undefined): boolean {
   );
 }
 
+function terminalErrorMessage(disposition: CodexPostToolDisposition): string {
+  if (disposition.terminalType === "response.failed") {
+    const error = isObject(disposition.response?.["error"])
+      ? disposition.response["error"]
+      : undefined;
+    return typeof error?.["message"] === "string" ? error["message"] : "Codex response failed";
+  }
+  const details = isObject(disposition.response?.["incomplete_details"])
+    ? disposition.response["incomplete_details"]
+    : undefined;
+  const reason = typeof details?.["reason"] === "string" ? details["reason"] : undefined;
+  return reason
+    ? `Response incomplete: ${reason}`
+    : "Response incomplete without a provider reason";
+}
+
+function completedAttemptToolCallIds(
+  message: AssistantMessage,
+  attempt: CodexStreamAttemptState,
+): string[] {
+  return [...attempt.completedContentIndexes]
+    .sort((left, right) => left - right)
+    .flatMap((index) => {
+      const block = message.content[index];
+      return block?.type === "toolCall" ? [block.id] : [];
+    });
+}
+
+function assertLinkedToolOutputs(context: Context, disposition: CodexPostToolDisposition): void {
+  const outputIds = new Set(
+    context.messages.flatMap((message) =>
+      message.role === "toolResult" ? [message.toolCallId] : [],
+    ),
+  );
+  const missing = disposition.callIds.filter((callId) => !outputIds.has(callId));
+  if (missing.length > 0) {
+    throw new Error(
+      `Codex cannot process the ${disposition.terminalType} response until Pi records tool output for: ${missing.join(", ")}`,
+    );
+  }
+}
+
 function responseRetryDelayMs(baseDelayMs: number, attempt: number): number {
   if (baseDelayMs <= 0) return 0;
   const exponential = baseDelayMs * 2 ** Math.max(0, attempt - 1);
@@ -808,6 +952,7 @@ export class CodexProviderRuntime {
     grammarToolInputProperties: GrammarToolInputProperties;
     priority: boolean;
     compactionMetadata: CodexCompactionMetadata;
+    compactionDecision: CompactionDecision;
     agentTurn?: ActiveAgentTurn;
     responsesLiteEnabled?: boolean;
   }): Promise<{ checkpoint: CheckpointData; usage?: Usage }> {
@@ -881,6 +1026,7 @@ export class CodexProviderRuntime {
         options.history,
         compacted.item,
         options.postCompactionTail,
+        options.compactionDecision,
       ),
       ...(compacted.usage ? { usage: compacted.usage } : {}),
     };
@@ -953,6 +1099,7 @@ export class CodexProviderRuntime {
       grammarToolInputProperties,
       priority: scope.config.fastMode,
       compactionMetadata: responsesCompactionV2Metadata("auto", "context_limit", "pre_turn"),
+      compactionDecision: { reason: "provider-boundary", willRetry: true },
       agentTurn,
       responsesLiteEnabled,
     });
@@ -1014,6 +1161,26 @@ export class CodexProviderRuntime {
           requestOptions.cacheRetention === "none" ? undefined : codexCacheKey(runtimeSessionId);
         const agentTurn = this.agentTurn(runtimeSessionId);
         const responsesLiteEnabled = this.responsesLiteEnabled(runtimeSessionId);
+        let carriedResponseRetries = 0;
+        const pendingPostToolDisposition = agentTurn.pendingPostToolDisposition;
+        if (pendingPostToolDisposition) {
+          assertLinkedToolOutputs(context, pendingPostToolDisposition);
+          delete agentTurn.pendingPostToolDisposition;
+          if (
+            pendingPostToolDisposition.type === "error" ||
+            pendingPostToolDisposition.retryAttempt > this.responseRetryPolicy.maxRetries
+          ) {
+            throw new Error(terminalErrorMessage(pendingPostToolDisposition));
+          }
+          carriedResponseRetries = pendingPostToolDisposition.retryAttempt;
+          await waitForResponseRetry(
+            responseRetryDelayMs(
+              this.responseRetryPolicy.baseDelayMs,
+              pendingPostToolDisposition.retryAttempt,
+            ),
+            requestOptions.signal,
+          );
+        }
         const grammarToolInputProperties = createGrammarToolInputProperties(
           context.tools,
           (model.compat as CodexCompat | undefined)?.supportsOpenAIGrammarTools ?? false,
@@ -1100,10 +1267,14 @@ export class CodexProviderRuntime {
           },
         };
         let responseRequests = 0;
-        let responseRetries = 0;
+        let responseRetries = carriedResponseRetries;
         while (true) {
           responseRequests += 1;
-          const attemptItems: ResponsesItem[] = [];
+          const attemptCapture: CodexAttemptCapture = {
+            streamedItems: [],
+            streamedToolCallIndexes: new Set(),
+            streamedCompletedToolCallIndexes: new Set(),
+          };
           const terminalState: CodexTerminalState = {};
           const attemptState: CodexStreamAttemptState = {
             startedContentIndexes: new Set(),
@@ -1116,7 +1287,7 @@ export class CodexProviderRuntime {
               startOnFirstEvent(
                 captureRawEvents(
                   this.transport.request(model, body, transportRequestOptions),
-                  attemptItems,
+                  attemptCapture,
                   terminalState,
                 ),
                 emitStart,
@@ -1140,12 +1311,71 @@ export class CodexProviderRuntime {
             throw error;
           }
           output.usage = accumulateUsage(usageBeforeAttempt, output.usage);
-          rawItems.push(...attemptItems.map((item) => structuredClone(item)));
+          // `response.output_item.done` is Codex's item-level commit point. Terminal
+          // response.output snapshots are deliberately ignored.
+          const attemptItems = attemptCapture.streamedItems;
+          const toolCalls = assessAttemptToolCalls(attemptItems, attemptCapture);
+          const incompleteDetails = isObject(terminalState.response?.["incomplete_details"])
+            ? terminalState.response["incomplete_details"]
+            : undefined;
+          const incompleteReason =
+            typeof incompleteDetails?.["reason"] === "string"
+              ? incompleteDetails["reason"]
+              : undefined;
+          const recordDecision = (
+            decision: CodexResponseDecision,
+            postToolDisposition?: "continue" | "error" | "retry",
+          ): void => {
+            const diagnostic = responseDecisionDiagnostic({
+              attempt: responseRequests,
+              attemptItems,
+              capture: attemptCapture,
+              decision,
+              ...(incompleteReason ? { incompleteReason } : {}),
+              ...(postToolDisposition ? { postToolDisposition } : {}),
+              terminalState,
+              toolCalls,
+            });
+            if (diagnostic) output.diagnostics = [...(output.diagnostics ?? []), diagnostic];
+          };
+
+          // Return each done tool call before processing an unsuccessful response
+          // terminal. Pi will execute the completed subset; started-only siblings
+          // are discarded and never enter provider history.
+          if (toolCalls.hasCompletedCalls) {
+            const callIds = completedAttemptToolCallIds(output, attemptState);
+            if (callIds.length !== toolCalls.completedCount) {
+              throw new Error("Codex completed tool-call items could not be mapped to Pi calls.");
+            }
+            let postToolDisposition: "continue" | "error" | "retry" = "continue";
+            if (
+              terminalState.type === "response.incomplete" ||
+              terminalState.type === "response.failed"
+            ) {
+              const retryable =
+                terminalState.type === "response.incomplete" ||
+                retryableResponseFailure(terminalState.response);
+              postToolDisposition = retryable ? "retry" : "error";
+              agentTurn.pendingPostToolDisposition = {
+                callIds,
+                ...(terminalState.response
+                  ? { response: structuredClone(terminalState.response) }
+                  : {}),
+                retryAttempt: retryable ? responseRetries + 1 : responseRetries,
+                terminalType: terminalState.type,
+                type: postToolDisposition,
+              };
+            }
+            discardIncompleteAttemptContent(output, attemptState);
+            rawItems.push(...attemptItems.map((item) => structuredClone(item)));
+            output.stopReason = "toolUse";
+            delete output.errorMessage;
+            recordDecision("return_tool_use", postToolDisposition);
+            break;
+          }
 
           const nextBody = continueResponseBody(body, attemptItems);
-          const attemptHasToolCall = [...attemptState.completedContentIndexes].some(
-            (index) => output.content[index]?.type === "toolCall",
-          );
+          rawItems.push(...attemptItems.map((item) => structuredClone(item)));
           discardIncompleteAttemptContent(output, attemptState);
           const retryableTerminal =
             terminalState.type === "response.incomplete" ||
@@ -1161,6 +1391,9 @@ export class CodexProviderRuntime {
             output.stopReason = "pending";
             delete output.errorMessage;
             delete output.rawStopReason;
+            recordDecision(
+              attemptItems.length === 0 ? "retry_original_input" : "continue_no_tools",
+            );
             await waitForResponseRetry(
               responseRetryDelayMs(this.responseRetryPolicy.baseDelayMs, responseRetries),
               requestOptions.signal,
@@ -1170,8 +1403,7 @@ export class CodexProviderRuntime {
 
           if (
             terminalState.type === "response.completed" &&
-            terminalState.response?.["end_turn"] === false &&
-            !attemptHasToolCall
+            terminalState.response?.["end_turn"] === false
           ) {
             if (!nextBody) {
               throw new Error(
@@ -1183,8 +1415,10 @@ export class CodexProviderRuntime {
             output.stopReason = "pending";
             delete output.errorMessage;
             delete output.rawStopReason;
+            recordDecision("continue_no_tools");
             continue;
           }
+          recordDecision("return_terminal");
           break;
         }
         if (requestOptions.signal?.aborted) throw new Error("Request was aborted");
@@ -1285,6 +1519,7 @@ export class CodexProviderRuntime {
     template: JsonRecord;
     priority: boolean;
     compactionMetadata: CodexCompactionMetadata;
+    compactionDecision: CompactionDecision;
   }): Promise<{ checkpoint: CheckpointData; usage?: Usage }> {
     validateCodexAuthentication(options.model, options.requestOptions.apiKey);
     const release = await this.acquireRequest(