pi-openai-codex-compat 0.0.18 → 0.0.20

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

@@ -0,0 +1,113 @@
+import { isString } from "./value-contracts.ts";
+import type { SessionEntry } from "@earendil-works/pi-coding-agent";
+import { isJsonValue, isObject, type JsonRecord } from "./codex-protocol.ts";
+import type { GrammarToolInputProperties } from "./compaction-checkpoint.ts";
+import { stableResponsesJson } from "./responses-replay.ts";
+
+/**
+ * Custom session entry holding the exact tool declarations a turn request sent.
+ * Pi's transcript declares every active tool, but Pi removes some from requests
+ * (codemode `only` mode) and other extensions can edit the request. Native
+ * compaction declares these saved tools so it shares the turns' prompt-cache
+ * prefix, also after a resume or a branch switch.
+ */
+export const REQUEST_TOOLS_ENTRY_TYPE = "openai-codex-compat-request-tools";
+export const REQUEST_TOOLS_FORMAT_VERSION = 1;
+
+export type RequestToolsData = {
+  kind: typeof REQUEST_TOOLS_ENTRY_TYPE;
+  version: typeof REQUEST_TOOLS_FORMAT_VERSION;
+  modelId: string;
+  tools: JsonRecord[];
+  /** Input properties of grammar tools, which replayed history encodes as custom tool calls. */
+  grammarToolInputProperties: Array<[string, string]>;
+};
+
+export type RequestTools = {
+  tools: JsonRecord[];
+  grammarToolInputProperties: GrammarToolInputProperties;
+};
+
+export function requestToolsData(
+  modelId: string,
+  tools: readonly JsonRecord[],
+  grammarToolInputProperties: GrammarToolInputProperties,
+): RequestToolsData {
+  return {
+    kind: REQUEST_TOOLS_ENTRY_TYPE,
+    version: REQUEST_TOOLS_FORMAT_VERSION,
+    modelId,
+    tools: tools.map((tool) => structuredClone(tool)),
+    grammarToolInputProperties: [...grammarToolInputProperties].toSorted(([left], [right]) =>
+      left.localeCompare(right),
+    ),
+  };
+}
+
+function parseRequestTools(value: unknown): RequestToolsData | undefined {
+  if (
+    !isObject(value) ||
+    value.kind !== REQUEST_TOOLS_ENTRY_TYPE ||
+    value.version !== REQUEST_TOOLS_FORMAT_VERSION ||
+    !isString(value.modelId) ||
+    !Array.isArray(value["tools"]) ||
+    !Array.isArray(value["grammarToolInputProperties"])
+  ) {
+    return undefined;
+  }
+  const tools: JsonRecord[] = [];
+  for (const tool of value["tools"]) {
+    if (!isObject(tool) || !isJsonValue(tool)) return undefined;
+    tools.push(structuredClone(tool));
+  }
+  const properties: Array<[string, string]> = [];
+  for (const pair of value["grammarToolInputProperties"]) {
+    if (!Array.isArray(pair) || pair.length !== 2) return undefined;
+    const [name, property] = pair;
+    if (!isString(name) || !isString(property)) return undefined;
+    properties.push([name, property]);
+  }
+  return {
+    kind: REQUEST_TOOLS_ENTRY_TYPE,
+    version: REQUEST_TOOLS_FORMAT_VERSION,
+    modelId: value.modelId,
+    tools,
+    grammarToolInputProperties: properties,
+  };
+}
+
+/**
+ * The tools of the branch's latest request to a model. Entries that do not
+ * parse, such as a format a later version wrote, are skipped.
+ */
+export function latestRequestTools(
+  branch: readonly SessionEntry[],
+  modelId: string,
+): RequestTools | undefined {
+  const data = latestRequestToolsData(branch, modelId);
+  return data
+    ? { tools: data.tools, grammarToolInputProperties: new Map(data.grammarToolInputProperties) }
+    : undefined;
+}
+
+function latestRequestToolsData(
+  branch: readonly SessionEntry[],
+  modelId: string,
+): RequestToolsData | undefined {
+  for (let index = branch.length - 1; index >= 0; index--) {
+    const entry = branch[index];
+    if (entry?.type !== "custom" || entry.customType !== REQUEST_TOOLS_ENTRY_TYPE) continue;
+    const data = parseRequestTools(entry.data);
+    if (data?.modelId === modelId) return data;
+  }
+  return undefined;
+}
+
+/** Whether a request's tools differ from the branch's latest saved tools for its model. */
+export function requestToolsChanged(
+  branch: readonly SessionEntry[],
+  data: RequestToolsData,
+): boolean {
+  const latest = latestRequestToolsData(branch, data.modelId);
+  return latest === undefined || stableResponsesJson(latest) !== stableResponsesJson(data);
+}

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

@@ -17,7 +17,6 @@ import {
   CODEX_TOOL_BACKGROUND_SCHEMA,
   CODEX_SHELL_TOOL_SCHEMA,
   IMAGE_DETAIL_SCHEMA,
-  REASONING_MODE_SCHEMA,
   REASONING_SUMMARY_SCHEMA,
   TEXT_VERBOSITY_SCHEMA,
   WEB_SEARCH_MODE_SCHEMA,
@@ -32,7 +31,7 @@ import {
 } from "./config.ts";
 import type { ConfigContext } from "./config-context.ts";
 import { selectedRegistryModel } from "./model-context.ts";
-import { isCodexModel, supportsReasoningMode } from "./request-options.ts";
+import { isCodexModel } from "./request-options.ts";
 import { usesResponsesLite } from "./responses-lite.ts";
 
 export const settingFields: SettingsField[] = [
@@ -60,12 +59,6 @@ export const settingFields: SettingsField[] = [
     description: "Choose reasoning summary detail, or omit summaries.",
     choices: [...REASONING_SUMMARY_SCHEMA.enum],
   },
-  {
-    id: "reasoningMode",
-    label: "Reasoning mode",
-    description: "Standard or pro execution on supported models, independent of effort.",
-    choices: [...REASONING_MODE_SCHEMA.enum],
-  },
   {
     id: "toolBackground",
     label: "Codex tool background",
@@ -205,9 +198,7 @@ export default function registerCodexSettings(
         const model = selectedRegistryModel(ctx);
         const fields = settingFields.map((field) => {
           const inactive =
-            !isCodexModel(model) ||
-            (field.id === "responsesLite" && !usesResponsesLite(model.id)) ||
-            (field.id === "reasoningMode" && !supportsReasoningMode(model.id));
+            !isCodexModel(model) || (field.id === "responsesLite" && !usesResponsesLite(model.id));
           return {
             ...field,
             description: `${inactive ? "Inactive on this model. " : ""}${field.description}`,

package/extensions/openai-codex-compat/vendor/pi-ai/README.md

@@ -4,6 +4,10 @@ This directory intentionally contains only the Pi AI methods needed to serialize
 
 [`openai-responses-serialization.ts`](openai-responses-serialization.ts) adapts the relevant methods from `@earendil-works/pi-ai@0.86.0`. Its header lists the upstream source files. It also carries the strict JSON-schema conversion from `src/api/constrained-sampling.ts`; Pi's built-in tools request strict sampling, and Codex rejects `strict: true` without that subset. Keep the wire-equivalence tests in [`test/pi-ai-serialization.test.ts`](../../../../test/pi-ai-serialization.test.ts) passing when updating the Pi dependencies.
 
+The copy also includes Pi 1.0.0's tool-call item-ID guard: same-model replay
+preserves valid `fc_` function IDs and `ctc_` grammar IDs, while incompatible
+item IDs are omitted without changing the `call_id` that pairs calls with results.
+
 Pi AI's transcript helpers replay system sections and tool declarations.
 `supportsAdditionalTools` and `supportsToolSearch` select the dynamic tool
 history representation for additive `toolsAdded` system messages:

package/extensions/openai-codex-compat/vendor/pi-ai/openai-responses-serialization.ts

@@ -826,10 +826,11 @@ export function convertResponsesMessages(
           const customInputProperty = options?.grammarToolInputProperties?.get(block.name);
           const namespaced = splitNamespacedToolName(block.name, options?.namespacedToolNames);
           let itemId = itemIdRaw;
-          if (
-            (isDifferentModel && itemId?.startsWith("fc_")) ||
-            (customInputProperty === undefined && !itemId?.startsWith("fc_"))
-          ) {
+          // Preserve item IDs only when they match the replayed tool type.
+          // Item IDs from another model of the same provider and API are always omitted.
+          // call_id still pairs every call with its result when an item ID is omitted.
+          const itemIdPrefix = customInputProperty === undefined ? "fc_" : "ctc_";
+          if (isDifferentModel || !itemId?.startsWith(itemIdPrefix)) {
             itemId = undefined;
           }
           if (customInputProperty !== undefined) {

package/extensions/openai-codex-compat/web-run.ts

@@ -169,6 +169,8 @@ export default function registerWebRun(
     parameters: WEB_RUN_PARAMETERS,
     executionMode: "parallel",
     renderShell: "self",
+    // Searching and browsing change nothing locally but reach the open web.
+    annotations: { readOnlyHint: true, openWorldHint: true },
     async execute(_toolCallId, params, signal, _onUpdate, ctx) {
       const model = ctx.model;
       if (!isCodexModel(model)) {

package/extensions/settings-session.ts

@@ -57,22 +57,25 @@ export function readSessionSettings(
       !object(data["observed"])
     )
       return fail();
+    // Newer versions may remove a setting or narrow its values. Skip such fields so a session
+    // saved by an older version still resumes; only a malformed record fails.
     const values: SettingValues = {};
     const session: SettingsSessionState = { changes: {} };
     for (const [id, value] of Object.entries(data["values"])) {
       const field = fields.find((candidate) => candidate.id === id);
-      if (!field || !valid(field, value)) return fail();
-      values[id] = value;
+      if (field && valid(field, value)) values[id] = value;
     }
     const observed: Record<string, [string, string]> = {};
     for (const [id, change] of Object.entries(data["changes"])) {
+      if (!Array.isArray(change) || change.length > 1) return fail();
       const field = fields.find((candidate) => candidate.id === id);
-      if (!field || !Array.isArray(change) || change.length > 1 || !Object.hasOwn(values, id))
-        return fail();
+      if (!field || !Object.hasOwn(values, id)) continue;
       const value: unknown = change[0];
-      if (change.length === 0) session.changes[id] = undefined;
-      else if (valid(field, value)) session.changes[id] = value;
-      else return fail();
+      let next: SettingValue | undefined;
+      if (change.length !== 0) {
+        if (!valid(field, value)) continue;
+        next = value;
+      }
       const hashes = data["observed"][id];
       if (!Array.isArray(hashes) || hashes.length !== 2) return fail();
       const global: unknown = hashes[0];
@@ -84,6 +87,7 @@ export function readSessionSettings(
         !/^[a-f0-9]{64}$/.test(project)
       )
         return fail();
+      session.changes[id] = next;
       observed[id] = [global, project];
     }
     if (Object.keys(session.changes).length) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-openai-codex-compat",
-  "version": "0.0.18",
+  "version": "0.0.20",
   "description": "OpenAI Codex compatibility for Pi with native compaction, fast mode, and Codex-optimized capabilities",
   "keywords": [
     "pi-package"
@@ -51,9 +51,9 @@
   "devDependencies": {
     "@2h2d/oxlint-config": "0.1.1",
     "@2h2d/ts-config": "0.0.1",
-    "@earendil-works/pi-ai": "0.99.1",
-    "@earendil-works/pi-coding-agent": "0.99.1",
-    "@earendil-works/pi-tui": "0.99.1",
+    "@earendil-works/pi-ai": "1.0.0",
+    "@earendil-works/pi-coding-agent": "1.0.0",
+    "@earendil-works/pi-tui": "1.0.0",
     "@types/node": "22.20.1",
     "oxfmt": "0.64.0",
     "oxlint": "1.79.0",
@@ -62,9 +62,9 @@
     "typescript": "7.0.2"
   },
   "peerDependencies": {
-    "@earendil-works/pi-ai": ">=0.99.1 <0.100.0",
-    "@earendil-works/pi-coding-agent": ">=0.99.1 <0.100.0",
-    "@earendil-works/pi-tui": ">=0.99.1 <0.100.0",
+    "@earendil-works/pi-ai": ">=1.0.0 <1.1.0",
+    "@earendil-works/pi-coding-agent": ">=1.0.0 <1.1.0",
+    "@earendil-works/pi-tui": ">=1.0.0 <1.1.0",
     "typebox": "*"
   },
   "engines": {