@aeye/core 0.5.3 → 0.6.0

package/dist/schema/dialects/openai.d.ts

@@ -0,0 +1,40 @@
+import type { FormatDescriptor } from '../descriptor';
+/**
+ * OpenAI strict. Records→pairs, tuples→numeric-keys, optional→nullable.
+ *
+ * Numeric bounds (`minimum`/`maximum`/`exclusive*`/`multipleOf`) and array
+ * sizes (`minItems`/`maxItems`) are in the documented supported list
+ * (developers.openai.com/api/docs/guides/structured-outputs, "Supported
+ * properties", read 2026-10-30). `minLength`/`maxLength` are listed as
+ * unsupported only for fine-tuned models; a strict `json_schema` carrying them
+ * was accepted and honored by gpt-5.4-mini on 2026-10-30, as were the
+ * numeric and array bounds, so all three are emitted.
+ *
+ * No documented per-request slot limit (max strict tools / optional params /
+ * 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. */
+export declare const OPENAI_NON_STRICT: FormatDescriptor;
+//# sourceMappingURL=openai.d.ts.map

package/dist/schema/dialects/openai.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai.d.ts","sourceRoot":"","sources":["../../../src/schema/dialects/openai.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAOtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,eAAO,MAAM,aAAa,EAAE,gBAkC1B,CAAC;AAEH,8EAA8E;AAC9E,eAAO,MAAM,iBAAiB,EAAE,gBAI9B,CAAC"}

package/dist/schema/dialects/openai.js

@@ -0,0 +1,81 @@
+import { LENIENT } from './lenient';
+const OPENAI_STRICT_FORMATS = new Set([
+    'date-time', 'time', 'date', 'duration', 'email', 'hostname', 'ipv4', 'ipv6', 'uuid',
+]);
+/**
+ * OpenAI strict. Records→pairs, tuples→numeric-keys, optional→nullable.
+ *
+ * Numeric bounds (`minimum`/`maximum`/`exclusive*`/`multipleOf`) and array
+ * sizes (`minItems`/`maxItems`) are in the documented supported list
+ * (developers.openai.com/api/docs/guides/structured-outputs, "Supported
+ * properties", read 2026-10-30). `minLength`/`maxLength` are listed as
+ * unsupported only for fine-tuned models; a strict `json_schema` carrying them
+ * was accepted and honored by gpt-5.4-mini on 2026-10-30, as were the
+ * numeric and array bounds, so all three are emitted.
+ *
+ * No documented per-request slot limit (max strict tools / optional params /
+ * 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 const OPENAI_STRICT = Object.freeze({
+    id: 'openai-strict',
+    family: 'openai',
+    strict: true,
+    objectAllFieldsRequired: true,
+    objectClosedByDefault: true,
+    recordEncoding: 'array-of-pairs',
+    tupleEncoding: 'object-numeric-keys',
+    allowAllOf: false,
+    allowAnyOf: true,
+    allowOneOf: false,
+    allowRootRef: true,
+    allowDefsRef: true,
+    emitPropertyOrdering: false,
+    supportedStringFormats: OPENAI_STRICT_FORMATS,
+    allowPattern: true,
+    allowMultiplePatterns: false,
+    allowMinMaxLength: true,
+    allowMinMaxItems: true,
+    allowMinimumMaximum: true,
+    optionalAsNullable: true,
+    anyEncoding: 'recursive-strict',
+    supportsRecursion: true,
+    // Every number is quoted from OpenAI's own "Supported schemas" section — see
+    // the descriptor doc above for the exact sentences and the date they were
+    // read. Frozen because `Object.freeze` on the descriptor is shallow.
+    schemaSizeLimits: Object.freeze({
+        maxObjectProperties: 5000,
+        maxNestingDepth: 10,
+        maxTotalStringChars: 120_000,
+        maxTotalEnumValues: 1000,
+        largeEnumValueCount: 250,
+        maxLargeEnumStringChars: 15_000,
+    }),
+});
+/** OpenAI non-strict — alias of LENIENT but tagged with the openai family. */
+export const OPENAI_NON_STRICT = Object.freeze({
+    ...LENIENT,
+    id: 'openai-non-strict',
+    family: 'openai',
+});
+//# sourceMappingURL=openai.js.map

package/dist/schema/dialects/openai.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai.js","sourceRoot":"","sources":["../../../src/schema/dialects/openai.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,MAAM,qBAAqB,GAAG,IAAI,GAAG,CAAC;IACpC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CACrF,CAAC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,CAAC,MAAM,aAAa,GAAqB,MAAM,CAAC,MAAM,CAAC;IAC3D,EAAE,EAAE,eAAe;IACnB,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,IAAI;IACZ,uBAAuB,EAAE,IAAI;IAC7B,qBAAqB,EAAE,IAAI;IAC3B,cAAc,EAAE,gBAAgB;IAChC,aAAa,EAAE,qBAAqB;IACpC,UAAU,EAAE,KAAK;IACjB,UAAU,EAAE,IAAI;IAChB,UAAU,EAAE,KAAK;IACjB,YAAY,EAAE,IAAI;IAClB,YAAY,EAAE,IAAI;IAClB,oBAAoB,EAAE,KAAK;IAC3B,sBAAsB,EAAE,qBAAqB;IAC7C,YAAY,EAAE,IAAI;IAClB,qBAAqB,EAAE,KAAK;IAC5B,iBAAiB,EAAE,IAAI;IACvB,gBAAgB,EAAE,IAAI;IACtB,mBAAmB,EAAE,IAAI;IACzB,kBAAkB,EAAE,IAAI;IACxB,WAAW,EAAE,kBAAkB;IAC/B,iBAAiB,EAAE,IAAI;IACvB,6EAA6E;IAC7E,0EAA0E;IAC1E,qEAAqE;IACrE,gBAAgB,EAAE,MAAM,CAAC,MAAM,CAAC;QAC9B,mBAAmB,EAAE,IAAI;QACzB,eAAe,EAAE,EAAE;QACnB,mBAAmB,EAAE,OAAO;QAC5B,kBAAkB,EAAE,IAAI;QACxB,mBAAmB,EAAE,GAAG;QACxB,uBAAuB,EAAE,MAAM;KAChC,CAAC;CACH,CAAC,CAAC;AAEH,8EAA8E;AAC9E,MAAM,CAAC,MAAM,iBAAiB,GAAqB,MAAM,CAAC,MAAM,CAAC;IAC/D,GAAG,OAAO;IACV,EAAE,EAAE,mBAAmB;IACvB,MAAM,EAAE,QAAQ;CACjB,CAAC,CAAC"}

package/dist/schema/dialects/xai.d.ts

@@ -0,0 +1,23 @@
+import type { FormatDescriptor } from '../descriptor';
+/**
+ * xAI (Grok) strict — per `docs.x.ai/docs/guides/structured-outputs`
+ * (read 2026-10-30). Tool calls are always strict on Grok 4 models.
+ *
+ * - Supported (re-read 2026-11-04): `anyOf`, `oneOf`, non-circular `$ref` /
+ *   `$defs`, `prefixItems` for tuples (array-form `items` is rejected),
+ *   `enum`, `const`, string formats (below), `pattern` without
+ *   backreferences or lookaround, and length / item / numeric bounds.
+ * - `allOf` is enforced only with a single subschema (more are best-effort),
+ *   so it stays off.
+ * - Array-form `items`, boolean property schemas, empty `enum`/`anyOf` and
+ *   `minContains`/`maxContains` are rejected; the emitter produces none.
+ * - Optional properties stay optional; `additionalProperties` defaults to
+ *   `false`, and schema-valued records were accepted live.
+ * - Circular references are documented as unsupported, so recursion goes
+ *   through the cycle breaker. Every other keyword above was accepted live
+ *   on `x-ai/grok-4.3` via OpenRouter on 2026-10-30.
+ */
+export declare const XAI_STRICT: FormatDescriptor;
+/** xAI non-strict — alias of LENIENT but tagged with the xai family. */
+export declare const XAI_NON_STRICT: FormatDescriptor;
+//# sourceMappingURL=xai.d.ts.map

package/dist/schema/dialects/xai.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xai.d.ts","sourceRoot":"","sources":["../../../src/schema/dialects/xai.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAOtD;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,UAAU,EAAE,gBAuBvB,CAAC;AAEH,wEAAwE;AACxE,eAAO,MAAM,cAAc,EAAE,gBAI3B,CAAC"}

package/dist/schema/dialects/xai.js

@@ -0,0 +1,53 @@
+import { LENIENT } from './lenient';
+const XAI_STRICT_FORMATS = new Set([
+    'date', 'time', 'date-time', 'email', 'uuid', 'ipv4', 'ipv6', 'uri',
+]);
+/**
+ * xAI (Grok) strict — per `docs.x.ai/docs/guides/structured-outputs`
+ * (read 2026-10-30). Tool calls are always strict on Grok 4 models.
+ *
+ * - Supported (re-read 2026-11-04): `anyOf`, `oneOf`, non-circular `$ref` /
+ *   `$defs`, `prefixItems` for tuples (array-form `items` is rejected),
+ *   `enum`, `const`, string formats (below), `pattern` without
+ *   backreferences or lookaround, and length / item / numeric bounds.
+ * - `allOf` is enforced only with a single subschema (more are best-effort),
+ *   so it stays off.
+ * - Array-form `items`, boolean property schemas, empty `enum`/`anyOf` and
+ *   `minContains`/`maxContains` are rejected; the emitter produces none.
+ * - Optional properties stay optional; `additionalProperties` defaults to
+ *   `false`, and schema-valued records were accepted live.
+ * - Circular references are documented as unsupported, so recursion goes
+ *   through the cycle breaker. Every other keyword above was accepted live
+ *   on `x-ai/grok-4.3` via OpenRouter on 2026-10-30.
+ */
+export const XAI_STRICT = Object.freeze({
+    id: 'xai-strict',
+    family: 'xai',
+    strict: true,
+    objectAllFieldsRequired: false,
+    objectClosedByDefault: true,
+    recordEncoding: 'open-record',
+    tupleEncoding: 'prefix-items',
+    allowAllOf: false,
+    allowAnyOf: true,
+    allowOneOf: true,
+    allowRootRef: false,
+    allowDefsRef: true,
+    emitPropertyOrdering: false,
+    supportedStringFormats: XAI_STRICT_FORMATS,
+    allowPattern: true,
+    allowMultiplePatterns: false,
+    allowMinMaxLength: true,
+    allowMinMaxItems: true,
+    allowMinimumMaximum: true,
+    optionalAsNullable: false,
+    anyEncoding: 'flat',
+    supportsRecursion: false,
+});
+/** xAI non-strict — alias of LENIENT but tagged with the xai family. */
+export const XAI_NON_STRICT = Object.freeze({
+    ...LENIENT,
+    id: 'xai-non-strict',
+    family: 'xai',
+});
+//# sourceMappingURL=xai.js.map

package/dist/schema/dialects/xai.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"xai.js","sourceRoot":"","sources":["../../../src/schema/dialects/xai.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,MAAM,kBAAkB,GAAG,IAAI,GAAG,CAAC;IACjC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK;CACpE,CAAC,CAAC;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,UAAU,GAAqB,MAAM,CAAC,MAAM,CAAC;IACxD,EAAE,EAAE,YAAY;IAChB,MAAM,EAAE,KAAK;IACb,MAAM,EAAE,IAAI;IACZ,uBAAuB,EAAE,KAAK;IAC9B,qBAAqB,EAAE,IAAI;IAC3B,cAAc,EAAE,aAAa;IAC7B,aAAa,EAAE,cAAc;IAC7B,UAAU,EAAE,KAAK;IACjB,UAAU,EAAE,IAAI;IAChB,UAAU,EAAE,IAAI;IAChB,YAAY,EAAE,KAAK;IACnB,YAAY,EAAE,IAAI;IAClB,oBAAoB,EAAE,KAAK;IAC3B,sBAAsB,EAAE,kBAAkB;IAC1C,YAAY,EAAE,IAAI;IAClB,qBAAqB,EAAE,KAAK;IAC5B,iBAAiB,EAAE,IAAI;IACvB,gBAAgB,EAAE,IAAI;IACtB,mBAAmB,EAAE,IAAI;IACzB,kBAAkB,EAAE,KAAK;IACzB,WAAW,EAAE,MAAM;IACnB,iBAAiB,EAAE,KAAK;CACzB,CAAC,CAAC;AAEH,wEAAwE;AACxE,MAAM,CAAC,MAAM,cAAc,GAAqB,MAAM,CAAC,MAAM,CAAC;IAC5D,GAAG,OAAO;IACV,EAAE,EAAE,gBAAgB;IACpB,MAAM,EAAE,KAAK;CACd,CAAC,CAAC"}

package/dist/schema/enum-values.d.ts

@@ -0,0 +1,44 @@
+import z from 'zod';
+import type { FormatDescriptor } from './descriptor';
+/**
+ * The values a `z.enum` actually EMITS as JSON-Schema `enum` members.
+ *
+ * A numeric TypeScript enum compiles to a two-way map (`{A: 0, 0: 'A'}`), so
+ * the reverse-mapping keys have to be dropped or every value appears twice.
+ * Shared with `analyzeSchema` deliberately: the size budget counts what goes on
+ * the wire, and "what goes on the wire" must have ONE definition (a second
+ * copy of this filter would drift from the emitter it is supposed to measure).
+ */
+export declare function enumEmittedValues(schema: z.ZodEnum): unknown[];
+/**
+ * The values a `z.literal` emits — one for the `const` form, several for the
+ * multi-value form that emits `enum`. Types JSON Schema cannot carry
+ * (functions, symbols, bigints, `undefined`) are dropped, matching the
+ * emitter. Shared with `analyzeSchema` for the same reason as above.
+ */
+export declare function literalEmittedValues(schema: z.ZodLiteral): unknown[];
+/**
+ * Decide whether a set of values may be emitted as a JSON-Schema `enum` under
+ * this descriptor, per `maxEnumValues`.
+ *
+ * Under the cap (or with no cap declared) the caller emits its `enum` as
+ * normal. Over it, the caller emits NO `enum` — just the widened `type` — and
+ * attaches `note`, which lists EVERY value in prose.
+ *
+ * Widening rather than truncating is the deliberate choice, and the two differ
+ * in what the model can still say. A truncated `enum` makes the values past the
+ * cap **unreachable**: the wire schema constrains them away, so a caller whose
+ * 96 values are all legitimately selectable loses 56 of them. Widening removes
+ * the wire-level constraint that the dialect can't compile in the first place
+ * and moves the full list into the `description`, so the model retains complete
+ * information and can name any of the 96. Nothing is hidden — it is described
+ * instead of enforced, and enforcement moves to whatever validates the value
+ * afterwards (`Tool.parse` against the ORIGINAL zod schema still rejects a name
+ * that was never in the enum, with a message the model can act on).
+ *
+ * The note is deliberately DOMAIN-NEUTRAL. This library has no idea what the
+ * values mean; whichever caller relies on the cap (a session's known-name enum,
+ * a country list, anything) reads its own semantics into them.
+ */
+export declare function describeOversizeEnum(values: readonly unknown[], descriptor: FormatDescriptor): string | undefined;
+//# sourceMappingURL=enum-values.d.ts.map

package/dist/schema/enum-values.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enum-values.d.ts","sourceRoot":"","sources":["../../src/schema/enum-values.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AACpB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAErD;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,GAAG,OAAO,EAAE,CAK9D;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,CAAC,CAAC,UAAU,GAAG,OAAO,EAAE,CAIpE;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,EAAE,UAAU,EAAE,gBAAgB,GAAG,MAAM,GAAG,SAAS,CAMjH"}

package/dist/schema/enum-values.js

@@ -0,0 +1,56 @@
+/**
+ * The values a `z.enum` actually EMITS as JSON-Schema `enum` members.
+ *
+ * A numeric TypeScript enum compiles to a two-way map (`{A: 0, 0: 'A'}`), so
+ * the reverse-mapping keys have to be dropped or every value appears twice.
+ * Shared with `analyzeSchema` deliberately: the size budget counts what goes on
+ * the wire, and "what goes on the wire" must have ONE definition (a second
+ * copy of this filter would drift from the emitter it is supposed to measure).
+ */
+export function enumEmittedValues(schema) {
+    const numericValues = Object.values(schema.def.entries).filter((v) => typeof v === 'number');
+    return Object.entries(schema.def.entries)
+        .filter(([k]) => numericValues.indexOf(+k) === -1)
+        .map(([, v]) => v);
+}
+/**
+ * The values a `z.literal` emits — one for the `const` form, several for the
+ * multi-value form that emits `enum`. Types JSON Schema cannot carry
+ * (functions, symbols, bigints, `undefined`) are dropped, matching the
+ * emitter. Shared with `analyzeSchema` for the same reason as above.
+ */
+export function literalEmittedValues(schema) {
+    return Array.from(schema.values).filter((v) => v !== undefined && typeof v !== 'function' && typeof v !== 'symbol' && typeof v !== 'bigint');
+}
+/**
+ * Decide whether a set of values may be emitted as a JSON-Schema `enum` under
+ * this descriptor, per `maxEnumValues`.
+ *
+ * Under the cap (or with no cap declared) the caller emits its `enum` as
+ * normal. Over it, the caller emits NO `enum` — just the widened `type` — and
+ * attaches `note`, which lists EVERY value in prose.
+ *
+ * Widening rather than truncating is the deliberate choice, and the two differ
+ * in what the model can still say. A truncated `enum` makes the values past the
+ * cap **unreachable**: the wire schema constrains them away, so a caller whose
+ * 96 values are all legitimately selectable loses 56 of them. Widening removes
+ * the wire-level constraint that the dialect can't compile in the first place
+ * and moves the full list into the `description`, so the model retains complete
+ * information and can name any of the 96. Nothing is hidden — it is described
+ * instead of enforced, and enforcement moves to whatever validates the value
+ * afterwards (`Tool.parse` against the ORIGINAL zod schema still rejects a name
+ * that was never in the enum, with a message the model can act on).
+ *
+ * The note is deliberately DOMAIN-NEUTRAL. This library has no idea what the
+ * values mean; whichever caller relies on the cap (a session's known-name enum,
+ * a country list, anything) reads its own semantics into them.
+ */
+export function describeOversizeEnum(values, descriptor) {
+    const cap = descriptor.maxEnumValues;
+    if (cap === undefined || values.length <= cap)
+        return undefined;
+    // A flat comma-separated list: it is how an enum reads in prose anyway, and
+    // the values are single tokens by construction (they were `enum` members).
+    return `One of these ${values.length} values: ${values.map((v) => String(v)).join(', ')}`;
+}
+//# sourceMappingURL=enum-values.js.map

package/dist/schema/enum-values.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enum-values.js","sourceRoot":"","sources":["../../src/schema/enum-values.ts"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,MAAM,UAAU,iBAAiB,CAAC,MAAiB;IACjD,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC;IAC7F,OAAO,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC;SACtC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;SACjD,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;AACvB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,oBAAoB,CAAC,MAAoB;IACvD,OAAO,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,MAAM,CACrC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,SAAS,IAAI,OAAO,CAAC,KAAK,UAAU,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,OAAO,CAAC,KAAK,QAAQ,CACpG,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,UAAU,oBAAoB,CAAC,MAA0B,EAAE,UAA4B;IAC3F,MAAM,GAAG,GAAG,UAAU,CAAC,aAAa,CAAC;IACrC,IAAI,GAAG,KAAK,SAAS,IAAI,MAAM,CAAC,MAAM,IAAI,GAAG;QAAE,OAAO,SAAS,CAAC;IAChE,4EAA4E;IAC5E,2EAA2E;IAC3E,OAAO,gBAAgB,MAAM,CAAC,MAAM,YAAY,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;AAC5F,CAAC"}

package/dist/schema/expressible.d.ts

@@ -0,0 +1,59 @@
+import z from 'zod';
+import type { FormatDescriptor } from './descriptor';
+/**
+ * Decide whether `schema` can be expressed as structured output under
+ * `descriptor`'s JSON-Schema dialect. Returns `false` when the schema uses a
+ * construct the descriptor forbids, so the caller can DROP the wire schema and
+ * deliver it as prompt text instead (see the ai-layer
+ * `applySchemaDeliveryFallback`).
+ *
+ * Walks the Zod schema in the same style as `strictify`/`convert`, honoring:
+ * - **unions** (`z.union` / `z.discriminatedUnion` → `anyOf`) when
+ *   `!descriptor.allowAnyOf` (e.g. Gemini strict rejects `anyOf`);
+ * - **intersections** (`z.intersection` → `allOf`) when `!descriptor.allowAllOf`;
+ * - **recursion** (a self-referential `z.lazy` cycle → `$ref`): a cycle back to
+ *   the ROOT is fine when `descriptor.allowRootRef && descriptor.supportsRecursion`
+ *   (Gemini supports `$ref: '#'`); a non-root cycle needs
+ *   `descriptor.allowDefsRef && descriptor.supportsRecursion`.
+ *
+ * `ZodNullable` / `ZodOptional` are transparent wrappers here (nullability is
+ * NOT treated as a union), so only genuine `z.union(...)` trips `allowAnyOf`.
+ * Non-combinator, non-recursive schemas (plain objects, arrays, primitives)
+ * are always expressible. The structure mirrors the descriptor flags so more
+ * feasibility checks are easy to add.
+ *
+ * Under a descriptor with `structuredOutputAlwaysStrict` the schema must also
+ * fit the strict limits on its own — the per-schema size limits and the
+ * per-request optional-parameter and union budgets — because that family has
+ * no non-strict structured output to degrade to.
+ */
+export declare function canExpress(schema: z.ZodType | z.core.$ZodType, descriptor: FormatDescriptor): boolean;
+/**
+ * Whether `schema`, as the only strict schema in a request, stays inside the
+ * descriptor's size limits and per-request budgets.
+ */
+export declare function fitsStrictAlone(schema: z.ZodType | z.core.$ZodType, descriptor: FormatDescriptor): boolean;
+/**
+ * `canExpress`, except that a cycle counts as EXPRESSIBLE whatever the
+ * descriptor's ref flags say, because `emitCachedRef` replaces any back-edge
+ * the descriptor cannot spell with the bounded `buildCycleBreakerSchema`
+ * placeholder. The emitted schema is therefore always *sendable*; it is only
+ * *looser* than the source at the back-edge.
+ *
+ * That distinction is the whole reason there are two predicates:
+ * - `canExpress` answers "will the model be properly CONSTRAINED by this?",
+ *   which is what a structured-OUTPUT delivery decision needs — a back-edge
+ *   silently widened to "any" is a good reason to deliver the schema as prompt
+ *   text instead (`applySchemaDeliveryFallback`), and
+ *   `ANTHROPIC_STRICT`'s `supportsRecursion: false` is exactly that case.
+ * - this one answers "will the provider REJECT this?", which is what a TOOL's
+ *   strict allocation needs. A tool has no prompt-text fallback, so degrading a
+ *   merely-loose schema to LENIENT would trade a real strict guarantee for
+ *   nothing.
+ *
+ * The combinator half is shared and is the half that actually bites: nothing
+ * rewrites a forbidden `anyOf`/`allOf` away, so a schema carrying one is a
+ * provider 400 under a descriptor that forbids it.
+ */
+export declare function sendableUnder(schema: z.ZodType | z.core.$ZodType, descriptor: FormatDescriptor): boolean;
+//# sourceMappingURL=expressible.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"expressible.d.ts","sourceRoot":"","sources":["../../src/schema/expressible.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AACpB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAIrD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,IAAI,CAAC,QAAQ,EACnC,UAAU,EAAE,gBAAgB,GAC3B,OAAO,CAGT;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,IAAI,CAAC,QAAQ,EAAE,UAAU,EAAE,gBAAgB,GAAG,OAAO,CAK1G;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,IAAI,CAAC,QAAQ,EACnC,UAAU,EAAE,gBAAgB,GAC3B,OAAO,CAET"}

package/dist/schema/expressible.js

@@ -0,0 +1,161 @@
+import z from 'zod';
+import { walkKey } from './walk-key';
+import { analyzeSchema, checkSchemaSizeLimits } from './analyze';
+/**
+ * Decide whether `schema` can be expressed as structured output under
+ * `descriptor`'s JSON-Schema dialect. Returns `false` when the schema uses a
+ * construct the descriptor forbids, so the caller can DROP the wire schema and
+ * deliver it as prompt text instead (see the ai-layer
+ * `applySchemaDeliveryFallback`).
+ *
+ * Walks the Zod schema in the same style as `strictify`/`convert`, honoring:
+ * - **unions** (`z.union` / `z.discriminatedUnion` → `anyOf`) when
+ *   `!descriptor.allowAnyOf` (e.g. Gemini strict rejects `anyOf`);
+ * - **intersections** (`z.intersection` → `allOf`) when `!descriptor.allowAllOf`;
+ * - **recursion** (a self-referential `z.lazy` cycle → `$ref`): a cycle back to
+ *   the ROOT is fine when `descriptor.allowRootRef && descriptor.supportsRecursion`
+ *   (Gemini supports `$ref: '#'`); a non-root cycle needs
+ *   `descriptor.allowDefsRef && descriptor.supportsRecursion`.
+ *
+ * `ZodNullable` / `ZodOptional` are transparent wrappers here (nullability is
+ * NOT treated as a union), so only genuine `z.union(...)` trips `allowAnyOf`.
+ * Non-combinator, non-recursive schemas (plain objects, arrays, primitives)
+ * are always expressible. The structure mirrors the descriptor flags so more
+ * feasibility checks are easy to add.
+ *
+ * Under a descriptor with `structuredOutputAlwaysStrict` the schema must also
+ * fit the strict limits on its own — the per-schema size limits and the
+ * per-request optional-parameter and union budgets — because that family has
+ * no non-strict structured output to degrade to.
+ */
+export function canExpress(schema, descriptor) {
+    return expressible(schema, descriptor, /* cycleBreakerCounts */ false)
+        && (!descriptor.structuredOutputAlwaysStrict || fitsStrictAlone(schema, descriptor));
+}
+/**
+ * Whether `schema`, as the only strict schema in a request, stays inside the
+ * descriptor's size limits and per-request budgets.
+ */
+export function fitsStrictAlone(schema, descriptor) {
+    const features = analyzeSchema(schema);
+    return checkSchemaSizeLimits(schema, descriptor).length === 0
+        && features.optionalParameterCount <= (descriptor.maxStrictOptionalParams ?? Infinity)
+        && features.unionTypeCount <= (descriptor.maxStrictUnionTypes ?? Infinity);
+}
+/**
+ * `canExpress`, except that a cycle counts as EXPRESSIBLE whatever the
+ * descriptor's ref flags say, because `emitCachedRef` replaces any back-edge
+ * the descriptor cannot spell with the bounded `buildCycleBreakerSchema`
+ * placeholder. The emitted schema is therefore always *sendable*; it is only
+ * *looser* than the source at the back-edge.
+ *
+ * That distinction is the whole reason there are two predicates:
+ * - `canExpress` answers "will the model be properly CONSTRAINED by this?",
+ *   which is what a structured-OUTPUT delivery decision needs — a back-edge
+ *   silently widened to "any" is a good reason to deliver the schema as prompt
+ *   text instead (`applySchemaDeliveryFallback`), and
+ *   `ANTHROPIC_STRICT`'s `supportsRecursion: false` is exactly that case.
+ * - this one answers "will the provider REJECT this?", which is what a TOOL's
+ *   strict allocation needs. A tool has no prompt-text fallback, so degrading a
+ *   merely-loose schema to LENIENT would trade a real strict guarantee for
+ *   nothing.
+ *
+ * The combinator half is shared and is the half that actually bites: nothing
+ * rewrites a forbidden `anyOf`/`allOf` away, so a schema carrying one is a
+ * provider 400 under a descriptor that forbids it.
+ */
+export function sendableUnder(schema, descriptor) {
+    return expressible(schema, descriptor, /* cycleBreakerCounts */ true);
+}
+function expressible(schema, descriptor, cycleBreakerCounts) {
+    // Keys, not objects — a rebuilt `z.lazy` getter defeats identity (see `walkKey`).
+    const rootKey = walkKey(schema);
+    // Nodes currently on the DFS stack — a re-encounter is a recursion cycle.
+    const inProgress = new Set();
+    // Completed nodes with their result, so shared (non-cyclic) sub-schemas
+    // aren't re-walked (guards against exponential blow-up on DAG-shaped schemas).
+    const completed = new Map();
+    const walk = (s) => {
+        const key = walkKey(s);
+        if (inProgress.has(key)) {
+            // Recursion cycle detected at `s`. The placeholder that makes a cycle
+            // sendable bottoms out at "any", which a `none` dialect cannot spell.
+            if (cycleBreakerCounts)
+                return descriptor.anyEncoding !== 'none';
+            if (key === rootKey)
+                return descriptor.allowRootRef && descriptor.supportsRecursion;
+            return descriptor.allowDefsRef && descriptor.supportsRecursion;
+        }
+        const cached = completed.get(key);
+        if (cached !== undefined)
+            return cached;
+        inProgress.add(key);
+        const result = walkNode(s);
+        inProgress.delete(key);
+        completed.set(key, result);
+        return result;
+    };
+    const walkNode = (s) => {
+        // ---- Transparent wrappers: recurse into the inner type ----
+        if (s instanceof z.ZodOptional || s instanceof z.ZodNullable)
+            return walk(s.unwrap());
+        if (s instanceof z.ZodDefault)
+            return walk(s._zod.def.innerType);
+        if (s instanceof z.ZodPrefault)
+            return walk(s._zod.def.innerType);
+        if (s instanceof z.ZodCatch)
+            return walk(s._zod.def.innerType);
+        if (s instanceof z.ZodReadonly)
+            return walk(s._zod.def.innerType);
+        if (s instanceof z.ZodNonOptional)
+            return walk(s._zod.def.innerType);
+        if (s instanceof z.ZodLazy)
+            return walk(s._zod.def.getter());
+        // ZodCodec must be checked before ZodPipe (it's a ZodPipe subclass in v4).
+        if (s instanceof z.ZodCodec)
+            return walk(s._zod.def.in) && walk(s._zod.def.out);
+        if (s instanceof z.ZodPipe)
+            return walk(s._zod.def.in) && walk(s._zod.def.out);
+        // ---- Combinators (the ones that actually bite) ----
+        // ZodDiscriminatedUnion is a ZodUnion subclass in v4, so this covers both.
+        if (s instanceof z.ZodUnion) {
+            if (!descriptor.allowAnyOf)
+                return false;
+            return s.options.every(walk);
+        }
+        if (s instanceof z.ZodIntersection) {
+            if (!descriptor.allowAllOf)
+                return false;
+            return walk(s._zod.def.left) && walk(s._zod.def.right);
+        }
+        // ---- Containers: recurse so nested combinators/cycles are reached ----
+        if (s instanceof z.ZodObject) {
+            for (const key in s.shape) {
+                if (!walk(s.shape[key]))
+                    return false;
+            }
+            return true;
+        }
+        if (s instanceof z.ZodArray)
+            return walk(s._zod.def.element);
+        if (s instanceof z.ZodTuple) {
+            for (const item of s._zod.def.items) {
+                if (!walk(item))
+                    return false;
+            }
+            return s._zod.def.rest ? walk(s._zod.def.rest) : true;
+        }
+        if (s instanceof z.ZodRecord)
+            return walk(s._zod.def.valueType);
+        if (s instanceof z.ZodMap)
+            return walk(s._zod.def.keyType) && walk(s._zod.def.valueType);
+        if (s instanceof z.ZodSet)
+            return walk(s._zod.def.valueType);
+        if (s instanceof z.ZodAny || s instanceof z.ZodUnknown)
+            return descriptor.anyEncoding !== 'none';
+        // ---- Leaves / anything without forbidden substructure ----
+        return true;
+    };
+    return walk(schema);
+}
+//# sourceMappingURL=expressible.js.map

package/dist/schema/expressible.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"expressible.js","sourceRoot":"","sources":["../../src/schema/expressible.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACrC,OAAO,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAC;AAEjE;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,UAAU,UAAU,CACxB,MAAmC,EACnC,UAA4B;IAE5B,OAAO,WAAW,CAAC,MAAM,EAAE,UAAU,EAAE,wBAAwB,CAAC,KAAK,CAAC;WACjE,CAAC,CAAC,UAAU,CAAC,4BAA4B,IAAI,eAAe,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC;AACzF,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,eAAe,CAAC,MAAmC,EAAE,UAA4B;IAC/F,MAAM,QAAQ,GAAG,aAAa,CAAC,MAAM,CAAC,CAAC;IACvC,OAAO,qBAAqB,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,MAAM,KAAK,CAAC;WACxD,QAAQ,CAAC,sBAAsB,IAAI,CAAC,UAAU,CAAC,uBAAuB,IAAI,QAAQ,CAAC;WACnF,QAAQ,CAAC,cAAc,IAAI,CAAC,UAAU,CAAC,mBAAmB,IAAI,QAAQ,CAAC,CAAC;AAC/E,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,aAAa,CAC3B,MAAmC,EACnC,UAA4B;IAE5B,OAAO,WAAW,CAAC,MAAM,EAAE,UAAU,EAAE,wBAAwB,CAAC,IAAI,CAAC,CAAC;AACxE,CAAC;AAED,SAAS,WAAW,CAClB,MAAmC,EACnC,UAA4B,EAC5B,kBAA2B;IAE3B,kFAAkF;IAClF,MAAM,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAChC,0EAA0E;IAC1E,MAAM,UAAU,GAAG,IAAI,GAAG,EAAwC,CAAC;IACnE,wEAAwE;IACxE,+EAA+E;IAC/E,MAAM,SAAS,GAAG,IAAI,GAAG,EAAiD,CAAC;IAE3E,MAAM,IAAI,GAAG,CAAC,CAA8B,EAAW,EAAE;QACvD,MAAM,GAAG,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;QACvB,IAAI,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YACxB,sEAAsE;YACtE,sEAAsE;YACtE,IAAI,kBAAkB;gBAAE,OAAO,UAAU,CAAC,WAAW,KAAK,MAAM,CAAC;YACjE,IAAI,GAAG,KAAK,OAAO;gBAAE,OAAO,UAAU,CAAC,YAAY,IAAI,UAAU,CAAC,iBAAiB,CAAC;YACpF,OAAO,UAAU,CAAC,YAAY,IAAI,UAAU,CAAC,iBAAiB,CAAC;QACjE,CAAC;QACD,MAAM,MAAM,GAAG,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAClC,IAAI,MAAM,KAAK,SAAS;YAAE,OAAO,MAAM,CAAC;QAExC,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACpB,MAAM,MAAM,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;QAC3B,UAAU,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QACvB,SAAS,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;QAC3B,OAAO,MAAM,CAAC;IAChB,CAAC,CAAC;IAEF,MAAM,QAAQ,GAAG,CAAC,CAA8B,EAAW,EAAE;QAC3D,8DAA8D;QAC9D,IAAI,CAAC,YAAY,CAAC,CAAC,WAAW,IAAI,CAAC,YAAY,CAAC,CAAC,WAAW;YAAE,OAAO,IAAI,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC;QACtF,IAAI,CAAC,YAAY,CAAC,CAAC,UAAU;YAAE,OAAO,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QACjE,IAAI,CAAC,YAAY,CAAC,CAAC,WAAW;YAAE,OAAO,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAClE,IAAI,CAAC,YAAY,CAAC,CAAC,QAAQ;YAAE,OAAO,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAC/D,IAAI,CAAC,YAAY,CAAC,CAAC,WAAW;YAAE,OAAO,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAClE,IAAI,CAAC,YAAY,CAAC,CAAC,cAAc;YAAE,OAAO,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QACrE,IAAI,CAAC,YAAY,CAAC,CAAC,OAAO;YAAE,OAAO,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC;QAC7D,2EAA2E;QAC3E,IAAI,CAAC,YAAY,CAAC,CAAC,QAAQ;YAAE,OAAO,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAChF,IAAI,CAAC,YAAY,CAAC,CAAC,OAAO;YAAE,OAAO,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAE/E,sDAAsD;QACtD,2EAA2E;QAC3E,IAAI,CAAC,YAAY,CAAC,CAAC,QAAQ,EAAE,CAAC;YAC5B,IAAI,CAAC,UAAU,CAAC,UAAU;gBAAE,OAAO,KAAK,CAAC;YACzC,OAAQ,CAAC,CAAC,OAAoD,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAC7E,CAAC;QACD,IAAI,CAAC,YAAY,CAAC,CAAC,eAAe,EAAE,CAAC;YACnC,IAAI,CAAC,UAAU,CAAC,UAAU;gBAAE,OAAO,KAAK,CAAC;YACzC,OAAO,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACzD,CAAC;QAED,yEAAyE;QACzE,IAAI,CAAC,YAAY,CAAC,CAAC,SAAS,EAAE,CAAC;YAC7B,KAAK,MAAM,GAAG,IAAI,CAAC,CAAC,KAAK,EAAE,CAAC;gBAC1B,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;oBAAE,OAAO,KAAK,CAAC;YACxC,CAAC;YACD,OAAO,IAAI,CAAC;QACd,CAAC;QACD,IAAI,CAAC,YAAY,CAAC,CAAC,QAAQ;YAAE,OAAO,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QAC7D,IAAI,CAAC,YAAY,CAAC,CAAC,QAAQ,EAAE,CAAC;YAC5B,KAAK,MAAM,IAAI,IAAI,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC;gBACpC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC;oBAAE,OAAO,KAAK,CAAC;YAChC,CAAC;YACD,OAAO,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QACxD,CAAC;QACD,IAAI,CAAC,YAAY,CAAC,CAAC,SAAS;YAAE,OAAO,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAChE,IAAI,CAAC,YAAY,CAAC,CAAC,MAAM;YAAE,OAAO,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QACzF,IAAI,CAAC,YAAY,CAAC,CAAC,MAAM;YAAE,OAAO,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAE7D,IAAI,CAAC,YAAY,CAAC,CAAC,MAAM,IAAI,CAAC,YAAY,CAAC,CAAC,UAAU;YAAE,OAAO,UAAU,CAAC,WAAW,KAAK,MAAM,CAAC;QAEjG,6DAA6D;QAC7D,OAAO,IAAI,CAAC;IACd,CAAC,CAAC;IAEF,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC;AACtB,CAAC"}

package/dist/schema/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Zod → provider JSON Schema: dialect descriptors, the strictify / decode
+ * round trip, the emitter, and the per-request strict budget.
+ */
+export * from './descriptor';
+export * from './dialects/lenient';
+export * from './dialects/openai';
+export * from './dialects/anthropic';
+export * from './dialects/google';
+export * from './dialects/xai';
+export * from './consistency';
+export * from './registry';
+export { canExpress } from './expressible';
+export * from './strictify';
+export * from './decode';
+export * from './json-schema';
+export * from './to-json-schema';
+export * from './analyze';
+export * from './budget';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schema/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,cAAc,cAAc,CAAC;AAC7B,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC;AACjC,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC"}

package/dist/schema/index.js

@@ -0,0 +1,20 @@
+/**
+ * Zod → provider JSON Schema: dialect descriptors, the strictify / decode
+ * round trip, the emitter, and the per-request strict budget.
+ */
+export * from './descriptor';
+export * from './dialects/lenient';
+export * from './dialects/openai';
+export * from './dialects/anthropic';
+export * from './dialects/google';
+export * from './dialects/xai';
+export * from './consistency';
+export * from './registry';
+export { canExpress } from './expressible';
+export * from './strictify';
+export * from './decode';
+export * from './json-schema';
+export * from './to-json-schema';
+export * from './analyze';
+export * from './budget';
+//# sourceMappingURL=index.js.map

package/dist/schema/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/schema/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,cAAc,cAAc,CAAC;AAC7B,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC;AACjC,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC"}