pi-openai-codex-compat 0.0.10 → 0.0.12

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## Unreleased
 
+## 0.0.12 - 2026-09-20
+
+### Fixed
+
+- Send Pi's strict-sampling tools (`read`, `bash`, `edit`, `write`) with the strict
+  JSON-schema subset Codex requires. On Pi 0.86 every request that declared a
+  built-in tool failed with an `Invalid schema for function` error.
+
+## 0.0.11 - 2026-09-20
+
+### Fixed
+
+- Report missing Pi transcript APIs when loading the extension instead of
+  failing on the first request.
+
 ## 0.0.10 - 2026-09-20
 
 ### Added

package/README.md

@@ -25,6 +25,11 @@ Pi provides the Codex OAuth flow and model catalog. At session start, this packa
 - Pi `>=0.86.0 <0.87.0`
 - An OpenAI Codex login in Pi
 
+Restart Pi after upgrading its runtime. `/reload` reloads extensions but cannot
+upgrade the running Pi process. The extension checks the host's transcript APIs
+at load time. `PI_PACKAGE_DIR` can point an older executable at newer package
+metadata, so its displayed version alone does not establish compatibility.
+
 Authenticate through Pi if needed:
 
 ```text
@@ -581,6 +586,11 @@ mise run test:live:codex
 
 The task obtains the local Codex bearer token and runs the tests with
 `gpt-5.6-luna` at medium reasoning effort.
+It also packs the extension and loads that archive through the shipped Pi
+0.86.0 CLI. Ordinary Responses and Responses Lite tests exercise tool calls,
+prompt reload, native compaction, and persisted-session resume against Codex.
+Test credentials stay in memory and child-process environments. Test sessions
+and configuration are isolated from the user's agent directory.
 
 The public package entrypoint is `extensions/index.ts`; implementation modules remain under
 `extensions/openai-codex-compat/`. The focused Pi AI serializer copy lives under
@@ -593,7 +603,7 @@ search, and compaction continuation.
 ## Release staging
 
 1. Run `npm run release -- X.Y.Z` from a clean, synchronized `main`.
-2. The command builds the exact package locally, records its SHA-256 in an SSH-signed release commit, proves a clean rebuild is reproducible, and creates a lightweight tag.
+2. The command builds the exact package locally and runs live CLI tests against that archive. It also runs the existing live SDK tests against checkout source. Both suites must pass before it records the archive's SHA-256 in an SSH-signed release commit, proves a clean rebuild is reproducible, and creates a lightweight tag. Missing credentials or failing live tests stop the release.
 3. Inspect the result, then push atomically with `git push --atomic origin main vX.Y.Z`.
 4. A read-only GitHub Actions job validates and packs the package. After approval in the tag-restricted `npm-publish` environment, a separate GitHub-owned job verifies the signature and signed digest before attesting and staging that exact archive through npm trusted publishing.
 5. Approve the staged package on npmjs.com, or with `npm stage approve <stage-id>`.

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

@@ -1,4 +1,6 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import * as piAi from "@earendil-works/pi-ai";
+import { requirePiTranscriptRuntime } from "./pi-runtime.ts";
 import { DEFAULT_CONFIG, loadConfig, type CodexCompatConfig } from "./config.ts";
 import type { ConfigContext } from "./config-context.ts";
 import { registerCodexProvider } from "./codex-provider.ts";
@@ -21,6 +23,7 @@ export {
 } from "./codex-transport.ts";
 
 export default function registerOpenAICodexCompat(pi: ExtensionAPI): void {
+  requirePiTranscriptRuntime(piAi);
   let activeConfig: CodexCompatConfig | undefined;
   const resolveConfig = (ctx: ConfigContext): CodexCompatConfig => {
     activeConfig ??= loadConfig(ctx.cwd, ctx.isProjectTrusted());

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

@@ -0,0 +1,20 @@
+const TRANSCRIPT_APIS = [
+  "normalizeContext",
+  "getCurrentSystemPrompt",
+  "getDeclaredTools",
+  "getInitialSystemMessage",
+  "resolveTranscriptTools",
+] as const;
+
+/** Check the loaded host, not package metadata that PI_PACKAGE_DIR can override. */
+export function requirePiTranscriptRuntime(api: Record<string, unknown>): void {
+  const missing = TRANSCRIPT_APIS.filter((name) => typeof api[name] !== "function");
+  if (missing.length > 0) {
+    throw new Error(
+      "pi-openai-codex-compat requires a running Pi 0.86.x runtime. " +
+        `Missing host APIs: ${missing.join(", ")}. ` +
+        "Exit Pi and start Pi 0.86.x after updating. /reload cannot upgrade the running " +
+        "runtime, and PI_PACKAGE_DIR can make an older executable report a newer version.",
+    );
+  }
+}

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

@@ -2,7 +2,7 @@
 
 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.86.0`. Its header lists the upstream source files. Keep the wire-equivalence tests in [`test/pi-ai-serialization.test.ts`](../../../../test/pi-ai-serialization.test.ts) passing when updating the Pi dependencies.
+[`openai-responses-serialization.ts`](openai-responses-serialization.ts) adapts the relevant methods from `@earendil-works/pi-ai@0.86.0`. Its header lists the upstream source files. It also carries the strict JSON-schema conversion from `src/api/constrained-sampling.ts`; Pi's built-in tools request strict sampling, and Codex rejects `strict: true` without that subset. Keep the wire-equivalence tests in [`test/pi-ai-serialization.test.ts`](../../../../test/pi-ai-serialization.test.ts) passing when updating the Pi dependencies.
 
 Pi AI's transcript helpers replay system sections and tool declarations.
 `supportsAdditionalTools` and `supportsToolSearch` select the dynamic tool

package/extensions/openai-codex-compat/vendor/pi-ai/openai-responses-serialization.ts

@@ -138,13 +138,170 @@ function inferGrammarInputProperty(tool: Tool): string {
   return inputProperty;
 }
 
+interface JsonSchemaObject {
+  [key: string]: unknown;
+  type?: unknown;
+  properties?: Record<string, JsonSchemaObject | undefined>;
+  required?: unknown;
+}
+
+export class UnsupportedStrictJsonSchemaError extends Error {}
+
+const UNSUPPORTED_STRICT_SCHEMA_KEYS = [
+  "$ref",
+  "$defs",
+  "definitions",
+  "allOf",
+  "oneOf",
+  "patternProperties",
+  "dependentSchemas",
+  "dependencies",
+  "unevaluatedProperties",
+  "propertyNames",
+  "contains",
+  "prefixItems",
+  "not",
+  "if",
+  "then",
+  "else",
+] as const;
+
+function isJsonSchemaObject(value: unknown): value is JsonSchemaObject {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isStructuredSchema(schema: unknown): boolean {
+  if (!isJsonSchemaObject(schema)) return false;
+  const types =
+    typeof schema.type === "string" ? [schema.type] : Array.isArray(schema.type) ? schema.type : [];
+  return (
+    types.includes("object") ||
+    types.includes("array") ||
+    schema.properties !== undefined ||
+    schema["items"] !== undefined
+  );
+}
+
+function schemaAllowsNull(schema: unknown): boolean {
+  if (!isJsonSchemaObject(schema)) return false;
+  if (schema.type === "null" || (Array.isArray(schema.type) && schema.type.includes("null"))) {
+    return true;
+  }
+  if (
+    schema["const"] === null ||
+    (Array.isArray(schema["enum"]) && schema["enum"].includes(null))
+  ) {
+    return true;
+  }
+  return (
+    Array.isArray(schema["anyOf"]) &&
+    schema["anyOf"].some((variant: unknown) => schemaAllowsNull(variant))
+  );
+}
+
+function makeJsonSchemaNodeStrict(schema: unknown): void {
+  if (!isJsonSchemaObject(schema)) {
+    throw new UnsupportedStrictJsonSchemaError("boolean schemas are unsupported");
+  }
+  for (const key of UNSUPPORTED_STRICT_SCHEMA_KEYS) {
+    if (schema[key] !== undefined) {
+      throw new UnsupportedStrictJsonSchemaError(`${key} schemas are unsupported`);
+    }
+  }
+
+  const anyOf: unknown = schema["anyOf"];
+  if (anyOf !== undefined) {
+    if (!Array.isArray(anyOf) || anyOf.length === 0) {
+      throw new UnsupportedStrictJsonSchemaError("anyOf must contain at least one schema");
+    }
+    for (const variant of anyOf) {
+      if (isStructuredSchema(variant)) {
+        throw new UnsupportedStrictJsonSchemaError("object and array unions are unsupported");
+      }
+      makeJsonSchemaNodeStrict(variant);
+    }
+  }
+
+  const items: unknown = schema["items"];
+  if (items !== undefined) {
+    if (Array.isArray(items)) {
+      throw new UnsupportedStrictJsonSchemaError("tuple schemas are unsupported");
+    }
+    makeJsonSchemaNodeStrict(items);
+  }
+
+  const isObjectSchema = schema.type === "object";
+  if (schema.properties !== undefined && !isObjectSchema) {
+    throw new UnsupportedStrictJsonSchemaError("properties require type object");
+  }
+  if (!isObjectSchema) return;
+  if (schema["additionalProperties"] !== undefined && schema["additionalProperties"] !== false) {
+    throw new UnsupportedStrictJsonSchemaError(
+      "schema-valued or true additionalProperties is unsupported",
+    );
+  }
+  if (schema.properties !== undefined && !isJsonSchemaObject(schema.properties)) {
+    throw new UnsupportedStrictJsonSchemaError("object properties must be a schema map");
+  }
+  if (
+    schema.required !== undefined &&
+    (!Array.isArray(schema.required) || schema.required.some((key) => typeof key !== "string"))
+  ) {
+    throw new UnsupportedStrictJsonSchemaError("object required must be a string array");
+  }
+
+  const properties = schema.properties ?? {};
+  const propertyNames = Object.keys(properties);
+  const required = new Set<unknown>(Array.isArray(schema.required) ? schema.required : []);
+  if ([...required].some((key) => !isString(key) || !propertyNames.includes(key))) {
+    throw new UnsupportedStrictJsonSchemaError("required contains an unknown property");
+  }
+  for (const [key, property] of Object.entries(properties)) {
+    makeJsonSchemaNodeStrict(property);
+    if (!required.has(key) && !schemaAllowsNull(property)) {
+      properties[key] = { anyOf: [property, { type: "null" }] };
+    }
+  }
+  schema.required = propertyNames;
+  schema["additionalProperties"] = false;
+}
+
+/** Convert a tool schema to the strict subset expected by provider constrained sampling. */
+export function makeStrictJsonSchema(schema: Tool["parameters"]): Record<string, unknown> {
+  const cloned: unknown = structuredClone(schema);
+  if (!isJsonSchemaObject(cloned)) {
+    throw new UnsupportedStrictJsonSchemaError("root schema must have type object");
+  }
+  makeJsonSchemaNodeStrict(cloned);
+  if (cloned.type !== "object") {
+    throw new UnsupportedStrictJsonSchemaError("root schema must have type object");
+  }
+  return cloned;
+}
+
+function getJsonSchemaToolParameters(tool: Tool, strict: boolean | undefined): unknown {
+  return strict === true ? makeStrictJsonSchema(tool.parameters) : tool.parameters;
+}
+
 function resolveJsonSchemaStrictSampling(
   tool: Tool,
   supportsStrictMode: boolean,
 ): boolean | undefined {
   const config = tool.constrainedSampling;
   if (!config || config.type !== "json_schema") return undefined;
-  if (supportsStrictMode) return true;
+  if (supportsStrictMode) {
+    try {
+      makeStrictJsonSchema(tool.parameters);
+      return true;
+    } catch (error) {
+      if (!(error instanceof UnsupportedStrictJsonSchemaError)) throw error;
+      if (config.strict !== "require") return undefined;
+      throw new Error(
+        `Tool "${tool.name}" requires JSON-schema constrained sampling, but ${error.message}.`,
+        { cause: error },
+      );
+    }
+  }
   if (config.strict === "require") {
     throw new Error(
       `Tool "${tool.name}" requires JSON-schema constrained sampling, but strict tools are unsupported.`,
@@ -226,17 +383,21 @@ export function convertResponsesTools(
     }
 
     const constrainedStrict = resolveJsonSchemaStrictSampling(tool, supportsStrictMode);
-    if (!isJsonValue(tool.parameters)) {
+    const strict = constrainedStrict ?? defaultStrict;
+    // Strict function tools must send the strict schema subset: every property required,
+    // optional properties nullable, and `additionalProperties: false` on each object.
+    const parameters = getJsonSchemaToolParameters(tool, strict === true);
+    if (!isJsonValue(parameters)) {
       throw new Error(`Tool "${tool.name}" has non-JSON parameters.`);
     }
     const converted: ResponsesItem = {
       type: "function",
       name: tool.name,
       description: tool.description,
-      parameters: tool.parameters,
+      parameters,
     };
     if (options?.deferLoading) converted["defer_loading"] = true;
-    if (supportsStrictMode) converted["strict"] = constrainedStrict ?? defaultStrict;
+    if (supportsStrictMode) converted["strict"] = strict;
     return converted;
   };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-openai-codex-compat",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "description": "OpenAI Codex compatibility for Pi with native compaction, fast mode, and Codex-optimized capabilities",
   "keywords": [
     "pi-package"
@@ -36,7 +36,7 @@
   "scripts": {
     "check": "hk check --all --check",
     "test": "node --test --test-concurrency=4 test/*.test.ts",
-    "test:live:codex": "PI_CODEX_LIVE_TEST=1 node --test --test-concurrency=1 test/codex-host.live.test.ts",
+    "test:live:codex": "PI_CODEX_LIVE_TEST=1 node --test --test-concurrency=1 test/codex-host.live.test.ts test/codex-cli.live.test.ts",
     "pack:dry": "npm pack --dry-run --allow-directory=all",
     "release": "node scripts/release.ts",
     "fmt": "oxfmt",