pi-openai-codex-compat 0.0.2 → 0.0.4

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

@@ -77,7 +77,7 @@ function asResponsesTool(
     name: tool.name,
     description: tool.description,
     parameters: tool.parameters as unknown,
-    strict: null,
+    strict: false,
   };
 }
 
@@ -131,7 +131,7 @@ function encodeMessages(
     grammarToolInputProperties,
     deferredTools: new Map(tools.map((tool) => [tool.name, tool])),
     toolOptions: {
-      strict: null,
+      strict: false,
       supportsStrictMode: compat?.supportsStrictMode ?? true,
       supportsOpenAIGrammarTools: compat?.supportsOpenAIGrammarTools ?? false,
     },

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

@@ -16,6 +16,8 @@ export const ENV_PREFIX = "PI_OPENAI_CODEX_COMPAT_";
 export interface CodexCompatConfig {
   /** Send OpenAI Codex requests through the priority service tier. */
   fastMode: boolean;
+  /** Use Codex's Responses Lite envelope on supported GPT-5.6 models. */
+  responsesLite: 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. */
@@ -40,6 +42,7 @@ export interface CodexCompatConfig {
 
 export const CONFIG_ENVIRONMENT_VARIABLES = {
   fastMode: `${ENV_PREFIX}FAST_MODE`,
+  responsesLite: `${ENV_PREFIX}RESPONSES_LITE`,
   applyPatch: `${ENV_PREFIX}APPLY_PATCH`,
   toolBackground: `${ENV_PREFIX}TOOL_BACKGROUND`,
   imageGeneration: `${ENV_PREFIX}IMAGE_GENERATION`,
@@ -54,6 +57,7 @@ export const CONFIG_ENVIRONMENT_VARIABLES = {
 
 export type ConfigLayer = {
   fastMode?: boolean;
+  responsesLite?: boolean;
   applyPatch?: boolean;
   toolBackground?: CodexToolBackground;
   imageGeneration?: boolean;
@@ -69,12 +73,13 @@ export type ConfigLayer = {
 export const CONFIG_FILE = "openai-codex-compat.json";
 export const DEFAULT_CONFIG: CodexCompatConfig = {
   fastMode: false,
+  responsesLite: false,
   applyPatch: true,
   toolBackground: "subtle",
   imageGeneration: true,
   imageDetail: "auto",
-  webRun: true,
-  webSearch: "cached",
+  webRun: false,
+  webSearch: "disabled",
   textVerbosity: "low",
   reasoningSummary: "auto",
   reasoningMode: "standard",
@@ -141,6 +146,9 @@ export function parseEnvironmentConfig(environment: Environment = process.env):
   const fastMode = environmentBoolean(environment, CONFIG_ENVIRONMENT_VARIABLES.fastMode);
   if (fastMode !== undefined) layer.fastMode = fastMode;
 
+  const responsesLite = environmentBoolean(environment, CONFIG_ENVIRONMENT_VARIABLES.responsesLite);
+  if (responsesLite !== undefined) layer.responsesLite = responsesLite;
+
   const applyPatch = environmentBoolean(environment, CONFIG_ENVIRONMENT_VARIABLES.applyPatch);
   if (applyPatch !== undefined) layer.applyPatch = applyPatch;
 
@@ -225,6 +233,9 @@ export function parseConfig(value: unknown): ConfigLayer {
   const fastMode = value["fastMode"];
   if (typeof fastMode === "boolean") layer.fastMode = fastMode;
 
+  const responsesLite = value["responsesLite"];
+  if (typeof responsesLite === "boolean") layer.responsesLite = responsesLite;
+
   const applyPatch = value["applyPatch"];
   if (typeof applyPatch === "boolean") layer.applyPatch = applyPatch;
 
@@ -305,6 +316,7 @@ export function resolveConfig(
   return {
     ...DEFAULT_CONFIG,
     ...(typeof merged.fastMode === "boolean" ? { fastMode: merged.fastMode } : {}),
+    ...(typeof merged.responsesLite === "boolean" ? { responsesLite: merged.responsesLite } : {}),
     ...(typeof merged.applyPatch === "boolean" ? { applyPatch: merged.applyPatch } : {}),
     ...(merged.toolBackground ? { toolBackground: merged.toolBackground } : {}),
     ...(typeof merged.imageGeneration === "boolean"
@@ -349,6 +361,7 @@ export function loadConfig(
 export function configLayer(config: CodexCompatConfig): ConfigLayer {
   return {
     fastMode: config.fastMode,
+    responsesLite: config.responsesLite,
     applyPatch: config.applyPatch,
     toolBackground: config.toolBackground,
     imageGeneration: config.imageGeneration,

package/extensions/openai-codex-compat/image-generation-schema.ts

@@ -0,0 +1,37 @@
+import { Type } from "typebox";
+
+export const MAX_EDIT_IMAGES = 5;
+
+export type ImageGenerationParameters = {
+  prompt: string;
+  referenced_image_paths?: string[] | null;
+  num_last_images_to_include?: number | null;
+};
+
+const REFERENCED_IMAGE_PATH_DESCRIPTION =
+  "Absolute path to a local PNG, JPEG, GIF, or WebP image to include in an edit. Convert relative paths to absolute paths before calling the tool; the file must exist and be readable.";
+
+/**
+ * Server-reserved image-generation schema. Range and selector constraints are
+ * enforced by the executor because OpenAI rejects additional schema keywords.
+ */
+export const IMAGE_GENERATION_PARAMETERS = Type.Unsafe<ImageGenerationParameters>({
+  type: "object",
+  properties: {
+    num_last_images_to_include: {
+      type: ["integer", "null"],
+    },
+    prompt: {
+      type: "string",
+    },
+    referenced_image_paths: {
+      type: ["array", "null"],
+      items: {
+        type: "string",
+        description: REFERENCED_IMAGE_PATH_DESCRIPTION,
+      },
+    },
+  },
+  required: ["prompt"],
+  additionalProperties: false,
+});

package/extensions/openai-codex-compat/image-generation.ts

@@ -1,17 +1,21 @@
 import { readFile, mkdir, writeFile } from "node:fs/promises";
-import { dirname, isAbsolute, join } from "node:path";
+import { dirname, isAbsolute, join, normalize } from "node:path";
 import {
   getAgentDir,
   type ExtensionAPI,
   type ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
 import type { Model } from "@earendil-works/pi-ai";
-import { Type } from "typebox";
 import type { CodexCompatConfig } from "./config.ts";
 import type { CodexToolBackgroundResolver } from "./codex-tool-surface.ts";
 import { DEFAULT_CONFIG } from "./config.ts";
 import { isObject, type JsonRecord, type ResponsesItem } from "./codex-protocol.ts";
 import { requestCodexJson, type CodexJsonRequestOptions } from "./codex-transport.ts";
+import {
+  IMAGE_GENERATION_PARAMETERS,
+  MAX_EDIT_IMAGES,
+  type ImageGenerationParameters,
+} from "./image-generation-schema.ts";
 import { IMAGE_GENERATION_TOOL_NAME } from "./namespaced-tools.ts";
 import {
   renderImageGenerationCall,
@@ -22,55 +26,25 @@ import { isCodexModel } from "./request-options.ts";
 import { codexToolAuthentication, codexToolHistory } from "./tool-runtime.ts";
 
 const IMAGE_MODEL = "gpt-image-2";
-const MAX_EDIT_IMAGES = 5;
 const GENERATION_ENDPOINT = "images/generations";
 const EDIT_ENDPOINT = "images/edits";
 const GENERATED_IMAGES_DIRECTORY = "generated_images";
 
-const IMAGE_GENERATION_DESCRIPTION = `The \`image_gen.imagegen\` tool enables image generation from descriptions and editing of existing images based on specific instructions. Use it when:
+const IMAGE_GENERATION_DESCRIPTION = `The \`image_gen.imagegen\` tool generates new images from descriptions and edits existing images according to specific instructions. Use it when:
 
 - The user requests an image based on a scene description, such as a diagram, portrait, comic, meme, or any other visual.
-- The user wants to modify an attached or previously generated image with specific changes, including adding or removing elements, altering colors, improving quality/resolution, or transforming the style (e.g., cartoon, oil painting).
+- The user wants to modify a local, attached, or previously generated image by adding or removing elements, changing colors, improving quality or resolution, or transforming its style.
 
 Guidelines:
-- imagegen needs a few minutes to finish. In code-mode, use the first-line @exec directive to give the initial call 120 seconds and the same yield for any waits that follow. Once it finishes, return the image with generatedImage(result).
+- Call \`image_gen.imagegen\` directly without reconfirmation unless required source images are unavailable.
 - Omit both \`referenced_image_paths\` and \`num_last_images_to_include\` when generating a brand new image.
-- For edits, use \`referenced_image_paths\` when every target image has a local file path.
-- If you have not seen a local image yet, use \`view_image\` to inspect it before editing.
-- Use \`num_last_images_to_include\` only when at least one target image has no local file path.
-- Set \`num_last_images_to_include\` to the smallest number of recent conversation images that includes every target image, up to 5.
+- For edits, use \`referenced_image_paths\` when every target image has an absolute local path, with at most 5 paths. Use \`read\` first when you need to inspect a local image.
+- Use \`num_last_images_to_include\` only when at least one target image has no local path, and set it to the smallest number of recent conversation images that includes every target, up to 5.
 - Never provide both \`referenced_image_paths\` and \`num_last_images_to_include\`.
 - If neither mechanism can include every target image, ask the user to attach the missing images again.
-- Directly generate the image without reconfirmation or clarification unless required images must be attached again.
-- Always use this tool for image editing unless the user explicitly requests otherwise. Do not use the \`python\` tool for image editing unless specifically instructed.
+- Generated images are returned, displayed, and saved automatically. Do not embed the image in the final response unless the user asks.
 `;
 
-const imageGenerationParameters = Type.Unsafe<{
-  prompt: string;
-  referenced_image_paths?: string[] | null;
-  num_last_images_to_include?: number | null;
-}>({
-  type: "object",
-  properties: {
-    num_last_images_to_include: {
-      type: ["integer", "null"],
-    },
-    prompt: {
-      type: "string",
-    },
-    referenced_image_paths: {
-      type: ["array", "null"],
-      items: {
-        type: "string",
-        description:
-          "A path that is guaranteed to be absolute and normalized (though it is not guaranteed to be canonicalized or exist on the filesystem).\n\nIMPORTANT: When deserializing an `AbsolutePathBuf`, a base path must be set using [AbsolutePathBufGuard::new]. If no base path is set, the deserialization will fail unless the path being deserialized is already absolute.",
-      },
-    },
-  },
-  required: ["prompt"],
-  additionalProperties: false,
-});
-
 export type { ImageGenerationDetails } from "./image-generation-render.ts";
 
 type JsonRequester = (
@@ -137,12 +111,12 @@ export function recentImageUrls(history: readonly ResponsesItem[], count: number
   return newestFirst.reverse();
 }
 
-function normalizeImagePath(path: string): string {
-  const normalized = path.startsWith("@") ? path.slice(1) : path;
-  if (!isAbsolute(normalized)) {
+export function normalizeImagePath(path: string): string {
+  const unprefixed = path.startsWith("@") ? path.slice(1) : path;
+  if (!isAbsolute(unprefixed)) {
     throw new Error(`referenced image path must be absolute: ${path}`);
   }
-  return normalized;
+  return normalize(unprefixed);
 }
 
 function imageMimeType(bytes: Uint8Array, path: string): string {
@@ -176,11 +150,7 @@ async function localImageUrl(path: string): Promise<string> {
 }
 
 async function imageRequest(
-  params: {
-    prompt: string;
-    referenced_image_paths?: string[] | null;
-    num_last_images_to_include?: number | null;
-  },
+  params: ImageGenerationParameters,
   history: readonly ResponsesItem[],
 ): Promise<ImageRequest> {
   const paths = params.referenced_image_paths ?? [];
@@ -290,7 +260,14 @@ export default function registerImageGeneration(
     name: IMAGE_GENERATION_TOOL_NAME,
     label: IMAGE_GENERATION_TOOL_NAME,
     description: IMAGE_GENERATION_DESCRIPTION,
-    parameters: imageGenerationParameters,
+    promptSnippet: "Generate new images or edit existing images",
+    promptGuidelines: [
+      "Use image_gen.imagegen directly to generate new images or edit existing images without reconfirmation unless required source images are unavailable.",
+      "For new images, call image_gen.imagegen without referenced_image_paths or num_last_images_to_include.",
+      "For image_gen.imagegen edits, use up to five absolute referenced_image_paths when every target is local; otherwise use num_last_images_to_include from 1 to 5, and use read when you need to inspect a local image.",
+      "Never pass both image selectors to image_gen.imagegen; ask the user to reattach images when every target cannot be referenced.",
+    ],
+    parameters: IMAGE_GENERATION_PARAMETERS,
     executionMode: "sequential",
     renderShell: "self",
     async execute(toolCallId, params, signal, onUpdate, ctx) {

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

@@ -8,17 +8,27 @@ import {
 import { registerCodexProvider } from "./codex-provider.ts";
 import { installCodexFooter } from "./footer.ts";
 import registerCodexModelPolicy from "./model-policy.ts";
+import registerOutputLimitContinuation from "./output-limit-continuation.ts";
 import registerRemoteCompaction from "./remote-compaction.ts";
 import registerCodexRequestOptions from "./request-options.ts";
 import registerCodexSettings from "./settings-pane.ts";
+import registerCodexThreadLineage from "./codex-thread-lineage.ts";
 import registerCodexTools, { syncCodexTools } from "./tools.ts";
 
+export {
+  closeOpenAICodexWebSocketSessions,
+  getOpenAICodexWebSocketDebugStats,
+  resetOpenAICodexWebSocketDebugStats,
+  type OpenAICodexWebSocketDebugStats,
+} from "./codex-transport.ts";
+
 const DISPLAY_NAME = "OpenAI Codex Compat";
 
 function settingsSummary(ctx: ExtensionContext, config: CodexCompatConfig): string {
   return [
     DISPLAY_NAME,
     `fast mode: ${config.fastMode ? "on" : "off"}`,
+    `Responses Lite: ${config.responsesLite ? "on" : "off"}`,
     `reasoning mode: ${config.reasoningMode}`,
     `Codex tool background: ${config.toolBackground}`,
     `apply_patch: ${config.applyPatch ? "on" : "off"}`,
@@ -51,14 +61,17 @@ export default function registerOpenAICodexCompat(pi: ExtensionAPI): void {
   });
 
   registerCodexTools(pi, resolveConfig, resolveToolBackground);
+  registerCodexThreadLineage(pi);
   const codexProvider = registerCodexProvider(pi, resolveConfig);
   registerCodexRequestOptions(pi, resolveConfig);
+  registerOutputLimitContinuation(pi);
   registerRemoteCompaction(pi, codexProvider, resolveConfig);
   registerCodexModelPolicy(pi, resolveConfig);
   registerCodexSettings(pi, {
     getConfig: resolveConfig,
     onChange(config, ctx) {
       activeConfig = config;
+      codexProvider.updateSessionConfig(ctx.sessionManager.getSessionId(), config);
       syncCodexTools(pi, ctx.model, config);
     },
   });

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

@@ -1,5 +1,6 @@
 export const IMAGE_GENERATION_TOOL_NAME = "image_gen.imagegen";
 export const WEB_RUN_TOOL_NAME = "web.run";
+export const DEFAULT_FUNCTION_NAMESPACE = "functions";
 
 export const CODEX_NAMESPACED_TOOL_NAMES: ReadonlySet<string> = new Set([
   IMAGE_GENERATION_TOOL_NAME,
@@ -35,6 +36,7 @@ export function namespacedToolCallName(namespace: unknown, name: unknown): strin
   if (typeof namespace !== "string" || typeof name !== "string") {
     throw new Error("Codex returned a namespaced tool call without a valid namespace and name.");
   }
+  if (namespace === "" || namespace === DEFAULT_FUNCTION_NAMESPACE) return name;
   const toolName = `${namespace}.${name}`;
   if (!CODEX_NAMESPACED_TOOL_NAMES.has(toolName)) {
     throw new Error(`Codex returned an unsupported namespaced tool call: ${toolName}`);

package/extensions/openai-codex-compat/output-limit-continuation.ts

@@ -0,0 +1,151 @@
+import { createHash } from "node:crypto";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { AssistantMessage, Model } from "@earendil-works/pi-ai";
+
+const CODEX_PROVIDER = "openai-codex";
+const CODEX_API = "openai-codex-responses";
+const OUTPUT_LIMIT_RAW_STOP_REASON = "incomplete.max_output_tokens";
+
+export const OUTPUT_LIMIT_CONTINUATION_TYPE = "openai-codex-compat-output-limit-continuation";
+export const OUTPUT_LIMIT_CONTINUATION_PROMPT =
+  "The previous model response reached its output token limit. Continue the interrupted task from where it stopped without repeating completed work.";
+
+type OutputLimitContinuationDetails = {
+  reason: "max_output_tokens";
+  responseIdHash?: string;
+};
+
+type PendingRecovery = {
+  responseIdHash: string | undefined;
+  compaction: "none" | "started" | "completed";
+  cancelled: boolean;
+};
+
+function isSelectedCodexModel(model: Model<any> | undefined): boolean {
+  return model?.provider === CODEX_PROVIDER && model.api === CODEX_API;
+}
+
+function isObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function lastAssistant(messages: readonly unknown[]): AssistantMessage | undefined {
+  return messages.findLast(
+    (message): message is AssistantMessage =>
+      typeof message === "object" &&
+      message !== null &&
+      (message as { role?: unknown }).role === "assistant",
+  );
+}
+
+function recoverableOutputLimit(
+  assistant: AssistantMessage | undefined,
+): assistant is AssistantMessage {
+  return (
+    assistant?.provider === CODEX_PROVIDER &&
+    assistant.api === CODEX_API &&
+    assistant.stopReason === "length" &&
+    assistant.rawStopReason === OUTPUT_LIMIT_RAW_STOP_REASON
+  );
+}
+
+function responseIdHash(responseId: string | undefined): string | undefined {
+  return responseId ? createHash("sha256").update(responseId, "utf8").digest("hex") : undefined;
+}
+
+function continuationAlreadyRecorded(ctx: ExtensionContext, hash: string | undefined): boolean {
+  if (!hash) return false;
+  return ctx.sessionManager.getBranch().some((entry) => {
+    if (entry.type !== "custom_message" || entry.customType !== OUTPUT_LIMIT_CONTINUATION_TYPE) {
+      return false;
+    }
+    const details = isObject(entry.details) ? entry.details : undefined;
+    return details?.["responseIdHash"] === hash;
+  });
+}
+
+export default function registerOutputLimitContinuation(pi: ExtensionAPI): void {
+  const pendingRecoveries = new Map<string, PendingRecovery>();
+
+  // Record intent at agent_end, then wait for agent_settled. Pi performs any
+  // post-run threshold compaction between those events, so a successful
+  // compaction is installed before the continuation starts.
+  pi.on("agent_end", (event, ctx) => {
+    const sessionId = ctx.sessionManager.getSessionId();
+    if (!isSelectedCodexModel(ctx.model) || ctx.hasPendingMessages()) {
+      pendingRecoveries.delete(sessionId);
+      return;
+    }
+
+    const assistant = lastAssistant(event.messages);
+    if (!recoverableOutputLimit(assistant)) {
+      pendingRecoveries.delete(sessionId);
+      return;
+    }
+
+    const hash = responseIdHash(assistant.responseId);
+    if (continuationAlreadyRecorded(ctx, hash)) {
+      pendingRecoveries.delete(sessionId);
+      return;
+    }
+    pendingRecoveries.set(sessionId, {
+      responseIdHash: hash,
+      compaction: "none",
+      cancelled: false,
+    });
+  });
+
+  pi.on("session_before_compact", (event, ctx) => {
+    const sessionId = ctx.sessionManager.getSessionId();
+    const recovery = pendingRecoveries.get(sessionId);
+    if (!recovery) return;
+
+    recovery.compaction = "started";
+    const cancel = () => {
+      if (pendingRecoveries.get(sessionId) === recovery) recovery.cancelled = true;
+    };
+    if (event.signal.aborted) cancel();
+    else event.signal.addEventListener("abort", cancel, { once: true });
+  });
+
+  pi.on("session_compact", (_event, ctx) => {
+    const recovery = pendingRecoveries.get(ctx.sessionManager.getSessionId());
+    if (recovery?.compaction === "started") recovery.compaction = "completed";
+  });
+
+  pi.on("agent_settled", (_event, ctx) => {
+    const sessionId = ctx.sessionManager.getSessionId();
+    const recovery = pendingRecoveries.get(sessionId);
+    if (!recovery) return;
+    pendingRecoveries.delete(sessionId);
+
+    const compactionFailed = recovery.compaction === "started";
+    if (
+      recovery.cancelled ||
+      compactionFailed ||
+      !ctx.isIdle() ||
+      ctx.hasPendingMessages() ||
+      continuationAlreadyRecorded(ctx, recovery.responseIdHash)
+    ) {
+      return;
+    }
+
+    const details: OutputLimitContinuationDetails = {
+      reason: "max_output_tokens",
+      ...(recovery.responseIdHash ? { responseIdHash: recovery.responseIdHash } : {}),
+    };
+    pi.sendMessage(
+      {
+        customType: OUTPUT_LIMIT_CONTINUATION_TYPE,
+        content: OUTPUT_LIMIT_CONTINUATION_PROMPT,
+        display: false,
+        details,
+      },
+      { triggerTurn: true },
+    );
+  });
+
+  pi.on("session_shutdown", (_event, ctx) => {
+    pendingRecoveries.delete(ctx.sessionManager.getSessionId());
+  });
+}

package/extensions/openai-codex-compat/provider-error.ts

@@ -0,0 +1,79 @@
+const MAX_PROVIDER_ERROR_BODY_CHARS = 4_000;
+
+type ProviderErrorShape = Error & {
+  statusCode?: unknown;
+  status?: unknown;
+  body?: unknown;
+  error?: unknown;
+  $metadata?: { httpStatusCode?: unknown };
+  $response?: { statusCode?: unknown; body?: unknown };
+};
+
+function safeJsonStringify(value: unknown): string {
+  try {
+    const serialized = JSON.stringify(value);
+    return serialized === undefined ? String(value) : serialized;
+  } catch {
+    return String(value);
+  }
+}
+
+function truncateErrorText(text: string): string {
+  return text.length <= MAX_PROVIDER_ERROR_BODY_CHARS
+    ? text
+    : `${text.slice(0, MAX_PROVIDER_ERROR_BODY_CHARS)}... [truncated ${
+        text.length - MAX_PROVIDER_ERROR_BODY_CHARS
+      } chars]`;
+}
+
+function isPlainNonEmptyObject(value: unknown): value is Record<string, unknown> {
+  if (typeof value !== "object" || value === null) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return (prototype === Object.prototype || prototype === null) && Object.keys(value).length > 0;
+}
+
+function isReadableStreamLike(value: unknown): boolean {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    "pipe" in value &&
+    typeof value.pipe === "function"
+  );
+}
+
+function errorStatus(error: ProviderErrorShape): number | undefined {
+  if (typeof error.statusCode === "number") return error.statusCode;
+  if (typeof error.status === "number") return error.status;
+  if (typeof error.$metadata?.httpStatusCode === "number") {
+    return error.$metadata.httpStatusCode;
+  }
+  if (typeof error.$response?.statusCode === "number") return error.$response.statusCode;
+  return undefined;
+}
+
+function errorBody(error: ProviderErrorShape): string | undefined {
+  let body: string | undefined;
+  if (typeof error.body === "string") body = error.body;
+  else if (isPlainNonEmptyObject(error.error)) body = safeJsonStringify(error.error);
+  else if (typeof error.$response?.body === "string") body = error.$response.body;
+  else if (
+    !isReadableStreamLike(error.$response?.body) &&
+    isPlainNonEmptyObject(error.$response?.body)
+  ) {
+    body = safeJsonStringify(error.$response.body);
+  }
+  const trimmed = body?.trim();
+  return trimmed ? truncateErrorText(trimmed) : undefined;
+}
+
+/** Match Pi AI's provider error normalization without importing a private package subpath. */
+export function formatProviderError(error: unknown): string {
+  if (!(error instanceof Error)) return safeJsonStringify(error);
+  const providerError = error as ProviderErrorShape;
+  const status = errorStatus(providerError);
+  const body = errorBody(providerError);
+  if (status !== undefined && body !== undefined && !error.message.includes(body)) {
+    return `${status}: ${body}`;
+  }
+  return error.message;
+}

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

@@ -16,6 +16,7 @@ import {
 } from "./compaction-checkpoint.ts";
 import { loadConfig, type CodexCompatConfig } from "./config.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";
 
 const CODEX_PROVIDER = "openai-codex";
@@ -106,6 +107,17 @@ function explain(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }
 
+function compactionMetadata(reason: SessionBeforeCompactEvent["reason"]): CodexCompactionMetadata {
+  switch (reason) {
+    case "manual":
+      return responsesCompactionV2Metadata("manual", "user_requested", "standalone_turn");
+    case "threshold":
+      return responsesCompactionV2Metadata("auto", "context_limit", "pre_turn");
+    case "overflow":
+      return responsesCompactionV2Metadata("auto", "context_limit", "mid_turn");
+  }
+}
+
 export default function registerRemoteCompaction(
   pi: ExtensionAPI,
   runtime: CodexProviderRuntime,
@@ -177,6 +189,7 @@ export default function registerRemoteCompaction(
           requestGrammarToolInputProperties(template, allTools),
         template,
         priority: config.fastMode,
+        compactionMetadata: compactionMetadata(event.reason),
       });
 
       return {

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

@@ -60,8 +60,8 @@ export function applyCodexRequestOptions(
     } else {
       updatedReasoning["summary"] = config.reasoningSummary;
     }
-    if (supportsReasoningMode(options.modelId)) {
-      updatedReasoning["mode"] = config.reasoningMode;
+    if (supportsReasoningMode(options.modelId) && config.reasoningMode === "pro") {
+      updatedReasoning["mode"] = "pro";
     } else {
       Reflect.deleteProperty(updatedReasoning, "mode");
     }