pi-openai-codex-compat 0.0.1-alpha.0

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

@@ -0,0 +1,298 @@
+import {
+  getSettingsListTheme,
+  type ExtensionAPI,
+  type ExtensionCommandContext,
+} from "@earendil-works/pi-coding-agent";
+import {
+  Container,
+  Key,
+  matchesKey,
+  type SettingItem,
+  SettingsList,
+  Text,
+} from "@earendil-works/pi-tui";
+import {
+  configLayer,
+  loadConfig,
+  saveConfig,
+  writableConfigPath,
+  type CodexCompatConfig,
+  type ConfigLayer,
+} from "./config.ts";
+
+const COMMAND_NAME = "codex-settings";
+
+type SettingId =
+  | "fastMode"
+  | "textVerbosity"
+  | "reasoningSummary"
+  | "reasoningMode"
+  | "toolBackground"
+  | "applyPatch"
+  | "imageGeneration"
+  | "imageDetail"
+  | "webRun"
+  | "webSearch"
+  | "autoCompactAtPercent";
+
+export type SettingsCallbacks = {
+  getConfig?: (ctx: ExtensionCommandContext) => CodexCompatConfig;
+  onChange?: (config: CodexCompatConfig, ctx: ExtensionCommandContext) => void;
+};
+
+function toggleValue(value: boolean): string {
+  return value ? "on" : "off";
+}
+
+function thresholdValue(value: number | undefined): string {
+  return value === undefined ? "Pi default" : `${value}%`;
+}
+
+export function settingItems(config: CodexCompatConfig): SettingItem[] {
+  return [
+    {
+      id: "fastMode",
+      label: "Fast mode",
+      description: "Send requests through OpenAI's priority service tier.",
+      currentValue: toggleValue(config.fastMode),
+      values: ["off", "on"],
+    },
+    {
+      id: "textVerbosity",
+      label: "Text verbosity",
+      description: "Set Responses API text.verbosity.",
+      currentValue: config.textVerbosity,
+      values: ["low", "medium", "high"],
+    },
+    {
+      id: "reasoningSummary",
+      label: "Reasoning summary",
+      description: "Choose the reasoning summary detail, or omit summaries.",
+      currentValue: config.reasoningSummary,
+      values: ["auto", "concise", "detailed", "off"],
+    },
+    {
+      id: "reasoningMode",
+      label: "Reasoning mode",
+      description:
+        "Choose standard or pro execution independently of reasoning effort. Applied only to GPT-5.6 models.",
+      currentValue: config.reasoningMode,
+      values: ["standard", "pro"],
+    },
+    {
+      id: "toolBackground",
+      label: "Codex tool background",
+      description: "Choose a distinct subtle surface, Pi's normal status colors, or no background.",
+      currentValue: config.toolBackground,
+      values: ["subtle", "status", "none"],
+    },
+    {
+      id: "applyPatch",
+      label: "apply_patch tool",
+      description: "Use Codex apply_patch instead of Pi's edit and write tools.",
+      currentValue: toggleValue(config.applyPatch),
+      values: ["off", "on"],
+    },
+    {
+      id: "imageGeneration",
+      label: "image_gen.imagegen tool",
+      description: "Generate or edit images through the standalone Codex image endpoint.",
+      currentValue: toggleValue(config.imageGeneration),
+      values: ["off", "on"],
+    },
+    {
+      id: "imageDetail",
+      label: "Image result detail",
+      description: "Set input_image.detail when image tool results are returned to the model.",
+      currentValue: config.imageDetail,
+      values: ["auto", "low", "high", "original"],
+    },
+    {
+      id: "webRun",
+      label: "web.run tool",
+      description: "Search and browse through the standalone Codex search endpoint.",
+      currentValue: toggleValue(config.webRun),
+      values: ["off", "on"],
+    },
+    {
+      id: "webSearch",
+      label: "Web search mode",
+      description:
+        "Control hosted search and web.run access: disabled removes hosted search but keeps web.run cached-only.",
+      currentValue: config.webSearch,
+      values: ["disabled", "cached", "indexed", "live"],
+    },
+    {
+      id: "autoCompactAtPercent",
+      label: "Auto-compact threshold",
+      description: "Add provider-boundary compaction or rely on Pi's normal compaction threshold.",
+      currentValue: thresholdValue(config.autoCompactAtPercent),
+      values: ["Pi default", "75%", "80%", "85%", "90%", "95%"],
+    },
+  ];
+}
+
+export function settingPatch(id: string, value: string): ConfigLayer | undefined {
+  switch (id as SettingId) {
+    case "fastMode":
+      return value === "on" || value === "off" ? { fastMode: value === "on" } : undefined;
+    case "textVerbosity":
+      if (value === "low" || value === "medium" || value === "high") {
+        return { textVerbosity: value };
+      }
+      return undefined;
+    case "reasoningSummary":
+      if (value === "auto" || value === "concise" || value === "detailed" || value === "off") {
+        return { reasoningSummary: value };
+      }
+      return undefined;
+    case "reasoningMode":
+      if (value === "standard" || value === "pro") return { reasoningMode: value };
+      return undefined;
+    case "toolBackground":
+      if (value === "subtle" || value === "status" || value === "none") {
+        return { toolBackground: value };
+      }
+      return undefined;
+    case "applyPatch":
+      return value === "on" || value === "off" ? { applyPatch: value === "on" } : undefined;
+    case "imageGeneration":
+      return value === "on" || value === "off" ? { imageGeneration: value === "on" } : undefined;
+    case "imageDetail":
+      if (value === "auto" || value === "low" || value === "high" || value === "original") {
+        return { imageDetail: value };
+      }
+      return undefined;
+    case "webRun":
+      return value === "on" || value === "off" ? { webRun: value === "on" } : undefined;
+    case "webSearch":
+      if (value === "disabled" || value === "cached" || value === "indexed" || value === "live") {
+        return { webSearch: value };
+      }
+      return undefined;
+    case "autoCompactAtPercent": {
+      if (value === "Pi default") return { autoCompactAtPercent: null };
+      const percent = Number(value.replace(/%$/, ""));
+      return Number.isFinite(percent) && percent > 0 && percent <= 100
+        ? { autoCompactAtPercent: percent }
+        : undefined;
+    }
+  }
+}
+
+function applySettingPatch(config: CodexCompatConfig, patch: ConfigLayer): CodexCompatConfig {
+  const next: CodexCompatConfig = { ...config };
+  if (typeof patch.fastMode === "boolean") next.fastMode = patch.fastMode;
+  if (typeof patch.applyPatch === "boolean") next.applyPatch = patch.applyPatch;
+  if (patch.toolBackground) next.toolBackground = patch.toolBackground;
+  if (typeof patch.imageGeneration === "boolean") {
+    next.imageGeneration = patch.imageGeneration;
+  }
+  if (patch.imageDetail) next.imageDetail = patch.imageDetail;
+  if (typeof patch.webRun === "boolean") next.webRun = patch.webRun;
+  if (patch.webSearch) next.webSearch = patch.webSearch;
+  if (patch.textVerbosity) next.textVerbosity = patch.textVerbosity;
+  if (patch.reasoningSummary) next.reasoningSummary = patch.reasoningSummary;
+  if (patch.reasoningMode) next.reasoningMode = patch.reasoningMode;
+  if (typeof patch.autoCompactAtPercent === "number") {
+    next.autoCompactAtPercent = patch.autoCompactAtPercent;
+  } else if (patch.autoCompactAtPercent === null) {
+    delete next.autoCompactAtPercent;
+  }
+  return next;
+}
+
+async function showSettings(
+  ctx: ExtensionCommandContext,
+  callbacks: SettingsCallbacks,
+): Promise<void> {
+  if (ctx.mode !== "tui") {
+    ctx.ui.notify(`/${COMMAND_NAME} requires TUI mode`, "error");
+    return;
+  }
+
+  let config = callbacks.getConfig?.(ctx) ?? loadConfig(ctx.cwd, ctx.isProjectTrusted());
+  let revision = 0;
+  let savedRevision = 0;
+  let saveQueue = Promise.resolve();
+  const filePath = writableConfigPath(ctx.cwd, ctx.isProjectTrusted());
+
+  await ctx.ui.custom((tui, theme, _keybindings, done) => {
+    const container = new Container();
+    container.addChild(
+      new Text(theme.fg("accent", theme.bold("OpenAI Codex Compatibility Settings")), 1, 1),
+    );
+    container.addChild(
+      new Text(theme.fg("dim", `Session-only. Ctrl+S saves to ${filePath}`), 1, 0),
+    );
+    const saveStatus = new Text(
+      theme.fg("dim", "Changes apply to this session immediately."),
+      1,
+      0,
+    );
+    container.addChild(saveStatus);
+
+    const list = new SettingsList(
+      settingItems(config),
+      12,
+      getSettingsListTheme(),
+      (id, value) => {
+        const patch = settingPatch(id, value);
+        if (!patch) return;
+
+        config = applySettingPatch(config, patch);
+        revision++;
+        callbacks.onChange?.(config, ctx);
+        saveStatus.setText(theme.fg("warning", "Unsaved session changes."));
+        tui.requestRender();
+      },
+      () => done(undefined),
+      { enableSearch: true },
+    );
+    container.addChild(list);
+
+    return {
+      render: (width: number) => container.render(width),
+      invalidate: () => container.invalidate(),
+      handleInput: (data: string) => {
+        if (matchesKey(data, Key.ctrl("s"))) {
+          const snapshot = configLayer(config);
+          const snapshotRevision = revision;
+          saveStatus.setText(theme.fg("dim", "Saving…"));
+          saveQueue = saveQueue.then(async () => {
+            try {
+              const savedPath = await saveConfig(ctx.cwd, ctx.isProjectTrusted(), snapshot);
+              savedRevision = Math.max(savedRevision, snapshotRevision);
+              saveStatus.setText(
+                savedRevision === revision
+                  ? theme.fg("success", `Saved to ${savedPath}`)
+                  : theme.fg("warning", "Unsaved session changes."),
+              );
+            } catch (error) {
+              const message = error instanceof Error ? error.message : String(error);
+              saveStatus.setText(theme.fg("error", message));
+              ctx.ui.notify(message, "error");
+            }
+            tui.requestRender();
+          });
+          tui.requestRender();
+          return;
+        }
+        list.handleInput(data);
+        tui.requestRender();
+      },
+    };
+  });
+
+  await saveQueue;
+}
+
+export default function registerCodexSettings(
+  pi: ExtensionAPI,
+  callbacks: SettingsCallbacks = {},
+): void {
+  pi.registerCommand(COMMAND_NAME, {
+    description: "Configure OpenAI Codex compatibility",
+    handler: async (_args, ctx) => showSettings(ctx, callbacks),
+  });
+}

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

@@ -0,0 +1,32 @@
+import type { ExtensionAPI, ExtensionContext, SessionEntry } from "@earendil-works/pi-coding-agent";
+import type { Model } from "@earendil-works/pi-ai";
+import { providerHistory } from "./compaction-checkpoint.ts";
+import type { ImageDetail } from "./config.ts";
+import type { ResponsesItem } from "./codex-protocol.ts";
+
+export async function codexToolAuthentication(
+  ctx: ExtensionContext,
+  model: Model<any>,
+): Promise<{ apiKey: string; headers?: Record<string, string> }> {
+  const authentication = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+  if (!authentication.ok) throw new Error(authentication.error);
+  if (!authentication.apiKey) throw new Error("OpenAI Codex authentication is unavailable.");
+  return {
+    apiKey: authentication.apiKey,
+    ...(authentication.headers ? { headers: authentication.headers } : {}),
+  };
+}
+
+export function codexToolHistory(
+  pi: ExtensionAPI,
+  ctx: ExtensionContext,
+  model: Model<any>,
+  imageDetail: ImageDetail = "auto",
+): ResponsesItem[] {
+  return providerHistory({
+    branch: ctx.sessionManager.getBranch() as SessionEntry[],
+    wireModel: model,
+    allTools: pi.getAllTools(),
+    imageDetail,
+  });
+}

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

@@ -0,0 +1,70 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { Model } from "@earendil-works/pi-ai";
+import registerApplyPatch, { APPLY_PATCH_TOOL_NAME } from "./apply-patch.ts";
+import type { CodexToolBackgroundResolver } from "./codex-tool-surface.ts";
+import type { CodexCompatConfig } from "./config.ts";
+import { DEFAULT_CONFIG } from "./config.ts";
+import registerImageGeneration from "./image-generation.ts";
+import { IMAGE_GENERATION_TOOL_NAME, WEB_RUN_TOOL_NAME } from "./namespaced-tools.ts";
+import { isCodexModel } from "./request-options.ts";
+import registerWebRun from "./web-run.ts";
+
+const PI_EDIT_TOOLS = ["edit", "write"] as const;
+const CODEX_EXTENSION_TOOLS = [
+  APPLY_PATCH_TOOL_NAME,
+  IMAGE_GENERATION_TOOL_NAME,
+  WEB_RUN_TOOL_NAME,
+] as const;
+const suppressedEditTools = new WeakMap<ExtensionAPI, Set<string>>();
+type ConfigResolver = (ctx: ExtensionContext) => CodexCompatConfig;
+
+export function setApplyPatchEnabled(pi: ExtensionAPI, enabled: boolean): void {
+  const active = new Set(pi.getActiveTools());
+  active.delete(APPLY_PATCH_TOOL_NAME);
+  if (enabled) {
+    let suppressed = suppressedEditTools.get(pi);
+    if (!suppressed) {
+      suppressed = new Set(PI_EDIT_TOOLS.filter((tool) => active.has(tool)));
+      suppressedEditTools.set(pi, suppressed);
+    }
+    for (const tool of PI_EDIT_TOOLS) active.delete(tool);
+    active.add(APPLY_PATCH_TOOL_NAME);
+  } else {
+    active.delete(APPLY_PATCH_TOOL_NAME);
+    const suppressed = suppressedEditTools.get(pi);
+    if (suppressed) {
+      for (const tool of suppressed) active.add(tool);
+      suppressedEditTools.delete(pi);
+    }
+  }
+  pi.setActiveTools([...active]);
+}
+
+export function syncCodexTools(
+  pi: ExtensionAPI,
+  model: Model<any> | undefined,
+  config: CodexCompatConfig,
+): void {
+  const codexSelected = isCodexModel(model);
+  setApplyPatchEnabled(pi, codexSelected && config.applyPatch);
+
+  const active = new Set(pi.getActiveTools());
+  for (const tool of CODEX_EXTENSION_TOOLS) {
+    if (tool !== APPLY_PATCH_TOOL_NAME) active.delete(tool);
+  }
+  if (codexSelected) {
+    if (config.imageGeneration) active.add(IMAGE_GENERATION_TOOL_NAME);
+    if (config.webRun) active.add(WEB_RUN_TOOL_NAME);
+  }
+  pi.setActiveTools([...active]);
+}
+
+export default function registerCodexTools(
+  pi: ExtensionAPI,
+  resolveConfig: ConfigResolver,
+  resolveToolBackground: CodexToolBackgroundResolver = () => DEFAULT_CONFIG.toolBackground,
+): void {
+  registerApplyPatch(pi, resolveToolBackground);
+  registerImageGeneration(pi, resolveConfig, resolveToolBackground);
+  registerWebRun(pi, resolveConfig, resolveToolBackground);
+}

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

@@ -0,0 +1,15 @@
+# Focused Pi AI code copies
+
+This directory intentionally contains only the Pi AI methods needed to serialize checkpoint and native replay history for OpenAI's Responses API. It does not contain Pi AI's complete source dependency graph.
+
+[`openai-responses-serialization.ts`](openai-responses-serialization.ts) adapts the relevant methods from `@earendil-works/pi-ai@0.83.0`. Its header lists the upstream source files. Keep the behavioral equivalence test in [`test/pi-ai-serialization.test.ts`](../../../../test/pi-ai-serialization.test.ts) passing when updating the Pi dependencies.
+
+The optional `namespacedToolNames`, `textContentItemToolResultNames`, and `toolResultImageDetail` paths are extension-owned additions. Without those options, serialization must continue to match Pi AI. `namespacedToolNames` groups only the fixed Codex allowlist into native Responses namespaces and replays namespace/member call identities. `textContentItemToolResultNames` preserves Codex tools such as `web.run` whose successful text output is transported as an `input_text` content-item array instead of Pi's usual plain string. `toolResultImageDetail` overrides the otherwise canonical `auto` detail used for image tool-result content.
+
+The local copy is necessary because Pi's extension loader does not expose `@earendil-works/pi-ai/api/openai-responses-shared` to extensions.
+
+The focused provider transport and stream-processing adaptations live in [`codex-transport.ts`](../../codex-transport.ts) and [`codex-stream.ts`](../../codex-stream.ts).
+
+Upstream: <https://github.com/earendil-works/pi/tree/main/packages/ai>
+
+License: MIT; see [`LICENSES/pi-ai-MIT.txt`](../../../../LICENSES/pi-ai-MIT.txt).