@aeye/core 0.5.2 → 0.5.4

package/README.md

@@ -521,6 +521,7 @@ The descriptor's full field list is exported as the `FormatDescriptor` interface
 | `optionalAsNullable` | Whether `optional` fields are emitted as `T \| null` (OpenAI strict) vs omitted from `required[]`. |
 | `supportsRecursion` | Whether `$ref` self-reference works under this dialect. |
 | `maxStrictTools` / `maxStrictOptionalParams` / `maxStrictUnionTypes` | Per-request budget caps; `undefined` means no documented limit. |
+| `schemaSizeLimits` | Per-SCHEMA size ceilings (properties, nesting, total string characters, enum values); `undefined` means no documented limit. An over-size schema degrades on its own, even when it asked for `strict: true`. |
 
 You don't need to set every field — spread an existing descriptor and override deltas. Tested via `analyzeSchema` + the schema test suite; see the strict-mode guide in `@aeye/docs` for end-to-end examples.
 

package/aeye-core-schema.md

@@ -34,6 +34,56 @@ A descriptor (see `src/schema.ts` line ~26 for the fully documented interface) d
 | `supportedStringFormats` | `'all'` or a `Set<string>` whitelist. |
 | `supportsRecursion` | Whether `$ref` self-reference works. |
 | `maxStrictTools` / `maxStrictOptionalParams` / `maxStrictUnionTypes` | Per-request slot budgets (`undefined` = no documented limit). |
+| `schemaSizeLimits` | Per-SCHEMA size ceilings — properties, nesting, total string characters, enum values (`undefined` = no documented limit) — see below. |
+| `maxEnumValues` | Opt-in ceiling on how many values ONE emitted `enum` may carry (`undefined` = no cap, and that is what every built-in declares) — see below. |
+
+### `schemaSizeLimits` — how BIG one strict schema may be
+
+Separate from the per-request slot budgets above: every bound here is a **sum over ONE schema** (one tool's `parameters`, or one structured-output schema), so no other item in the request can change the verdict. `SchemaBudget` therefore treats an over-size schema as a feasibility failure rather than a budget one — that single item degrades to the family's non-strict descriptor **even when it asked for `strict: true`**, and the rest of the request is untouched.
+
+```typescript
+interface SchemaSizeLimits {
+  maxObjectProperties: number;      // summed over every nesting level
+  maxNestingDepth: number;          // levels of nested containers below the root
+  maxTotalStringChars: number;      // property names + enum values + const values
+  maxTotalEnumValues: number;       // summed across every enum property
+  largeEnumValueCount: number;      // the single-enum value count above which…
+  maxLargeEnumStringChars: number;  // …that one enum's string values are also bounded
+}
+```
+
+**`OPENAI_STRICT` is the only built-in that declares them**, because Structured Outputs is the only one of the three dialects that documents them. Verified against developers.openai.com "Supported schemas" on 2026-08-23: *"A schema may have up to 5000 object properties total, with up to 10 levels of nesting"*, *"total string length of all property names, definition names, enum values, and const values cannot exceed 120,000 characters"*, *"A schema may have up to 1000 enum values across all enum properties"*, and *"For a single enum property with string values, the total string length of all enum values cannot exceed 15,000 characters when there are more than 250 enum values"*. Every one of those was raised in July 2025 (100→5000 properties, 15,000→120,000 characters, 500→1000 enum values, 7,500→15,000 for the >250-value enum); the pre-raise numbers are still widely quoted secondhand.
+
+Scope is Structured Outputs — a tool carrying `strict: true`, or a `json_schema` response format. Non-strict function calling is best-effort with no compiled decoder, which is exactly why degrading the offending item is a complete answer rather than a partial one.
+
+`checkSchemaSizeLimits(schema, descriptor)` is the public form and returns one line per bound broken (empty = it fits, or the dialect publishes none) — the answer to "why did my tool silently stop being strict?".
+
+The measurement is taken from the **Zod** schema rather than from the emitted JSON, so where an encoding is descriptor-dependent it counts the widest one (a record as its `{key, value}` pair form, a tuple as its numeric-key form). Over-counting costs strictness on a schema that would have fitted; under-counting costs an HTTP 400, so the rounding goes up. `$defs` entry names are not counted: they are generated at emit time, few, and short against a 120,000-character budget.
+
+### `maxEnumValues` — an opt-in dialect ceiling that WIDENS, and why no built-in sets one
+
+Some providers may reject a schema whose `enum` is simply too long. That is **not** one of the per-request budgets above: those are strict-mode allowances the `SchemaBudget` spends across a whole request, degrading an item that no longer fits to the family's non-strict descriptor, whereas this one would fire whatever the strictness, so it is enforced structurally at the point an `enum` is emitted.
+
+Over the cap the emitter **widens** — it does not truncate. It drops the `enum` keyword, emits the node's plain scalar `type`, and puts **every** value into the `description`:
+
+```jsonc
+// z.enum([...20 values]) under a descriptor with maxEnumValues: 8
+{ "type": "string", "description": "One of these 20 values: name_0, name_1, …, name_19" }
+```
+
+Truncating would make the values past the cap **unreachable** — the wire schema would constrain them away, so a caller whose 96 values are all legitimately selectable would lose 56 of them. Widening removes only the cardinality the dialect cannot compile, and the model keeps complete information. If the source schema carries its own `.describe()`, the value list is appended to it rather than replacing it.
+
+The trade is enforcement: a widened node no longer rejects a value structurally, so whatever validates the model's output afterwards must. `Tool.parse` does — it runs against the ORIGINAL zod schema, whose `enum` is untouched — so a hallucinated member comes back as a normal, re-promptable validation error.
+
+**No built-in descriptor declares a cap, and that is a measured result.** The field exists because a large `enum` was believed to make Gemini answer `400 INVALID_ARGUMENT`. Measured against `google/gemini-3-flash-preview` through OpenRouter (2026-08-23), it does not: single-parameter enums at 50/64/72/80/96/128/256/512/1024/**2048** values (52 KB of tool schema) all returned HTTP 200 with the expected tool call, under `tool_choice` both `required` (which is what makes Gemini compile a decoding grammar) and `auto` — as did 96 values with 80-character members, 20 tools each carrying a 96-value enum in one request, a 96-value enum next to `strict: true` / `minItems` / `propertyOrdering` / a sibling `anyOf`, and a 2048-value enum inside a `response_format` schema. Reliability was compared too, since a cap's whole cost is losing the enum's can't-hallucinate guarantee: 10 trials each of `enum` vs plain-string-with-full-list, over confusable near-duplicate names, at 96 and again at 512 values — both picked the correct member 10/10 with zero off-list answers.
+
+A second pass answered the obvious objection — that an isolated probe is not what a real session sends. Same date and model, upstream **pinned to Google AI Studio** with fallbacks off (the upstream that served the production failures), an eleven-tool roster emitted through this library for a Google model and modelled on a real kind-authoring agent (`fn_load` / `fn_search` / `type_load` / `api_signature` / `api_set` / …, real descriptions, real system prompt): a 96-value enum on one of those tools returned 200 with the expected tool call under `tool_choice` `required` and `auto` alike, as did the same roster at 8 values and a tool carrying a bare typeless `{}` property.
+
+The caveat that keeps that from being proof: the **control** — the recursive `$defs/Any` shape documented elsewhere in this file as 100% reproducible HTTP 400 — also returned 200, pinned and unpinned, forced and automatic, both hand-built and as the product's real 32 KB gin `api_set` schema. That failure class is not visible from this route today, so treat the numbers as evidence, not a verdict.
+
+One trap for whoever measures this next: at `max_tokens: 64` the `$defs/Any` tool answered `finish_reason: "length"` with no tool call and empty content, which reads exactly like a grammar that produced nothing. It is not — this model spends reasoning tokens first, and at 400 the identical request emitted a correct call in 28 output tokens. Give a forced-tool probe room before calling an empty completion a failure.
+
+So: **set this only against a measured provider rejection, and set it as high as the measurement allows.** An `enum` that fits is the more correct encoding, because it is the one the model cannot answer outside of.
 
 ### `anyEncoding` — and what each mode requires
 
@@ -80,8 +130,9 @@ strictPriority(requested: boolean | number | undefined): number
 
 - `toJSONSchema` accepts a descriptor, a `ToJSONSchemaOptions` object, or a boolean (back-compat: `true` ⇒ `OPENAI_STRICT`, `false` ⇒ `LENIENT`).
 - `strictify` rewrites a Zod schema in place per the descriptor (results cached in a WeakMap; same OOM-safe pattern as `analyzeSchema`).
-- `analyzeSchema` returns `SchemaFeatures`: `{ hasRecursion, optionalParameterCount, unionTypeCount, recordCount, tupleCount }` — cached per schema.
-- `checkDescriptorConsistency` reports settings that ask the emitter for a keyword the same descriptor forbids (today: `anyEncoding` vs `allowAnyOf` / `allowDefsRef` / `supportsRecursion`). `registerDescriptor` runs it and `console.warn`s each problem, because otherwise the first report of a contradiction is a provider HTTP 400.
+- `analyzeSchema` returns `SchemaFeatures`: `{ hasRecursion, optionalParameterCount, unionTypeCount, recordCount, tupleCount, enums, objectPropertyCount, maxNestingDepth, stringSizeChars }` — cached per schema. The last four feed `schemaSizeLimits`; `enums` keeps a per-enum `{valueCount, stringValueChars}` breakdown because the large-enum character rule is conditional on that SAME enum's value count, which a pair of totals cannot answer.
+- `checkSchemaSizeLimits(schema, descriptor)` reports the per-schema size bounds a schema breaks (see `schemaSizeLimits`).
+- `checkDescriptorConsistency` reports settings that ask the emitter for a keyword the same descriptor forbids (`anyEncoding` vs `allowAnyOf` / `allowDefsRef` / `supportsRecursion`), or a limit that would quietly stop governing anything: a `maxEnumValues` below 1 or non-integer (which widens every enum the dialect emits), a non-positive `schemaSizeLimits` bound (which degrades every schema), a `largeEnumValueCount` at or above `maxTotalEnumValues` (unreachable rule), or size limits on a non-strict descriptor (the API applies none). `registerDescriptor` runs it and `console.warn`s each problem, because otherwise the first report of a contradiction is a provider HTTP 400.
 
 ```typescript
 import { OPENAI_STRICT, ANTHROPIC_STRICT, getDescriptor, toJSONSchema } from '@aeye/core';
@@ -103,11 +154,13 @@ toJSONSchema(schema, false);                         // === LENIENT
 `new SchemaBudget(descriptor)` allocates strict "slots" across a single request when a descriptor has per-request limits (e.g. Anthropic). Providers call:
 
 ```typescript
-budget.allocateTool(schema, requested): FormatDescriptor   // returns strict or LENIENT, decrements
+budget.allocateTool(schema, requested): FormatDescriptor   // returns strict or the family's non-strict, decrements
 budget.allocateOutput(schema, requested): FormatDescriptor // output schema; consumes param/union budget, not a tool slot
 ```
 
-It returns `LENIENT` when `requested === false`, when the schema uses an unrepresentable feature, or when a positive-number request can't fit the remaining budget (priority order; `true` always wins subject to *budget*, never subject to feasibility).
+It falls back when `requested === false`, when the schema uses an unrepresentable feature, when the schema exceeds the dialect's `schemaSizeLimits`, or when a positive-number request can't fit the remaining budget (priority order; `true` always wins subject to *budget*, never subject to feasibility or size).
+
+**The fallback is the descriptor's own family, non-strict — never the family-blind `LENIENT`.** A dialect rule can outlive strict mode: `GOOGLE_NON_STRICT` exists for exactly one such rule, the `unconstrained` encoding of `z.any()`, because Gemini compiles a decoding grammar whenever a tool call is forced and no per-tool `strict` flag is involved. Degrading to `LENIENT` put the self-referencing `$defs/Any` that encoding was created to avoid straight back on the Google wire — and did so for *every* schema that degrades, which under `GOOGLE_STRICT` (`allowAnyOf: false`) is every recursive gin/query program schema there is. For the other families the change is behaviour-neutral by construction: `OPENAI_NON_STRICT` / `ANTHROPIC_NON_STRICT` are `LENIENT` with a family tag, and a family that registers no non-strict variant resolves to `LENIENT`. Only the `descriptor` id pinned on the tool differs, and it round-trips through `getDescriptorById`.
 
 "Unrepresentable" here means a **combinator the descriptor forbids** (`z.union` → `anyOf`, `z.intersection` → `allOf`), because nothing rewrites those away — a schema carrying one under `GOOGLE_STRICT` is a provider HTTP 400. **Recursion is not unrepresentable**: the emitter replaces any back-edge the descriptor cannot spell with a bounded placeholder, so a recursive schema stays strict (looser at the back-edge, never rejected). That is the difference between this check and `canExpress`, which additionally treats a widened back-edge as a reason to fall back — the right answer for a structured *output* (it can be delivered as prompt text instead) and the wrong one for a *tool* (it cannot).
 

package/dist/schema.d.ts

@@ -11,6 +11,48 @@ import z from 'zod';
  * registry functions, model declarations, etc.
  */
 export type DescriptorFamily = 'openai' | 'anthropic' | 'google' | (string & {});
+/**
+ * Documented ceilings on how BIG one strict schema may be, as opposed to which
+ * keywords it may use. Every limit here is a SUM taken over a single schema —
+ * one tool's `parameters`, or one structured-output schema — not a per-request
+ * allowance shared between them (that is `maxStrictTools` and friends, which
+ * the `SchemaBudget` spends across the whole request).
+ *
+ * A schema that exceeds one of these is a guaranteed provider rejection under
+ * strict mode, so `SchemaBudget.allocate` treats it like any other
+ * infeasibility and degrades that ONE item to the family's non-strict
+ * descriptor, where no size rule applies. The rest of the request is
+ * unaffected.
+ *
+ * Declared as one object rather than six optional fields on purpose: a
+ * provider documents these together, and the object being present is what says
+ * "this dialect publishes size limits". Adding a rule here is then a compile
+ * error at every descriptor that declares the group, which is the point
+ * (a missed limit is invisible until a 400).
+ */
+export interface SchemaSizeLimits {
+    /** Maximum object properties in one schema, summed over every nesting level. */
+    readonly maxObjectProperties: number;
+    /** Maximum levels of nested containers below the schema root. */
+    readonly maxNestingDepth: number;
+    /**
+     * Maximum total characters over the schema's property names, `enum` values
+     * and `const` values together.
+     */
+    readonly maxTotalStringChars: number;
+    /** Maximum `enum` values summed across every enum property in one schema. */
+    readonly maxTotalEnumValues: number;
+    /**
+     * The single-enum value count above which `maxLargeEnumStringChars` starts
+     * to apply. A smaller enum is bounded only by the two totals above.
+     */
+    readonly largeEnumValueCount: number;
+    /**
+     * Maximum total characters of ONE enum's string values, applied only to an
+     * enum carrying more than `largeEnumValueCount` values.
+     */
+    readonly maxLargeEnumStringChars: number;
+}
 /**
  * Format descriptor — describes the JSON Schema dialect of a target.
  *
@@ -95,6 +137,110 @@ export interface FormatDescriptor {
     readonly maxStrictOptionalParams?: number;
     /** Maximum total union-type parameters across all strict schemas in one request. */
     readonly maxStrictUnionTypes?: number;
+    /**
+     * Documented ceilings on the SIZE of one strict schema (properties, nesting,
+     * total string bytes, enum values), or `undefined` when the dialect
+     * publishes none. See {@link SchemaSizeLimits} for what each bound counts and
+     * why it is per-schema rather than per-request.
+     *
+     * Only a STRICT descriptor declares these: they are Structured-Outputs rules
+     * — the API compiles the schema into a decoder and rejects one it cannot —
+     * and a non-strict schema is a best-effort hint the API does not compile. So
+     * degrading the offending item to the family's non-strict descriptor is both
+     * the fix and the reason the limits stop applying to it
+     * (`SchemaBudget.allocate`, `checkSchemaSizeLimits`).
+     *
+     * The measurement is taken from the ZOD schema, not from the emitted JSON,
+     * so it is deliberately CONSERVATIVE where an encoding is descriptor-
+     * dependent (a record counts as its widest encoding, a tuple as its
+     * numeric-key one). Over-counting costs strictness on a schema that would
+     * have fit; under-counting costs an HTTP 400, so the round goes up.
+     */
+    readonly schemaSizeLimits?: SchemaSizeLimits;
+    /**
+     * Maximum number of values ONE emitted `enum` may carry, or `undefined`
+     * (the default) for no cap.
+     *
+     * This is deliberately NOT one of the per-request budget fields above. Those
+     * are strict-mode allowances the SchemaBudget spends across a whole request,
+     * degrading an item that no longer fits to the family's non-strict
+     * descriptor; this one is a property of the dialect itself — it fires whatever the strictness — so it is enforced
+     * structurally at the point an `enum` is emitted (`convertSchema`), where
+     * the cardinality is actually known.
+     *
+     * Over the cap the emitter **widens** rather than truncates: it drops the
+     * `enum` keyword entirely, emits the node's plain scalar `type`
+     * (`{type: 'string'}` for a string enum), and puts EVERY value into the
+     * node's `description`. Nothing becomes unreachable — the model still has
+     * the complete list and can name any member — and the cardinality the
+     * dialect could not compile is simply no longer on the wire.
+     *
+     * The trade this makes is enforcement: a widened node no longer rejects a
+     * value structurally, so whatever validates the model's output afterwards
+     * has to. `Tool.parse` does, against the ORIGINAL zod schema — the enum is
+     * still there, only the emitted JSON Schema widened — so a hallucinated
+     * member comes back as a normal, re-promptable validation error.
+     *
+     * **`GOOGLE_STRICT`/`GOOGLE_NON_STRICT` declare 40. Every other built-in
+     * declares no cap.** Two earlier rounds of live measurement against
+     * `google/gemini-3-flash-preview` through OpenRouter (2026-08-23) — single
+     * enums up to 2048 SYNTHETIC values, 20 tools each with a 96-value enum, and
+     * an eleven-tool roster modelled on a real kind-authoring agent — all
+     * returned HTTP 200 and concluded there was no reproducible limit. **That
+     * conclusion was wrong, because none of those enums used the CONTENT of a
+     * real session.** A third round replayed the exact wire bytes of a real
+     * product request — `fn_load`'s `names` array, enum-constrained to the
+     * session's actual 98 known component/fn names (`default_renderer`,
+     * `QueryWidget`, `ConfirmPrompt`, `list_widget_types`, …) — and it 400'd,
+     * reproducibly, twice, byte-for-byte identical to what the provider was
+     * actually sent. Bisecting that same real value list: 90 values passes, 93
+     * fails. Bisecting what changes between the passing synthetic probes and the
+     * failing real one: 98 SHORT synthetic values (`n0`..`n97`, 284 chars) pass;
+     * 206 short values matching the REAL list's total character count (714
+     * chars) also pass; only the REAL, longer, dictionary-like/identifier-shaped
+     * values fail, and only past ~92 of them. So the limit tracks neither raw
+     * member count nor total character/byte budget — most likely actual
+     * tokenized grammar-state count, which short repetitive synthetic strings
+     * compress far below what real identifier text does at the same count or
+     * character budget. This is why the first two rounds' synthetic and
+     * lightly-realistic probes never tripped it.
+     *
+     * **The widen-to-string fallback this field triggers was verified against
+     * the exact failing real schema**: dropping `enum` and putting the same 98
+     * values into the `description` of a plain string field returned HTTP 200
+     * with the expected tool call — confirming the fallback mechanism actually
+     * fixes the failure it exists for, not just a synthetic stand-in.
+     *
+     * **40 is not a measured edge — it is a conservative floor with roughly 2x
+     * margin under the real one (90 passes / 93 fails) measured on this one real
+     * value set.** Given the failure tracks content, not just count, a different
+     * session's actual name list could plausibly fail at a different count; 40
+     * was also the cap this exact product ran under in production for months
+     * before a since-reverted attempt to remove it, which is corroborating
+     * evidence it holds in practice, not just in this one measurement.
+     *
+     * The reliability comparison from the earlier rounds still stands and is
+     * why a cap is preferable to leaving every enum uncapped "to be safe" at a
+     * much lower number: `enum` vs plain-string-with-full-list, 10 trials each
+     * over confusable near-duplicate names at 96 and 512 values, scored 10/10
+     * on-target with zero off-list answers for BOTH encodings. So there is no
+     * reliability cost to raising this cap later if a higher safe value is
+     * measured — only downside risk to leaving it too high.
+     *
+     * One trap for whoever measures this next: with `max_tokens` at 64, a
+     * forced-tool probe can come back `finish_reason: 'length'` with no tool
+     * call and empty content, which reads exactly like a grammar that produced
+     * nothing. It usually is not — this model spends reasoning tokens first.
+     * Give a forced-tool probe room before calling an empty completion a
+     * failure.
+     *
+     * So: set this only where a provider is MEASURED to reject a large enum
+     * using the SESSION'S OWN real content, not synthetic stand-ins, and set it
+     * conservatively below the measured edge until more value sets are tested.
+     * An `enum` that fits is the more correct encoding, because it is the one
+     * the model cannot answer outside of.
+     */
+    readonly maxEnumValues?: number;
     /**
      * Whether the descriptor can express recursive `$ref` schemas (`$ref: '#'`
      * to root, or any `$ref: '#/$defs/X'` whose target transitively references
@@ -141,10 +287,28 @@ export declare const LENIENT: FormatDescriptor;
  * tuples→numeric-keys, optional→nullable.
  *
  * No documented per-request slot limit (max strict tools / optional params /
- * union types). The SchemaBudget treats those caps as `undefined` (no limit)
- * for OpenAI; OpenAI's own ~5000-property and ~5-level-depth schema caps
- * aren't enforced here either — they're rare in practice and produce a
- * server-side rejection that the user can react to.
+ * union types) — the SchemaBudget treats those caps as `undefined` for OpenAI.
+ *
+ * OpenAI DOES document per-SCHEMA size limits for Structured Outputs, and they
+ * are declared below (`schemaSizeLimits`). Verified against
+ * developers.openai.com/api/docs/guides/structured-outputs on 2026-08-23,
+ * section "Supported schemas": *"A schema may have up to 5000 object
+ * properties total, with up to 10 levels of nesting"*, *"total string length of
+ * all property names, definition names, enum values, and const values cannot
+ * exceed 120,000 characters"*, *"A schema may have up to 1000 enum values
+ * across all enum properties"*, and *"For a single enum property with string
+ * values, the total string length of all enum values cannot exceed 15,000
+ * characters when there are more than 250 enum values"*. Every one of those
+ * numbers was raised in July 2025 (100→5000 properties, 15,000→120,000
+ * characters, 500→1000 enum values, 7,500→15,000 for the >250-value enum) —
+ * the pre-raise figures are still widely quoted secondhand, so they are named
+ * here to keep a future reader from "correcting" these downward.
+ *
+ * Scope is Structured Outputs, i.e. a tool carrying `strict: true` or a
+ * `json_schema` response format — the function-calling guide defines strict
+ * mode as "leveraging our structured outputs feature", and non-strict function
+ * calling is best-effort with no compiled decoder. That is exactly why
+ * degrading the over-size item to `OPENAI_NON_STRICT` is a complete answer.
  */
 export declare const OPENAI_STRICT: FormatDescriptor;
 /** OpenAI non-strict — alias of LENIENT but tagged with the openai family. */
@@ -192,10 +356,21 @@ export declare const ANTHROPIC_NON_STRICT: FormatDescriptor;
  *   this descriptor used to declare was a schema it says it cannot emit.
  *   Gemini compiles the tool schemas into a decoding grammar whenever the
  *   caller forces a tool call (`toolChoice: 'required'` → Google's function
- *   calling mode `ANY`), and a self-referencing `$defs/Any` fails that
- *   compile with `400 INVALID_ARGUMENT` — the same request succeeds under
+ *   calling mode `ANY`), and a self-referencing `$defs/Any` failed that
+ *   compile with `400 INVALID_ARGUMENT` — the same request succeeded under
  *   `toolChoice: 'auto'`, where no grammar is built. Reported against
- *   `google/gemini-3-flash-preview` via OpenRouter, 100% reproducible.
+ *   `google/gemini-3-flash-preview` via OpenRouter as 100% reproducible.
+ *
+ *   **That 400 no longer reproduces (re-measured 2026-08-23)** and the
+ *   encoding stays anyway. Same model, same route, upstream pinned to Google
+ *   AI Studio with fallbacks off, `tool_choice` forced to one named tool: the
+ *   hand-built recursive `$defs/Any` tool, and the product's real 32 KB gin
+ *   `api_set` schema carrying nine `#/$defs/Any` references, both answered
+ *   HTTP 200 with a valid tool call. So the upstream either fixed or now
+ *   sanitizes it. The descriptor still declares what this dialect's own
+ *   documented keyword list supports; depending on a provider's current
+ *   leniency for a shape we say it cannot express is how the first version of
+ *   this descriptor shipped a guaranteed 400 in the first place.
  */
 export declare const GOOGLE_STRICT: FormatDescriptor;
 /**
@@ -217,7 +392,8 @@ export declare const GOOGLE_STRICT: FormatDescriptor;
 export declare const GOOGLE_NON_STRICT: FormatDescriptor;
 /**
  * Report the ways a `FormatDescriptor` contradicts itself — settings that ask
- * the emitter to produce a keyword the same descriptor forbids. Returns one
+ * the emitter to produce a keyword the same descriptor forbids, or a limit
+ * that would quietly strip every constraint it governs. Returns one
  * human-readable line per problem; an empty array means the descriptor is
  * internally consistent.
  *
@@ -463,10 +639,27 @@ export interface JSONSchema {
  * ```
  */
 export declare function toJSONSchema(schema: z.ZodType, options: ToJSONSchemaOptions | boolean | FormatDescriptor): JSONSchema;
+/**
+ * One emitted `enum` node's contribution to a dialect's size limits. A dialect
+ * bounds the TOTAL number of enum values in a schema and, separately, the
+ * character length of a SINGLE large enum — so the per-enum breakdown has to
+ * survive the walk; a pair of totals cannot answer the second question
+ * (two enums, one long-valued and one many-valued, would answer it wrongly).
+ */
+export interface EnumFeature {
+    /** How many members the enum emits. */
+    readonly valueCount: number;
+    /**
+     * Total character length of its STRING members. Non-string members
+     * contribute nothing: the character rules are written for string values.
+     */
+    readonly stringValueChars: number;
+}
 /**
  * Structural feature counts for a Zod schema, used by the SchemaBudget to
- * decide whether an item fits a descriptor's per-request budget and whether
- * the descriptor can express it at all.
+ * decide whether an item fits a descriptor's per-request budget, whether it
+ * fits the dialect's per-schema size limits, and whether the descriptor can
+ * express it at all.
  */
 export interface SchemaFeatures {
     /** True if the schema (or any subschema) uses `z.lazy` / self-recursion. */
@@ -483,6 +676,25 @@ export interface SchemaFeatures {
     recordCount: number;
     /** Count of `z.tuple` nodes. */
     tupleCount: number;
+    /** One entry per emitted `enum` node, in walk order. */
+    enums: readonly EnumFeature[];
+    /**
+     * Object properties the schema emits, summed over every nesting level. A
+     * record counts as the 2 properties its widest encoding emits
+     * (`{key, value}` pairs) and a tuple as one per item (numeric-key
+     * encoding) — the count is descriptor-independent, so it takes the largest
+     * encoding any dialect could choose (see `schemaSizeLimits`).
+     */
+    objectPropertyCount: number;
+    /** Deepest container nesting below the root (an object of scalars is 1). */
+    maxNestingDepth: number;
+    /**
+     * Total characters over property names plus `enum` and `const` string
+     * values — the "total string size" a dialect bounds. `$defs` entry names are
+     * NOT included: they are generated at emit time, are few, and are short
+     * relative to a 120,000-character budget.
+     */
+    stringSizeChars: number;
 }
 /**
  * Walk a Zod schema once and count its structural features. Result is
@@ -497,14 +709,36 @@ export interface SchemaFeatures {
  * request to a strict-family model (`SchemaBudget.allocate`).
  */
 export declare function analyzeSchema(schema: z.ZodType | z.core.$ZodType): SchemaFeatures;
+/**
+ * Report the ways ONE schema exceeds the descriptor's documented per-schema
+ * size limits (`FormatDescriptor.schemaSizeLimits`). Empty means it fits, or
+ * that the dialect publishes no limits.
+ *
+ * This is a FEASIBILITY question, not a budget one: the numbers bound a single
+ * schema, so no other tool in the request can change the answer, and
+ * `SchemaBudget.allocate` therefore treats a hit exactly like an
+ * unrepresentable keyword — that item degrades to the family's non-strict
+ * descriptor and the rest of the request is untouched.
+ *
+ * Exported because "why did my tool silently stop being strict?" needs an
+ * answer a caller can print; each line names the bound and the measurement.
+ *
+ * @example
+ * ```ts
+ * checkSchemaSizeLimits(z.object({ pick: z.enum(tenThousandNames) }), OPENAI_STRICT);
+ * //  → ['enum values 10000 exceed maxTotalEnumValues 1000']
+ * ```
+ */
+export declare function checkSchemaSizeLimits(schema: z.ZodType | z.core.$ZodType, descriptor: FormatDescriptor): readonly string[];
 /**
  * Per-request strict-mode allocator.
  *
  * Constructed once per outgoing request with the chosen model's strictest
  * descriptor. Tracks remaining slots (strict tools, optional parameters,
  * union types) against the descriptor's documented per-request limits and
- * decides per-tool / per-output whether to emit strict or fall back to
- * LENIENT.
+ * decides per-tool / per-output whether to emit strict or fall back to the
+ * SAME FAMILY's non-strict descriptor (`degraded` — never the family-blind
+ * `LENIENT`, which would undo dialect rules that outlive strict mode).
  *
  * Selection guarantees that any tool with `strict: true` (hard requirement)
  * has a model that supports the family — `allocate` therefore always grants
@@ -518,6 +752,29 @@ export declare function analyzeSchema(schema: z.ZodType | z.core.$ZodType): Sche
  */
 export declare class SchemaBudget {
     private readonly descriptor;
+    /**
+     * What an item that does NOT get strict is emitted through: the descriptor's
+     * own family, non-strict.
+     *
+     * It is deliberately NOT the family-blind `LENIENT`. A dialect restriction
+     * can belong to the DIALECT rather than to strict mode — `GOOGLE_NON_STRICT`
+     * exists for exactly one such rule, the `unconstrained` encoding of
+     * `z.any()`, because Gemini builds a decoding grammar whenever a tool call is
+     * forced, with no per-tool strict flag involved. Degrading to `LENIENT` put
+     * the self-referencing `$defs/Any` that encoding was created to avoid back on
+     * the Google wire — and it did so for every gin/query-style recursive `anyOf`
+     * schema, i.e. the schemas that ALWAYS degrade, since `GOOGLE_STRICT` cannot
+     * express `anyOf` at all (measured: the product's real `api_set` tool schema
+     * allocates to `lenient` under `GOOGLE_STRICT`, and its emitted JSON carries
+     * nine `#/$defs/Any` references).
+     *
+     * For the other families this is behaviour-neutral by construction:
+     * `OPENAI_NON_STRICT` and `ANTHROPIC_NON_STRICT` are `LENIENT` with a family
+     * tag, and a family with no registered non-strict variant resolves to
+     * `LENIENT` (`getDescriptor`). Only the pinned `descriptor` id on the tool
+     * changes, which round-trips through `getDescriptorById`.
+     */
+    private readonly degraded;
     private remainingTools;
     private remainingOptionalParams;
     private remainingUnionTypes;
@@ -526,12 +783,15 @@ export declare class SchemaBudget {
      * Decide the effective descriptor for a tool's parameter schema given the
      * dev's strict request, the schema's features, and the remaining budget.
      *
-     * Returns `LENIENT` when:
+     * Returns the family's NON-STRICT descriptor (`LENIENT` for a family that
+     * registers none) when:
      * - `requested === false`
      * - the schema uses a feature the descriptor can't represent
+     * - the schema exceeds the dialect's per-schema size limits
+     *   (`checkSchemaSizeLimits`)
      * - the descriptor has slot limits and the budget is exhausted (only
      *   applies to `requested` being a positive number; `true` always wins
-     *   subject to feasibility)
+     *   subject to feasibility and size)
      *
      * Returns the strict descriptor (and decrements the budget) otherwise.
      */
@@ -557,6 +817,13 @@ export declare class SchemaBudget {
  * shared between `convertTools` and `convertResponseFormat` — Anthropic's
  * documented limits apply across the whole request, so the strictest
  * descriptor wins.
+ *
+ * `schemaSizeLimits` deliberately does NOT participate. Those bounds are
+ * per-schema, so they are evaluated against whichever descriptor this returns
+ * rather than shared between the two — and every provider here passes two
+ * descriptors resolved from the SAME family, so there is nothing to break the
+ * tie on. Ranking six size bounds against three slot budgets would be an
+ * invented ordering, not a documented one.
  */
 export declare function strictestOf(a: FormatDescriptor, b: FormatDescriptor): FormatDescriptor;
 /**

package/dist/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB;;;;;;;;;;GAUG;AACH,MAAM,MAAM,gBAAgB,GAAG,QAAQ,GAAG,WAAW,GAAG,QAAQ,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;AAEjF;;;;;;;;;GASG;AACH,MAAM,WAAW,gBAAgB;IAC/B,0DAA0D;IAC1D,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB;;;;;;OAMG;IACH,QAAQ,CAAC,MAAM,EAAE,gBAAgB,GAAG,SAAS,CAAC;IAC9C,4EAA4E;IAC5E,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IAGzB,6EAA6E;IAC7E,QAAQ,CAAC,uBAAuB,EAAE,OAAO,CAAC;IAC1C,mEAAmE;IACnE,QAAQ,CAAC,qBAAqB,EAAE,OAAO,CAAC;IAGxC,sCAAsC;IACtC,QAAQ,CAAC,cAAc,EAAE,gBAAgB,GAAG,aAAa,CAAC;IAG1D;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,EAAE,qBAAqB,GAAG,cAAc,GAAG,aAAa,CAAC;IAG/E,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAG7B,2DAA2D;IAC3D,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;IAC/B,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;IAC/B,4DAA4D;IAC5D,QAAQ,CAAC,oBAAoB,EAAE,OAAO,CAAC;IAGvC,yEAAyE;IACzE,QAAQ,CAAC,sBAAsB,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,KAAK,CAAC;IAC7D,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;IAC/B,QAAQ,CAAC,qBAAqB,EAAE,OAAO,CAAC;IAGxC,QAAQ,CAAC,iBAAiB,EAAE,OAAO,CAAC;IACpC,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;IACnC,QAAQ,CAAC,mBAAmB,EAAE,OAAO,CAAC;IAGtC,oFAAoF;IACpF,QAAQ,CAAC,kBAAkB,EAAE,OAAO,CAAC;IAGrC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,QAAQ,CAAC,WAAW,EAAE,kBAAkB,GAAG,gBAAgB,GAAG,MAAM,GAAG,eAAe,CAAC;IAOvF,4EAA4E;IAC5E,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,kFAAkF;IAClF,QAAQ,CAAC,uBAAuB,CAAC,EAAE,MAAM,CAAC;IAC1C,oFAAoF;IACpF,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAGtC;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,iBAAiB,EAAE,OAAO,CAAC;IAGpC;;;;;;;;;OASG;IACH,QAAQ,CAAC,uBAAuB,CAAC,EAAE,MAAM,CAAC;CAC3C;AAED;;;;GAIG;AACH,eAAO,MAAM,iCAAiC,qJACiG,CAAC;AAEhJ;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,UAAU,EAAE,gBAAgB,GAAG,MAAM,CAE/E;AAMD,0GAA0G;AAC1G,eAAO,MAAM,OAAO,EAAE,gBAuBpB,CAAC;AAEH;;;;;;;;;GASG;AACH,eAAO,MAAM,aAAa,EAAE,gBAuB1B,CAAC;AAEH,8EAA8E;AAC9E,eAAO,MAAM,iBAAiB,EAAE,gBAI9B,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,gBAAgB,EAAE,gBAmC7B,CAAC;AAEH,eAAO,MAAM,oBAAoB,EAAE,gBAIjC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,aAAa,EAAE,gBA+B1B,CAAC;AAEH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,iBAAiB,EAAE,gBAO9B,CAAC;AAqBH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,0BAA0B,CAAC,UAAU,EAAE,gBAAgB,GAAG,MAAM,EAAE,CAiBjF;AAgCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,gBAAgB,GAAG,IAAI,CAKrE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,gBAAgB,EAAE,MAAM,EAAE,OAAO,GAAG,gBAAgB,CAOzF;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,GAAG,gBAAgB,CAG1E;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAGvE;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,gBAAgB,GAAG,mBAAmB,GAAG,OAAO,GAAG,SAAS,GAClE,gBAAgB,CAMlB;AAiCD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,IAAI,CAAC,QAAQ,EACnC,UAAU,EAAE,gBAAgB,GAC3B,OAAO,CAET;AAyHD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,CAAC,EAAE,UAAU,GAAE,gBAAgC,GAAG,CAAC,CAezG;AA2bD;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,OAAO,CAmB5D;AASD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,gBAAgB,GAAG,OAAO,CAanG;AAED;;GAEG;AACH;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,GAAG,gBAAgB,CAAC;AAEhD;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;OAEG;IACH,MAAM,EAAE,OAAO,CAAC;IAChB;;;;OAIG;IACH,MAAM,CAAC,EAAE,gBAAgB,CAAC;CAC3B;AAED,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,GAAG,SAAS,CAAC;AAEvG;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,IAAI,CAAC,EAAE,cAAc,GAAG,cAAc,EAAE,CAAC;IACzC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACxC,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;IAC3B,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,oBAAoB,CAAC,EAAE,OAAO,GAAG,UAAU,CAAC;IAC5C,aAAa,CAAC,EAAE,UAAU,CAAC;IAC3B,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;IACb,KAAK,CAAC,EAAE,UAAU,EAAE,CAAC;IACrB,KAAK,CAAC,EAAE,UAAU,EAAE,CAAC;IACrB,eAAe,CAAC,EAAE,OAAO,GAAG,UAAU,CAAC;IACvC,GAAG,CAAC,EAAE,UAAU,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,GAAG,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,GAAG,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACnC,8EAA8E;IAC9E,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC5B,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;CAC7B;AAqBD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,CAAC,CAAC,OAAO,EACjB,OAAO,EAAE,mBAAmB,GAAG,OAAO,GAAG,gBAAgB,GACxD,UAAU,CAqBZ;AAm7BD;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,4EAA4E;IAC5E,YAAY,EAAE,OAAO,CAAC;IACtB,6DAA6D;IAC7D,sBAAsB,EAAE,MAAM,CAAC;IAC/B;;;;OAIG;IACH,cAAc,EAAE,MAAM,CAAC;IACvB,iCAAiC;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,gCAAgC;IAChC,UAAU,EAAE,MAAM,CAAC;CACpB;AAYD;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,IAAI,CAAC,QAAQ,GAAG,cAAc,CA6FjF;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAmB;IAC9C,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,uBAAuB,CAAS;IACxC,OAAO,CAAC,mBAAmB,CAAS;gBAExB,UAAU,EAAE,gBAAgB;IAOxC;;;;;;;;;;;;OAYG;IACH,YAAY,CACV,MAAM,EAAE,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,IAAI,CAAC,QAAQ,EACnC,SAAS,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,GACtC,gBAAgB;IAInB;;;;;OAKG;IACH,cAAc,CACZ,MAAM,EAAE,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,IAAI,CAAC,QAAQ,EACnC,SAAS,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,GACtC,gBAAgB;IAInB,uEAAuE;IACvE,SAAS,IAAI;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE;IAQhF,OAAO,CAAC,QAAQ;CAwDjB;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,gBAAgB,EAAE,CAAC,EAAE,gBAAgB,GAAG,gBAAgB,CAWtF;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,GAAG,MAAM,CAK9E"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"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"}