@monotykamary/pi-better-openai 0.2.6 → 0.2.8

package/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Changelog
+
+## 0.2.8
+
+- Add GPT-6.1 Sol fallback metadata and Fast support for the GPT-6 model family.
+- Add `/openai-tier` for Standard, Fast, and capability-gated API Astra Ultrafast, with explicit pricing warnings, persistence, diagnostics, and footer labels.
+- Add opt-in `openai_decide` and `/openai-decisions` through Pi's classifier API, with typed validation, cancellation, safe errors, and usage accounting.
+- Include classifier tool usage in footer totals and preserve legacy Fast settings and customized model lists.
+- Document remaining native OpenAI Decisions, Codex subscription Ultrafast, and hosted multi-agent integration gates; no undocumented endpoint or chat fallback is assumed.
+
+## 0.2.7
+
+- Validate against Pi 0.99.0, including an offline real-host package-loading probe.
+- Declare imported host packages as wildcard peers and pin development dependencies to Pi 0.99.0.

package/README.md

@@ -30,8 +30,9 @@ Usage display, image generation, and live voice require pi's `openai-codex` OAut
 
 ## Features
 
-- GPT-6 Astra and Daybreak Blue/Red model fallbacks for the built-in `openai-codex` provider.
-- Fast mode for supported OpenAI models, toggled with `/fast` or in `/openai-settings`.
+- 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.
 - 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.
@@ -40,7 +41,9 @@ Usage display, image generation, and live voice require pi's `openai-codex` OAut
 - Codex-backed realtime voice through `/live`, with an animated microphone waveform and coding-task delegation into the active pi session.
 - Animated Codex custom pets rendered in the Better OpenAI footer.
 - Commands:
-  - `/fast` toggles fast mode.
+  - `/fast` toggles Fast and Standard; it never enables Ultrafast.
+  - `/openai-tier [standard|fast|ultrafast]` shows or selects the requested service tier.
+  - `/openai-decisions [models|use provider/model|off]` inspects or configures typed decisions.
   - `/openai-image <prompt>` generates an image directly.
   - `/openai-websearch <query>` searches the web and inserts the cited answer into the session.
   - `/live` starts or stops realtime voice mode. `Ctrl+Shift+L` is the keyboard toggle.
@@ -72,7 +75,14 @@ Default supported models:
 [
   "openai/gpt-5.4",
   "openai/gpt-5.5",
+  "openai/gpt-6-astra",
+  "openai/gpt-6.1-sol",
+  "openai/gpt-6-sol",
+  "openai/gpt-6-luna",
   "openai-codex/gpt-6-astra",
+  "openai-codex/gpt-6.1-sol",
+  "openai-codex/gpt-6-sol",
+  "openai-codex/gpt-6-luna",
   "openai-codex/gpt-5.6-sol",
   "openai-codex/gpt-5.6-terra",
   "openai-codex/gpt-5.6-luna",
@@ -87,8 +97,12 @@ Example config:
 {
   "persistState": true,
   "notifyOnModelSwitch": true,
-  "desiredActive": false,
-  "supportedModels": ["openai/gpt-5.5", "openai-codex/gpt-5.5"],
+  "serviceTier": "standard",
+  "decisions": {
+    "enabled": false,
+    "model": "",
+    "timeoutMs": 10000
+  },
   "usage": {
     "enabled": true,
     "refreshIntervalMs": 60000,
@@ -125,9 +139,56 @@ Example config:
 }
 ```
 
+## Service tiers
+
+`/openai-tier fast` requests `service_tier: "priority"`. `/openai-tier standard` explicitly requests `"default"`, clearing an inherited Fast/Ultrafast request tier on OpenAI providers. Legacy disabled configurations without an explicit tier leave payloads untouched. `/fast` and the `--fast` flag never select Ultrafast.
+
+`/openai-tier ultrafast` explicitly opts into **6x Standard token prices** for `openai/gpt-6-astra` over the Responses API. Only the documented global (`https://api.openai.com/v1`) and US (`https://us.api.openai.com/v1`) endpoints are enabled. EU/regional endpoints, custom proxies, other models, and Codex subscription Ultrafast are not enabled without verified support. This does not promise account entitlement or available rate limits. Unsupported selections remain requested but inactive; the extension does not inject a lower-tier fallback or retry a rejected request.
+
+The footer shows `fast` or `ultrafast` only when supported by the current model. Diagnostics distinguish the requested tier and last injected payload from server-confirmed service or billing. **Pi's host cost estimates may omit the Ultrafast premium**; use OpenAI billing for actual charges. The host's native transport is preserved; WebSockets are recommended by OpenAI but HTTP is also supported. See [Ultrafast documentation](https://developers.openai.com/api/docs/guides/ultrafast-mode) and [pricing](https://developers.openai.com/api/docs/pricing?latest-pricing=ultrafast).
+
+`serviceTier` takes precedence over legacy `desiredActive`/`active` within each config layer; project state still overrides global state. `persistState: false` keeps tier changes session-only. `supportedModels` overrides the Fast allowlist, not Ultrafast capabilities. Unknown config fields and customized model lists are preserved.
+
+## 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:
+
+```text
+/openai-decisions models
+/openai-decisions use typesafe/jev-latest
+```
+
+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 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).
+
+Example tool input:
+
+```json
+{
+  "state": { "testFailure": "connection to local test database timed out" },
+  "questions": {
+    "route": {
+      "type": "choice",
+      "instructions": "Classify the failure for human review.",
+      "criteria": { "environment": "Environment problem", "code": "Code defect" }
+    }
+  }
+}
+```
+
+- `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.
+- 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.
+- Reported classifier token usage/cost is included in tool results and the Better OpenAI footer. Missing usage or catalog pricing is not evidence that a request was free.
+
 ## Codex model fallbacks
 
-The extension adds `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.
+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.
+
+The GPT-6.1 Sol fallback uses Codex's conservative 272K context default, 128K output limit, and published short/long-context pricing. It maps Pi's `minimal` level to `low` and disables `off`; the model does not accept `none` or `minimal` reasoning efforts. See [model documentation](https://developers.openai.com/api/docs/models/gpt-6.1-sol) and the [upstream Codex catalog change](https://github.com/openai/codex/commit/b1e72963c3b71a9265a551e54beff078384efed9).
 
 Daybreak models require separate OpenAI approval and provisioning. pi currently exposes reasoning levels through `max`; Codex's `ultra` automatic-delegation mode is not a pi thinking level.
 

package/index.ts

@@ -1,8 +1,7 @@
 /**
  * Better OpenAI for pi.
  *
- * Adds `service_tier: "priority"` to OpenAI provider payloads while fast mode is
- * enabled and the selected model is in the configured allow-list.
+ * Adds capability-gated OpenAI service tiers and opt-in native typed decisions.
  */
 import {
   type ExtensionAPI,
@@ -17,6 +16,7 @@ import {
   SettingsList,
   type SettingsListTheme,
 } from "@earendil-works/pi-tui";
+import type { Usage } from "@earendil-works/pi-ai";
 import { registerOpenAICodexModels } from "./src/codex-models.ts";
 import { CONFIG_BASENAME, STATUS_KEY } from "./src/identity.ts";
 import {
@@ -49,6 +49,8 @@ import {
   LIVE_SETTING_DESCRIPTORS,
   PET_SETTING_DESCRIPTORS,
   FAST_SETTING_DESCRIPTORS,
+  DECISIONS_SETTING_DESCRIPTORS,
+  isServiceTier,
   type SettingsOptionDescriptor,
   configPaths,
   type ResolvedConfig,
@@ -80,6 +82,7 @@ import { ResetController } from "./src/reset-controller.ts";
 import { registerOpenAIImage, _imageTest } from "./src/image.ts";
 import { registerOpenAIWebSearch, _websearchTest } from "./src/websearch.ts";
 import { registerOpenAILive } from "./src/live/index.ts";
+import { registerOpenAIDecisions } from "./src/decisions.ts";
 import {
   type CodexPetPackage,
   codexHome,
@@ -91,7 +94,7 @@ import {
   registerOpenAIPets,
   _petsTest,
 } from "./src/pets.ts";
-import { FastController, modelList, supportsFast } from "./src/fast-controller.ts";
+import { FastController, supportsFast } from "./src/fast-controller.ts";
 import { isOpenAISubscriptionModel, UsageController } from "./src/usage-controller.ts";
 import { PetFooterController } from "./src/pet-footer-controller.ts";
 import {
@@ -338,12 +341,14 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
       ...nextConfig,
       active: fastController.active,
       desiredActive: fastController.desiredActive,
+      serviceTier: fastController.desiredTier,
     };
     if (!nextConfig.persistState) return;
     writeConfig(nextConfig.configPath, {
       ...readRawConfig(nextConfig.configPath),
       active: fastController.active,
       desiredActive: fastController.desiredActive,
+      serviceTier: fastController.desiredTier,
     });
   }
 
@@ -368,15 +373,22 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
     ctx.ui.notify(fastController.stateText(ctx, nextConfig), "info");
   }
 
+  function addFooterUsage(usage: Usage | undefined): void {
+    if (!usage) return;
+    footerTotals.input += usage.input;
+    footerTotals.output += usage.output;
+    footerTotals.cacheRead += usage.cacheRead;
+    footerTotals.cacheWrite += usage.cacheWrite;
+    footerTotals.cost += usage.cost.total;
+  }
+
   function refreshFooterTotals(ctx: ExtensionContext): void {
     footerTotals = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 };
     for (const entry of ctx.sessionManager.getEntries()) {
-      if (entry.type !== "message" || entry.message.role !== "assistant") continue;
-      footerTotals.input += entry.message.usage.input;
-      footerTotals.output += entry.message.usage.output;
-      footerTotals.cacheRead += entry.message.usage.cacheRead;
-      footerTotals.cacheWrite += entry.message.usage.cacheWrite;
-      footerTotals.cost += entry.message.usage.cost.total;
+      if (entry.type !== "message") continue;
+      if (entry.message.role === "assistant" || entry.message.role === "toolResult") {
+        addFooterUsage(entry.message.usage);
+      }
     }
   }
 
@@ -433,6 +445,9 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
       `Image default save: ${cfg.image.defaultSave}`,
       `Websearch enabled: ${cfg.websearch.enabled}`,
       `Websearch model: ${cfg.websearch.model} (${cfg.websearch.reasoningEffort}/${cfg.websearch.responseLength}, ${cfg.websearch.maxOutputTokens} tokens, ${cfg.websearch.timeoutMs}ms)`,
+      `Decisions enabled: ${cfg.decisions.enabled}`,
+      `Decision classifier: ${cfg.decisions.model || "not selected"} (${cfg.decisions.timeoutMs}ms)`,
+      "Native OpenAI Decisions requires a registered classifier adapter; no chat fallback.",
       `Live enabled: ${cfg.live.enabled}`,
       `Live voice: ${cfg.live.voice}`,
       `Pet enabled: ${cfg.pets.enabled}`,
@@ -531,6 +546,37 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
     },
   });
 
+  pi.registerCommand("openai-tier", {
+    description: "Select standard, fast, or ultrafast (API Astra; 6x Standard token prices)",
+    handler: async (args, ctx) => {
+      const tier = args.trim().toLowerCase();
+      if (!tier) {
+        ctx.ui.notify(
+          `Requested tier: ${fastController.desiredTier}. ${fastController.stateText(ctx, config(ctx))}`,
+          "info",
+        );
+        return;
+      }
+      if (!isServiceTier(tier)) {
+        ctx.ui.notify(
+          "Usage: /openai-tier [standard | fast | ultrafast]. Ultrafast explicitly opts into 6x Standard token prices.",
+          "error",
+        );
+        return;
+      }
+      const cfg = refresh(ctx);
+      fastController.setTier(ctx, cfg, tier);
+      persist(cfg);
+      updateFooter(ctx);
+      ctx.ui.notify(
+        fastController.stateText(ctx, cfg),
+        tier === "ultrafast" || (fastController.desiredActive && !fastController.active)
+          ? "warning"
+          : "info",
+      );
+    },
+  });
+
   pi.registerCommand(OPENAI_STATUS_COMMAND, {
     description: "Show OpenAI subscription usage status",
     handler: async (_args, ctx) => {
@@ -798,16 +844,9 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
   }
 
   function buildFastSettingsItems(cfg: ResolvedConfig): SettingsPickerItem[] {
-    return [
-      {
-        id: "fast.enabled",
-        label: "Fast mode",
-        currentValue: String(fastController.desiredActive),
-        values: ["true", "false"],
-        description: `Request OpenAI fast mode. Activates for supported models: ${modelList(cfg.supportedModels)}.`,
-      },
-      ...settingsItemsFromDescriptors(FAST_SETTING_DESCRIPTORS, cfg),
-    ];
+    return settingsItemsFromDescriptors(FAST_SETTING_DESCRIPTORS, cfg, {
+      serviceTier: { currentValue: fastController.desiredTier },
+    });
   }
 
   function buildFooterSettingsItems(cfg: ResolvedConfig): SettingsPickerItem[] {
@@ -870,12 +909,13 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
     return [
       {
         id: "section.fast",
-        label: "Fast mode",
+        label: "Service tier",
         currentValue: fastSettingsSummary(ctx, cfg),
-        description: "Configure OpenAI fast mode and persistence.",
+        description:
+          "Configure Standard, Fast, Ultrafast, and persistence. Ultrafast costs 6x Standard.",
         submenu: (_value, done) =>
           settingsSubmenu(
-            "Fast mode settings",
+            "Service tier settings",
             () => buildFastSettingsItems(config(ctx)),
             ctx,
             () => done(fastSettingsSummary(ctx, config(ctx))),
@@ -933,6 +973,38 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
             () => done(websearchSettingsSummary(config(ctx))),
           ),
       },
+      {
+        id: "section.decisions",
+        label: "Typed decisions",
+        currentValue: cfg.decisions.enabled ? cfg.decisions.model || "model required" : "disabled",
+        description: "Opt-in native classifier requests; no chat fallback or automatic actions.",
+        submenu: (_value, done) =>
+          settingsSubmenu(
+            "Typed decision settings",
+            () => {
+              const next = config(ctx);
+              const models = ctx.modelRegistry.getModelsOfType("classifier");
+              return settingsItemsFromDescriptors(DECISIONS_SETTING_DESCRIPTORS, next, {
+                "decisions.model": {
+                  values: [
+                    ...new Set([
+                      "",
+                      next.decisions.model,
+                      ...models.map((model) => `${model.provider}/${model.id}`),
+                    ]),
+                  ],
+                },
+              });
+            },
+            ctx,
+            () =>
+              done(
+                config(ctx).decisions.enabled
+                  ? config(ctx).decisions.model || "model required"
+                  : "disabled",
+              ),
+          ),
+      },
       {
         id: "section.live",
         label: "Live voice",
@@ -998,14 +1070,29 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
     const bool = rawValue === "true";
     if (id === "fast.enabled") {
       fastController.setDesired(ctx, cfg, bool);
+    } else if (id === "serviceTier") {
+      if (!isServiceTier(rawValue)) return;
+      fastController.setTier(ctx, cfg, rawValue);
+      ctx.ui.notify(
+        fastController.stateText(ctx, cfg),
+        rawValue === "ultrafast" || (fastController.desiredActive && !fastController.active)
+          ? "warning"
+          : "info",
+      );
     }
     const petKey = id.startsWith("pets.") ? id.slice("pets.".length) : undefined;
     const nextRawConfig = applySettingToRawConfig(current, id, rawValue, {
       persistState: cfg.persistState,
       active: fastController.active,
       desiredActive: fastController.desiredActive,
+      serviceTier: fastController.desiredTier,
       petEmptyValue: PET_EMPTY_VALUE,
     });
+    if (id === "persistState" && bool) {
+      nextRawConfig.serviceTier = fastController.desiredTier;
+      nextRawConfig.active = fastController.active;
+      nextRawConfig.desiredActive = fastController.desiredActive;
+    }
     if (petKey) {
       if (petKey === "enabled" || petKey === "sizeCells" || petKey === "slug")
         petController.invalidateLoadKey();
@@ -1102,6 +1189,7 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
 
   registerOpenAIImage(pi, config);
   registerOpenAIWebSearch(pi, config);
+  registerOpenAIDecisions(pi, config, refresh);
   registerOpenAILive(pi, config);
   registerOpenAIPets(pi, {
     wake: async (ctx, slug) => {
@@ -1270,8 +1358,9 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
 
           const modelName = ctx.model?.id || "no-model";
           const thinkingLevel = pi.getThinkingLevel();
-          const fastSuffix =
-            fastController.active && supportsFast(ctx, cfg.supportedModels) ? " fast" : "";
+          const fastSuffix = fastController.statusSegment(ctx, cfg)
+            ? ` ${fastController.desiredTier}`
+            : "";
           let rightWithoutProvider = modelName;
           if (ctx.model?.reasoning) {
             rightWithoutProvider =
@@ -1448,7 +1537,9 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
     fastController.initializeForSession(ctx, nextConfig, pi.getFlag(FLAG) === true);
     if (
       fastController.desiredActive !== nextConfig.desiredActive ||
-      fastController.active !== nextConfig.active
+      fastController.active !== nextConfig.active ||
+      fastController.desiredTier !==
+        (nextConfig.serviceTier ?? (nextConfig.desiredActive ? "fast" : "standard"))
     )
       persist(nextConfig);
     if (hasTerminalUI(ctx)) petController.installResizeGuard(ctx);
@@ -1489,11 +1580,8 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
   pi.on("turn_end", (event, ctx) => {
     invalidateContextUsage();
     if (event.message?.role === "assistant") {
-      footerTotals.input += event.message.usage.input;
-      footerTotals.output += event.message.usage.output;
-      footerTotals.cacheRead += event.message.usage.cacheRead;
-      footerTotals.cacheWrite += event.message.usage.cacheWrite;
-      footerTotals.cost += event.message.usage.cost.total;
+      addFooterUsage(event.message.usage);
+      for (const result of event.toolResults ?? []) addFooterUsage(result.usage);
     } else refreshFooterTotals(ctx);
     updateFooter(ctx);
     void usageController.refresh(ctx);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monotykamary/pi-better-openai",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "description": "Improve OpenAI in pi with fast mode, usage stats, realtime voice, image generation, and footer polish.",
   "keywords": [
     "fast",
@@ -38,6 +38,8 @@
     "index.ts",
     "src/",
     "README.md",
+    "CHANGELOG.md",
+    "plans/devday-integration.md",
     "LICENSE",
     "THIRD_PARTY_NOTICES.md"
   ],
@@ -52,7 +54,8 @@
     "lint": "oxlint --deny-warnings index.ts src/*.ts src/*/*.ts tests/*.ts",
     "lint:fix": "oxlint --fix index.ts src/*.ts src/*/*.ts tests/*.ts",
     "test": "vitest run",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "test:pi": "node scripts/test-pi-compat.mjs"
   },
   "dependencies": {
     "https-proxy-agent": "9.1.0",
@@ -62,9 +65,9 @@
     "ws": "8.21.2"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "0.87.0",
-    "@earendil-works/pi-coding-agent": "0.87.0",
-    "@earendil-works/pi-tui": "0.87.0",
+    "@earendil-works/pi-ai": "0.99.0",
+    "@earendil-works/pi-coding-agent": "0.99.0",
+    "@earendil-works/pi-tui": "0.99.0",
     "@types/node": "~22.19.0",
     "@types/proxy-from-env": "1.0.4",
     "@types/ws": "8.18.1",
@@ -86,8 +89,8 @@
     "@oh-my-pi/pi-natives-win32-x64": "17.2.9"
   },
   "overrides": {
-    "@earendil-works/pi-agent-core": "0.87.0",
-    "@earendil-works/pi-ai": "0.87.0",
+    "@earendil-works/pi-agent-core": "0.99.0",
+    "@earendil-works/pi-ai": "0.99.0",
     "brace-expansion": "5.0.9",
     "nanoid": "3.3.18",
     "postcss": "8.5.25",

package/plans/devday-integration.md

@@ -0,0 +1,48 @@
+# DevDay integration status
+
+Research checkpoint: September 29, 2026 (UTC). Announcements and account entitlements can change independently of source releases.
+
+## Implemented
+
+- GPT-6.1 Sol fallback metadata, with native Pi transport/auth and live catalog precedence preserved.
+- Fast-mode defaults for GPT-6 Astra, 6.1 Sol, Sol, and Luna on OpenAI/Codex.
+- Explicit Standard/Fast/Ultrafast selection, legacy state migration, model/endpoint capability gates, persistence, diagnostics, cost disclosure, and footer labels.
+- `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
+
+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 tool works with explicitly selected registered classifiers, including Jev. It does not pretend this is OpenAI's new service. Once OpenAI publishes its contract:
+
+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.
+
+### Evaluation checklist
+
+Before automated routing or background triage is enabled, compare pinned Jev/OpenAI classifier versions on the same consented, non-sensitive labeled cases:
+
+- failure classification, candidate-tool ranking, task routing, and notification relevance;
+- p50/p95 end-to-end latency, cost per useful decision, invalid-result/refusal/timeout rates;
+- accuracy and abstention coverage; Brier score/calibration only for outputs documented as probabilities;
+- low-confidence escalation and immutable policy/permission boundaries.
+
+Do not automatically run paid benchmark requests. A typed result is not proof of truth or authorization. TypeSafe's [September 15 Jev announcement](https://typesafe.ai/blog/introducing-system-one-models-and-jev) establishes timing and the decision-oriented interface, not OpenAI implementation provenance.
+
+## Codex subscription Ultrafast: capability gate remains closed
+
+The [public Ultrafast guide](https://developers.openai.com/api/docs/guides/ultrafast-mode) documents API Astra support. Codex has catalog-driven tier controls and WebSocket tier-switch tests, but its inspected bundled Astra/Sol catalog advertises Fast, not a subscription Ultrafast entitlement.
+
+Enable subscription Ultrafast only after an authenticated model/account capability contract is established, with tests for account switching, capability withdrawal, and unsupported requests. Arbitrary `supportedModels` configuration must not bypass this gate. Global/US API Astra is the verified path today. Host cost reporting currently may omit its 6x premium; never describe local estimates as actual billing.
+
+## Hosted Responses multi-agent: deliberately deferred
+
+[Responses multi-agent](https://developers.openai.com/api/docs/guides/responses-multi-agent) is a separate beta protocol, not a tier or ordinary thinking level. Adding only `multi_agent.enabled` is insufficient and could conflict with Fabric's orchestration.
+
+A future opt-in integration must handle agent identities, hosted collaboration items versus client tool calls, interleaved streams, continuation routing, cancellation, concurrency and total-spend limits, and permission enforcement for every child. Do not assume `max_concurrent_subagents` limits total agents, tree depth, or total spend. Keep the existing local orchestration owner until these invariants are verified.
+
+Dots, Space, and other consumer surfaces are not added without a documented integration contract.

package/src/codex-models.ts

@@ -59,6 +59,26 @@ export const CODEX_MODEL_FALLBACKS: CodexModel[] = [
     },
     compat: CODEX_COMPAT,
   },
+  {
+    id: "gpt-6.1-sol",
+    name: "GPT-6.1 Sol",
+    api: CODEX_API,
+    provider: CODEX_PROVIDER_ID,
+    baseUrl: CODEX_BASE_URL,
+    reasoning: true,
+    thinkingLevelMap: { off: null, minimal: "low", xhigh: "xhigh", max: "max" },
+    input: ["text", "image"],
+    contextWindow: 272000,
+    maxTokens: 128000,
+    cost: {
+      input: 2,
+      output: 10,
+      cacheRead: 0.1,
+      cacheWrite: 2.5,
+      tiers: [{ inputTokensAbove: 272000, input: 4, output: 15, cacheRead: 0.2, cacheWrite: 5 }],
+    },
+    compat: CODEX_COMPAT,
+  },
   {
     id: "gpt-daybreak-blue-latest",
     name: "Daybreak Blue",