@aeye/core 0.5.4 → 0.7.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/check-bag.d.ts

@@ -0,0 +1,28 @@
+import z from 'zod';
+/**
+ * The constraints a schema's checks add up to — the fields the JSON Schema
+ * converter reads for strings, numbers, arrays and tuples.
+ *
+ * zod 4.1 kept these on `schema._zod.bag`, filled by each check as it was
+ * attached. From zod 4.6 the bag stays empty for first-party checks and zod's
+ * own converter folds `def.checks` instead (`aggregateChecks`, which zod does
+ * not export). {@link checkBag} is that fold, so the converter reads the same
+ * facts on either version.
+ */
+export interface CheckBag {
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: number;
+    exclusiveMaximum?: number;
+    multipleOf?: number;
+    format?: string;
+    patterns?: Set<RegExp>;
+    contentEncoding?: string;
+}
+/**
+ * A schema's constraints, folded from its checks. A format schema (`z.email()`,
+ * `z.int()`) is its own first check, as zod treats it; anything zod still puts
+ * on `_zod.bag` (third-party `onattach` hooks) is merged in last.
+ */
+export declare function checkBag(schema: z.core.$ZodType): CheckBag;
+//# sourceMappingURL=check-bag.d.ts.map

package/dist/schema/check-bag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-bag.d.ts","sourceRoot":"","sources":["../../src/schema/check-bag.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB;;;;;;;;;GASG;AACH,MAAM,WAAW,QAAQ;IACvB,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,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACvB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAsGD;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAkB1D"}

package/dist/schema/check-bag.js

@@ -0,0 +1,129 @@
+import z from 'zod';
+/** The value a numeric check carries, as a plain number (bigint bounds are converted). */
+function numeric(value) {
+    return typeof value === 'number' ? value : Number(value);
+}
+function narrowMin(bag, key, value) {
+    const current = bag[key];
+    if (current === undefined || value > current)
+        bag[key] = value;
+}
+function narrowMax(bag, key, value) {
+    const current = bag[key];
+    if (current === undefined || value < current)
+        bag[key] = value;
+}
+function addPattern(bag, pattern) {
+    bag.patterns ??= new Set();
+    bag.patterns.add(pattern);
+}
+/**
+ * Every first-party check kind. Typed against zod's own union, so a kind zod
+ * adds or renames fails to compile here rather than being skipped silently.
+ */
+const FIRST_PARTY = {
+    less_than: true, greater_than: true, multiple_of: true, number_format: true, bigint_format: true,
+    max_size: true, min_size: true, size_equals: true, max_length: true, min_length: true,
+    length_equals: true, string_format: true, property: true, mime_type: true, overwrite: true,
+};
+function isFirstPartyKind(kind) {
+    return typeof kind === 'string' && Object.hasOwn(FIRST_PARTY, kind);
+}
+/** A check zod's first-party union describes, so its `def` narrows by `check`. */
+function isFirstParty(check) {
+    return isFirstPartyKind(check._zod.def.check);
+}
+/** A format schema (`z.email()`, `z.int()`) — a schema that is also its own first check. */
+function isFormatSchema(schema) {
+    return schema._zod.traits.has('$ZodCheck') && isFirstPartyKind(Reflect.get(schema._zod.def, 'check'));
+}
+/** Folds one check into the bag. Kinds with no JSON Schema meaning are ignored. */
+function applyCheck(bag, check) {
+    const def = check._zod.def;
+    switch (def.check) {
+        case 'greater_than':
+            narrowMin(bag, def.inclusive ? 'minimum' : 'exclusiveMinimum', numeric(def.value));
+            return;
+        case 'less_than':
+            narrowMax(bag, def.inclusive ? 'maximum' : 'exclusiveMaximum', numeric(def.value));
+            return;
+        case 'multiple_of':
+            bag.multipleOf ??= numeric(def.value);
+            return;
+        case 'number_format': {
+            bag.format = def.format;
+            const [min, max] = z.core.util.NUMBER_FORMAT_RANGES[def.format];
+            narrowMin(bag, 'minimum', min);
+            narrowMax(bag, 'maximum', max);
+            return;
+        }
+        case 'bigint_format': {
+            bag.format = def.format;
+            const [min, max] = z.core.util.BIGINT_FORMAT_RANGES[def.format];
+            narrowMin(bag, 'minimum', Number(min));
+            narrowMax(bag, 'maximum', Number(max));
+            return;
+        }
+        case 'min_length':
+        case 'min_size':
+            narrowMin(bag, 'minimum', def.minimum);
+            return;
+        case 'max_length':
+        case 'max_size':
+            narrowMax(bag, 'maximum', def.maximum);
+            return;
+        case 'length_equals':
+            narrowMin(bag, 'minimum', def.length);
+            narrowMax(bag, 'maximum', def.length);
+            return;
+        case 'size_equals':
+            narrowMin(bag, 'minimum', def.size);
+            narrowMax(bag, 'maximum', def.size);
+            return;
+        case 'string_format':
+            bag.format = def.format;
+            if (def.pattern)
+                addPattern(bag, def.pattern);
+            if (def.format === 'base64' || def.format === 'base64url')
+                bag.contentEncoding = def.format;
+            return;
+        default:
+            return;
+    }
+}
+/**
+ * A schema's constraints, folded from its checks. A format schema (`z.email()`,
+ * `z.int()`) is its own first check, as zod treats it; anything zod still puts
+ * on `_zod.bag` (third-party `onattach` hooks) is merged in last.
+ */
+export function checkBag(schema) {
+    const bag = {};
+    const internals = schema._zod;
+    if (isFormatSchema(schema))
+        applyCheck(bag, schema);
+    for (const check of internals.def.checks ?? [])
+        if (isFirstParty(check))
+            applyCheck(bag, check);
+    const legacy = internals.bag;
+    if (typeof legacy.minimum === 'number')
+        narrowMin(bag, 'minimum', legacy.minimum);
+    if (typeof legacy.exclusiveMinimum === 'number')
+        narrowMin(bag, 'exclusiveMinimum', legacy.exclusiveMinimum);
+    if (typeof legacy.maximum === 'number')
+        narrowMax(bag, 'maximum', legacy.maximum);
+    if (typeof legacy.exclusiveMaximum === 'number')
+        narrowMax(bag, 'exclusiveMaximum', legacy.exclusiveMaximum);
+    if (typeof legacy.multipleOf === 'number')
+        bag.multipleOf ??= legacy.multipleOf;
+    if (typeof legacy.format === 'string')
+        bag.format ??= legacy.format;
+    if (typeof legacy.contentEncoding === 'string')
+        bag.contentEncoding ??= legacy.contentEncoding;
+    if (legacy.patterns instanceof Set) {
+        for (const pattern of legacy.patterns)
+            if (pattern instanceof RegExp)
+                addPattern(bag, pattern);
+    }
+    return bag;
+}
+//# sourceMappingURL=check-bag.js.map

package/dist/schema/check-bag.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-bag.js","sourceRoot":"","sources":["../../src/schema/check-bag.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAuBpB,0FAA0F;AAC1F,SAAS,OAAO,CAAC,KAA6B;IAC5C,OAAO,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AAC3D,CAAC;AAED,SAAS,SAAS,CAAC,GAAa,EAAE,GAAmC,EAAE,KAAa;IAClF,MAAM,OAAO,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC;IACzB,IAAI,OAAO,KAAK,SAAS,IAAI,KAAK,GAAG,OAAO;QAAE,GAAG,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AACjE,CAAC;AAED,SAAS,SAAS,CAAC,GAAa,EAAE,GAAmC,EAAE,KAAa;IAClF,MAAM,OAAO,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC;IACzB,IAAI,OAAO,KAAK,SAAS,IAAI,KAAK,GAAG,OAAO;QAAE,GAAG,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AACjE,CAAC;AAED,SAAS,UAAU,CAAC,GAAa,EAAE,OAAe;IAChD,GAAG,CAAC,QAAQ,KAAK,IAAI,GAAG,EAAE,CAAC;IAC3B,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;AAC5B,CAAC;AAKD;;;GAGG;AACH,MAAM,WAAW,GAA8C;IAC7D,SAAS,EAAE,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,aAAa,EAAE,IAAI;IAChG,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI;IACrF,aAAa,EAAE,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI;CAC3F,CAAC;AAEF,SAAS,gBAAgB,CAAC,IAAa;IACrC,OAAO,OAAO,IAAI,KAAK,QAAQ,IAAI,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC;AACtE,CAAC;AAED,kFAAkF;AAClF,SAAS,YAAY,CAAoC,KAAQ;IAC/D,OAAO,gBAAgB,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;AAChD,CAAC;AAED,4FAA4F;AAC5F,SAAS,cAAc,CAAC,MAAuB;IAC7C,OAAO,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,WAAW,CAAC,IAAI,gBAAgB,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC,CAAC;AACxG,CAAC;AAED,mFAAmF;AACnF,SAAS,UAAU,CAAC,GAAa,EAAE,KAAwB;IACzD,MAAM,GAAG,GAAG,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC;IAC3B,QAAQ,GAAG,CAAC,KAAK,EAAE,CAAC;QAClB,KAAK,cAAc;YACjB,SAAS,CAAC,GAAG,EAAE,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,kBAAkB,EAAE,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;YACnF,OAAO;QACT,KAAK,WAAW;YACd,SAAS,CAAC,GAAG,EAAE,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,kBAAkB,EAAE,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;YACnF,OAAO;QACT,KAAK,aAAa;YAChB,GAAG,CAAC,UAAU,KAAK,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;YACtC,OAAO;QACT,KAAK,eAAe,CAAC,CAAC,CAAC;YACrB,GAAG,CAAC,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC;YACxB,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;YAChE,SAAS,CAAC,GAAG,EAAE,SAAS,EAAE,GAAG,CAAC,CAAC;YAC/B,SAAS,CAAC,GAAG,EAAE,SAAS,EAAE,GAAG,CAAC,CAAC;YAC/B,OAAO;QACT,CAAC;QACD,KAAK,eAAe,CAAC,CAAC,CAAC;YACrB,GAAG,CAAC,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC;YACxB,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;YAChE,SAAS,CAAC,GAAG,EAAE,SAAS,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;YACvC,SAAS,CAAC,GAAG,EAAE,SAAS,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;YACvC,OAAO;QACT,CAAC;QACD,KAAK,YAAY,CAAC;QAClB,KAAK,UAAU;YACb,SAAS,CAAC,GAAG,EAAE,SAAS,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;YACvC,OAAO;QACT,KAAK,YAAY,CAAC;QAClB,KAAK,UAAU;YACb,SAAS,CAAC,GAAG,EAAE,SAAS,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;YACvC,OAAO;QACT,KAAK,eAAe;YAClB,SAAS,CAAC,GAAG,EAAE,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;YACtC,SAAS,CAAC,GAAG,EAAE,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;YACtC,OAAO;QACT,KAAK,aAAa;YAChB,SAAS,CAAC,GAAG,EAAE,SAAS,EAAE,GAAG,CAAC,IAAI,CAAC,CAAC;YACpC,SAAS,CAAC,GAAG,EAAE,SAAS,EAAE,GAAG,CAAC,IAAI,CAAC,CAAC;YACpC,OAAO;QACT,KAAK,eAAe;YAClB,GAAG,CAAC,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC;YACxB,IAAI,GAAG,CAAC,OAAO;gBAAE,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;YAC9C,IAAI,GAAG,CAAC,MAAM,KAAK,QAAQ,IAAI,GAAG,CAAC,MAAM,KAAK,WAAW;gBAAE,GAAG,CAAC,eAAe,GAAG,GAAG,CAAC,MAAM,CAAC;YAC5F,OAAO;QACT;YACE,OAAO;IACX,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,QAAQ,CAAC,MAAuB;IAC9C,MAAM,GAAG,GAAa,EAAE,CAAC;IACzB,MAAM,SAAS,GAAG,MAAM,CAAC,IAAI,CAAC;IAC9B,IAAI,cAAc,CAAC,MAAM,CAAC;QAAE,UAAU,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;IACpD,KAAK,MAAM,KAAK,IAAI,SAAS,CAAC,GAAG,CAAC,MAAM,IAAI,EAAE;QAAE,IAAI,YAAY,CAAC,KAAK,CAAC;YAAE,UAAU,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;IAEhG,MAAM,MAAM,GAAsC,SAAS,CAAC,GAAG,CAAC;IAChE,IAAI,OAAO,MAAM,CAAC,OAAO,KAAK,QAAQ;QAAE,SAAS,CAAC,GAAG,EAAE,SAAS,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC;IAClF,IAAI,OAAO,MAAM,CAAC,gBAAgB,KAAK,QAAQ;QAAE,SAAS,CAAC,GAAG,EAAE,kBAAkB,EAAE,MAAM,CAAC,gBAAgB,CAAC,CAAC;IAC7G,IAAI,OAAO,MAAM,CAAC,OAAO,KAAK,QAAQ;QAAE,SAAS,CAAC,GAAG,EAAE,SAAS,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC;IAClF,IAAI,OAAO,MAAM,CAAC,gBAAgB,KAAK,QAAQ;QAAE,SAAS,CAAC,GAAG,EAAE,kBAAkB,EAAE,MAAM,CAAC,gBAAgB,CAAC,CAAC;IAC7G,IAAI,OAAO,MAAM,CAAC,UAAU,KAAK,QAAQ;QAAE,GAAG,CAAC,UAAU,KAAK,MAAM,CAAC,UAAU,CAAC;IAChF,IAAI,OAAO,MAAM,CAAC,MAAM,KAAK,QAAQ;QAAE,GAAG,CAAC,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC;IACpE,IAAI,OAAO,MAAM,CAAC,eAAe,KAAK,QAAQ;QAAE,GAAG,CAAC,eAAe,KAAK,MAAM,CAAC,eAAe,CAAC;IAC/F,IAAI,MAAM,CAAC,QAAQ,YAAY,GAAG,EAAE,CAAC;QACnC,KAAK,MAAM,OAAO,IAAI,MAAM,CAAC,QAAQ;YAAE,IAAI,OAAO,YAAY,MAAM;gBAAE,UAAU,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;IACjG,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC"}

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"}