pi-openai-codex-compat 0.0.11 → 0.0.13

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 ## Unreleased
 
+## 0.0.13 - 2026-09-21
+
+### Fixed
+
+- Declare the complete current tool set in the top-level `tools` field on
+  every request and never inside `input`, as the official Codex client does.
+  Tools added mid-session were replayed as inline `additional_tools` items;
+  the Codex backend then often treated other tools as unavailable, and after a
+  percentage-triggered compaction the inline declarations were gone entirely,
+  so the model reported that it had no callable tools. A mid-session tool
+  change now costs one prompt-cache miss instead.
+
+### Changed
+
+- Use Pi 0.86.1 as the development and packaged-CLI integration baseline. The
+  supported range stays `>=0.86.0 <0.87.0`.
+
+## 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/README.md

@@ -68,7 +68,7 @@ The compatibility baseline is official Codex CLI `0.149.1`, released August 24,
 | Branching                   | Checkpoints and native response overrides follow Pi's active session branch. Official Codex uses its own thread, turn, rollback, fork, and context-window lineage.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
 | Model switching             | This package rejects model switches while the active Pi branch contains a native Codex checkpoint because the checkpoint is model-specific.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
 | System instructions         | Replay Pi's system-message sections into the complete current prompt. Responses Lite models prepend it as developer input after `additional_tools`; other models send it through Responses `instructions`. Do not replay older Pi system-prompt text alongside that current prompt. `/reload`, forced prompts, compaction snapshots, and resumed sessions use the current state without rewriting old checkpoints.                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
-| Dynamic tool declarations   | Replay additive `toolsAdded` system messages in place as `additional_tools` or tool-search pairs on capable models. Tool removal or redefinition uses the complete current top-level tool set instead. Compaction rebases declarations so tools remain available after their history is replaced.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| Dynamic tool declarations   | Send the complete current tool set, replayed from Pi's `toolsAdded` and `toolsRemoved` system messages, in the top-level `tools` field on every request, as the official Codex client does. Tool declarations never travel inside `input`: inline `additional_tools` items and synthetic tool-search pairs made the Codex backend unreliable about which tools exist. A mid-session tool change costs one prompt-cache miss, and native checkpoints need no declaration rebase.                                                                                                                                                                                                                                                                                                                                                                                                                  |
 | Turn metadata               | Requests send a persisted installation id plus Pi-derived session, thread, context-window, turn, source, sandbox, request-kind, and nested compaction-operation metadata in `client_metadata` and compatible headers. The in-memory context-window number advances after successful compaction. One turn id is reused throughout a Pi agent run, while prewarm has its own id. First-party requests also carry Codex's model-and-tier routing hint. The provider captures the server-issued `x-codex-turn-state` once per agent run, replays it on WebSocket retries, SSE requests, and WebSocket-to-SSE fallback, and records all identity values in transport diagnostics. Pi does not reconstruct prior window number after extension reload/session resume or reproduce workspace Git/parent/subagent/Code Mode metadata. Each marked Pi tree branch receives its own persisted thread UUID. |
 | Cache preparation           | Before the first cache-enabled WebSocket turn, the package prewarms only the stable instruction/tool prefix: ordinary Responses uses empty `input`, while Responses Lite uses `additional_tools` plus the developer instructions. The first generated request then contributes only dynamic conversation input to the continuation. No explicit prompt-cache breakpoints are added.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
 | Mid-turn compaction         | Provider-boundary percentage compaction preserves a successful `end_turn:false` prefix as its own Pi assistant message, installs a checkpoint, and continues without synthetic model input. Pi threshold compaction normally runs after the agent response; after Codex output-token truncation, the extension queues a hidden continuation so threshold compaction completes before sampling resumes. Official Codex owns this sampling and compaction loop directly.                                                                                                                                                                                                                                                                                                                                                                                                                           |
@@ -115,19 +115,19 @@ The package implements the Codex-specific pieces that fit a provider compatibili
 
 The following official Codex facilities are not exact equivalents in this package:
 
-| Official Codex facility                                                 | Pi/package behavior                                                                                                                                              |
-| ----------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `view_image`                                                            | Pi `read` already accepts images; no canonical `view_image` alias is registered.                                                                                 |
-| `update_plan`, `request_user_input`, permissions, and environment tools | Not implemented by this package.                                                                                                                                 |
-| `send_user_message_async`                                               | Not implemented; Pi owns visible assistant output and user-message history, while this package does not own Codex's asynchronous message-injection lifecycle.    |
-| Context-window and clock tools                                          | Not implemented. Compaction remains host/provider managed rather than model managed.                                                                             |
-| MCP resources and dynamic MCP tools                                     | Pi does not provide this package with Codex's MCP runtime.                                                                                                       |
-| Plugin/connector installation                                           | Not implemented; package installation remains an explicit Pi/user operation.                                                                                     |
-| Searchable `tool_search` catalog                                        | Pi can replay additive tool-search history for capable models, but this package does not implement Codex's searchable deferred-tool catalog and ranking runtime. |
-| Multi-agent V1/V2 coordination                                          | Out of scope; no Codex agent tree, mailbox, task-path, or fork-depth runtime is implemented.                                                                     |
-| JavaScript Code Mode and yielded cells                                  | Out of scope; no V8 isolate, nested tool namespace, cell storage, or `wait` lifecycle is implemented.                                                            |
-| Goals, memories, and remote skill-resource tools                        | Not implemented; Pi's sessions, files, and native skills remain separate systems.                                                                                |
-| Remote/deferred execution environments                                  | Not implemented.                                                                                                                                                 |
+| Official Codex facility                                                 | Pi/package behavior                                                                                                                                           |
+| ----------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `view_image`                                                            | Pi `read` already accepts images; no canonical `view_image` alias is registered.                                                                              |
+| `update_plan`, `request_user_input`, permissions, and environment tools | Not implemented by this package.                                                                                                                              |
+| `send_user_message_async`                                               | Not implemented; Pi owns visible assistant output and user-message history, while this package does not own Codex's asynchronous message-injection lifecycle. |
+| Context-window and clock tools                                          | Not implemented. Compaction remains host/provider managed rather than model managed.                                                                          |
+| MCP resources and dynamic MCP tools                                     | Pi does not provide this package with Codex's MCP runtime.                                                                                                    |
+| Plugin/connector installation                                           | Not implemented; package installation remains an explicit Pi/user operation.                                                                                  |
+| Searchable `tool_search` catalog                                        | This package declares every tool at the top level and does not implement Codex's searchable deferred-tool catalog and ranking runtime.                        |
+| Multi-agent V1/V2 coordination                                          | Out of scope; no Codex agent tree, mailbox, task-path, or fork-depth runtime is implemented.                                                                  |
+| JavaScript Code Mode and yielded cells                                  | Out of scope; no V8 isolate, nested tool namespace, cell storage, or `wait` lifecycle is implemented.                                                         |
+| Goals, memories, and remote skill-resource tools                        | Not implemented; Pi's sessions, files, and native skills remain separate systems.                                                                             |
+| Remote/deferred execution environments                                  | Not implemented.                                                                                                                                              |
 
 See [`OFFICIAL_CODEX_CLI_TOOL_CATALOG.md`](OFFICIAL_CODEX_CLI_TOOL_CATALOG.md) for the complete researched Codex tool inventory, and [`CUSTOM_CODEX_PROVIDER_WEB_REFERENCES.md`](CUSTOM_CODEX_PROVIDER_WEB_REFERENCES.md) for the unimplemented citation/reference design.
 
@@ -587,7 +587,7 @@ 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,
+0.86.1 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.
@@ -606,7 +606,9 @@ search, and compaction continuation.
 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>`.
+5. A final job creates the immutable GitHub release for the tag from the same verified archive, its
+   checksum, and the version's `CHANGELOG.md` section (`Unreleased` for prereleases).
+6. Approve the staged package on npmjs.com, or with `npm stage approve <stage-id>`.
 
 Stable releases use `latest`; prereleases derive their npm dist-tag from the first prerelease identifier.
 

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

@@ -59,7 +59,6 @@ export function splitUnsampledUserInput(options: {
     allTools: options.allTools,
     grammarToolInputProperties: options.grammarToolInputProperties,
     imageDetail: options.imageDetail,
-    anchorsToolAdditions: false,
   });
   if (encoded.length === 0 || encoded.length > options.history.length) return { kind: "unsafe" };
 

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

@@ -6,9 +6,9 @@ import {
   clampThinkingLevel,
   createAssistantMessageEventStream,
   getCurrentSystemPrompt,
+  getCurrentTools,
   getDeclaredTools,
   normalizeContext,
-  resolveTranscriptTools,
   type Api,
   type AssistantMessage,
   type AssistantMessageEventStream,
@@ -495,7 +495,6 @@ export class CodexProviderRuntime {
     context: TranscriptContext,
     grammarToolInputProperties: GrammarToolInputProperties,
     sessionId: string | undefined,
-    anchorsToolAdditions: boolean,
   ): ResponsesInputItem[] {
     const scope = sessionId ? this.scopes.get(sessionId) : undefined;
     const compat = responsesCompatibility(model.compat);
@@ -505,8 +504,8 @@ export class CodexProviderRuntime {
         includeSystemPrompt: false,
         includeSystemUpdates: false,
         supportsMidConvoSystemMessages: true,
-        supportsAdditionalTools: anchorsToolAdditions && (compat.supportsAdditionalTools ?? false),
-        supportsToolSearch: anchorsToolAdditions && (compat.supportsToolSearch ?? false),
+        supportsAdditionalTools: false,
+        supportsToolSearch: false,
         grammarToolInputProperties,
         toolOptions: {
           strict: false,
@@ -528,7 +527,6 @@ export class CodexProviderRuntime {
       allTools: this.pi.getAllTools(),
       grammarToolInputProperties,
       imageDetail: scope.config.imageDetail,
-      anchorsToolAdditions,
     });
   }
 
@@ -543,39 +541,18 @@ export class CodexProviderRuntime {
       turnId,
     } = options;
     const compat = responsesCompatibility(model.compat);
-    const scope = runtimeSessionId ? this.scopes.get(runtimeSessionId) : undefined;
-    const threshold = scope?.config.autoCompactAtPercent;
-    // Percentage compaction drops historical tool additions. Rebase declarations
-    // before serialization so both the compaction and its continuation stay valid.
-    const compactionPending =
-      threshold !== undefined &&
-      scope?.contextPercent !== null &&
-      scope?.contextPercent !== undefined &&
-      scope.contextPercent >= threshold;
-    const toolPlacement = resolveTranscriptTools(
-      context.messages,
-      !compactionPending &&
-        ((compat.supportsAdditionalTools ?? false) || (compat.supportsToolSearch ?? false)),
-    );
-    // A forced prompt can project all tools into a single leading system message.
-    // Do not replay additions from the stored branch after that projection.
-    const anchorsToolAdditions =
-      toolPlacement.anchorsAdditions &&
-      context.messages
-        .slice(1)
-        .some((message) => message.role === "system" && (message.toolsAdded?.length ?? 0) > 0);
+    // Every request declares the complete current tool set at the top level,
+    // as the official Codex client does. Replaying additions inside the input
+    // made the Codex backend unreliable about which tools exist, and a native
+    // checkpoint drops such history anyway. A mid-session tool change costs one
+    // cache miss.
+    const requestTools = getCurrentTools(context.messages);
     let body: JsonRecord = {
       model: model.id,
       store: false,
       stream: true,
       instructions: getCurrentSystemPrompt(context.messages) || "You are a helpful assistant.",
-      input: this.wireHistory(
-        model,
-        context,
-        grammarToolInputProperties,
-        runtimeSessionId,
-        anchorsToolAdditions,
-      ),
+      input: this.wireHistory(model, context, grammarToolInputProperties, runtimeSessionId),
       text: { verbosity: requestOptions.textVerbosity ?? "low" },
       include: ["reasoning.encrypted_content"],
       tool_choice: requestOptions.toolChoice ?? "auto",
@@ -594,8 +571,8 @@ export class CodexProviderRuntime {
       ),
     });
     if (requestOptions.serviceTier !== undefined) body.service_tier = requestOptions.serviceTier;
-    if (toolPlacement.requestTools.length > 0) {
-      body.tools = convertResponsesTools(toolPlacement.requestTools, {
+    if (requestTools.length > 0) {
+      body.tools = convertResponsesTools(requestTools, {
         strict: false,
         supportsStrictMode: compat.supportsStrictMode ?? true,
         supportsOpenAIGrammarTools: compat.supportsOpenAIGrammarTools ?? false,

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

@@ -153,7 +153,6 @@ type EncodeMessagesOptions = {
   allTools: readonly ToolInfo[];
   grammarToolInputProperties: GrammarToolInputProperties;
   imageDetail: ImageDetail;
-  anchorsToolAdditions?: boolean;
   nativeAssistantItems?: ReadonlyMap<string, readonly ResponsesOutputItem[]>;
 };
 
@@ -165,10 +164,16 @@ export type EncodeSessionEntriesOptions = {
   imageDetail?: ImageDetail;
   nativeAssistantItems?: ReadonlyMap<string, readonly ResponsesOutputItem[]>;
   initialSystemMessage?: SystemMessage;
-  anchorsToolAdditions?: boolean;
 };
 
-/** Encode Pi's canonical messages using Pi AI's OpenAI Responses serializer. */
+/**
+ * Encode Pi's canonical messages using Pi AI's OpenAI Responses serializer.
+ *
+ * Tool declarations never enter the input: every request carries the complete
+ * current tool set at the top level, as the official Codex client does. Inline
+ * `additional_tools` items and synthetic tool-search pairs made the Codex
+ * backend unreliable about which tools exist, so neither is emitted.
+ */
 function encodeMessages(options: EncodeMessagesOptions): ResponsesInputItem[] {
   const { model, messages, grammarToolInputProperties, imageDetail, nativeAssistantItems } =
     options;
@@ -177,10 +182,8 @@ function encodeMessages(options: EncodeMessagesOptions): ResponsesInputItem[] {
     includeSystemPrompt: false,
     includeSystemUpdates: false,
     supportsMidConvoSystemMessages: true,
-    supportsAdditionalTools:
-      options.anchorsToolAdditions !== false && (compat.supportsAdditionalTools ?? false),
-    supportsToolSearch:
-      options.anchorsToolAdditions !== false && (compat.supportsToolSearch ?? false),
+    supportsAdditionalTools: false,
+    supportsToolSearch: false,
     grammarToolInputProperties,
     toolOptions: {
       strict: false,
@@ -221,9 +224,6 @@ export function encodeSessionEntries(options: EncodeSessionEntriesOptions): Resp
     grammarToolInputProperties,
     imageDetail,
   };
-  if (options.anchorsToolAdditions !== undefined) {
-    encodeOptions.anchorsToolAdditions = options.anchorsToolAdditions;
-  }
   if (nativeAssistantItems) encodeOptions.nativeAssistantItems = nativeAssistantItems;
   return encodeMessages(encodeOptions);
 }
@@ -347,7 +347,6 @@ export function providerHistory(options: {
   grammarToolInputProperties?: GrammarToolInputProperties;
   imageDetail?: ImageDetail;
   recoverLatestOverflowPrefix?: boolean;
-  anchorsToolAdditions?: boolean;
 }): ResponsesInputItem[] {
   const branch = [...options.branch];
   let recoveredPrefix: ResponsesInputItem[] = [];
@@ -397,9 +396,6 @@ export function providerHistory(options: {
         imageDetail: options.imageDetail ?? "auto",
         nativeAssistantItems,
         ...(initialSystemMessage ? { initialSystemMessage } : {}),
-        ...(options.anchorsToolAdditions === undefined
-          ? {}
-          : { anchorsToolAdditions: options.anchorsToolAdditions }),
       }),
       ...recoveredPrefix,
     ];
@@ -414,9 +410,6 @@ export function providerHistory(options: {
       grammarToolInputProperties: options.grammarToolInputProperties ?? new Map(),
       imageDetail: options.imageDetail ?? "auto",
       nativeAssistantItems,
-      ...(options.anchorsToolAdditions === undefined
-        ? {}
-        : { anchorsToolAdditions: options.anchorsToolAdditions }),
     }),
     ...recoveredPrefix,
   ];

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

@@ -1,9 +1,9 @@
 const TRANSCRIPT_APIS = [
   "normalizeContext",
   "getCurrentSystemPrompt",
+  "getCurrentTools",
   "getDeclaredTools",
   "getInitialSystemMessage",
-  "resolveTranscriptTools",
 ] as const;
 
 /** Check the loaded host, not package metadata that PI_PACKAGE_DIR can override. */

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

@@ -249,9 +249,7 @@ export default function registerRemoteCompaction(
         grammarToolInputProperties,
         imageDetail: config.imageDetail,
         recoverLatestOverflowPrefix: event.reason === "overflow" && event.willRetry,
-        anchorsToolAdditions: false,
       });
-      // A cached turn template can contain only the initial declarations.
       // Compaction rebases history, so use the complete current tool set.
       const template: JsonRecord = { ...matching?.payload };
       template.tools =

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.13",
   "description": "OpenAI Codex compatibility for Pi with native compaction, fast mode, and Codex-optimized capabilities",
   "keywords": [
     "pi-package"
@@ -51,9 +51,9 @@
   "devDependencies": {
     "@2h2d/oxlint-config": "0.1.1",
     "@2h2d/ts-config": "0.0.1",
-    "@earendil-works/pi-ai": "0.86.0",
-    "@earendil-works/pi-coding-agent": "0.86.0",
-    "@earendil-works/pi-tui": "0.86.0",
+    "@earendil-works/pi-ai": "0.86.1",
+    "@earendil-works/pi-coding-agent": "0.86.1",
+    "@earendil-works/pi-tui": "0.86.1",
     "@types/node": "22.20.1",
     "oxfmt": "0.64.0",
     "oxlint": "1.79.0",