pi-openai-codex-compat 0.0.7 → 0.0.8

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## Unreleased
 
+## 0.0.8 - 2026-08-16
+
+### Fixed
+
+- Match Codex tool-call commit semantics by trusting only `response.output_item.done`, ignoring terminal output snapshots and terminal-only calls, executing the completed subset of mixed batches, and preserving completed calls across incomplete or failed response handling.
+
 ## 0.0.7 - 2026-08-16
 
 ### Added

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

@@ -115,6 +115,7 @@ type ActiveAgentTurn = {
   turnId: string;
   startedAtUnixMs: number;
   turnState: CodexTurnState;
+  pendingPostToolDisposition?: CodexPostToolDisposition;
 };
 
 type CodexCompat = {
@@ -130,25 +131,27 @@ type CodexTerminalState = {
 
 type CodexAttemptCapture = {
   streamedItems: ResponsesItem[];
-  streamedToolCallKeys: Set<string>;
-  streamedCompletedToolCallKeys: Set<string>;
-  terminalItems?: ResponsesItem[];
+  streamedToolCallIndexes: Set<number>;
+  streamedCompletedToolCallIndexes: Set<number>;
 };
 
 type CodexToolCallAssessment = {
-  allComplete: boolean;
-  authoritativeCount: number;
-  hasToolCalls: boolean;
-  omittedStreamedCount: number;
-  terminalCount: number;
+  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"
-  | "preserve_terminal_error"
-  | "reject_terminal_stream_mismatch"
   | "retry_original_input"
-  | "return_length_incomplete_call"
   | "return_terminal"
   | "return_tool_use";
 
@@ -217,62 +220,22 @@ 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 eventOutputIndex(event: JsonRecord): number {
+  return typeof event["output_index"] === "number" ? event["output_index"] : 0;
 }
 
 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),
+  const completedCount = items.filter(isToolCallItem).length;
+  const discardedPartialCount = [...capture.streamedToolCallIndexes].filter(
+    (index) => !capture.streamedCompletedToolCallIndexes.has(index),
   ).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,
+    completedCount,
+    discardedPartialCount,
+    hasCompletedCalls: completedCount > 0,
   };
 }
 
@@ -291,6 +254,7 @@ function responseDecisionDiagnostic(options: {
   capture: CodexAttemptCapture;
   decision: CodexResponseDecision;
   incompleteReason?: string;
+  postToolDisposition?: "continue" | "error" | "retry";
   terminalState: CodexTerminalState;
   toolCalls: CodexToolCallAssessment;
 }): AssistantMessageDiagnostic | undefined {
@@ -302,8 +266,7 @@ function responseDecisionDiagnostic(options: {
     options.attempt > 1 ||
     options.terminalState.type !== "response.completed" ||
     endTurn === false ||
-    options.toolCalls.hasToolCalls ||
-    options.toolCalls.omittedStreamedCount > 0;
+    options.capture.streamedToolCallIndexes.size > 0;
   if (!nontrivial) return undefined;
 
   return {
@@ -314,14 +277,12 @@ function responseDecisionDiagnostic(options: {
       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,
+      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,
     },
   };
@@ -340,28 +301,17 @@ function captureRawEvents(
           isResponsesItem(event.item) &&
           isToolCallItem(event.item)
         ) {
-          capture.streamedToolCallKeys.add(toolCallKey(event.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 key = toolCallKey(item);
-            capture.streamedToolCallKeys.add(key);
-            capture.streamedCompletedToolCallKeys.add(key);
+            const index = eventOutputIndex(event);
+            capture.streamedToolCallIndexes.add(index);
+            capture.streamedCompletedToolCallIndexes.add(index);
           }
         }
-        if (
-          (event.type === "response.completed" ||
-            event.type === "response.incomplete" ||
-            event.type === "response.failed") &&
-          isObject(event.response) &&
-          Array.isArray(event.response["output"])
-        ) {
-          capture.terminalItems = event.response["output"]
-            .filter(isResponsesItem)
-            .map((item) => structuredClone(item));
-        }
         if (
           terminalState &&
           (event.type === "response.completed" ||
@@ -462,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);
@@ -1169,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,
@@ -1255,20 +1267,19 @@ export class CodexProviderRuntime {
           },
         };
         let responseRequests = 0;
-        let responseRetries = 0;
+        let responseRetries = carriedResponseRetries;
         while (true) {
           responseRequests += 1;
           const attemptCapture: CodexAttemptCapture = {
             streamedItems: [],
-            streamedToolCallKeys: new Set(),
-            streamedCompletedToolCallKeys: new Set(),
+            streamedToolCallIndexes: new Set(),
+            streamedCompletedToolCallIndexes: 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 {
@@ -1300,14 +1311,10 @@ export class CodexProviderRuntime {
             throw error;
           }
           output.usage = accumulateUsage(usageBeforeAttempt, output.usage);
-          // 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,
-          );
+          // `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;
@@ -1315,67 +1322,55 @@ export class CodexProviderRuntime {
             typeof incompleteDetails?.["reason"] === "string"
               ? incompleteDetails["reason"]
               : undefined;
-          const maxOutputIncomplete =
-            terminalState.type === "response.incomplete" &&
-            incompleteReason === "max_output_tokens";
-          const recordDecision = (decision: CodexResponseDecision): void => {
+          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];
           };
 
-          // 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;
+          // 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.");
             }
-
-            output.content.splice(contentLengthBeforeAttempt);
+            let postToolDisposition: "continue" | "error" | "retry" = "continue";
             if (
-              terminalState.type === "response.failed" &&
-              retryableResponseFailure(terminalState.response) &&
-              responseRetries < this.responseRetryPolicy.maxRetries
+              terminalState.type === "response.incomplete" ||
+              terminalState.type === "response.failed"
             ) {
-              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;
+              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,
+              };
             }
-            recordDecision(
-              toolCalls.omittedStreamedCount > 0
-                ? "reject_terminal_stream_mismatch"
-                : output.stopReason === "length"
-                  ? "return_length_incomplete_call"
-                  : "preserve_terminal_error",
-            );
+            discardIncompleteAttemptContent(output, attemptState);
+            rawItems.push(...attemptItems.map((item) => structuredClone(item)));
+            output.stopReason = "toolUse";
+            delete output.errorMessage;
+            recordDecision("return_tool_use", postToolDisposition);
             break;
           }
 
@@ -1396,7 +1391,9 @@ export class CodexProviderRuntime {
             output.stopReason = "pending";
             delete output.errorMessage;
             delete output.rawStopReason;
-            recordDecision("continue_no_tools");
+            recordDecision(
+              attemptItems.length === 0 ? "retry_original_input" : "continue_no_tools",
+            );
             await waitForResponseRetry(
               responseRetryDelayMs(this.responseRetryPolicy.baseDelayMs, responseRetries),
               requestOptions.signal,

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
@@ -210,7 +205,7 @@ export async function processCodexStream(
   let terminal = false;
   const slots = new Map<number, OutputSlot>();
   const completedOutputItems = new Set<string>();
-  const reasoningById = new Map<string, ThinkingContent>();
+  const completedToolCallContentIndexes = new Set<number>();
   const applyMessagePhaseStopReason = (item: JsonRecord): void => {
     if (item.type === "message" && item["phase"] === "final_answer") {
       output.stopReason = "stop";
@@ -336,7 +331,6 @@ export async function processCodexStream(
     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,
@@ -375,6 +369,7 @@ export async function processCodexStream(
         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);
@@ -388,6 +383,7 @@ export async function processCodexStream(
         partial: output,
       });
       trackCompleted(slot);
+      completedToolCallContentIndexes.add(slot.contentIndex);
       slots.delete(index);
     }
   };
@@ -424,20 +420,6 @@ export async function processCodexStream(
       output.usage,
       typeof response.service_tier === "string" ? response.service_tier : undefined,
     );
-    const terminalItems = responseItems(response["output"]);
-    terminalItems.forEach((item, index) => completeOutputItem(index, item));
-    for (const item of terminalItems) {
-      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"]
@@ -452,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";
     }
   };

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-openai-codex-compat",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "description": "OpenAI Codex compatibility for Pi with native compaction, fast mode, and Codex-optimized capabilities",
   "keywords": [
     "pi-package"