pi-openai-codex-compat 0.0.6 → 0.0.7

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 {
@@ -126,6 +128,30 @@ type CodexTerminalState = {
   response?: JsonRecord;
 };
 
+type CodexAttemptCapture = {
+  streamedItems: ResponsesItem[];
+  streamedToolCallKeys: Set<string>;
+  streamedCompletedToolCallKeys: Set<string>;
+  terminalItems?: ResponsesItem[];
+};
+
+type CodexToolCallAssessment = {
+  allComplete: boolean;
+  authoritativeCount: number;
+  hasToolCalls: boolean;
+  omittedStreamedCount: number;
+  terminalCount: number;
+};
+
+type CodexResponseDecision =
+  | "continue_no_tools"
+  | "preserve_terminal_error"
+  | "reject_terminal_stream_mismatch"
+  | "retry_original_input"
+  | "return_length_incomplete_call"
+  | "return_terminal"
+  | "return_tool_use";
+
 export type CodexResponseRetryPolicy = {
   maxRetries: number;
   baseDelayMs: number;
@@ -187,16 +213,143 @@ function nativeOverrideRequired(
   );
 }
 
+function isToolCallItem(item: ResponsesItem): boolean {
+  return item.type === "function_call" || item.type === "custom_tool_call";
+}
+
+function toolCallKey(item: ResponsesItem): string {
+  const callId = typeof item["call_id"] === "string" ? item["call_id"] : undefined;
+  const itemId = typeof item.id === "string" ? item.id : undefined;
+  return `${String(item.type)}:${itemId ? `item:${itemId}` : `call:${callId ?? "missing"}`}`;
+}
+
+function hasValidToolCallPayload(item: ResponsesItem): boolean {
+  if (
+    typeof item.id !== "string" ||
+    typeof item["call_id"] !== "string" ||
+    typeof item.name !== "string"
+  ) {
+    return false;
+  }
+  if (item.type === "custom_tool_call") return typeof item.input === "string";
+  if (item.type !== "function_call" || typeof item.arguments !== "string") return false;
+  try {
+    return isObject(JSON.parse(item.arguments));
+  } catch {
+    return false;
+  }
+}
+
+function toolCallIsComplete(
+  item: ResponsesItem,
+  capture: CodexAttemptCapture,
+  terminalType: CodexTerminalState["type"],
+): boolean {
+  if (!hasValidToolCallPayload(item)) return false;
+  const status = typeof item["status"] === "string" ? item["status"] : undefined;
+  if (status !== undefined) return status === "completed";
+  if (capture.streamedCompletedToolCallKeys.has(toolCallKey(item))) return true;
+  return terminalType === "response.completed";
+}
+
+function assessAttemptToolCalls(
+  items: readonly ResponsesItem[],
+  capture: CodexAttemptCapture,
+  terminalType: CodexTerminalState["type"],
+): CodexToolCallAssessment {
+  const calls = items.filter(isToolCallItem);
+  const authoritativeKeys = new Set(calls.map(toolCallKey));
+  const omittedStreamedCount = [...capture.streamedToolCallKeys].filter(
+    (key) => !authoritativeKeys.has(key),
+  ).length;
+  const hasToolCalls = calls.length > 0 || capture.streamedToolCallKeys.size > 0;
+  return {
+    hasToolCalls,
+    allComplete:
+      hasToolCalls &&
+      omittedStreamedCount === 0 &&
+      calls.length > 0 &&
+      calls.every((item) => toolCallIsComplete(item, capture, terminalType)),
+    authoritativeCount: calls.length,
+    omittedStreamedCount,
+    terminalCount: capture.terminalItems?.filter(isToolCallItem).length ?? 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;
+  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.toolCalls.hasToolCalls ||
+    options.toolCalls.omittedStreamedCount > 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 }),
+      itemSource: options.capture.terminalItems ? "terminal" : "stream-fallback",
+      outputItemTypes: outputItemTypeCounts(options.attemptItems),
+      streamedCallsStarted: options.capture.streamedToolCallKeys.size,
+      streamedCallsCompleted: options.capture.streamedCompletedToolCallKeys.size,
+      terminalCalls: options.toolCalls.terminalCount,
+      authoritativeCalls: options.toolCalls.authoritativeCount,
+      terminalOmittedStreamedCalls: options.toolCalls.omittedStreamedCount,
+      allCallsComplete: options.toolCalls.allComplete,
+      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.added" &&
+          isResponsesItem(event.item) &&
+          isToolCallItem(event.item)
+        ) {
+          capture.streamedToolCallKeys.add(toolCallKey(event.item));
+        }
         if (event.type === "response.output_item.done" && isResponsesItem(event.item)) {
-          items.push(structuredClone(event.item));
+          const item = structuredClone(event.item);
+          capture.streamedItems.push(item);
+          if (isToolCallItem(item)) {
+            const key = toolCallKey(item);
+            capture.streamedToolCallKeys.add(key);
+            capture.streamedCompletedToolCallKeys.add(key);
+          }
         }
         if (
           (event.type === "response.completed" ||
@@ -205,10 +358,9 @@ function captureRawEvents(
           isObject(event.response) &&
           Array.isArray(event.response["output"])
         ) {
-          const terminalItems = event.response["output"].filter(isResponsesItem);
-          if (terminalItems.length > 0) {
-            items.splice(0, items.length, ...terminalItems.map((item) => structuredClone(item)));
-          }
+          capture.terminalItems = event.response["output"]
+            .filter(isResponsesItem)
+            .map((item) => structuredClone(item));
         }
         if (
           terminalState &&
@@ -808,6 +960,7 @@ export class CodexProviderRuntime {
     grammarToolInputProperties: GrammarToolInputProperties;
     priority: boolean;
     compactionMetadata: CodexCompactionMetadata;
+    compactionDecision: CompactionDecision;
     agentTurn?: ActiveAgentTurn;
     responsesLiteEnabled?: boolean;
   }): Promise<{ checkpoint: CheckpointData; usage?: Usage }> {
@@ -881,6 +1034,7 @@ export class CodexProviderRuntime {
         options.history,
         compacted.item,
         options.postCompactionTail,
+        options.compactionDecision,
       ),
       ...(compacted.usage ? { usage: compacted.usage } : {}),
     };
@@ -953,6 +1107,7 @@ export class CodexProviderRuntime {
       grammarToolInputProperties,
       priority: scope.config.fastMode,
       compactionMetadata: responsesCompactionV2Metadata("auto", "context_limit", "pre_turn"),
+      compactionDecision: { reason: "provider-boundary", willRetry: true },
       agentTurn,
       responsesLiteEnabled,
     });
@@ -1103,12 +1258,17 @@ export class CodexProviderRuntime {
         let responseRetries = 0;
         while (true) {
           responseRequests += 1;
-          const attemptItems: ResponsesItem[] = [];
+          const attemptCapture: CodexAttemptCapture = {
+            streamedItems: [],
+            streamedToolCallKeys: new Set(),
+            streamedCompletedToolCallKeys: new Set(),
+          };
           const terminalState: CodexTerminalState = {};
           const attemptState: CodexStreamAttemptState = {
             startedContentIndexes: new Set(),
             completedContentIndexes: new Set(),
           };
+          const contentLengthBeforeAttempt = output.content.length;
           const usageBeforeAttempt = structuredClone(output.usage);
           output.usage = emptyUsage();
           try {
@@ -1116,7 +1276,7 @@ export class CodexProviderRuntime {
               startOnFirstEvent(
                 captureRawEvents(
                   this.transport.request(model, body, transportRequestOptions),
-                  attemptItems,
+                  attemptCapture,
                   terminalState,
                 ),
                 emitStart,
@@ -1140,12 +1300,87 @@ export class CodexProviderRuntime {
             throw error;
           }
           output.usage = accumulateUsage(usageBeforeAttempt, output.usage);
-          rawItems.push(...attemptItems.map((item) => structuredClone(item)));
+          // A terminal response.output is the complete provider snapshot when present.
+          // Stream-completed items are the fallback for transports that omit that field.
+          const attemptItems = attemptCapture.terminalItems ?? attemptCapture.streamedItems;
+          const toolCalls = assessAttemptToolCalls(
+            attemptItems,
+            attemptCapture,
+            terminalState.type,
+          );
+          const incompleteDetails = isObject(terminalState.response?.["incomplete_details"])
+            ? terminalState.response["incomplete_details"]
+            : undefined;
+          const incompleteReason =
+            typeof incompleteDetails?.["reason"] === "string"
+              ? incompleteDetails["reason"]
+              : undefined;
+          const maxOutputIncomplete =
+            terminalState.type === "response.incomplete" &&
+            incompleteReason === "max_output_tokens";
+          const recordDecision = (decision: CodexResponseDecision): void => {
+            const diagnostic = responseDecisionDiagnostic({
+              attempt: responseRequests,
+              attemptItems,
+              capture: attemptCapture,
+              decision,
+              ...(incompleteReason ? { incompleteReason } : {}),
+              terminalState,
+              toolCalls,
+            });
+            if (diagnostic) output.diagnostics = [...(output.diagnostics ?? []), diagnostic];
+          };
+
+          // Tool calls create a client-execution boundary. Never append them to an
+          // internal provider continuation before Pi can return the linked outputs.
+          if (toolCalls.hasToolCalls) {
+            if (
+              toolCalls.allComplete &&
+              ((terminalState.type === "response.completed" && output.stopReason === "toolUse") ||
+                maxOutputIncomplete)
+            ) {
+              discardIncompleteAttemptContent(output, attemptState);
+              rawItems.push(...attemptItems.map((item) => structuredClone(item)));
+              output.stopReason = "toolUse";
+              delete output.errorMessage;
+              recordDecision("return_tool_use");
+              break;
+            }
+
+            output.content.splice(contentLengthBeforeAttempt);
+            if (
+              terminalState.type === "response.failed" &&
+              retryableResponseFailure(terminalState.response) &&
+              responseRetries < this.responseRetryPolicy.maxRetries
+            ) {
+              responseRetries += 1;
+              output.stopReason = "pending";
+              delete output.errorMessage;
+              delete output.rawStopReason;
+              recordDecision("retry_original_input");
+              await waitForResponseRetry(
+                responseRetryDelayMs(this.responseRetryPolicy.baseDelayMs, responseRetries),
+                requestOptions.signal,
+              );
+              continue;
+            }
+            if (terminalState.type === "response.completed" && output.stopReason !== "error") {
+              output.stopReason = "length";
+              output.rawStopReason = "incomplete.tool_call";
+              delete output.errorMessage;
+            }
+            recordDecision(
+              toolCalls.omittedStreamedCount > 0
+                ? "reject_terminal_stream_mismatch"
+                : output.stopReason === "length"
+                  ? "return_length_incomplete_call"
+                  : "preserve_terminal_error",
+            );
+            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 +1396,7 @@ export class CodexProviderRuntime {
             output.stopReason = "pending";
             delete output.errorMessage;
             delete output.rawStopReason;
+            recordDecision("continue_no_tools");
             await waitForResponseRetry(
               responseRetryDelayMs(this.responseRetryPolicy.baseDelayMs, responseRetries),
               requestOptions.signal,
@@ -1170,8 +1406,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 +1418,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 +1522,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(