pi-openai-codex-compat 0.0.3 → 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,6 +73,7 @@ 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,
@@ -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/index.ts

@@ -8,9 +8,11 @@ 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 {
@@ -26,6 +28,7 @@ function settingsSummary(ctx: ExtensionContext, config: CodexCompatConfig): stri
   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"}`,
@@ -58,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/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");
     }

package/extensions/openai-codex-compat/responses-lite.ts

@@ -0,0 +1,147 @@
+import { isObject, type JsonRecord } from "./codex-protocol.ts";
+import { DEFAULT_FUNCTION_NAMESPACE } from "./namespaced-tools.ts";
+
+export const RESPONSES_LITE_HEADER = "x-openai-internal-codex-responses-lite";
+export const RESPONSES_LITE_WS_METADATA_KEY =
+  "ws_request_header_x_openai_internal_codex_responses_lite";
+const RESPONSES_LITE_MODELS: ReadonlySet<string> = new Set([
+  "gpt-5.6-sol",
+  "gpt-5.6-terra",
+  "gpt-5.6-luna",
+]);
+
+function isHostedTool(tool: JsonRecord): boolean {
+  return (
+    tool.type === "web_search" ||
+    tool.type === "web_search_preview" ||
+    tool.type === "image_generation"
+  );
+}
+
+function responsesLiteTools(value: unknown): JsonRecord[] {
+  const functions: JsonRecord = {
+    type: "namespace",
+    name: DEFAULT_FUNCTION_NAMESPACE,
+    description: "",
+    tools: [],
+  };
+  const functionTools = functions["tools"] as JsonRecord[];
+  const result: JsonRecord[] = [];
+  let functionsIndex: number | undefined;
+
+  for (const candidate of Array.isArray(value) ? value : []) {
+    if (!isObject(candidate)) throw new Error("Responses Lite received an invalid tool.");
+    const tool = structuredClone(candidate);
+    if (tool.type === "function" || tool.type === "custom") {
+      if (typeof tool.name !== "string") {
+        throw new Error("Responses Lite received an invalid default-namespace tool.");
+      }
+      functionsIndex ??= result.length;
+      functionTools.push(tool);
+      continue;
+    }
+    if (tool.type === "namespace" && tool.name === DEFAULT_FUNCTION_NAMESPACE) {
+      functionsIndex ??= result.length;
+      if (typeof tool["description"] === "string" && tool["description"].trim()) {
+        functions["description"] = tool["description"];
+      }
+      if (!Array.isArray(tool.tools)) {
+        throw new Error("Responses Lite received an invalid functions namespace.");
+      }
+      for (const child of tool.tools) {
+        if (
+          !isObject(child) ||
+          (child.type !== "function" && child.type !== "custom") ||
+          typeof child.name !== "string"
+        ) {
+          throw new Error("Responses Lite received an invalid functions namespace tool.");
+        }
+        const cloned = structuredClone(child);
+        functionTools.push(cloned);
+      }
+      continue;
+    }
+    if (!isHostedTool(tool)) result.push(tool);
+  }
+
+  if (functionsIndex !== undefined && functionTools.length > 0) {
+    result.splice(functionsIndex, 0, functions);
+  }
+  return result;
+}
+
+function prepareInputItem(value: unknown): unknown {
+  if (Array.isArray(value)) {
+    return value.map((item) => prepareInputItem(item));
+  }
+  if (!isObject(value)) return value;
+
+  const result: JsonRecord = {};
+  for (const [key, child] of Object.entries(value)) {
+    if (key === "detail" && value.type === "input_image") continue;
+    result[key] = prepareInputItem(child);
+  }
+  return result;
+}
+
+export function usesResponsesLite(modelId: string, enabled = true): boolean {
+  return enabled && RESPONSES_LITE_MODELS.has(modelId);
+}
+
+export function applyResponsesLite(
+  payload: JsonRecord,
+  modelId: string,
+  enabled = true,
+): JsonRecord {
+  if (!usesResponsesLite(modelId, enabled)) return payload;
+  if (!Array.isArray(payload.input)) {
+    throw new Error("Responses Lite requires array input.");
+  }
+
+  const requestInput = payload.input;
+  const result = structuredClone(payload);
+  const tools = responsesLiteTools(result.tools);
+  const input = requestInput.map((item) => prepareInputItem(item));
+  const prefix: JsonRecord[] = [{ type: "additional_tools", role: "developer", tools }];
+  if (typeof result.instructions === "string" && result.instructions.length > 0) {
+    prefix.push({
+      type: "message",
+      role: "developer",
+      content: [{ type: "input_text", text: result.instructions }],
+    });
+  }
+  result.input = [...prefix, ...input];
+  delete result.instructions;
+  delete result.tools;
+  result.parallel_tool_calls = false;
+  result["reasoning"] = {
+    ...(isObject(result["reasoning"]) ? result["reasoning"] : {}),
+    context: "all_turns",
+  };
+  result.client_metadata = {
+    ...(isObject(result.client_metadata) ? result.client_metadata : {}),
+    [RESPONSES_LITE_WS_METADATA_KEY]: "true",
+  };
+  return result;
+}
+
+export function applyResponsesLiteHeaders(headers: Headers, payload: JsonRecord): void {
+  const metadata = payload.client_metadata;
+  if (isObject(metadata) && metadata[RESPONSES_LITE_WS_METADATA_KEY] === "true") {
+    headers.set(RESPONSES_LITE_HEADER, "true");
+  }
+}
+
+/** Keep the WebSocket-only Lite marker out of HTTP/SSE request bodies. */
+export function responsesLiteSsePayload(payload: JsonRecord): JsonRecord {
+  const metadata = payload.client_metadata;
+  if (!isObject(metadata) || metadata[RESPONSES_LITE_WS_METADATA_KEY] === undefined) {
+    return payload;
+  }
+  const clientMetadata = { ...metadata };
+  delete clientMetadata[RESPONSES_LITE_WS_METADATA_KEY];
+  return {
+    ...payload,
+    client_metadata: clientMetadata,
+  };
+}

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

@@ -28,6 +28,7 @@ const COMMAND_NAME = "codex-settings";
 
 type SettingId =
   | "fastMode"
+  | "responsesLite"
   | "textVerbosity"
   | "reasoningSummary"
   | "reasoningMode"
@@ -64,6 +65,13 @@ export function settingItems(
       currentValue: toggleValue(config.fastMode),
       values: ["off", "on"],
     },
+    {
+      id: "responsesLite",
+      label: "Responses Lite",
+      description: "Use Codex's Responses Lite envelope on supported GPT-5.6 models.",
+      currentValue: toggleValue(config.responsesLite),
+      values: ["off", "on"],
+    },
     {
       id: "textVerbosity",
       label: "Text verbosity",
@@ -155,6 +163,8 @@ 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 "responsesLite":
+      return value === "on" || value === "off" ? { responsesLite: value === "on" } : undefined;
     case "textVerbosity":
       if (value === "low" || value === "medium" || value === "high") {
         return { textVerbosity: value };
@@ -202,6 +212,7 @@ export function settingPatch(id: string, value: string): ConfigLayer | undefined
 function applySettingPatch(config: CodexCompatConfig, patch: ConfigLayer): CodexCompatConfig {
   const next: CodexCompatConfig = { ...config };
   if (typeof patch.fastMode === "boolean") next.fastMode = patch.fastMode;
+  if (typeof patch.responsesLite === "boolean") next.responsesLite = patch.responsesLite;
   if (typeof patch.applyPatch === "boolean") next.applyPatch = patch.applyPatch;
   if (patch.toolBackground) next.toolBackground = patch.toolBackground;
   if (typeof patch.imageGeneration === "boolean") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-openai-codex-compat",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "OpenAI Codex compatibility for Pi with native compaction, fast mode, and Codex-optimized capabilities",
   "keywords": [
     "pi-package"
@@ -31,7 +31,7 @@
   "scripts": {
     "check": "hk check --all --check",
     "test": "node --test --test-concurrency=1 test/*.test.ts",
-    "test:live:codex": "PI_CODEX_LIVE_TEST=1 node --test --test-concurrency=1 test/codex-transport.live.test.ts",
+    "test:live:codex": "PI_CODEX_LIVE_TEST=1 node --test --test-concurrency=1 test/codex-host.live.test.ts",
     "fmt": "oxfmt",
     "lint": "oxlint",
     "lint:fix": "oxlint --fix"