pi-openai-codex-compat 0.0.2 → 0.0.4

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/responses-replay.ts

@@ -24,10 +24,3 @@ export function normalizeReplayItem(item: JsonRecord): JsonRecord {
   }
   return normalized;
 }
-
-export function replayItemsEqual(
-  left: readonly JsonRecord[] | undefined,
-  right: readonly JsonRecord[] | undefined,
-): boolean {
-  return stableResponsesJson(left ?? []) === stableResponsesJson(right ?? []);
-}

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/extensions/openai-codex-compat/web-run.ts

@@ -116,6 +116,13 @@ export default function registerWebRun(
     name: WEB_RUN_TOOL_NAME,
     label: WEB_RUN_TOOL_NAME,
     description: WEB_RUN_DESCRIPTION,
+    promptSnippet: "Search and browse the internet",
+    promptGuidelines: [
+      "Use `web.run` when the user explicitly asks to browse or when answering requires current, niche, high-stakes, or precisely sourced information, including recommendations that may change over time.",
+      'Batch independent `web.run` operations in one call, pass only required parameters, and keep `search_query` to at most four queries; use `response_length: "medium"` or `"long"` when sending four.',
+      "For technical research, prefer primary sources; for OpenAI product questions, inspect local code first and restrict fallback browsing to official OpenAI sites.",
+      "Cite supported claims with direct Markdown links near the relevant text, never expose internal reference IDs, and respect the description's quotation and source word limits.",
+    ],
     parameters: WEB_RUN_PARAMETERS,
     executionMode: "parallel",
     renderShell: "self",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-openai-codex-compat",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "OpenAI Codex compatibility for Pi with native compaction, fast mode, and Codex-optimized capabilities",
   "keywords": [
     "pi-package"
@@ -31,6 +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-host.live.test.ts",
     "fmt": "oxfmt",
     "lint": "oxlint",
     "lint:fix": "oxlint --fix"