@ultimat3/ai 24.0.0 → 25.0.0

package/src/tools.ts

@@ -6,8 +6,9 @@
 // permissions" concept in Ultimate, because there is no second authz system.
 //
 // `run` below is `ProjectableAction`'s — the projection SEAM, which is what carries `invoke`.
-// It is not a member of the action facade: an `action()` is `as`/`tool`/`openapi`/`job`/
-// `contract` and the callable itself, and this header claimed `action.run` until 2026-08.
+// It is not a member of the action facade: an `action()` is `as`/`openapi`/`client`/`job`/
+// `contract` and the callable itself (no `tool` since 25.0.0 — `@ultimat3/mcp`'s `toolFrom` is
+// the MCP projection), and this header claimed `action.run` until 2026-08.
 // `asProjectableAction` is what BUILDS that seam out of a real `action()`, so an app writes
 // `agent({ tools: [publishPost] })` and never a hand-shaped stand-in — the same union
 // @ultimat3/mcp's `ListedPrimitive` accepts, adapted at this package's own edge because the two
@@ -20,14 +21,15 @@
 import type { AnyAction } from '@ultimat3/action';
 import { actionName, invoke, isAction } from '@ultimat3/action';
 import type { Actor } from '@ultimat3/core';
-import { hasPublicCause, isMcpExposed, isUltimateError, stringField } from '@ultimat3/core';
-import { statusFor } from '@ultimat3/http';
+import { isMcpExposed, tryUseContext } from '@ultimat3/core';
 import type { WireJsonSchema } from '@ultimat3/schema';
 import { toWireSchema } from '@ultimat3/schema';
+import { discloseFailure } from './failure-disclosure';
+import { takeToolIdempotencyKey, withToolIdempotencyKey } from './tool-idempotency';
 
 /**
  * The JSON Schema subset the framework emits for tool arguments — `@ultimat3/schema`'s
- * `WireJsonSchema`, the one document `.tool()`, `tools/list` and the model are all handed.
+ * `WireJsonSchema`, the one document `toolFrom`, `tools/list` and the model are all handed.
  */
 export type JsonSchema = WireJsonSchema;
 
@@ -75,7 +77,7 @@ export interface ProjectableAction {
  *
  * The real `action()` comes first because it is what an app has. Until 2026-08 this list took
  * `ProjectableAction` alone, which no `action()` structurally satisfies — an action carries
- * `as`/`tool`/`openapi`/`job`/`contract` and never `run` — so the documented shape
+ * `as`/`openapi`/`client`/`job`/`contract` and never `run` — so the documented shape
  * `agent({ tools: [publishPost] })` was a `TS2741` and every test in this package hand-built a
  * stand-in, which is why the suite stayed green over an API that did not compile (issue #124).
  * `ProjectableAction` stays in the union for a surface that builds its catalog programmatically
@@ -84,8 +86,8 @@ export interface ProjectableAction {
 export type AgentTool = AnyAction | ProjectableAction;
 
 /**
- * Adapt whatever the author listed. The same shape @ultimat3/mcp's `asProjectable` produces, from
- * the same `invoke` — an in-app agent and an external MCP client end at one execution path, so one
+ * Adapt whatever the author listed. The same shape @ultimat3/mcp's `primitiveFromAction` produces,
+ * from the same `invoke` — an in-app agent and an external MCP client end at one execution path, so one
  * policy decides both. The execution adapter is not shared code and cannot be — `mcp` is this
  * package's own tier — but the schema is: both publish `@ultimat3/schema`'s `toWireSchema`.
  *
@@ -96,17 +98,30 @@ export type AgentTool = AnyAction | ProjectableAction;
 export function asProjectableAction(listed: AgentTool): ProjectableAction {
   if (!isAction(listed)) return listed;
   const mcp = listed.mcp;
+  // Throws `X_ACTION_UNREGISTERED` on an unnamed action rather than offering a tool called `''`:
+  // a nameless tool is unaddressable by the model, by `runLlmToolCall` and by the author.
+  const name = actionName(listed);
+  const wire = toWireSchema(listed.input);
+  // `idempotent: true` is honoured here as over MCP and HTTP: the model's key reaches `invoke`,
+  // which files it under the action, the caller and the key. Until 25.0.0 this adapter dropped it,
+  // so an action an external agent could retry safely was one an in-app agent could not.
+  const keyed = listed.describe().idempotent;
   return {
-    // Throws `X_ACTION_UNREGISTERED` on an unnamed action rather than offering a tool called `''`:
-    // a nameless tool is unaddressable by the model, by `runLlmToolCall` and by the author.
-    name: actionName(listed),
+    name,
     ...(mcp === undefined ? {} : { mcp }),
     ...(mcp?.description === undefined ? {} : { description: mcp.description }),
-    inputJsonSchema: toWireSchema(listed.input),
+    inputJsonSchema: keyed ? withToolIdempotencyKey(name, wire) : wire,
     // The actor rides in on the options and `invoke` swaps it inside the one execution path —
     // the action's own `policy` still decides, and its `input:` still parses what the model sent,
     // which is what drops a `{ actor: 'admin' }` the model invented before any handler sees it.
-    run: ({ input, actor }) => invoke(listed, input, { surface: 'mcp', actor }),
+    // No `admit`: MCP's is its early gate ahead of ITS argument validation, and this surface has
+    // none — `invoke` asks the same policy before it reads the input, which is the same order.
+    run: keyed
+      ? ({ input: args, actor }) => {
+          const { input, idempotencyKey } = takeToolIdempotencyKey(args);
+          return invoke(listed, input, { surface: 'mcp', actor, idempotencyKey });
+        }
+      : ({ input, actor }) => invoke(listed, input, { surface: 'mcp', actor }),
   };
 }
 
@@ -162,7 +177,7 @@ export async function runLlmToolCall(
     return resultOf(call.id, output);
   } catch (error) {
     // A policy denial is an outcome the model should read and react to, not a crash.
-    return { toolUseId: call.id, content: describeFailure(error), isError: true };
+    return { toolUseId: call.id, content: describeFailure(error, call.name), isError: true };
   }
 }
 
@@ -195,29 +210,16 @@ function resultOf(toolUseId: string, output: unknown): LlmToolResult {
  * it: the provider keeps every request it is sent, and a cause that reached it cannot be recalled.
  */
 export const HIDDEN_TOOL_CAUSE =
-  'the tool failed inside the server; the details are withheld from this conversation and are in the server logs';
+  'the tool failed inside the server; the details are withheld from this conversation; the server log records its code and where it failed';
 
 /**
- * The thrown value, read STRUCTURALLY and totally. `stringField` from `@ultimat3/core`, never
- * `typeof e.code === 'string'`: the value is whatever an app's handler, its driver or its SDK
- * threw, so each read is a getter call or a `Proxy` trap — and it runs inside the catch block
- * that has nothing left to answer the model with if the probe itself raises.
- *
- * A 5xx code's cause is shown only when core's `hasPublicCause` allows it — the rule a production
- * problem document follows (`@ultimat3/http`'s `toProblem`). Hidden, the developer's `fix` goes with
- * it (a driver writes it from the statement it failed on); a `callerFix` an `UltimateError` built in
- * this process is authored for a remote reader and stays.
+ * `discloseFailure`'s verdict, rendered as the `tool_result` line — the same rule a hive member's
+ * reason follows, so what an agent may read of a throw is decided once. An uncoded throw says only
+ * that it failed; a withheld cause becomes `HIDDEN_TOOL_CAUSE`, and the log has the rest.
  */
-function describeFailure(error: unknown): string {
-  const code = stringField(error, 'code');
-  if (code === undefined) return 'tool failed';
-  if (statusFor(code) >= 500 && !hasPublicCause(code)) {
-    const callerFix = isUltimateError(error) ? stringField(error, 'callerFix') : undefined;
-    return callerFix === undefined
-      ? `${code}: ${HIDDEN_TOOL_CAUSE}`
-      : `${code}: ${HIDDEN_TOOL_CAUSE} (fix: ${callerFix})`;
-  }
-  const cause = stringField(error, 'cause') ?? 'unknown';
-  const fix = stringField(error, 'fix') ?? '';
-  return fix === '' ? `${code}: ${cause}` : `${code}: ${cause} (fix: ${fix})`;
+function describeFailure(error: unknown, toolName: string): string {
+  const shown = discloseFailure(error, tryUseContext()?.logger, `tool ${toolName}`);
+  if (shown.code === undefined) return 'tool failed';
+  const line = `${shown.code}: ${shown.cause ?? HIDDEN_TOOL_CAUSE}`;
+  return shown.fix === undefined ? line : `${line} (fix: ${shown.fix})`;
 }

package/src/vector-scope.ts

@@ -33,10 +33,10 @@ export const UNSCOPED: VectorScope = Object.freeze({ crossTenant: true });
 export const UNBOUND: VectorScope = Object.freeze({});
 
 /** The tenant column value a row carries when its store had no tenant bound. */
-export const NO_TENANT = '';
+export const NO_VECTOR_TENANT = '';
 
 export function tenantOf(scope: VectorScope): string {
-  return scope.tenant ?? NO_TENANT;
+  return scope.tenant ?? NO_VECTOR_TENANT;
 }
 
 /**

package/src/vector.ts

@@ -1,5 +1,5 @@
 // Vector storage and retrieval: the `VectorStore` contract and the in-memory dev store.
-// `PgVectorStore` — the production path — implements this same contract in `pg-vector.ts`.
+// `PostgresVectorStore` — the production path — implements this same contract in `pg-vector.ts`.
 //
 // The store interface is shaped for pgvector (one table, one index, SQL you can read), with
 // an in-memory cosine implementation as the dev default. Hybrid search is first-class rather
@@ -9,11 +9,11 @@
 // be comparable — which they never are.
 
 import { finiteCount, finiteOption } from '@ultimat3/core';
-import { cosine, tokenize } from './embeddings';
+import { cosine, wordTokens } from './embeddings';
 import { VectorDimMismatchError } from './errors';
 import {
   assertTenantRead,
-  NO_TENANT,
+  NO_VECTOR_TENANT,
   narrowScope,
   scopeAdmits,
   UNBOUND,
@@ -95,6 +95,15 @@ export interface StoredRecord extends VectorRecord {
   readonly tenant: string;
 }
 
+/** The row's primary key, `(tenant, id)` as the pg table declares it. NUL never occurs in a tenant. */
+const storageKey = (tenant: string, id: string): string => `${tenant}\u0000${id}`;
+
+/** A row and its score inside one ranking, before the tenant is dropped from the public hit. */
+interface Scored {
+  readonly record: StoredRecord;
+  readonly score: number;
+}
+
 export class MemoryVectorStore implements VectorStore {
   readonly name: string;
   readonly dimension: number;
@@ -119,7 +128,7 @@ export class MemoryVectorStore implements VectorStore {
   }
 
   /**
-   * Same envelope, same rule as `PgVectorStore.scoped`. The dev store enforces it too, because
+   * Same envelope, same rule as `PostgresVectorStore.scoped`. The dev store enforces it too, because
    * a tenant leak that only reproduces against production Postgres is a leak nobody finds.
    */
   scoped(scope: VectorScope): MemoryVectorStore {
@@ -131,10 +140,10 @@ export class MemoryVectorStore implements VectorStore {
   }
 
   async upsert(records: readonly VectorRecord[]): Promise<void> {
-    const tenant = this.scope.tenant ?? NO_TENANT;
+    const tenant = this.scope.tenant ?? NO_VECTOR_TENANT;
     for (const record of records) {
       this.assertDimension(record.vector.length);
-      this.records.set(`${tenant}\u0000${record.id}`, { ...record, tenant });
+      this.records.set(storageKey(tenant, record.id), { ...record, tenant });
     }
   }
 
@@ -147,10 +156,9 @@ export class MemoryVectorStore implements VectorStore {
     this.assertDimension(vector.length);
     // `k` carries no default, so `??` never sees it and nothing else does either: `slice(0, NaN)`
     // is `[]`, which is a search that answers "no matches" for every query and reports success.
-    return this.candidates(filter)
-      .map((record) => this.hit(record, cosine(vector, record.vector)))
-      .sort(byScoreDesc)
-      .slice(0, finiteCount(SUBJECT, 'k', k));
+    return this.dense(vector, finiteCount(SUBJECT, 'k', k), filter).map(({ record, score }) =>
+      this.hit(record, score),
+    );
   }
 
   /** BM25 over the stored text. Real lexical scoring, so a rare exact term actually wins. */
@@ -160,12 +168,66 @@ export class MemoryVectorStore implements VectorStore {
     filter?: MetadataFilter,
   ): Promise<readonly SearchHit[]> {
     assertTenantRead(this.name, this.scope);
-    const width = finiteCount(SUBJECT, 'k', k);
+    return this.lexical(query, finiteCount(SUBJECT, 'k', k), filter).map(({ record, score }) =>
+      this.hit(record, score),
+    );
+  }
+
+  /**
+   * Reciprocal-rank fusion. Each ranking contributes `1 / (rrfK + rank)`, so only ORDER
+   * matters — the two score scales never have to be reconciled, and a document ranked first
+   * by exact term match beats one that merely leads a flat vector ranking.
+   *
+   * Fused on the stored `(tenant, id)`, as `hybridSql` groups: an unscoped read sees every
+   * tenant's rows, and two tenants may share an id. Fusing on the id alone summed both rows'
+   * ranks into whichever came first and dropped the other. `fuse` keys on `SearchHit.id`, so the
+   * rankings reach it under the row's storage key and leave under the caller's id again.
+   */
+  async hybrid(input: HybridSearchInput): Promise<readonly SearchHit[]> {
+    assertTenantRead(this.name, this.scope);
+    this.assertDimension(input.vector.length);
+    // Three bounds, none of which `Math.max` screens — it PROPAGATES a `NaN`. A `NaN` `k` collapses
+    // both candidate widths and the final slice to `[]`; a `NaN` `rrfK` makes every fused score
+    // `NaN`, and the ranking this method exists to produce becomes whatever order the sort left.
+    const k = finiteCount(HYBRID, 'k', input.k);
+    const width = finiteCount(HYBRID, 'candidates', input.candidates ?? Math.max(k * 4, 20));
+    const rrfK = finiteOption(HYBRID, 'rrfK', input.rrfK ?? 60);
+    const rows = new Map<string, StoredRecord>();
+    const keyed = (ranking: readonly Scored[]): readonly SearchHit[] =>
+      ranking.map(({ record, score }) => {
+        const key = storageKey(record.tenant, record.id);
+        rows.set(key, record);
+        return { ...this.hit(record, score), id: key };
+      });
+    const fused = fuse(
+      [
+        keyed(this.dense(input.vector, width, input.filter)),
+        keyed(this.lexical(input.query, width, input.filter)),
+      ],
+      rrfK,
+    );
+    // Re-sorted once the ids are the caller's again: the tie-break is `d."id" asc`, never the key.
+    return fused
+      .map((hit) => ({ ...hit, id: rows.get(hit.id)?.id ?? hit.id }))
+      .sort(byScoreDesc)
+      .slice(0, k);
+  }
+
+  /** The cosine ranking `search` answers and `hybrid` fuses, rows still carrying their tenant. */
+  private dense(vector: Float32Array, k: number, filter?: MetadataFilter): readonly Scored[] {
+    return this.candidates(filter)
+      .map((record) => ({ record, score: cosine(vector, record.vector) }))
+      .sort(byRankDesc)
+      .slice(0, k);
+  }
+
+  /** BM25 over the stored text, rows still carrying their tenant. Only a positive score matches. */
+  private lexical(query: string, width: number, filter?: MetadataFilter): readonly Scored[] {
     const candidates = this.candidates(filter);
     if (candidates.length === 0) return [];
-    const docs = candidates.map((record) => ({ record, tokens: tokenize(record.text) }));
+    const docs = candidates.map((record) => ({ record, tokens: wordTokens(record.text) }));
     const avgLength = docs.reduce((sum, d) => sum + d.tokens.length, 0) / docs.length;
-    const terms = [...new Set(tokenize(query))];
+    const terms = [...new Set(wordTokens(query))];
 
     return docs
       .map(({ record, tokens }) => {
@@ -178,33 +240,13 @@ export class MemoryVectorStore implements VectorStore {
           const norm = this.k1 * (1 - this.b + (this.b * tokens.length) / avgLength);
           score += idf * ((tf * (this.k1 + 1)) / (tf + norm));
         }
-        return this.hit(record, score);
+        return { record, score };
       })
-      .filter((hit) => hit.score > 0)
-      .sort(byScoreDesc)
+      .filter((scored) => scored.score > 0)
+      .sort(byRankDesc)
       .slice(0, width);
   }
 
-  /**
-   * Reciprocal-rank fusion. Each ranking contributes `1 / (rrfK + rank)`, so only ORDER
-   * matters — the two score scales never have to be reconciled, and a document ranked first
-   * by exact term match beats one that merely leads a flat vector ranking.
-   */
-  async hybrid(input: HybridSearchInput): Promise<readonly SearchHit[]> {
-    assertTenantRead(this.name, this.scope);
-    // Three bounds, none of which `Math.max` screens — it PROPAGATES a `NaN`. A `NaN` `k` collapses
-    // both candidate widths and the final slice to `[]`; a `NaN` `rrfK` makes every fused score
-    // `NaN`, and the ranking this method exists to produce becomes whatever order the sort left.
-    const k = finiteCount(HYBRID, 'k', input.k);
-    const width = finiteCount(HYBRID, 'candidates', input.candidates ?? Math.max(k * 4, 20));
-    const rrfK = finiteOption(HYBRID, 'rrfK', input.rrfK ?? 60);
-    const [dense, lexical] = await Promise.all([
-      this.search(input.vector, width, input.filter),
-      this.searchText(input.query, width, input.filter),
-    ]);
-    return fuse([dense, lexical], rrfK).slice(0, k);
-  }
-
   /** Scoped and filtered, exactly like `pruneSql`: everything `filter` matches but `keep`. */
   async prune(filter: MetadataFilter, keep: readonly string[]): Promise<void> {
     const kept = new Set(keep);
@@ -247,6 +289,14 @@ export class MemoryVectorStore implements VectorStore {
   }
 }
 
+/**
+ * The one way to build the in-process store — the twin of `postgresVectorStore()`. The class is a
+ * type in the barrel only (`X_FACTORY_NAME_SPELLING`), so `new` is never a second spelling.
+ */
+export function memoryVectorStore(input: MemoryVectorStoreInput): MemoryVectorStore {
+  return new MemoryVectorStore(input);
+}
+
 /**
  * Fuse ranked lists by reciprocal rank. Exported so a reranker can reuse it — which is why the
  * damping is screened HERE too and not only in `hybrid`: a default parameter is a bound like any
@@ -279,4 +329,20 @@ export function fuse(
  * sort then resolves them by dense-list insertion order, which no SQL engine reproduces.
  */
 const byScoreDesc = (a: SearchHit, b: SearchHit): number =>
-  b.score - a.score || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+  byScore(a.score, b.score) || byId(a.id, b.id);
+
+/** The same order over a ranking's rows, which still carry their tenant. */
+const byRankDesc = (a: Scored, b: Scored): number =>
+  byScore(a.score, b.score) || byId(a.record.id, b.record.id);
+
+const byId = (a: string, b: string): number => (a < b ? -1 : a > b ? 1 : 0);
+
+/**
+ * Descending, `NaN` last. A cosine against a zero-norm vector is `NaN`, and float8 orders `NaN`
+ * above every number, so pg's `order by distance` puts that row at the end. `b - a` alone is `NaN`
+ * for any pair holding one, which reads as a tie and leaves the sort inconsistent.
+ */
+function byScore(a: number, b: number): number {
+  if (Number.isNaN(a) || Number.isNaN(b)) return Number.isNaN(a) ? (Number.isNaN(b) ? 0 : 1) : -1;
+  return b - a;
+}

package/src/wire.ts

@@ -185,9 +185,14 @@ export class MessageStream {
     }
   }
 
-  /** True once `message_stop` arrived. False means the connection died mid-answer. */
+  /**
+   * True once `message_stop` arrived with every tool_use block closed. False means the connection
+   * died mid-answer — or the stream ended with a call's arguments still open, which drops the call
+   * (it is emitted whole or not at all), and for `llm()` that call IS the answer. `openai-wire.ts`
+   * refuses the same case.
+   */
   isComplete(): boolean {
-    return this.stopped;
+    return this.stopped && this.pending.size === 0;
   }
 
   state(): StreamState {

package/src/fix-line.evals.ts

@@ -1,35 +0,0 @@
-/**
- * The eval attached to `fixLinePrompt`. Cases live here rather than in the test file, matching
- * every app's own prompts — a fixture-driven, deterministic `exact` scorer, no judge, because
- * this is a proof of the eval mechanism itself and a proof that can drift is not one.
- */
-
-import { defineEval } from './evals';
-import { fixLinePrompt } from './fix-line';
-import { exact } from './scorers';
-
-export const fixLineCases = [
-  {
-    name: 'runnable/x-command',
-    vars: { fixLine: 'bun run scripts/verify.ts --only lint,boundaries' },
-    expected: 'runnable',
-  },
-  { name: 'runnable/cli-flag', vars: { fixLine: 'x db migrate' }, expected: 'runnable' },
-  {
-    name: 'vague/check',
-    vars: { fixLine: 'check the configuration and try again' },
-    expected: 'vague',
-  },
-  { name: 'vague/see-docs', vars: { fixLine: 'see the docs for details' }, expected: 'vague' },
-];
-
-export const fixLineEval = defineEval({
-  name: 'ai.fix-line-runnable',
-  prompt: fixLinePrompt,
-  // The gate is the drop from this recorded score, never an absolute number: models drift,
-  // prompts should not. Accepting a new number is a diff in the committed baseline file.
-  baseline: import.meta.resolve('./fix-line.v1.baseline.json'),
-  tolerance: 0.05,
-  scorers: [exact],
-  cases: fixLineCases,
-});

package/src/fix-line.ts

@@ -1,27 +0,0 @@
-/**
- * The prompt behind `fix-line` — `@ultimat3/ai`'s own dogfood eval, and the package's first
- * framework-level `*.eval.test.ts`. Not an app feature: every app that declares a prompt is
- * required to pair it with an eval and a committed baseline (`defineEval`, `X_EVAL_MISSING`,
- * `X_EVAL_BASELINE_MISSING`), and this proves that whole convention actually catches a
- * regression from inside the package that owns it — through the real opt-in suite `x verify`'s
- * `eval` step runs, not only through `evals.test.ts`'s unit fixtures against a temp-dir baseline.
- *
- * The task is small on purpose: classify whether an error's `fix:` line is a runnable command —
- * axiom 4, "errors are instructions" — or vague guidance ("check the config", "see the docs").
- */
-
-import { definePrompt } from './prompt';
-
-export const fixLinePrompt = definePrompt<{ fixLine: string }>({
-  id: 'ai.fix-line-runnable',
-  version: '1',
-  template:
-    'Reply with exactly one word: "runnable" if the fix line below names a command to run, or ' +
-    '"vague" if it only describes what to do without naming one.\nFix line: {{fixLine}}',
-  input: {
-    type: 'object',
-    properties: { fixLine: { type: 'string' } },
-    required: ['fixLine'],
-  },
-  output: { type: 'string', enum: ['runnable', 'vague'] },
-});

package/src/openai-models.ts

@@ -1,84 +0,0 @@
-// The OpenAI-format built-in catalogue: the vendor's own list prices, registered through the same
-// public `registerModel` the Anthropic built-ins use. Here rather than in models.ts because these
-// rows belong to a PROVIDER — models.ts owns the registry mechanism, never one vendor's price list.
-
-import type { Money } from '@ultimat3/money';
-import type { ModelId } from './models';
-import { registerModel } from './models';
-
-/** A price per million tokens, in INTEGER MINOR UNITS. Same rule as models.ts: never a float. */
-const usd = (minor: number): Money => ({ minor, currency: 'USD' });
-
-/**
- * The ids this package prices, in ladder order (most capable first). A provider's `models` list is
- * still its own — an endpoint speaking this format serves whatever ids it was deployed with, and
- * `openAiProvider({ models })` is where those are named.
- */
-export const OPENAI_MODEL_IDS: readonly ModelId[] = [
-  'gpt-5.6-sol',
-  'gpt-5.6-terra',
-  'gpt-5.6-luna',
-];
-
-/**
- * Shared by the whole 5.6 family: a 1.05M context, a 128k output ceiling, and `reasoning_effort`
- * over exactly the five rungs `EFFORTS` declares (the endpoint also takes `none`, which is what
- * `thinking: 'disabled'` maps onto). `adaptive` is false because the format has no
- * adaptive-thinking control at all — depth is `reasoning_effort` and nothing else.
- */
-const FAMILY = {
-  /** One ladder: `moreCapableThan` compares these three with each other and with nothing else. */
-  family: 'openai',
-  contextWindow: 1_050_000,
-  maxOutput: 128_000,
-  /** Automatic caching starts at a 1024-token prefix; a shorter one silently does not cache. */
-  cacheMinimumTokens: 1_024,
-  reasoning: { effort: true, adaptive: false, disableThinkingUpTo: undefined },
-} as const;
-
-/**
- * The three models this package is confident enough to price, and no more.
- *
- * Prices are the vendor's published list, read from developers.openai.com/api/docs/pricing on
- * **2026-08-16**, in USD per million tokens:
- *
- * | id | input | cached input | output |
- * |---|---|---|---|
- * | `gpt-5.6-sol` | $5.00 | $0.50 | $30.00 |
- * | `gpt-5.6-terra` | $2.00 | $0.20 | $12.00 |
- * | `gpt-5.6-luna` | $0.20 | $0.02 | $1.20 |
- *
- * Deliberately not registered: `gpt-4o`, `gpt-4o-mini` and the `o1` family, whose cached input is
- * **0.5x** their input rate rather than the 0.1x `costOf` assumes — a spec that prices them would
- * under-report a cache-heavy workload by four fifths, and `costOf` answers confidently either way.
- * `gpt-5.5-pro` and `o1-pro` are out for the same class of reason: they publish no cached rate.
- * A wrong price is worse than no entry, so an app wanting one of those registers it itself, with
- * the rate its own contract names.
- */
-export function registerOpenAiModels(): void {
-  registerModel({
-    id: 'gpt-5.6-sol',
-    ...FAMILY,
-    inputPerMillion: usd(500),
-    outputPerMillion: usd(3_000),
-  });
-  registerModel({
-    id: 'gpt-5.6-terra',
-    ...FAMILY,
-    inputPerMillion: usd(200),
-    outputPerMillion: usd(1_200),
-  });
-  registerModel({
-    id: 'gpt-5.6-luna',
-    ...FAMILY,
-    inputPerMillion: usd(20),
-    outputPerMillion: usd(120),
-  });
-}
-
-// The same shape models.ts uses for its built-ins: registration is a module side effect, so the
-// default path is the app's path and importing the provider is enough to price what it serves.
-// Exported as well as called, because the registry is module state and a suite that clears it with
-// `resetModels()` otherwise leaves this provider serving ids nothing can price. Re-registering
-// REPLACES, so an app with a negotiated rate calls `registerModel` after this one and wins.
-registerOpenAiModels();