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

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

@@ -0,0 +1,304 @@
+import {
+  buildSessionContext,
+  convertToLlm,
+  sessionEntryToContextMessages,
+  type SessionEntry,
+  type ToolInfo,
+} from "@earendil-works/pi-coding-agent";
+import type { Message, Model, OpenAIResponsesCompat, Tool } from "@earendil-works/pi-ai";
+import { APPLY_PATCH_LARK_GRAMMAR, APPLY_PATCH_TOOL_NAME } from "./apply-patch.ts";
+import type { ImageDetail } from "./config.ts";
+import {
+  installCompactionItem,
+  isObject,
+  isResponsesItem,
+  type ResponsesItem,
+} from "./codex-protocol.ts";
+import { nativeResponseOverrides } from "./native-history.ts";
+import {
+  CODEX_NAMESPACED_TOOL_NAMES,
+  CODEX_TEXT_CONTENT_ITEM_TOOL_RESULT_NAMES,
+  splitNamespacedToolName,
+} from "./namespaced-tools.ts";
+import { convertResponsesMessages } from "./vendor/pi-ai/openai-responses-serialization.ts";
+
+export const CHECKPOINT_ENTRY_TYPE = "openai-codex-compat-remote-compaction";
+export const CHECKPOINT_FORMAT_VERSION = 1;
+
+export type CheckpointData = {
+  kind: typeof CHECKPOINT_ENTRY_TYPE;
+  version: typeof CHECKPOINT_FORMAT_VERSION;
+  modelId: string;
+  history: ResponsesItem[];
+};
+
+export type CheckpointSearch =
+  | { kind: "absent" }
+  | { kind: "corrupt"; entryIndex: number; entryId: string }
+  | { kind: "found"; entryIndex: number; entryId: string; data: CheckpointData };
+
+export type GrammarToolInputProperties = ReadonlyMap<string, string>;
+
+function asResponsesTool(
+  tool: ToolInfo,
+  grammarToolInputProperties: GrammarToolInputProperties,
+): ResponsesItem {
+  if (tool.name === APPLY_PATCH_TOOL_NAME && grammarToolInputProperties.has(tool.name)) {
+    return {
+      type: "custom",
+      name: tool.name,
+      description: tool.description,
+      format: {
+        type: "grammar",
+        syntax: "lark",
+        definition: APPLY_PATCH_LARK_GRAMMAR,
+      },
+    };
+  }
+  const namespaced = splitNamespacedToolName(tool.name);
+  if (namespaced) {
+    return {
+      type: "namespace",
+      name: namespaced.namespace,
+      description: `Tools in the ${namespaced.namespace} namespace.`,
+      tools: [
+        {
+          type: "function",
+          name: namespaced.name,
+          description: tool.description,
+          parameters: tool.parameters as unknown,
+          strict: false,
+        },
+      ],
+    };
+  }
+  return {
+    type: "function",
+    name: tool.name,
+    description: tool.description,
+    parameters: tool.parameters as unknown,
+    strict: null,
+  };
+}
+
+export function activeResponsesTools(
+  allTools: readonly ToolInfo[],
+  activeNames: readonly string[],
+  grammarToolInputProperties: GrammarToolInputProperties = new Map(),
+): unknown[] | undefined {
+  const enabled = new Set(activeNames);
+  const tools = allTools.filter((tool) => enabled.has(tool.name));
+  return tools.length > 0
+    ? tools.map((tool) => asResponsesTool(tool, grammarToolInputProperties))
+    : undefined;
+}
+
+const CODEX_TOOL_CALL_PROVIDERS: ReadonlySet<string> = new Set([
+  "openai",
+  "openai-codex",
+  "opencode",
+]);
+
+function asPiTool(tool: ToolInfo, grammarToolInputProperties: GrammarToolInputProperties): Tool {
+  return {
+    name: tool.name,
+    description: tool.description,
+    parameters: tool.parameters,
+    ...(tool.name === APPLY_PATCH_TOOL_NAME && grammarToolInputProperties.has(tool.name)
+      ? {
+          constrainedSampling: {
+            type: "grammar" as const,
+            variants: { openai_lark: APPLY_PATCH_LARK_GRAMMAR },
+          },
+        }
+      : {}),
+  };
+}
+
+/** Encode Pi's canonical messages using Pi AI's OpenAI Responses serializer. */
+function encodeMessages(
+  model: Model<any>,
+  messages: Message[],
+  allTools: readonly ToolInfo[],
+  grammarToolInputProperties: GrammarToolInputProperties,
+  imageDetail: ImageDetail,
+  nativeAssistantItems?: ReadonlyMap<string, readonly ResponsesItem[]>,
+): ResponsesItem[] {
+  const tools = allTools.map((tool) => asPiTool(tool, grammarToolInputProperties));
+  const compat = model.compat as OpenAIResponsesCompat | undefined;
+  return convertResponsesMessages(model, { messages, tools }, CODEX_TOOL_CALL_PROVIDERS, {
+    includeSystemPrompt: false,
+    grammarToolInputProperties,
+    deferredTools: new Map(tools.map((tool) => [tool.name, tool])),
+    toolOptions: {
+      strict: null,
+      supportsStrictMode: compat?.supportsStrictMode ?? true,
+      supportsOpenAIGrammarTools: compat?.supportsOpenAIGrammarTools ?? false,
+    },
+    namespacedToolNames: CODEX_NAMESPACED_TOOL_NAMES,
+    textContentItemToolResultNames: CODEX_TEXT_CONTENT_ITEM_TOOL_RESULT_NAMES,
+    toolResultImageDetail: imageDetail,
+    ...(nativeAssistantItems ? { nativeAssistantItems } : {}),
+  }) as unknown as ResponsesItem[];
+}
+
+export function encodeSessionEntries(
+  model: Model<any>,
+  entries: readonly SessionEntry[],
+  allTools: readonly ToolInfo[],
+  grammarToolInputProperties: GrammarToolInputProperties = new Map(),
+  imageDetail: ImageDetail = "auto",
+  nativeAssistantItems?: ReadonlyMap<string, readonly ResponsesItem[]>,
+): ResponsesItem[] {
+  const messages = entries.flatMap((entry) => sessionEntryToContextMessages(entry));
+  return encodeMessages(
+    model,
+    convertToLlm(messages),
+    allTools,
+    grammarToolInputProperties,
+    imageDetail,
+    nativeAssistantItems,
+  );
+}
+
+export function parseCheckpoint(value: unknown): CheckpointData | undefined {
+  if (!isObject(value)) return undefined;
+  if (value.kind !== CHECKPOINT_ENTRY_TYPE || value.version !== CHECKPOINT_FORMAT_VERSION) {
+    return undefined;
+  }
+  if (typeof value.modelId !== "string" || !Array.isArray(value.history)) return undefined;
+
+  const history: ResponsesItem[] = [];
+  for (const item of value.history) {
+    if (!isResponsesItem(item)) return undefined;
+    history.push(structuredClone(item));
+  }
+  if (history.length === 0) return undefined;
+
+  const compactionItems = history.filter((item) => item.type === "compaction");
+  if (compactionItems.length !== 1 || typeof compactionItems[0]!.encrypted_content !== "string") {
+    return undefined;
+  }
+
+  return {
+    kind: CHECKPOINT_ENTRY_TYPE,
+    version: CHECKPOINT_FORMAT_VERSION,
+    modelId: value.modelId,
+    history,
+  };
+}
+
+/** Find the newest applicable checkpoint on the active branch. */
+export function searchCheckpoint(branch: readonly SessionEntry[]): CheckpointSearch {
+  for (let index = branch.length - 1; index >= 0; index--) {
+    const entry = branch[index]!;
+    let candidate: unknown;
+
+    if (entry.type === "compaction") {
+      if (!isObject(entry.details) || entry.details.kind !== CHECKPOINT_ENTRY_TYPE) {
+        return { kind: "absent" };
+      }
+      candidate = entry.details;
+    } else if (entry.type === "custom" && entry.customType === CHECKPOINT_ENTRY_TYPE) {
+      candidate = entry.data;
+    } else {
+      continue;
+    }
+
+    const data = parseCheckpoint(candidate);
+    if (!data) return { kind: "corrupt", entryIndex: index, entryId: entry.id };
+    return { kind: "found", entryIndex: index, entryId: entry.id, data };
+  }
+
+  return { kind: "absent" };
+}
+
+/** Return whether the active branch contains any native Codex checkpoint entry. */
+export function hasNativeCheckpointEntry(branch: readonly SessionEntry[]): boolean {
+  return branch.some(
+    (entry) =>
+      (entry.type === "compaction" &&
+        isObject(entry.details) &&
+        entry.details.kind === CHECKPOINT_ENTRY_TYPE) ||
+      (entry.type === "custom" && entry.customType === CHECKPOINT_ENTRY_TYPE),
+  );
+}
+
+export function checkpointData(
+  modelId: string,
+  inputHistory: readonly ResponsesItem[],
+  compactionItem: ResponsesItem,
+  postCompactionTail: readonly ResponsesItem[] = [],
+): CheckpointData {
+  return {
+    kind: CHECKPOINT_ENTRY_TYPE,
+    version: CHECKPOINT_FORMAT_VERSION,
+    modelId,
+    history: [
+      ...installCompactionItem(inputHistory, compactionItem),
+      ...postCompactionTail.map((item) => structuredClone(item)),
+    ],
+  };
+}
+
+/**
+ * Materialize provider history for the active branch. Checkpoint history
+ * replaces everything before its entry; later branch entries form the tail.
+ */
+export function providerHistory(options: {
+  branch: readonly SessionEntry[];
+  wireModel: Model<any>;
+  allTools: readonly ToolInfo[];
+  grammarToolInputProperties?: GrammarToolInputProperties;
+  imageDetail?: ImageDetail;
+  dropLatestFailedAssistant?: boolean;
+}): ResponsesItem[] {
+  const branch = [...options.branch];
+  if (options.dropLatestFailedAssistant) {
+    const index = branch.findLastIndex(
+      (entry) => entry.type === "message" && entry.message.role === "assistant",
+    );
+    const entry = index >= 0 ? branch[index] : undefined;
+    if (
+      entry?.type === "message" &&
+      entry.message.role === "assistant" &&
+      (entry.message.stopReason === "error" || entry.message.stopReason === "aborted")
+    ) {
+      branch.splice(index, 1);
+    }
+  }
+
+  const checkpoint = searchCheckpoint(branch);
+  const nativeAssistantItems = nativeResponseOverrides(branch, options.wireModel.id);
+  if (checkpoint.kind === "corrupt") {
+    throw new Error("The latest Codex compaction checkpoint is corrupt.");
+  }
+  if (checkpoint.kind === "found") {
+    if (checkpoint.data.modelId !== options.wireModel.id) {
+      throw new Error(
+        `The latest Codex compaction checkpoint belongs to ${checkpoint.data.modelId}, not ${options.wireModel.id}.`,
+      );
+    }
+    return [
+      ...checkpoint.data.history.map((item) => structuredClone(item)),
+      ...encodeSessionEntries(
+        options.wireModel,
+        branch.slice(checkpoint.entryIndex + 1),
+        options.allTools,
+        options.grammarToolInputProperties,
+        options.imageDetail,
+        nativeAssistantItems,
+      ),
+    ];
+  }
+
+  const context = buildSessionContext(branch);
+  return encodeMessages(
+    options.wireModel,
+    convertToLlm(context.messages),
+    options.allTools,
+    options.grammarToolInputProperties ?? new Map(),
+    options.imageDetail ?? "auto",
+    nativeAssistantItems,
+  );
+}

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

@@ -0,0 +1,268 @@
+import { randomUUID } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+import { CONFIG_DIR_NAME, getAgentDir } from "@earendil-works/pi-coding-agent";
+
+export type WebSearchMode = "disabled" | "cached" | "indexed" | "live";
+export type TextVerbosity = "low" | "medium" | "high";
+export type ReasoningSummary = "auto" | "concise" | "detailed" | "off";
+export type ReasoningMode = "standard" | "pro";
+export type ImageDetail = "auto" | "low" | "high" | "original";
+export type CodexToolBackground = "subtle" | "status" | "none";
+
+export interface CodexCompatConfig {
+  /** Send OpenAI Codex requests through the priority service tier. */
+  fastMode: boolean;
+  /** Replace Pi's active edit and write tools with the extension's apply_patch tool. */
+  applyPatch: boolean;
+  /** Select the shared background surface for extension-owned Codex tools. */
+  toolBackground: CodexToolBackground;
+  /** Expose the standalone Codex image-generation namespace tool. */
+  imageGeneration: boolean;
+  /** Set input_image.detail when image tool results are returned to the model. */
+  imageDetail: ImageDetail;
+  /** Expose the standalone Codex web-search namespace tool. */
+  webRun: boolean;
+  /**
+   * Compact at a provider request boundary when context usage reaches this
+   * percentage. Omit it to rely only on Pi's compaction lifecycle (`/compact`,
+   * threshold compaction, and overflow recovery).
+   */
+  autoCompactAtPercent?: number;
+  webSearch: WebSearchMode;
+  textVerbosity: TextVerbosity;
+  reasoningSummary: ReasoningSummary;
+  reasoningMode: ReasoningMode;
+}
+
+export type ConfigLayer = {
+  fastMode?: boolean;
+  applyPatch?: boolean;
+  toolBackground?: CodexToolBackground;
+  imageGeneration?: boolean;
+  imageDetail?: ImageDetail;
+  webRun?: boolean;
+  autoCompactAtPercent?: number | null;
+  webSearch?: WebSearchMode;
+  textVerbosity?: TextVerbosity;
+  reasoningSummary?: ReasoningSummary;
+  reasoningMode?: ReasoningMode;
+};
+
+export const CONFIG_FILE = "openai-codex-compat.json";
+export const DEFAULT_CONFIG: CodexCompatConfig = {
+  fastMode: false,
+  applyPatch: true,
+  toolBackground: "subtle",
+  imageGeneration: true,
+  imageDetail: "auto",
+  webRun: true,
+  webSearch: "cached",
+  textVerbosity: "low",
+  reasoningSummary: "auto",
+  reasoningMode: "standard",
+};
+
+const WEB_SEARCH_MODES = new Set<WebSearchMode>(["disabled", "cached", "indexed", "live"]);
+const TEXT_VERBOSITIES = new Set<TextVerbosity>(["low", "medium", "high"]);
+const REASONING_SUMMARIES = new Set<ReasoningSummary>(["auto", "concise", "detailed", "off"]);
+const REASONING_MODES = new Set<ReasoningMode>(["standard", "pro"]);
+const IMAGE_DETAILS = new Set<ImageDetail>(["auto", "low", "high", "original"]);
+const CODEX_TOOL_BACKGROUNDS = new Set<CodexToolBackground>(["subtle", "status", "none"]);
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+export function parseConfig(value: unknown): ConfigLayer {
+  if (!isRecord(value)) return {};
+
+  const layer: ConfigLayer = {};
+
+  const fastMode = value["fastMode"];
+  if (typeof fastMode === "boolean") layer.fastMode = fastMode;
+
+  const applyPatch = value["applyPatch"];
+  if (typeof applyPatch === "boolean") layer.applyPatch = applyPatch;
+
+  const toolBackground = value["toolBackground"];
+  if (
+    typeof toolBackground === "string" &&
+    CODEX_TOOL_BACKGROUNDS.has(toolBackground as CodexToolBackground)
+  ) {
+    layer.toolBackground = toolBackground as CodexToolBackground;
+  }
+
+  const imageGeneration = value["imageGeneration"];
+  if (typeof imageGeneration === "boolean") layer.imageGeneration = imageGeneration;
+
+  const imageDetail = value["imageDetail"];
+  if (typeof imageDetail === "string" && IMAGE_DETAILS.has(imageDetail as ImageDetail)) {
+    layer.imageDetail = imageDetail as ImageDetail;
+  }
+
+  const webRun = value["webRun"];
+  if (typeof webRun === "boolean") layer.webRun = webRun;
+
+  const threshold = value["autoCompactAtPercent"];
+  if (threshold === null) {
+    layer.autoCompactAtPercent = null;
+  } else if (
+    typeof threshold === "number" &&
+    Number.isFinite(threshold) &&
+    threshold > 0 &&
+    threshold <= 100
+  ) {
+    layer.autoCompactAtPercent = threshold;
+  }
+
+  const webSearch = value["webSearch"];
+  if (typeof webSearch === "string" && WEB_SEARCH_MODES.has(webSearch as WebSearchMode)) {
+    layer.webSearch = webSearch as WebSearchMode;
+  }
+
+  const textVerbosity = value["textVerbosity"];
+  if (typeof textVerbosity === "string" && TEXT_VERBOSITIES.has(textVerbosity as TextVerbosity)) {
+    layer.textVerbosity = textVerbosity as TextVerbosity;
+  }
+
+  const reasoningSummary = value["reasoningSummary"];
+  if (
+    typeof reasoningSummary === "string" &&
+    REASONING_SUMMARIES.has(reasoningSummary as ReasoningSummary)
+  ) {
+    layer.reasoningSummary = reasoningSummary as ReasoningSummary;
+  }
+
+  const reasoningMode = value["reasoningMode"];
+  if (typeof reasoningMode === "string" && REASONING_MODES.has(reasoningMode as ReasoningMode)) {
+    layer.reasoningMode = reasoningMode as ReasoningMode;
+  }
+
+  return layer;
+}
+
+function readConfig(filePath: string): ConfigLayer {
+  if (!existsSync(filePath)) return {};
+
+  try {
+    return parseConfig(JSON.parse(readFileSync(filePath, "utf8")));
+  } catch {
+    // Invalid configuration must not prevent Pi from starting.
+    return {};
+  }
+}
+
+export function resolveConfig(
+  globalConfig: ConfigLayer,
+  projectConfig: ConfigLayer,
+): CodexCompatConfig {
+  const merged = { ...globalConfig, ...projectConfig };
+  return {
+    ...DEFAULT_CONFIG,
+    ...(typeof merged.fastMode === "boolean" ? { fastMode: merged.fastMode } : {}),
+    ...(typeof merged.applyPatch === "boolean" ? { applyPatch: merged.applyPatch } : {}),
+    ...(merged.toolBackground ? { toolBackground: merged.toolBackground } : {}),
+    ...(typeof merged.imageGeneration === "boolean"
+      ? { imageGeneration: merged.imageGeneration }
+      : {}),
+    ...(merged.imageDetail ? { imageDetail: merged.imageDetail } : {}),
+    ...(typeof merged.webRun === "boolean" ? { webRun: merged.webRun } : {}),
+    ...(typeof merged.autoCompactAtPercent === "number"
+      ? { autoCompactAtPercent: merged.autoCompactAtPercent }
+      : {}),
+    ...(merged.webSearch ? { webSearch: merged.webSearch } : {}),
+    ...(merged.textVerbosity ? { textVerbosity: merged.textVerbosity } : {}),
+    ...(merged.reasoningSummary ? { reasoningSummary: merged.reasoningSummary } : {}),
+    ...(merged.reasoningMode ? { reasoningMode: merged.reasoningMode } : {}),
+  };
+}
+
+export function globalConfigPath(): string {
+  return join(getAgentDir(), CONFIG_FILE);
+}
+
+export function projectConfigPath(cwd: string): string {
+  return join(cwd, CONFIG_DIR_NAME, CONFIG_FILE);
+}
+
+/** Use an existing trusted project override; otherwise persist global settings. */
+export function writableConfigPath(cwd: string, projectTrusted: boolean): string {
+  const projectPath = projectConfigPath(cwd);
+  return projectTrusted && existsSync(projectPath) ? projectPath : globalConfigPath();
+}
+
+export function loadConfig(cwd: string, projectTrusted: boolean): CodexCompatConfig {
+  const globalConfig = readConfig(globalConfigPath());
+  const projectConfig = projectTrusted ? readConfig(projectConfigPath(cwd)) : {};
+  return resolveConfig(globalConfig, projectConfig);
+}
+
+export function configLayer(config: CodexCompatConfig): ConfigLayer {
+  return {
+    fastMode: config.fastMode,
+    applyPatch: config.applyPatch,
+    toolBackground: config.toolBackground,
+    imageGeneration: config.imageGeneration,
+    imageDetail: config.imageDetail,
+    webRun: config.webRun,
+    autoCompactAtPercent: config.autoCompactAtPercent ?? null,
+    webSearch: config.webSearch,
+    textVerbosity: config.textVerbosity,
+    reasoningSummary: config.reasoningSummary,
+    reasoningMode: config.reasoningMode,
+  };
+}
+
+async function readWritableConfig(filePath: string): Promise<Record<string, unknown>> {
+  try {
+    const value = JSON.parse(await readFile(filePath, "utf8")) as unknown;
+    if (!isRecord(value)) throw new Error("the root value must be a JSON object");
+    return value;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return {};
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new Error(`Cannot update ${filePath}: ${detail}`);
+  }
+}
+
+/**
+ * Merge known setting changes into the dedicated extension file. Unknown keys
+ * are retained, and an invalid existing file is never overwritten.
+ */
+export async function saveConfig(
+  cwd: string,
+  projectTrusted: boolean,
+  patch: ConfigLayer,
+): Promise<string> {
+  const filePath = writableConfigPath(cwd, projectTrusted);
+  const current = await readWritableConfig(filePath);
+  const next = { ...current, ...patch };
+  const directory = dirname(filePath);
+  const temporaryPath = join(
+    directory,
+    `.${basename(filePath)}.${process.pid}.${randomUUID()}.tmp`,
+  );
+
+  await mkdir(directory, { recursive: true });
+  const existingMode = await stat(filePath)
+    .then((metadata) => metadata.mode & 0o777)
+    .catch((error: NodeJS.ErrnoException) => {
+      if (error.code === "ENOENT") return 0o600;
+      throw error;
+    });
+
+  try {
+    await writeFile(temporaryPath, `${JSON.stringify(next, null, 2)}\n`, {
+      encoding: "utf8",
+      flag: "wx",
+      mode: existingMode,
+    });
+    await rename(temporaryPath, filePath);
+  } finally {
+    await rm(temporaryPath, { force: true });
+  }
+
+  return filePath;
+}

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

@@ -0,0 +1,99 @@
+import type { Model } from "@earendil-works/pi-ai";
+import {
+  FooterComponent,
+  type ExtensionContext,
+  type ReadonlyFooterDataProvider,
+} from "@earendil-works/pi-coding-agent";
+import type { Component, TUI } from "@earendil-works/pi-tui";
+import type { CodexCompatConfig } from "./config.ts";
+import { isCodexModel } from "./request-options.ts";
+
+export type ConfigResolver = (ctx: ExtensionContext) => CodexCompatConfig;
+
+export function footerSettingLabels(config: CodexCompatConfig): string[] {
+  return [
+    config.fastMode ? "fast" : undefined,
+    config.reasoningMode === "pro" ? "pro" : undefined,
+    config.textVerbosity !== "low" ? `verbosity ${config.textVerbosity}` : undefined,
+    config.reasoningSummary !== "auto" ? `summary ${config.reasoningSummary}` : undefined,
+  ].filter((label): label is string => label !== undefined);
+}
+
+export function footerModel(
+  model: Model<any> | undefined,
+  thinkingLevel: string,
+  config: CodexCompatConfig,
+): Model<any> | undefined {
+  if (!model || !isCodexModel(model)) return model;
+
+  const settings = footerSettingLabels(config);
+  if (settings.length === 0) return model;
+
+  const reasoning = model.reasoning
+    ? thinkingLevel === "off"
+      ? "thinking off"
+      : thinkingLevel
+    : undefined;
+  const id = [model.id, reasoning, ...settings]
+    .filter((part): part is string => part !== undefined)
+    .join(" • ");
+  return { ...model, id, reasoning: false };
+}
+
+type FooterSession = ConstructorParameters<typeof FooterComponent>[0];
+
+function footerSession(ctx: ExtensionContext, resolveConfig: ConfigResolver): FooterSession {
+  return {
+    get state() {
+      return {
+        model: footerModel(ctx.model, ctx.thinkingLevel ?? "off", resolveConfig(ctx)),
+        thinkingLevel: ctx.thinkingLevel ?? "off",
+      };
+    },
+    sessionManager: ctx.sessionManager,
+    getContextUsage: () => ctx.getContextUsage(),
+    modelRuntime: {
+      isUsingOAuth(provider: string) {
+        const model = ctx.model;
+        return Boolean(
+          model && model.provider === provider && ctx.modelRegistry.isUsingOAuth(model),
+        );
+      },
+    },
+  } as unknown as FooterSession;
+}
+
+class CodexFooter implements Component {
+  private readonly footer: FooterComponent;
+  private readonly unsubscribe: () => void;
+
+  constructor(
+    tui: TUI,
+    footerData: ReadonlyFooterDataProvider,
+    ctx: ExtensionContext,
+    resolveConfig: ConfigResolver,
+  ) {
+    this.footer = new FooterComponent(footerSession(ctx, resolveConfig), footerData);
+    this.unsubscribe = footerData.onBranchChange(() => tui.requestRender());
+  }
+
+  render(width: number): string[] {
+    return this.footer.render(width);
+  }
+
+  invalidate(): void {
+    this.footer.invalidate();
+  }
+
+  dispose(): void {
+    this.unsubscribe();
+    this.footer.dispose();
+  }
+}
+
+export function installCodexFooter(ctx: ExtensionContext, resolveConfig: ConfigResolver): void {
+  if (ctx.mode !== "tui") return;
+  ctx.ui.setFooter(
+    (tui, _theme, footerData) => new CodexFooter(tui, footerData, ctx, resolveConfig),
+  );
+}