pi-openai-codex-compat 0.0.17 → 0.0.19

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

@@ -1,4 +1,3 @@
-import { isString } from "./value-contracts.ts";
 import type {
   BeforeProviderHeadersEvent,
   CompactionResult,
@@ -6,31 +5,34 @@ import type {
   ExtensionAPI,
   ExtensionContext,
   SessionBeforeCompactEvent,
-  ToolInfo,
 } from "@earendil-works/pi-coding-agent";
-import type {
-  Api,
-  Model,
-  OpenAICodexResponsesOptions,
-  ProviderHeaders,
+import {
+  getCurrentTools,
+  type Api,
+  type Message,
+  type Model,
+  type OpenAICodexResponsesOptions,
+  type ProviderHeaders,
 } from "@earendil-works/pi-ai";
-import { addRemoteCompactionFeature, isObject, type JsonRecord } from "./codex-protocol.ts";
+import { addRemoteCompactionFeature, type JsonRecord } from "./codex-protocol.ts";
 import { CODEX_API, CODEX_PROVIDER } from "./codex-identifiers.ts";
 import {
-  activeResponsesTools,
   branchInstructions,
-  declaresActiveTools,
+  branchTranscript,
   providerHistory,
   remoteCompactionMarkerSummary,
+  requestGrammarToolInputProperties,
+  requestTools,
   responsesCompatibility,
   searchCheckpoint,
   type GrammarToolInputProperties,
 } from "./compaction-checkpoint.ts";
+import { APPLY_PATCH_INPUT_PROPERTY, APPLY_PATCH_TOOL_NAME } from "./apply-patch.ts";
 import { resolveFileConfig, type ConfigResolver } from "./config-context.ts";
 import type { CodexProviderRuntime } from "./codex-provider.ts";
 import { responsesCompactionV2Metadata, type CodexCompactionMetadata } from "./codex-metadata.ts";
-import { APPLY_PATCH_INPUT_PROPERTY, APPLY_PATCH_TOOL_NAME } from "./apply-patch.ts";
 import { errorFromThrown } from "./error-from-thrown.ts";
+import { latestRequestTools } from "./request-tools-entry.ts";
 import { selectedRegistryModel } from "./model-context.ts";
 
 export type RemoteCompactionContext = Parameters<ConfigResolver>[0] & {
@@ -88,7 +90,6 @@ export type RemoteCompactionHookHandler = (
 
 export type RemoteCompactionApi = {
   getActiveTools: () => string[];
-  getAllTools: () => ToolInfo[];
   onBeforeProviderHeaders: (handler: RemoteCompactionHeadersHandler) => void;
   onContext: (handler: RemoteCompactionContextHandler) => void;
   onSessionBeforeCompact: (handler: RemoteCompactionHookHandler) => void;
@@ -113,7 +114,6 @@ export function remoteCompactionApi(pi: ExtensionAPI): RemoteCompactionApi {
 
   return {
     getActiveTools: () => pi.getActiveTools(),
-    getAllTools: () => pi.getAllTools(),
     onBeforeProviderHeaders: (handler) =>
       pi.on("before_provider_headers", (event, ctx) => handler(event, context(ctx))),
     // The full-transcript event returns messages verbatim. A changed `context`
@@ -156,45 +156,28 @@ function instructionsForCompaction(systemPrompt: string, customInstructions?: st
     : systemPrompt;
 }
 
-function toolInputProperty(tool: ToolInfo | undefined): string | undefined {
-  if (tool?.name === APPLY_PATCH_TOOL_NAME) return APPLY_PATCH_INPUT_PROPERTY;
-  if (!tool || !isObject(tool.parameters)) return undefined;
-  const required = Array.isArray(tool.parameters["required"])
-    ? tool.parameters["required"].filter((name): name is string => typeof name === "string")
-    : [];
-  if (required.length !== 1 || !isObject(tool.parameters["properties"])) return undefined;
-  const requiredProperty = required[0];
-  if (requiredProperty === undefined) return undefined;
-  const property = tool.parameters["properties"][requiredProperty];
-  return isObject(property) && property.type === "string" ? requiredProperty : undefined;
-}
-
-function requestGrammarToolInputProperties(
-  payload: JsonRecord,
-  tools: readonly ToolInfo[],
-): GrammarToolInputProperties {
-  const byName = new Map(tools.map((tool) => [tool.name, tool]));
-  const properties = new Map<string, string>();
-  if (!Array.isArray(payload.tools)) return properties;
-
-  for (const declaration of payload.tools) {
-    if (!isObject(declaration)) continue;
-    const tool = declaration;
-    if (tool.type !== "custom" || !isString(tool.name)) continue;
-    const property = toolInputProperty(byName.get(tool.name));
-    if (property) properties.set(tool.name, property);
-  }
-  return properties;
-}
-
+/**
+ * Grammar input properties for a branch without saved request tools. The next
+ * turn declares the transcript's tools plus the active ones. Sessions from
+ * before Pi recorded tool declarations declare none, so an active
+ * `apply_patch`, the only grammar tool Pi's tool registry can identify, is
+ * added as that turn would add it. Its replayed calls then keep their custom
+ * tool call and output types.
+ */
 function fallbackGrammarToolInputProperties(
-  activeNames: readonly string[],
   model: Model<Api>,
+  transcript: readonly Message[],
+  activeNames: readonly string[],
 ): GrammarToolInputProperties {
-  const compat = responsesCompatibility(model.compat);
-  return activeNames.includes(APPLY_PATCH_TOOL_NAME) && compat?.supportsOpenAIGrammarTools
-    ? new Map([[APPLY_PATCH_TOOL_NAME, APPLY_PATCH_INPUT_PROPERTY]])
-    : new Map();
+  const properties = new Map(requestGrammarToolInputProperties(model, transcript));
+  if (
+    !properties.has(APPLY_PATCH_TOOL_NAME) &&
+    activeNames.includes(APPLY_PATCH_TOOL_NAME) &&
+    responsesCompatibility(model.compat).supportsOpenAIGrammarTools
+  ) {
+    properties.set(APPLY_PATCH_TOOL_NAME, APPLY_PATCH_INPUT_PROPERTY);
+  }
+  return properties;
 }
 
 function compactionMetadata(reason: SessionBeforeCompactEvent["reason"]): CodexCompactionMetadata {
@@ -242,13 +225,19 @@ export default function registerRemoteCompaction(
       if (!authentication.apiKey) throw new Error("OpenAI Codex authentication is unavailable.");
 
       const sessionId = ctx.sessionManager.getSessionId();
-      const allTools = pi.getAllTools();
       const cached = runtime.latestTemplate(sessionId);
       const matching = cached?.modelId === ctx.model.id ? cached : undefined;
+      // Declare the tools the branch's latest request to this model sent, as
+      // saved in the session. The transcript also lists tools Pi leaves out of
+      // requests (codemode `only` mode), and other extensions can edit them.
+      // Sessions without a saved entry, such as those older versions wrote,
+      // declare the transcript's current tools.
+      const saved = latestRequestTools(event.branchEntries, ctx.model.id);
+      const transcript = saved ? undefined : branchTranscript(event.branchEntries);
       const config = resolveConfig(ctx);
       const grammarToolInputProperties =
-        matching?.grammarToolInputProperties ??
-        fallbackGrammarToolInputProperties(pi.getActiveTools(), ctx.model);
+        saved?.grammarToolInputProperties ??
+        fallbackGrammarToolInputProperties(ctx.model, transcript ?? [], pi.getActiveTools());
       const history = providerHistory({
         branch: event.branchEntries,
         wireModel: ctx.model,
@@ -256,22 +245,10 @@ export default function registerRemoteCompaction(
         imageDetail: config.imageDetail,
         recoverLatestOverflowPrefix: event.reason === "overflow" && event.willRetry,
       });
-      // Reuse the last turn's exact declarations when they still describe the
-      // active tools, so the compaction request shares the turn requests'
-      // prompt-cache prefix. Rebuild from the registry when the active set or
-      // any definition (including a parameter schema under an unchanged name)
-      // changed since that turn, or when no turn template exists.
-      const template: JsonRecord = { ...matching?.payload };
-      const activeNames = pi.getActiveTools();
-      const cachedTools = Array.isArray(matching?.payload.tools)
-        ? matching.payload.tools.filter(isObject)
-        : undefined;
-      template.tools =
-        cachedTools &&
-        matching &&
-        declaresActiveTools(cachedTools, matching.toolFingerprint, allTools, activeNames)
-          ? cachedTools
-          : (activeResponsesTools(allTools, activeNames, grammarToolInputProperties) ?? []);
+      const template: JsonRecord = {
+        ...matching?.payload,
+        tools: saved?.tools ?? requestTools(ctx.model, getCurrentTools(transcript ?? [])),
+      };
       const requestOptions: OpenAICodexResponsesOptions = {
         ...matching?.requestOptions,
         apiKey: authentication.apiKey,
@@ -291,9 +268,7 @@ export default function registerRemoteCompaction(
           branchInstructions(ctx.model, event.branchEntries) || ctx.getSystemPrompt(),
           event.customInstructions,
         ),
-        grammarToolInputProperties:
-          matching?.grammarToolInputProperties ??
-          requestGrammarToolInputProperties(template, allTools),
+        grammarToolInputProperties,
         template,
         priority: config.fastMode,
         compactionMetadata: compactionMetadata(event.reason),

package/extensions/openai-codex-compat/request-options.ts

@@ -19,10 +19,6 @@ export function isCodexModel(model: Model<Api> | undefined): model is Model<type
   return model !== undefined && model.provider === CODEX_PROVIDER && hasApi(model, CODEX_API);
 }
 
-export function supportsReasoningMode(modelId: string): boolean {
-  return modelId === "gpt-6-astra" || /^gpt-5\.6(?:-|$)/.test(modelId);
-}
-
 function isWebSearchTool(value: unknown): boolean {
   return isObject(value) && value.type === "web_search";
 }
@@ -72,11 +68,8 @@ export function applyCodexRequestOptions(
     } else {
       updatedReasoning["summary"] = config.reasoningSummary;
     }
-    if (supportsReasoningMode(options.modelId) && config.reasoningMode === "pro") {
-      updatedReasoning["mode"] = "pro";
-    } else {
-      Reflect.deleteProperty(updatedReasoning, "mode");
-    }
+    // The Codex endpoint rejects `reasoning.mode`.
+    Reflect.deleteProperty(updatedReasoning, "mode");
     result["reasoning"] = updatedReasoning;
   }
 

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/responses-lite.ts

@@ -12,6 +12,7 @@ const RESPONSES_LITE_MODELS: ReadonlySet<string> = new Set([
   "gpt-6-astra",
   "gpt-6-sol",
   "gpt-6-luna",
+  "gpt-6.1-sol",
 ]);
 
 function isHostedTool(tool: JsonRecord): boolean {

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/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.17",
+  "version": "0.0.19",
   "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.87.1",
-    "@earendil-works/pi-coding-agent": "0.87.1",
-    "@earendil-works/pi-tui": "0.87.1",
+    "@earendil-works/pi-ai": "0.99.1",
+    "@earendil-works/pi-coding-agent": "0.99.1",
+    "@earendil-works/pi-tui": "0.99.1",
     "@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.87.0 <0.88.0",
-    "@earendil-works/pi-coding-agent": ">=0.87.0 <0.88.0",
-    "@earendil-works/pi-tui": ">=0.87.0 <0.88.0",
+    "@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",
     "typebox": "*"
   },
   "engines": {