@monotykamary/pi-better-openai 0.2.12 → 0.2.14

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.2.13
+
+- Add a native OpenAI Decisions compatibility classifier for hosts without upstream support, preserving OpenAI chat/auth and deferring to the host adapter when available.
+- Support typed predicates, choices, scores, inline images, cancellation, hooks, HTTP retries, and input-only usage accounting through native codemode and pi-fabric.
+- Keep the bounded decision tool opt-in, explicitly disable its provider retries, and verify real-host codemode with offline HTTP fixtures.
+- Upgrade sharp and pin patched source-map-js/tinypool dependencies to resolve high/critical security advisories.
+
 ## 0.2.12
 
 - Validate against Pi 1.0.2, where `openai` supports ChatGPT subscription OAuth and `openai-codex` is labeled legacy; preserve the native OpenAI provider and transport.

package/README.md

@@ -34,7 +34,7 @@ Pi labels `openai-codex` **legacy**, but this extension's usage polling, banked
 
 - GPT-6.1 Sol, GPT-6 Astra, and Daybreak Blue/Red model fallbacks for the built-in `openai-codex` provider.
 - Standard, Fast, and capability-gated Ultrafast service tiers via `/openai-tier` or `/openai-settings`; `/fast` remains a quick Fast toggle.
-- Opt-in typed decisions through `openai_decide`, using an explicitly selected Pi classifier provider (including Jev). Native OpenAI Decisions remains gated on a published adapter.
+- Native OpenAI Decisions (`openai/gpt-6-luna`) through Pi's classifier API, codemode, and pi-fabric; optional bounded `openai_decide` tool also supports Jev.
 - OpenAI subscription usage display via `/openai-usage` and the footer.
 - Interactive settings picker via `/openai-settings`.
 - Footer customization for model, thinking, fast mode, usage, and token/cost context.
@@ -155,16 +155,48 @@ The footer shows `fast` or `ultrafast` only when supported by the current model.
 
 ## Typed decisions
 
-The `openai_decide` tool returns typed judgments through Pi's classifier API, **not chat completions**. It is disabled by default and never chooses a provider automatically. To use an existing Jev classifier explicitly:
+OpenAI's [Decisions API](https://developers.openai.com/api/docs/guides/decisions) is available as the native classifier `openai/gpt-6-luna`, **not a chat-completion fallback**. Pi 1.1.0 ships the adapter, including native codemode image classification. This extension supplies a compatibility implementation only when the host lacks one; a built-in Decisions adapter always wins. Native OpenAI chat models, authentication, and transport are preserved.
+
+Use an **OpenAI API key** via `/login openai` or `OPENAI_API_KEY`. ChatGPT/Codex OAuth does not grant Decisions access. If `/login openai` stores OAuth, it takes precedence over the environment key: select the API-key login instead. No credentials are copied between providers. Catalog presence does not guarantee account entitlement.
+
+The optional `openai_decide` tool is disabled by default and never chooses a provider automatically. To enable it:
 
 ```text
 /openai-decisions models
-/openai-decisions use typesafe/jev-latest
+/openai-decisions use openai/gpt-6-luna
+```
+
+Jev also works: select `typesafe/jev-latest` and configure `TYPESAFE_API_KEY` through Pi. The model list shows registered classifiers, not guaranteed credentials or entitlement. `/openai-decisions use` saves the selected model and enables decisions in the active project/global config; `/openai-decisions off` disables requests. These settings are independent of service-tier persistence. Provider-qualified IDs containing further slashes, such as `openrouter/typesafe/jev-1.13`, are supported when registered by the host. Prefer pinned versions for stable evaluations.
+
+### Native codemode and pi-fabric
+
+The same classifier is available through `models` in Pi's codemode and pi-fabric's `fabric_exec` (`tools.models` is a Fabric alias). These are direct native-model calls: they do **not** depend on `decisions.enabled` or use the optional tool's size/deadline limits. Disabling `openai_decide` does not disable the classifier catalog or direct model calls. Enable Pi codemode with `"defaultTools": ["+codemode"]`; Fabric users can use their existing execution tool.
+
+```js
+const available = await models.getAvailableOfType("classifier", "openai");
+const model = available.find((m) => m.id === "gpt-6-luna");
+if (!model) return "Configure an OpenAI API key with Decisions access.";
+const result = await models.classify(model, {
+  state: { message: "The deployment worked." },
+  questions: {
+    approved: {
+      type: "bool",
+      instructions: "Does the message approve the result?",
+      criteria: { true: "Approval", false: "No approval" },
+    },
+  },
+});
+if (result.stopReason !== "stop") return result.errorMessage;
+return result.answers;
 ```
 
-Configure that provider's credentials through Pi (for example, `TYPESAFE_API_KEY` for TypeSafe). The model list shows registered classifiers, not guaranteed credentials or entitlement. `/openai-decisions use` saves the selected model and enables decisions in the active project/global config; `/openai-decisions off` disables requests. These settings are independent of service-tier persistence. Provider-qualified IDs containing further slashes, such as `openrouter/typesafe/jev-1.13`, are supported when registered by the host. Prefer pinned versions for stable evaluations.
+Native requests also accept `images: [{ type: "image", data: "<base64>", mimeType: "image/png" }]` beside `state` and `questions` (at most 128). The adapter performs no file reads or remote-image fetches; supply inline PNG/JPEG/GIF/WebP data. Older Fabric builds must support `NativeClassifierContext.images`; otherwise use text or upgrade Fabric. The bounded `openai_decide` wrapper remains JSON-state-only.
+
+Pi maps `bool` to OpenAI `predicate`, labeled `choice` criteria to options, and ordered `score` criteria to levels. Scores are expected zero-based level indices, not probabilities. Refusals fail with `stopReason: "error"`; billed usage is retained. Native calls follow provider HTTP retries (default two, never retrying 504); the optional tool explicitly disables retries and applies its own deadline.
+
+Decisions pricing starts at **$0.10 per million input tokens**, with no output/cache charges. Catalog long-context pricing doubles input above 272K tokens; regional premiums and actual billing may differ. See the [integration status](plans/devday-integration.md).
 
-**Native OpenAI Decisions is not yet implemented:** as of the September 29, 2026 research checkpoint, no verifiable public endpoint/schema or SDK adapter was found. The bridge accepts OpenAI only once a classifier adapter is registered in Pi; it does not invent an endpoint, forward Codex OAuth to another service, or silently substitute a chat model. See the [integration status and remaining gates](plans/devday-integration.md).
+### Optional bounded tool
 
 Example tool input:
 
@@ -182,7 +214,7 @@ Example tool input:
 ```
 
 - `state`: JSON object; send only the necessary context, never credentials or the entire session.
-- `questions`: 1–32 named questions. `choice` uses 2–64 labeled criteria; `bool` uses `true`/`false` criteria; `score` uses 2–64 ordered criteria. Pi maps boolean questions to Jev's `noul` representation.
+- `questions`: 1–32 named questions. `choice` uses 2–64 labeled criteria; `bool` uses `true`/`false` criteria; `score` uses 2–64 ordered criteria. Pi maps boolean questions to OpenAI's `predicate` or Jev's `noul` representation.
 - Total input is capped at 64 KiB. `decisions.timeoutMs` defaults to 10000 and is clamped to 1000–60000. Cancellation/deadlines abort the provider request; there are no automatic retries. A timed-out upstream request may still incur charges.
 - Results have `status: "ok"`, provider/model provenance, and typed `answers`; errors have `status: "error"` and mark the tool failed. Structured output is available to programmatic callers. Provider error text is withheld to prevent credential/state leakage.
 - Probabilities and confidence remain uncertain judgments; scores retain their provider-specific scale. No claim of cross-provider calibration is made. Decisions never authorize tools, execute commands, change the active model, or start background polling.
@@ -190,7 +222,7 @@ Example tool input:
 
 ## Codex model fallbacks
 
-These fallbacks remain scoped to the legacy provider. The native `openai` provider and its catalog are not replaced or redirected to Codex.
+These chat fallbacks remain scoped to the legacy provider. Native `openai` chat models and transport are not replaced or redirected to Codex; only the missing Decisions classifier is added on older hosts.
 
 The extension adds `gpt-6.1-sol`, `gpt-6-astra`, `gpt-daybreak-blue-latest`, and `gpt-daybreak-red-latest` to the built-in `openai-codex` provider without requiring local `models.json` entries. Existing built-in models remain available, and metadata from pi's live catalog takes precedence when pi publishes an official entry with the same ID.
 

package/THIRD_PARTY_NOTICES.md

@@ -1,5 +1,31 @@
 # Third-party notices
 
+## Pi
+
+`src/openai-decisions.ts` adapts the wire mapping, classifier contract, model metadata, and HTTP behavior from [`earendil-works/pi`](https://github.com/earendil-works/pi), notably `packages/ai/src/api/openai-decisions.ts`, `classifier-shared.ts`, and the classifier tests.
+
+MIT License
+
+Copyright (c) 2025 Mario Zechner
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
 ## oh-my-pi
 
 Portions of `src/live/` are adapted from [`can1357/oh-my-pi`](https://github.com/can1357/oh-my-pi), including its live protocol, transport, session orchestration, attestation, and terminal visualizer design.

package/index.ts

@@ -18,6 +18,7 @@ import {
 } from "@earendil-works/pi-tui";
 import type { Usage } from "@earendil-works/pi-ai";
 import { registerOpenAICodexModels } from "./src/codex-models.ts";
+import { registerOpenAIDecisionsProvider } from "./src/openai-decisions.ts";
 import { CONFIG_BASENAME, STATUS_KEY } from "./src/identity.ts";
 import {
   CODEX_PROVIDER_ID,
@@ -278,6 +279,7 @@ function textPanel(title: string, lines: string[], done: () => void) {
 
 export default function betterOpenAI(pi: ExtensionAPI): void {
   registerOpenAICodexModels(pi);
+  registerOpenAIDecisionsProvider(pi);
 
   const fastController = new FastController(SERVICE_TIER);
   let cachedConfig: ResolvedConfig | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monotykamary/pi-better-openai",
-  "version": "0.2.12",
+  "version": "0.2.14",
   "description": "Improve OpenAI in pi with fast mode, usage stats, realtime voice, image generation, and footer polish.",
   "keywords": [
     "fast",
@@ -60,14 +60,14 @@
   "dependencies": {
     "https-proxy-agent": "9.1.0",
     "proxy-from-env": "2.1.0",
-    "sharp": "0.35.4",
+    "sharp": "0.35.5",
     "undici": "8.10.2",
     "ws": "8.21.2"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "1.0.2",
-    "@earendil-works/pi-coding-agent": "1.0.2",
-    "@earendil-works/pi-tui": "1.0.2",
+    "@earendil-works/pi-ai": "1.1.0",
+    "@earendil-works/pi-coding-agent": "1.1.0",
+    "@earendil-works/pi-tui": "1.1.0",
     "@types/node": "~22.19.0",
     "@types/proxy-from-env": "1.0.4",
     "@types/ws": "8.18.1",
@@ -89,12 +89,14 @@
     "@oh-my-pi/pi-natives-win32-x64": "17.2.9"
   },
   "overrides": {
-    "@earendil-works/pi-agent-core": "1.0.2",
-    "@earendil-works/pi-ai": "1.0.2",
-    "brace-expansion": "5.0.11",
+    "@earendil-works/pi-agent-core": "1.1.0",
+    "@earendil-works/pi-ai": "1.1.0",
+    "brace-expansion": "5.0.12",
     "nanoid": "3.3.18",
     "postcss": "8.5.25",
     "protobufjs": "7.6.5",
+    "source-map-js": "1.2.2",
+    "tinypool": "2.1.2",
     "undici": "8.10.2"
   },
   "engines": {

package/plans/devday-integration.md

@@ -10,17 +10,17 @@ Research checkpoint: September 29, 2026 (UTC). Announcements and account entitle
 - `openai_decide`: an opt-in bridge to Pi's classifier API. Explicit model selection, bounded typed input/output, cancellation/deadlines, usage reporting, and no chat/provider fallback.
 - No autonomous actions, model routing, approval bypasses, or inference-driven polling. Classification is an advisory primitive; application code owns policy and execution.
 
-## Native OpenAI Decisions: blocked on a verifiable contract
+## Native OpenAI Decisions: compatibility adapter available
 
-The announcement is reported in [DevDay coverage](https://www.axios.com/2026/09/29/openai-dev-day-2026-dots-space-sol). At the research checkpoint, the public docs index and OpenAI Node SDK did not expose a verifiable Decisions contract; Codex search hits concerned existing approval decisions. This is not proof that private or later access is unavailable.
+The [public Decisions guide](https://developers.openai.com/api/docs/guides/decisions) now documents `POST /v1/decisions`, `gpt-6-luna`, predicates/choices/scores, inline image inputs, refusals, and input-only pricing. This supersedes the original research checkpoint above.
 
-The tool works with explicitly selected registered classifiers, including Jev. It does not pretend this is OpenAI's new service. Once OpenAI publishes its contract:
+Pi 1.1.0, now pinned for development, ships `packages/ai/src/api/openai-decisions.ts` and the `openai` classifier registration. `src/openai-decisions.ts` provides compatibility through the same native classifier contract; it skips registration entirely when the host provides Decisions. Remove the shim once the minimum supported host ships the adapter.
 
-1. Verify model IDs, schema, error/refusal behavior, modalities, endpoint, auth audience, rate limits, pricing, and data residency.
-2. Prefer a native Pi classifier adapter rather than duplicating credentials and transport here. Register classifier models, not chat models; the current tool can then select them.
-3. Preserve provider semantics. Do not equate arbitrary numeric scores or self-reported confidence with calibrated probabilities, or silently translate incompatible question types.
-4. Keep API-key and Codex subscription access separate until subscription authorization is documented. Do not infer OAuth compatibility from a product announcement.
-5. Add fixture tests and an opt-in live probe before claiming support. No default model ID is guessed today.
+- OpenAI chat transport, catalog, and native credential resolution are retained. Only the missing classifier operation is added. OAuth discovery excludes Decisions; API-key access is required, with no Codex credential substitution or chat fallback.
+- Native codemode and Fabric call `modelRegistry.classify`; no separate decision tool protocol is required. Native requests support optional inline `images`. The bounded `openai_decide` wrapper remains JSON-state-only and opt-in.
+- Typed result mapping preserves predicates, choice distributions, zero-based expected scores, error/aborted stop reasons, and billed usage, including refusals. Provider hooks, header overrides, cancellation, HTTP retry budgets, and long-context costs are covered by offline fixtures.
+- `bun run test:pi` exercises real Pi loading, credential isolation, and codemode text/image requests with synthetic HTTP. Fabric's native-codemode tests cover the same context shape in QuickJS, Node, and Bun. No paid live request or account entitlement is implied by these tests.
+- The provider's default HTTP retry policy is independent of the optional wrapper, which sends `maxRetries: 0` and enforces its own deadline. Neither interface authorizes actions.
 
 ### Evaluation checklist
 

package/src/config.ts

@@ -678,7 +678,7 @@ export const DECISIONS_SETTING_DESCRIPTORS: readonly SettingsOptionDescriptor[]
     currentValue: (cfg) => cfg.decisions.model,
     parse: stringSetting,
     description:
-      "Select with /openai-decisions use provider/model. OpenAI requires a published native classifier; Jev can be selected explicitly today.",
+      "Select with /openai-decisions use provider/model. OpenAI Decisions: openai/gpt-6-luna (API key only). Jev is also supported.",
   },
   {
     id: "decisions.timeoutMs",

package/src/decisions.ts

@@ -264,7 +264,7 @@ export async function evaluateDecision(
     const model = ctx.modelRegistry.getModelOfType("classifier", key.provider, key.id);
     requireDecision(
       model,
-      "The configured native classifier is unavailable. No OpenAI endpoint or chat fallback is assumed; inspect /openai-decisions models.",
+      "The configured native classifier is unavailable. Inspect /openai-decisions models; no chat fallback is used.",
     );
     const request = validateDecisionRequest(input);
     requireDecision(!controller.signal.aborted, "Decision request aborted.");
@@ -279,7 +279,7 @@ export async function evaluateDecision(
     });
     timer = setTimeout(abort, cfg.decisions.timeoutMs);
     result = await Promise.race([
-      ctx.modelRegistry.classify(model, request, { signal: controller.signal }),
+      ctx.modelRegistry.classify(model, request, { signal: controller.signal, maxRetries: 0 }),
       cancelled,
     ]);
     requireDecision(
@@ -360,7 +360,7 @@ export function registerOpenAIDecisions(
           models.length
             ? models.map((m) => `${m.provider}/${m.id}`).join("\n") +
                 "\nCatalog entries do not guarantee credentials or entitlement."
-            : "No native classifiers registered. No OpenAI Decisions endpoint is assumed.",
+            : "No native classifiers registered.",
           "info",
         );
       } else if (arg.startsWith("use ")) {
@@ -381,7 +381,7 @@ export function registerOpenAIDecisions(
       } else if (!arg) {
         const cfg = getConfig(ctx).decisions;
         ctx.ui.notify(
-          `Decisions: ${cfg.enabled ? "enabled" : "disabled"}; model: ${cfg.model || "not selected"}; timeout: ${cfg.timeoutMs}ms.\n/openai-decisions models | use provider/model | off\nOpenAI native Decisions requires a published classifier adapter in Pi; no endpoint is guessed.`,
+          `Decisions: ${cfg.enabled ? "enabled" : "disabled"}; model: ${cfg.model || "not selected"}; timeout: ${cfg.timeoutMs}ms.\n/openai-decisions models | use provider/model | off\nOpenAI Decisions: openai/gpt-6-luna requires an OpenAI API key (not ChatGPT/Codex OAuth).`,
           "info",
         );
       } else {
@@ -393,7 +393,7 @@ export function registerOpenAIDecisions(
     name: OPENAI_DECIDE_TOOL,
     label: "Typed decision",
     description:
-      "Answer bounded choice, bool, or score questions using the user's explicitly configured native classifier. Disabled until opt-in. Supports Pi classifier providers (including Jev); OpenAI requires a native adapter. Never uses a chat fallback or executes decisions.",
+      "Answer bounded choice, bool, or score questions using the user's explicitly configured native classifier. Disabled until opt-in. Supports OpenAI Decisions (openai/gpt-6-luna, API key only) and other Pi classifiers including Jev. Never uses a chat fallback or executes decisions.",
     parameters: DECISION_PARAMETERS,
     outputSchema: DECISION_OUTPUT,
     promptGuidelines: [

package/src/openai-decisions.ts

@@ -0,0 +1,379 @@
+// Compatibility implementation of Pi's upstream OpenAI Decisions classifier.
+// Remove once the minimum supported Pi ships it. See THIRD_PARTY_NOTICES.md.
+import { setTimeout as sleep } from "node:timers/promises";
+import {
+  calculateCost,
+  type ClassifierContext,
+  type ClassifierModel,
+  type ClassifierOptions,
+  type ClassifierResult,
+  type ImageContent,
+  type Provider,
+  type ProviderHeaders,
+  type Usage,
+} from "@earendil-works/pi-ai";
+import { builtinProviders } from "@earendil-works/pi-ai/providers/all";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { isRecord } from "./config.ts";
+
+export const OPENAI_DECISIONS_API = "openai-decisions";
+export const OPENAI_DECISIONS_MODEL: ClassifierModel<typeof OPENAI_DECISIONS_API> = {
+  type: "classifier",
+  provider: "openai",
+  id: "gpt-6-luna",
+  name: "GPT-6 Luna (Decisions)",
+  api: OPENAI_DECISIONS_API,
+  baseUrl: "https://api.openai.com/v1",
+  input: ["text", "image"],
+  contextWindow: 922000,
+  cost: {
+    input: 0.1,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    tiers: [{ inputTokensAbove: 272000, input: 0.2, output: 0, cacheRead: 0, cacheWrite: 0 }],
+  },
+};
+
+// Structural compatibility with Pi's upcoming ClassifierContext.images field.
+export type OpenAIDecisionsContext = ClassifierContext & { images?: ImageContent[] };
+
+class DecisionsError extends Error {}
+
+function requireValue(condition: unknown, message: string): asserts condition {
+  if (!condition) throw new DecisionsError(message);
+}
+
+function number(value: unknown, field: string, maximum = 1): number {
+  requireValue(
+    typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= maximum,
+    `OpenAI Decisions returned invalid ${field}.`,
+  );
+  return value;
+}
+
+function wireInput(context: OpenAIDecisionsContext): unknown {
+  const state = JSON.stringify(context.state);
+  const images = context.images ?? [];
+  requireValue(
+    Array.isArray(images) && images.length <= 128,
+    "Decisions accepts at most 128 images.",
+  );
+  if (!images.length) return state;
+  return [
+    {
+      role: "user",
+      content: [
+        { type: "input_text", text: state },
+        ...images.map((image) => {
+          requireValue(
+            isRecord(image) &&
+              image.type === "image" &&
+              typeof image.mimeType === "string" &&
+              /^image\/(png|jpeg|gif|webp)$/.test(image.mimeType) &&
+              typeof image.data === "string" &&
+              image.data.length > 0 &&
+              /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(image.data),
+            "Decisions images must be inline base64 PNG, JPEG, GIF, or WebP blocks.",
+          );
+          return { type: "input_image", image_url: `data:${image.mimeType};base64,${image.data}` };
+        }),
+      ],
+    },
+  ];
+}
+
+function wireQuestions(context: ClassifierContext): unknown[] {
+  return Object.entries(context.questions).map(([name, q]) => {
+    if (q.type === "choice")
+      return {
+        type: "choice",
+        name,
+        instructions: q.instructions,
+        choices: Object.entries(q.criteria).map(([value, description]) =>
+          description ? { value, description } : { value },
+        ),
+      };
+    if (q.type === "score")
+      return {
+        type: "score",
+        name,
+        instructions: q.instructions,
+        levels: q.criteria.map((label) => ({ label })),
+      };
+    requireValue(q.type === "bool", "Unsupported Decisions question type.");
+    const meanings = [
+      q.criteria.true && `True means: ${q.criteria.true}`,
+      q.criteria.false && `False means: ${q.criteria.false}`,
+    ].filter(Boolean);
+    return {
+      type: "predicate",
+      name,
+      instructions: meanings.length
+        ? `${q.instructions}\n\n${meanings.join("\n")}`
+        : q.instructions,
+    };
+  });
+}
+
+function parseAnswers(value: unknown, context: ClassifierContext): ClassifierResult["answers"] {
+  requireValue(Array.isArray(value), "OpenAI Decisions returned invalid answers.");
+  const byName = new Map<string, Record<string, unknown>>();
+  for (const answer of value) {
+    requireValue(
+      isRecord(answer) && typeof answer.name === "string" && !byName.has(answer.name),
+      "OpenAI Decisions returned invalid answer names.",
+    );
+    byName.set(answer.name, answer);
+  }
+  requireValue(
+    byName.size === Object.keys(context.questions).length,
+    "OpenAI Decisions returned incomplete answers.",
+  );
+  return Object.fromEntries(
+    Object.entries(context.questions).map(([id, q]) => {
+      const answer = byName.get(id);
+      requireValue(answer, "OpenAI Decisions omitted an answer.");
+      requireValue(answer.type !== "refusal", "OpenAI Decisions refused a question.");
+      if (q.type === "bool") {
+        requireValue(
+          answer.type === "predicate",
+          "OpenAI Decisions returned an invalid predicate.",
+        );
+        return [id, { type: "bool", probability: number(answer.probability, "probability") }];
+      }
+      requireValue(answer.type === q.type, "OpenAI Decisions returned an invalid answer type.");
+      const confidence = number(answer.confidence, "confidence");
+      if (q.type === "score")
+        return [
+          id,
+          {
+            type: "score",
+            score: number(answer.score, "score", q.criteria.length - 1),
+            confidence,
+          },
+        ];
+      requireValue(
+        typeof answer.choice === "string" &&
+          Object.hasOwn(q.criteria, answer.choice) &&
+          Array.isArray(answer.probabilities),
+        "OpenAI Decisions returned an invalid choice.",
+      );
+      const probabilities: Record<string, number> = Object.create(null);
+      for (const entry of answer.probabilities) {
+        requireValue(
+          isRecord(entry) &&
+            typeof entry.value === "string" &&
+            Object.hasOwn(q.criteria, entry.value) &&
+            !Object.hasOwn(probabilities, entry.value),
+          "OpenAI Decisions returned invalid choice probabilities.",
+        );
+        probabilities[entry.value] = number(entry.probability, "probability");
+      }
+      requireValue(
+        Object.keys(probabilities).length === Object.keys(q.criteria).length &&
+          Math.abs(Object.values(probabilities).reduce((sum, p) => sum + p, 0) - 1) <= 0.001,
+        "OpenAI Decisions returned incomplete choice probabilities.",
+      );
+      return [id, { type: "choice", choice: answer.choice, probabilities, confidence }];
+    }),
+  );
+}
+
+function parseUsage(value: unknown, model: ClassifierModel<string>): Usage | undefined {
+  if (!isRecord(value) || (value.input_tokens === undefined && value.output_tokens === undefined))
+    return undefined;
+  const count = (n: unknown) => (typeof n === "number" && Number.isFinite(n) && n > 0 ? n : 0);
+  const input = count(value.input_tokens),
+    output = count(value.output_tokens);
+  const usage: Usage = {
+    input,
+    output,
+    cacheRead: 0,
+    cacheWrite: 0,
+    totalTokens: input + output,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+  };
+  calculateCost(model, usage);
+  return usage;
+}
+
+function headers(...sources: (ProviderHeaders | undefined)[]): Headers {
+  const result = new Headers();
+  for (const source of sources)
+    for (const [key, value] of Object.entries(source ?? {})) {
+      if (value === null) result.delete(key);
+      else if (value !== undefined) result.set(key, value);
+    }
+  return result;
+}
+
+async function post(
+  model: ClassifierModel<string>,
+  context: OpenAIDecisionsContext,
+  options: ClassifierOptions,
+): Promise<unknown> {
+  requireValue(
+    options.apiKey,
+    "OpenAI Decisions requires an OpenAI API key, not a ChatGPT subscription.",
+  );
+  let payload: unknown = {
+    model: model.id,
+    input: wireInput(context),
+    questions: wireQuestions(context),
+  };
+  const transformed = await options.onPayload?.(payload, model);
+  if (transformed !== undefined) payload = transformed;
+  const body = JSON.stringify(payload);
+  const url = new URL("decisions", `${model.baseUrl.replace(/\/+$/u, "")}/`);
+  const requestHeaders = headers(
+    { authorization: `Bearer ${options.apiKey}`, "content-type": "application/json" },
+    model.headers,
+    options.headers,
+  );
+  for (let attempt = 0; ; attempt++) {
+    options.signal?.throwIfAborted();
+    const timeout =
+      options.timeoutMs === undefined ? undefined : AbortSignal.timeout(options.timeoutMs);
+    const signal =
+      options.signal && timeout
+        ? AbortSignal.any([options.signal, timeout])
+        : (options.signal ?? timeout);
+    let response: Response;
+    try {
+      response = await (options.fetch ?? globalThis.fetch)(url, {
+        method: "POST",
+        headers: requestHeaders,
+        body,
+        signal,
+      });
+      await options.onResponse?.(
+        { status: response.status, headers: Object.fromEntries(response.headers) },
+        model,
+      );
+      if (response.ok) return await response.json();
+    } catch {
+      throw new DecisionsError(
+        timeout?.aborted
+          ? "OpenAI Decisions request timed out."
+          : "OpenAI Decisions request failed.",
+      );
+    }
+    // Do not surface provider bodies, which can echo credentials or submitted state.
+    await response.body?.cancel();
+    const hint = response.headers.get("x-should-retry");
+    const retryable =
+      hint === "true" ||
+      (hint !== "false" && ([408, 409, 429].includes(response.status) || response.status >= 500));
+    // Like upstream Pi, never retry gateway timeouts caused by very large inputs.
+    requireValue(
+      response.status !== 504,
+      "OpenAI Decisions gateway timeout (504). Reduce the input size.",
+    );
+    requireValue(
+      retryable && attempt < (options.maxRetries ?? 2),
+      `OpenAI Decisions HTTP ${response.status}. Check API-key access and request limits.`,
+    );
+    const afterMs = response.headers.get("retry-after-ms"),
+      after = response.headers.get("retry-after");
+    let delay =
+      afterMs !== null
+        ? Number(afterMs)
+        : after !== null
+          ? Number.isNaN(Number(after))
+            ? Date.parse(after) - Date.now()
+            : Number(after) * 1000
+          : NaN;
+    if (!Number.isFinite(delay))
+      delay = Math.min(500 * 2 ** attempt, 8000) * (1 - Math.random() * 0.25);
+    const cap = options.maxRetryDelayMs ?? 60000;
+    requireValue(
+      cap <= 0 || delay <= cap,
+      "OpenAI Decisions retry delay exceeds the configured limit.",
+    );
+    await sleep(Math.max(0, delay), undefined, { signal: options.signal });
+  }
+}
+
+export async function classifyOpenAIDecisions(
+  model: ClassifierModel<string>,
+  context: OpenAIDecisionsContext,
+  options: ClassifierOptions = {},
+): Promise<ClassifierResult> {
+  const result: ClassifierResult = {
+    api: model.api,
+    provider: model.provider,
+    model: model.id,
+    answers: {},
+    stopReason: "stop",
+    timestamp: Date.now(),
+  };
+  try {
+    requireValue(model.api === OPENAI_DECISIONS_API, "Unsupported OpenAI classifier API.");
+    const body = await post(model, context, options);
+    requireValue(isRecord(body), "OpenAI Decisions returned an invalid response.");
+    result.usage = parseUsage(body.usage, model);
+    result.answers = parseAnswers(body.answers, context);
+  } catch (error) {
+    result.stopReason = options.signal?.aborted ? "aborted" : "error";
+    result.errorMessage =
+      result.stopReason === "aborted"
+        ? "OpenAI Decisions request aborted."
+        : error instanceof DecisionsError
+          ? error.message
+          : "OpenAI Decisions request failed.";
+  }
+  return result;
+}
+
+export function withOpenAIDecisions(builtIn: Provider): Provider {
+  const catalog = () => builtIn.getAllModels?.() ?? builtIn.getModels();
+  // Never replace a classifier implementation shipped by the host.
+  if (
+    builtIn.classify &&
+    catalog().some((m) => m.type === "classifier" && m.api === OPENAI_DECISIONS_API)
+  )
+    return builtIn;
+  return {
+    ...builtIn,
+    getAllModels: () => [
+      ...catalog().filter((m) => !(m.type === "classifier" && m.id === OPENAI_DECISIONS_MODEL.id)),
+      OPENAI_DECISIONS_MODEL,
+    ],
+    filterAllModels: (models, credential) => {
+      const available =
+        builtIn.filterAllModels?.(models, credential) ??
+        models.filter(
+          (m) =>
+            m.type === "classifier" ||
+            m.type === "image" ||
+            !builtIn.filterModels ||
+            builtIn.filterModels([m], credential).length > 0,
+        );
+      return credential?.type === "oauth"
+        ? available.filter((m) => m.api !== OPENAI_DECISIONS_API)
+        : available;
+    },
+    classify: (model, context, options) =>
+      model.api === OPENAI_DECISIONS_API
+        ? classifyOpenAIDecisions(model, context, options)
+        : builtIn.classify
+          ? builtIn.classify(model, context, options)
+          : Promise.resolve({
+              api: model.api,
+              provider: model.provider,
+              model: model.id,
+              timestamp: Date.now(),
+              answers: {},
+              stopReason: "error",
+              errorMessage: "Unsupported classifier API.",
+            }),
+  };
+}
+
+export function registerOpenAIDecisionsProvider(pi: ExtensionAPI): void {
+  const builtIn = builtinProviders().find((provider) => provider.id === "openai");
+  if (!builtIn) return;
+  const provider = withOpenAIDecisions(builtIn);
+  if (provider !== builtIn) pi.registerProvider(provider);
+}