pi-openai-codex-compat 0.0.18 → 0.0.19

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/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.19",
   "description": "OpenAI Codex compatibility for Pi with native compaction, fast mode, and Codex-optimized capabilities",
   "keywords": [
     "pi-package"