@aeye/core 0.5.3 → 0.6.0

package/dist/schema/any-value.js

@@ -0,0 +1,77 @@
+/**
+ * True when the descriptor's "any" encoding is a self-referencing definition,
+ * i.e. it has to be hoisted into `$defs/Any` and referenced by `$ref`. The
+ * non-recursive encodings (`flat`, `unconstrained`) are inlined at each use
+ * site instead, so no `$defs` entry is ever created for them.
+ */
+export function usesSharedAnyDefinition(descriptor) {
+    return descriptor.anyEncoding === 'recursive-strict'
+        || descriptor.anyEncoding === 'recursive-open';
+}
+/**
+ * Builds the body of the "any value" schema — for most dialects an `anyOf`
+ * covering every JSON value (string, number, boolean, null, array, object).
+ *
+ * Encoding modes:
+ * - `recursive-strict` (OpenAI strict): self-referencing `$defs/Any` with
+ *   array-of-pairs records (no open-object support in strict mode).
+ * - `recursive-open` (Lenient): self-referencing `$defs/Any` with
+ *   `additionalProperties: <self>` records.
+ * - `flat` (xAI strict): non-recursive — array branch has no `items`
+ *   constraint, object branch is `additionalProperties: true`. Equivalent
+ *   to TypeScript `any`; safe under descriptors that reject cyclic `$defs`.
+ * - `unconstrained` (Google): the empty schema `{}`. A schema with no
+ *   assertion keywords validates every instance, so this says "any JSON
+ *   value" using zero keywords — the only option for a dialect that forbids
+ *   `anyOf` AND named `$defs`/`$ref`. The caller re-attaches `description`
+ *   from the source schema's metadata, so the model still gets the prose.
+ * - `none` (Anthropic strict): no spelling exists. `expressible` keeps such a
+ *   schema off a strict request, so this is only reached by a direct
+ *   `toJSONSchema` call, which gets the empty schema.
+ */
+export function buildAnyValueSchema(descriptor) {
+    if (descriptor.anyEncoding === 'unconstrained' || descriptor.anyEncoding === 'none') {
+        return {};
+    }
+    const isFlat = descriptor.anyEncoding === 'flat';
+    const selfRef = isFlat ? {} : { $ref: '#/$defs/Any' };
+    const arrayBranch = isFlat
+        ? { type: 'array' }
+        : { type: 'array', items: selfRef };
+    const branches = [
+        { type: 'string' },
+        { type: 'number' },
+        { type: 'boolean' },
+        { type: 'null' },
+        arrayBranch,
+    ];
+    if (descriptor.anyEncoding === 'recursive-strict') {
+        branches.push({
+            type: 'array',
+            items: {
+                type: 'object',
+                properties: {
+                    key: { type: 'string' },
+                    value: selfRef,
+                },
+                required: ['key', 'value'],
+                additionalProperties: false,
+            },
+        });
+    }
+    else if (descriptor.anyEncoding === 'recursive-open') {
+        branches.push({
+            type: 'object',
+            additionalProperties: selfRef,
+        });
+    }
+    else {
+        // flat
+        branches.push({
+            type: 'object',
+            additionalProperties: true,
+        });
+    }
+    return { anyOf: branches };
+}
+//# sourceMappingURL=any-value.js.map

package/dist/schema/any-value.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"any-value.js","sourceRoot":"","sources":["../../src/schema/any-value.ts"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,MAAM,UAAU,uBAAuB,CAAC,UAA4B;IAClE,OAAO,UAAU,CAAC,WAAW,KAAK,kBAAkB;WAC/C,UAAU,CAAC,WAAW,KAAK,gBAAgB,CAAC;AACnD,CAAC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,mBAAmB,CAAC,UAA4B;IAC9D,IAAI,UAAU,CAAC,WAAW,KAAK,eAAe,IAAI,UAAU,CAAC,WAAW,KAAK,MAAM,EAAE,CAAC;QACpF,OAAO,EAAE,CAAC;IACZ,CAAC;IACD,MAAM,MAAM,GAAG,UAAU,CAAC,WAAW,KAAK,MAAM,CAAC;IACjD,MAAM,OAAO,GAAe,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,CAAC;IAClE,MAAM,WAAW,GAAe,MAAM;QACpC,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE;QACnB,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;IACtC,MAAM,QAAQ,GAAiB;QAC7B,EAAE,IAAI,EAAE,QAAQ,EAAE;QAClB,EAAE,IAAI,EAAE,QAAQ,EAAE;QAClB,EAAE,IAAI,EAAE,SAAS,EAAE;QACnB,EAAE,IAAI,EAAE,MAAM,EAAE;QAChB,WAAW;KACZ,CAAC;IACF,IAAI,UAAU,CAAC,WAAW,KAAK,kBAAkB,EAAE,CAAC;QAClD,QAAQ,CAAC,IAAI,CAAC;YACZ,IAAI,EAAE,OAAO;YACb,KAAK,EAAE;gBACL,IAAI,EAAE,QAAQ;gBACd,UAAU,EAAE;oBACV,GAAG,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;oBACvB,KAAK,EAAE,OAAO;iBACf;gBACD,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC;gBAC1B,oBAAoB,EAAE,KAAK;aAC5B;SACF,CAAC,CAAC;IACL,CAAC;SAAM,IAAI,UAAU,CAAC,WAAW,KAAK,gBAAgB,EAAE,CAAC;QACvD,QAAQ,CAAC,IAAI,CAAC;YACZ,IAAI,EAAE,QAAQ;YACd,oBAAoB,EAAE,OAAO;SAC9B,CAAC,CAAC;IACL,CAAC;SAAM,CAAC;QACN,OAAO;QACP,QAAQ,CAAC,IAAI,CAAC;YACZ,IAAI,EAAE,QAAQ;YACd,oBAAoB,EAAE,IAAI;SAC3B,CAAC,CAAC;IACL,CAAC;IACD,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC;AAC7B,CAAC"}

package/dist/schema/budget.d.ts

@@ -0,0 +1,114 @@
+import z from 'zod';
+import type { FormatDescriptor } from './descriptor';
+/**
+ * Per-request strict-mode allocator.
+ *
+ * Constructed once per outgoing request with the chosen model's tool and
+ * structured-output descriptors (the same one when only one is given; they
+ * differ when the model has strict tools but not strict output, or the
+ * reverse). The slot limits come from the stricter of the two. 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 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
+ * strict for `requested === true` (subject only to feasibility, not budget;
+ * if `true` items overflow the budget the API call will fail, which is the
+ * correct behavior for hard requirements).
+ *
+ * Numeric `strict: <priority>` items are allocated greedily after `true`
+ * items have consumed their share of the budget. Caller is expected to
+ * pre-sort by descending priority before iterating.
+ */
+export declare class SchemaBudget {
+    private readonly tool;
+    private readonly output;
+    /**
+     * 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 degradedTool;
+    private readonly degradedOutput;
+    private remainingTools;
+    private remainingOptionalParams;
+    private remainingUnionTypes;
+    constructor(tool: FormatDescriptor, output?: FormatDescriptor);
+    /**
+     * 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 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 and size)
+     *
+     * Returns the strict descriptor (and decrements the budget) otherwise.
+     */
+    allocateTool(schema: z.ZodType | z.core.$ZodType, requested: boolean | number | undefined): FormatDescriptor;
+    /**
+     * Same as `allocateTool` but for the request's structured-output schema.
+     * The output schema doesn't consume a tool slot but it does count toward
+     * the optional-parameter and union-type budgets — descriptors document
+     * those limits as "across all strict schemas in one request".
+     */
+    allocateOutput(schema: z.ZodType | z.core.$ZodType, requested: boolean | number | undefined): FormatDescriptor;
+    /** Snapshot of remaining budget. Useful for telemetry / debug logs. */
+    remaining(): {
+        strictTools: number;
+        optionalParams: number;
+        unionTypes: number;
+    };
+    private allocate;
+}
+/**
+ * Compare two descriptors and return the one with the tighter per-request
+ * budget. Used by providers to pick a single descriptor for a 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;
+/**
+ * Convert a `boolean | number | undefined` strict request into a numeric
+ * priority for sorting. Used by providers to allocate strict slots in
+ * descending priority order.
+ *
+ * - `true` → `+Infinity` (hard requirement; always first in line)
+ * - `false` → `-Infinity` (always lenient; never wants strict)
+ * - `number > 0` → the number itself
+ * - `number <= 0` or `undefined` → `0` (no preference)
+ */
+export declare function strictPriority(requested: boolean | number | undefined): number;
+//# sourceMappingURL=budget.d.ts.map

package/dist/schema/budget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"budget.d.ts","sourceRoot":"","sources":["../../src/schema/budget.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AACpB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAKrD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAmB;IACxC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAmB;IAC1C;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAmB;IAChD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAmB;IAClD,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,uBAAuB,CAAS;IACxC,OAAO,CAAC,mBAAmB,CAAS;gBAExB,IAAI,EAAE,gBAAgB,EAAE,MAAM,GAAE,gBAAuB;IAanE;;;;;;;;;;;;;;;OAeG;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;CAkEjB;AAYD;;;;;;;;;;;;;GAaG;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"}

package/dist/schema/budget.js

@@ -0,0 +1,223 @@
+import { getDescriptor } from './registry';
+import { fitsStrictAlone, sendableUnder } from './expressible';
+import { analyzeSchema } from './analyze';
+/**
+ * Per-request strict-mode allocator.
+ *
+ * Constructed once per outgoing request with the chosen model's tool and
+ * structured-output descriptors (the same one when only one is given; they
+ * differ when the model has strict tools but not strict output, or the
+ * reverse). The slot limits come from the stricter of the two. 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 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
+ * strict for `requested === true` (subject only to feasibility, not budget;
+ * if `true` items overflow the budget the API call will fail, which is the
+ * correct behavior for hard requirements).
+ *
+ * Numeric `strict: <priority>` items are allocated greedily after `true`
+ * items have consumed their share of the budget. Caller is expected to
+ * pre-sort by descending priority before iterating.
+ */
+export class SchemaBudget {
+    tool;
+    output;
+    /**
+     * 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`.
+     */
+    degradedTool;
+    degradedOutput;
+    remainingTools;
+    remainingOptionalParams;
+    remainingUnionTypes;
+    constructor(tool, output = tool) {
+        this.tool = tool;
+        this.output = output;
+        this.degradedTool = degrade(tool);
+        // A family with no non-strict structured output keeps the strict dialect
+        // (`canExpress` already kept an unfitting schema off the wire)
+        this.degradedOutput = output.structuredOutputAlwaysStrict ? output : degrade(output);
+        const descriptor = strictestOf(tool, output);
+        this.remainingTools = descriptor.maxStrictTools ?? Infinity;
+        this.remainingOptionalParams = descriptor.maxStrictOptionalParams ?? Infinity;
+        this.remainingUnionTypes = descriptor.maxStrictUnionTypes ?? Infinity;
+    }
+    /**
+     * 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 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 and size)
+     *
+     * Returns the strict descriptor (and decrements the budget) otherwise.
+     */
+    allocateTool(schema, requested) {
+        return this.allocate(schema, requested, /* isTool */ true);
+    }
+    /**
+     * Same as `allocateTool` but for the request's structured-output schema.
+     * The output schema doesn't consume a tool slot but it does count toward
+     * the optional-parameter and union-type budgets — descriptors document
+     * those limits as "across all strict schemas in one request".
+     */
+    allocateOutput(schema, requested) {
+        return this.allocate(schema, requested, /* isTool */ false);
+    }
+    /** Snapshot of remaining budget. Useful for telemetry / debug logs. */
+    remaining() {
+        return {
+            strictTools: this.remainingTools,
+            optionalParams: this.remainingOptionalParams,
+            unionTypes: this.remainingUnionTypes,
+        };
+    }
+    allocate(schema, requested, isTool) {
+        const descriptor = isTool ? this.tool : this.output;
+        const degraded = isTool ? this.degradedTool : this.degradedOutput;
+        // strict: false → always non-strict, no budget movement.
+        if (requested === false)
+            return degraded;
+        // Descriptor itself is lenient → nothing to allocate.
+        if (!descriptor.strict)
+            return degraded;
+        const isHardRequired = requested === true;
+        const isPreferredNumeric = typeof requested === 'number' && requested > 0;
+        if (!isHardRequired && !isPreferredNumeric) {
+            // requested is undefined or 0 — treat as no preference; default to
+            // non-strict so callers explicitly opt into strict. Decided BEFORE any
+            // walk of `schema`: analysing a schema whose verdict is already
+            // non-strict is pure waste on the hot path of every tool of every request.
+            return degraded;
+        }
+        // FEASIBILITY, before budget — the second clause of this method's contract,
+        // and the one that was documented but never implemented. Emitting a strict
+        // schema carrying a combinator the descriptor forbids is a guaranteed
+        // provider 400, not a degradation: `GOOGLE_STRICT` forbids `anyOf`, and the
+        // recursive union a gin/query codegen layer produces is nothing but.
+        // Degrading to the family's non-strict descriptor is the documented answer
+        // for a TOOL (unlike a structured OUTPUT, a tool schema has no prompt-text
+        // delivery to fall back to — `applySchemaDeliveryFallback` covers
+        // `responseFormat` only), and it is also what keeps the API-level
+        // `strict: true` flag off the wire, since providers set it from
+        // `descriptor.strict`.
+        //
+        // `sendableUnder`, not `canExpress`: a cycle is always sendable (the
+        // emitter's bounded placeholder), only looser — see that function's note on
+        // why the two questions are different.
+        if (!sendableUnder(schema, descriptor))
+            return degraded;
+        // SIZE, still before budget and still regardless of priority: the per-SCHEMA
+        // bounds (see `checkSchemaSizeLimits`), and the per-request budgets when
+        // this schema alone exceeds them, cannot be met by anything else in the
+        // request, and a hard `strict: true` cannot force a schema the API will
+        // refuse to compile.
+        if (!fitsStrictAlone(schema, descriptor))
+            return degraded;
+        const features = analyzeSchema(schema);
+        // Soft-priority items must fit the budget. Hard-required items skip
+        // budget checks because selection already promised the model can take
+        // them — if there are too many, that's a request-construction bug we
+        // surface via API error rather than degrading silently.
+        if (isPreferredNumeric) {
+            if (isTool && this.remainingTools <= 0)
+                return degraded;
+            if (this.remainingOptionalParams - features.optionalParameterCount < 0)
+                return degraded;
+            if (this.remainingUnionTypes - features.unionTypeCount < 0)
+                return degraded;
+        }
+        // Allocation succeeded — decrement.
+        if (isTool)
+            this.remainingTools -= 1;
+        this.remainingOptionalParams -= features.optionalParameterCount;
+        this.remainingUnionTypes -= features.unionTypeCount;
+        return descriptor;
+    }
+}
+/**
+ * What an item that does not get strict is emitted through (see
+ * `SchemaBudget.degradedTool`). An already-non-strict descriptor degrades to
+ * itself: there is nothing looser in its family, and `LENIENT`'s own family
+ * has no other variant.
+ */
+function degrade(descriptor) {
+    return descriptor.strict ? getDescriptor(descriptor.family, false) : descriptor;
+}
+/**
+ * Compare two descriptors and return the one with the tighter per-request
+ * budget. Used by providers to pick a single descriptor for a 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 function strictestOf(a, b) {
+    // LENIENT is the loosest — pick the strict side if either is strict.
+    if (a.strict && !b.strict)
+        return a;
+    if (b.strict && !a.strict)
+        return b;
+    if (!a.strict && !b.strict)
+        return a;
+    // Both strict — pick the one with the smallest documented limits.
+    const score = (d) => (d.maxStrictTools ?? Infinity) +
+        (d.maxStrictOptionalParams ?? Infinity) +
+        (d.maxStrictUnionTypes ?? Infinity);
+    return score(a) <= score(b) ? a : b;
+}
+/**
+ * Convert a `boolean | number | undefined` strict request into a numeric
+ * priority for sorting. Used by providers to allocate strict slots in
+ * descending priority order.
+ *
+ * - `true` → `+Infinity` (hard requirement; always first in line)
+ * - `false` → `-Infinity` (always lenient; never wants strict)
+ * - `number > 0` → the number itself
+ * - `number <= 0` or `undefined` → `0` (no preference)
+ */
+export function strictPriority(requested) {
+    if (requested === true)
+        return Infinity;
+    if (requested === false)
+        return -Infinity;
+    if (typeof requested === 'number')
+        return requested > 0 ? requested : 0;
+    return 0;
+}
+//# sourceMappingURL=budget.js.map

package/dist/schema/budget.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"budget.js","sourceRoot":"","sources":["../../src/schema/budget.ts"],"names":[],"mappings":"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"}

package/dist/schema/consistency.d.ts

@@ -0,0 +1,27 @@
+import type { FormatDescriptor } from './descriptor';
+/**
+ * Report the ways a `FormatDescriptor` contradicts itself — settings that ask
+ * 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.
+ *
+ * This exists because a contradiction here is invisible until a provider
+ * answers HTTP 400: `GOOGLE_STRICT` shipped with `allowAnyOf: false` +
+ * `allowDefsRef: false` AND `anyEncoding: 'recursive-open'` (which needs
+ * both), so every `z.any()` in a Gemini tool schema emitted exactly the
+ * `anyOf` + `$defs/Any` shape the descriptor declared unrepresentable.
+ * Nothing checked, so nothing caught it.
+ *
+ * Called by `registerDescriptor` (which warns) and asserted over every
+ * built-in by the test suite.
+ *
+ * @example
+ * ```ts
+ * checkDescriptorConsistency(GOOGLE_STRICT);   // → []
+ * checkDescriptorConsistency({ ...GOOGLE_STRICT, anyEncoding: 'flat' });
+ * //  → ["anyEncoding 'flat' emits `anyOf`, but allowAnyOf is false"]
+ * ```
+ */
+export declare function checkDescriptorConsistency(descriptor: FormatDescriptor): string[];
+//# sourceMappingURL=consistency.d.ts.map

package/dist/schema/consistency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consistency.d.ts","sourceRoot":"","sources":["../../src/schema/consistency.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAoB,MAAM,cAAc,CAAC;AAsBvE;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,0BAA0B,CAAC,UAAU,EAAE,gBAAgB,GAAG,MAAM,EAAE,CA6BjF"}

package/dist/schema/consistency.js

@@ -0,0 +1,110 @@
+// ============================================================================
+// Descriptor self-consistency
+// ============================================================================
+/**
+ * JSON-Schema keywords each `anyEncoding` has to emit. Single source of truth
+ * for both `buildAnyValueSchema` (which produces the shape) and
+ * `checkDescriptorConsistency` (which checks the descriptor is allowed to).
+ */
+const ANY_ENCODING_REQUIREMENTS = Object.freeze({
+    'recursive-strict': { anyOf: true, defsRef: true },
+    'recursive-open': { anyOf: true, defsRef: true },
+    'flat': { anyOf: true, defsRef: false },
+    'unconstrained': { anyOf: false, defsRef: false },
+    'none': { anyOf: false, defsRef: false },
+});
+/**
+ * Report the ways a `FormatDescriptor` contradicts itself — settings that ask
+ * 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.
+ *
+ * This exists because a contradiction here is invisible until a provider
+ * answers HTTP 400: `GOOGLE_STRICT` shipped with `allowAnyOf: false` +
+ * `allowDefsRef: false` AND `anyEncoding: 'recursive-open'` (which needs
+ * both), so every `z.any()` in a Gemini tool schema emitted exactly the
+ * `anyOf` + `$defs/Any` shape the descriptor declared unrepresentable.
+ * Nothing checked, so nothing caught it.
+ *
+ * Called by `registerDescriptor` (which warns) and asserted over every
+ * built-in by the test suite.
+ *
+ * @example
+ * ```ts
+ * checkDescriptorConsistency(GOOGLE_STRICT);   // → []
+ * checkDescriptorConsistency({ ...GOOGLE_STRICT, anyEncoding: 'flat' });
+ * //  → ["anyEncoding 'flat' emits `anyOf`, but allowAnyOf is false"]
+ * ```
+ */
+export function checkDescriptorConsistency(descriptor) {
+    const problems = [];
+    const needs = ANY_ENCODING_REQUIREMENTS[descriptor.anyEncoding];
+    if (needs === undefined) {
+        problems.push(`anyEncoding '${descriptor.anyEncoding}' is not a known encoding`);
+        return problems;
+    }
+    if (needs.anyOf && !descriptor.allowAnyOf) {
+        problems.push(`anyEncoding '${descriptor.anyEncoding}' emits \`anyOf\`, but allowAnyOf is false`);
+    }
+    if (needs.defsRef && !descriptor.allowDefsRef) {
+        problems.push(`anyEncoding '${descriptor.anyEncoding}' emits a self-referencing \`$defs/Any\`, but allowDefsRef is false`);
+    }
+    if (needs.defsRef && !descriptor.supportsRecursion) {
+        problems.push(`anyEncoding '${descriptor.anyEncoding}' emits a self-referencing \`$defs/Any\`, but supportsRecursion is false`);
+    }
+    // `maxEnumValues` is an independent scalar — there is no other field it can
+    // contradict — but a cap below 1 widens EVERY enum the dialect ever emits
+    // (including a two-member one), and a fractional cap reads as a threshold
+    // nobody intended. Both are silent: the schema stays valid, it just stops
+    // constraining anything, which is the "invisible until you read the wire"
+    // class this function exists to catch. Only reachable through
+    // `registerDescriptor`; the built-ins are asserted clean by the test suite.
+    const cap = descriptor.maxEnumValues;
+    if (cap !== undefined && (!Number.isInteger(cap) || cap < 1)) {
+        problems.push(`maxEnumValues must be a positive integer, got ${cap}`);
+    }
+    problems.push(...schemaSizeLimitProblems(descriptor));
+    return problems;
+}
+/**
+ * The ways a `schemaSizeLimits` group contradicts itself or the descriptor
+ * carrying it. Split out only to keep `checkDescriptorConsistency` readable;
+ * it is part of the same contract.
+ *
+ * The failures below are all SILENT: a non-positive bound degrades every
+ * schema to lenient (strict mode simply stops happening, with no error
+ * anywhere), a threshold above the total makes the large-enum rule
+ * unreachable, and limits on a non-strict descriptor describe a rule the API
+ * does not apply — each one is a rule that reads as enforced and is not.
+ */
+function schemaSizeLimitProblems(descriptor) {
+    const limits = descriptor.schemaSizeLimits;
+    if (limits === undefined)
+        return [];
+    const problems = [];
+    if (!descriptor.strict) {
+        problems.push('schemaSizeLimits is declared on a non-strict descriptor, but the size rules bound Structured Outputs only');
+    }
+    // Keyed off the interface, so a bound added to `SchemaSizeLimits` is checked
+    // here without an edit — `satisfies` makes a missed key a compile error.
+    const bounds = {
+        maxObjectProperties: limits.maxObjectProperties,
+        maxNestingDepth: limits.maxNestingDepth,
+        maxTotalStringChars: limits.maxTotalStringChars,
+        maxTotalEnumValues: limits.maxTotalEnumValues,
+        largeEnumValueCount: limits.largeEnumValueCount,
+        maxLargeEnumStringChars: limits.maxLargeEnumStringChars,
+    };
+    for (const [name, value] of Object.entries(bounds)) {
+        if (!Number.isInteger(value) || value < 1) {
+            problems.push(`schemaSizeLimits.${name} must be a positive integer, got ${value}`);
+        }
+    }
+    if (limits.largeEnumValueCount >= limits.maxTotalEnumValues) {
+        problems.push(`schemaSizeLimits.largeEnumValueCount (${limits.largeEnumValueCount}) is not below maxTotalEnumValues ` +
+            `(${limits.maxTotalEnumValues}), so the large-enum character rule can never apply`);
+    }
+    return problems;
+}
+//# sourceMappingURL=consistency.js.map

package/dist/schema/consistency.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"consistency.js","sourceRoot":"","sources":["../../src/schema/consistency.ts"],"names":[],"mappings":"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"}

package/dist/schema/cycle-breaker.d.ts

@@ -0,0 +1,14 @@
+import z from 'zod';
+import type { FormatDescriptor } from './descriptor';
+import type { JSONSchema } from './json-schema';
+/**
+ * Build the inline placeholder used in place of a cyclic `$ref` for
+ * descriptors with `supportsRecursion: false`. Inspects the recursive zod
+ * `schema` and emits a JSON-Schema node whose top-level shape matches it
+ * (number → `{type: 'number'}`, array → `{type: 'array', items: ...}`, union
+ * → `{anyOf: [...]}`, etc.) so the LLM still knows what JSON value to send
+ * at the cycle position. One level of structural fidelity, then bottoms out
+ * at the descriptor's flat "any" encoding.
+ */
+export declare function buildCycleBreakerSchema(schema: z.ZodType | z.core.$ZodType, refId: string, descriptor: FormatDescriptor): JSONSchema;
+//# sourceMappingURL=cycle-breaker.d.ts.map

package/dist/schema/cycle-breaker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cycle-breaker.d.ts","sourceRoot":"","sources":["../../src/schema/cycle-breaker.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AACpB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAGhD;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,IAAI,CAAC,QAAQ,EACnC,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,gBAAgB,GAC3B,UAAU,CAUZ"}