pi-openai-codex-compat 0.0.11 → 0.0.12

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## 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

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.11",
+  "version": "0.0.12",
   "description": "OpenAI Codex compatibility for Pi with native compaction, fast mode, and Codex-optimized capabilities",
   "keywords": [
     "pi-package"