pi-openai-codex-compat 0.0.22 → 0.0.23

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## Unreleased
 
+## 0.0.23 - 2026-10-12
+
+### Fixed
+
+- Send system messages that other extensions add to a single request, such as
+  context-threshold instructions from `pi-compact-assistant`, to Codex as
+  developer messages at their position. Codex requests are built from the
+  stored session, so these messages were previously dropped.
+
 ## 0.0.22 - 2026-10-08
 
 ### Fixed

package/README.md

@@ -76,7 +76,7 @@ The compatibility baseline is official Codex CLI `0.149.1`, released August 24,
 | Session storage             | Pi remains the canonical session owner. Opaque Codex compaction checkpoints are stored in Pi `compaction` entries, otherwise lossy Responses output is stored in sparse custom native-response entries, and each change to the tools a turn request sends is stored in a custom request-tools entry. Official Codex owns a rollout/thread store directly.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
 | Branching                   | Checkpoints and native response overrides follow Pi's active session branch. Official Codex uses its own thread, turn, rollback, fork, and context-window lineage.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
 | Model switching             | This package rejects model switches while the active Pi branch contains a native Codex checkpoint because the checkpoint is model-specific.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| System instructions         | Send the leading Pi system message as the prompt, as Pi AI's Codex adapter does: Responses Lite models prepend it as developer input after `additional_tools`; other models send it through Responses `instructions`. Later Pi system messages (`/reload`, section changes) travel inline as developer items on models that accept mid-conversation system messages and collapse into the leading prompt otherwise. A forced prompt replaces the leading message. Compaction snapshots and resumed sessions lead with Pi's replayed prompt without rewriting old checkpoints.                                                                                                                                                                                                                                                                                                                    |
+| System instructions         | Send the leading Pi system message as the prompt, as Pi AI's Codex adapter does: Responses Lite models prepend it as developer input after `additional_tools`; other models send it through Responses `instructions`. Later Pi system messages (`/reload`, section changes) travel inline as developer items on models that accept mid-conversation system messages and collapse into the leading prompt otherwise. Request history is rebuilt from the stored session, and system messages that another extension adds to only one request, such as `pi-compact-assistant` instructions, are inserted after the stored message they follow. A forced prompt replaces the leading message. Compaction snapshots and resumed sessions lead with Pi's replayed prompt without rewriting old checkpoints.                                                                                           |
 | Dynamic tool declarations   | Send the complete current tool set, replayed from Pi's `toolsAdded` and `toolsRemoved` system messages, in the top-level `tools` field on every request, as the official Codex client does. Tool declarations never travel inside `input`: inline `additional_tools` items and synthetic tool-search pairs made the Codex backend unreliable about which tools exist. A mid-session tool change costs one prompt-cache miss, and native checkpoints need no declaration rebase.                                                                                                                                                                                                                                                                                                                                                                                                                  |
 | Turn metadata               | Requests send a persisted installation id plus Pi-derived session, thread, context-window, turn, source, sandbox, request-kind, and nested compaction-operation metadata in `client_metadata` and compatible headers. The in-memory context-window number advances after successful compaction. One turn id is reused throughout a Pi agent run, while prewarm has its own id. First-party requests also carry Codex's model-and-tier routing hint. The provider captures the server-issued `x-codex-turn-state` once per agent run, replays it on WebSocket retries, SSE requests, and WebSocket-to-SSE fallback, and records all identity values in transport diagnostics. Pi does not reconstruct prior window number after extension reload/session resume or reproduce workspace Git/parent/subagent/Code Mode metadata. Each marked Pi tree branch receives its own persisted thread UUID. |
 | Cache preparation           | Before the first cache-enabled WebSocket turn, the package prewarms only the stable instruction/tool prefix: ordinary Responses uses empty `input`, while Responses Lite uses `additional_tools` plus the developer instructions. The first generated request then contributes only dynamic conversation input to the continuation. No explicit prompt-cache breakpoints are added.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |

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

@@ -524,11 +524,14 @@ export class CodexProviderRuntime {
         convertResponsesMessages(model, context, CODEX_TOOL_CALL_PROVIDERS, serializationOptions),
       );
     }
+    // History comes from the branch so native items replay exactly. Pi's live
+    // transcript adds only the system messages extensions placed in this request.
     return providerHistory({
       branch: scope.manager.getBranch(),
       wireModel: model,
       grammarToolInputProperties,
       imageDetail: scope.config.imageDetail,
+      requestMessages: context.messages,
     });
   }
 

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

@@ -169,6 +169,8 @@ export type EncodeSessionEntriesOptions = {
   initialSystemMessage?: SystemMessage;
   /** Model-visible messages per entry. Defaults to the entry's raw messages. */
   entryMessages?: (entry: SessionEntry) => AgentMessages;
+  /** Pi's live request transcript, whose request-local system messages are added in place. */
+  requestMessages?: readonly Message[];
 };
 
 /**
@@ -221,6 +223,7 @@ export function encodeSessionEntries(options: EncodeSessionEntriesOptions): Resp
     entryMessages = sessionEntryToContextMessages,
   } = options;
   const messages = entries.flatMap((entry) => entryMessages(entry));
+  const converted = convertToLlm(messages);
   const encodeOptions: EncodeMessagesOptions = {
     model,
     // A partial tail can start with a system update. Seed its prior state so
@@ -228,7 +231,9 @@ export function encodeSessionEntries(options: EncodeSessionEntriesOptions): Resp
     // leading system message that `instructions` already carries.
     messages: [
       options.initialSystemMessage ?? { role: "system", content: "", timestamp: 0 },
-      ...convertToLlm(messages),
+      ...(options.requestMessages
+        ? withRequestSystemMessages(converted, options.requestMessages)
+        : converted),
     ],
     grammarToolInputProperties,
     imageDetail,
@@ -237,6 +242,68 @@ export function encodeSessionEntries(options: EncodeSessionEntriesOptions): Resp
   return encodeMessages(encodeOptions);
 }
 
+function systemKey(message: SystemMessage): string {
+  return JSON.stringify([message.timestamp, message.content, message.sections ?? null]);
+}
+
+function sameMessage(left: Message, right: Message): boolean {
+  if (left.role !== right.role || left.timestamp !== right.timestamp) return false;
+  if (left.role === "toolResult" && right.role === "toolResult") {
+    return left.toolCallId === right.toolCallId;
+  }
+  return true;
+}
+
+/**
+ * Add the system messages an extension placed in Pi's live request transcript
+ * without storing them in the session, such as request-local instructions from a
+ * `context_with_system` handler. History is built from the session branch, so
+ * such messages would otherwise never reach Codex.
+ *
+ * A request-local system message is one that matches no stored system message by
+ * timestamp, content, and sections; the leading prompt is excluded. It follows the
+ * nearest earlier request message that is also in `messages`, matched by role,
+ * timestamp, and tool call ID. Without such a message it leads the conversation
+ * after `start` messages. Messages anchored before an encoded range are skipped.
+ */
+export function withRequestSystemMessages(
+  messages: readonly Message[],
+  requestMessages: readonly Message[],
+  start = 0,
+): Message[] {
+  const stored = new Set(
+    messages.flatMap((message) => (message.role === "system" ? [systemKey(message)] : [])),
+  );
+  const after = new Map<number, Message[]>();
+  for (let index = 1; index < requestMessages.length; index++) {
+    const message = requestMessages[index];
+    if (message?.role !== "system" || stored.has(systemKey(message))) continue;
+    let position = start - 1;
+    for (let previous = index - 1; previous > 0; previous--) {
+      const anchor = requestMessages[previous];
+      if (!anchor || anchor.role === "system") continue;
+      const found = messages.findLastIndex(
+        (candidate) => candidate.role !== "system" && sameMessage(candidate, anchor),
+      );
+      if (found >= 0) {
+        position = found;
+        break;
+      }
+      position = Number.NaN;
+    }
+    if (Number.isNaN(position)) continue;
+    after.set(position, [...(after.get(position) ?? []), message]);
+  }
+  if (after.size === 0) return [...messages];
+  return [
+    ...messages.slice(0, start),
+    ...(after.get(start - 1) ?? []),
+    ...messages
+      .slice(start)
+      .flatMap((message, offset) => [message, ...(after.get(start + offset) ?? [])]),
+  ];
+}
+
 export function parseCheckpoint(value: unknown): CheckpointData | undefined {
   if (!isObject(value)) return undefined;
   if (value.kind !== CHECKPOINT_ENTRY_TYPE || value.version !== CHECKPOINT_FORMAT_VERSION) {
@@ -415,6 +482,8 @@ export function providerHistory(options: {
   grammarToolInputProperties?: GrammarToolInputProperties;
   imageDetail?: ImageDetail;
   recoverLatestOverflowPrefix?: boolean;
+  /** Pi's live request transcript, whose request-local system messages are added in place. */
+  requestMessages?: readonly Message[];
 }): ResponsesInputItem[] {
   const branch = [...options.branch];
   let recoveredPrefix: ResponsesInputItem[] = [];
@@ -486,17 +555,25 @@ export function providerHistory(options: {
         nativeAssistantItems,
         entryMessages,
         ...(initialSystemMessage ? { initialSystemMessage } : {}),
+        ...(options.requestMessages ? { requestMessages: options.requestMessages } : {}),
       }),
       ...recoveredPrefix,
     ];
   }
 
+  const messages = convertToLlm(
+    projection.entries.flatMap((entry) => entryMessages(entry.sourceEntry)),
+  );
   return [
     ...encodeMessages({
       model: options.wireModel,
-      messages: convertToLlm(
-        projection.entries.flatMap((entry) => entryMessages(entry.sourceEntry)),
-      ),
+      messages: options.requestMessages
+        ? withRequestSystemMessages(
+            messages,
+            options.requestMessages,
+            getInitialSystemMessage(messages) ? 1 : 0,
+          )
+        : messages,
       grammarToolInputProperties: options.grammarToolInputProperties ?? new Map(),
       imageDetail: options.imageDetail ?? "auto",
       nativeAssistantItems,

package/package.json

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