@vectoriox/iox-ui 5.61.0 → 5.62.1

package/src/generation-core/strict-schema.ts

@@ -9,12 +9,26 @@ import type { JsonSchema } from './json-schema';
  * The limits are per REQUEST — every strict schema in it together. The ONE counter: the specs hold every schema iox-cms
  * sends to it, and the fake Claude API refuses with it exactly as Claude does — the plan stage once sent 213 optional
  * parameters and every suite stayed green because the fake accepted anything (vectoriox/iox-cms#45).
+ *
+ * Beyond those, Claude refuses a grammar it compiles too large — a limit the docs name ("additional internal limits on
+ * the compiled grammar size") without a number. MEASURED against the API on 2026-10-27 (vectoriox/iox-cms#47): the
+ * total number of properties decides it, not enums or descriptions — 64 and 61 properties refused, 53 and fewer
+ * accepted (53 already took ~9 s to compile). So 60 is the line we refuse above, and 40 is what we send.
  */
 
-export const STRICT_SCHEMA_LIMITS = { strictTools: 20, optional: 24, unions: 16 } as const;
+export const STRICT_SCHEMA_LIMITS = {
+    strictTools: 20,
+    optional: 24,
+    unions: 16,
+    /** MEASURED, not documented (2026-10-27): the smallest refused request held 61 properties, the largest accepted 53. */
+    properties: 60,
+} as const;
 
-/** What a schema iox-cms sends may use — half of each limit, so a step can gain a field (or a strict tool) without a 400. */
-export const STRICT_SCHEMA_BUDGET = { optional: 12, unions: 8 } as const;
+/**
+ * What one request iox-cms sends may use: half of each documented limit, so a step can gain a field (or a strict tool)
+ * without a 400 — and 40 properties, a third under the measured grammar line, where compiling stays a few seconds.
+ */
+export const STRICT_SCHEMA_BUDGET = { optional: 12, unions: 8, properties: 40 } as const;
 
 export interface StrictSchemaComplexity {
     /** Properties not listed in their object's `required`, every object of every schema. */
@@ -23,6 +37,10 @@ export interface StrictSchemaComplexity {
     unions: number;
     /** Tools with `strict: true` (a JSON output format is not a tool). */
     strictTools: number;
+    /** Every key of every object's `properties`, at every depth — what the compiled grammar's size follows. */
+    properties: number;
+    /** Objects that declare `properties`. */
+    objects: number;
     /** What the strict mode does not support, each with its path (`pages.items.properties.route: minLength`). */
     unsupported: string[];
 }
@@ -45,6 +63,8 @@ function count(node: unknown, path: string, out: StrictSchemaComplexity): void {
     if (node['type'] === 'object' || properties) {
         const required = new Set(Array.isArray(node['required']) ? (node['required'] as string[]) : []);
         out.optional += Object.keys(properties ?? {}).filter(key => !required.has(key)).length;
+        out.properties += Object.keys(properties ?? {}).length;
+        if (properties) out.objects++;
         if (node['additionalProperties'] !== false) out.unsupported.push(`${at('additionalProperties')}: must be false`);
     }
     for (const key of UNSUPPORTED_KEYWORDS) if (key in node) out.unsupported.push(`${at(key)}: not supported`);
@@ -63,7 +83,7 @@ function count(node: unknown, path: string, out: StrictSchemaComplexity): void {
 
 /** The cost of ONE request's strict schemas together: its JSON output format and its strict tools' input schemas. */
 export function strictSchemaComplexity(schemas: ReadonlyArray<JsonSchema>, strictTools = 0): StrictSchemaComplexity {
-    const out: StrictSchemaComplexity = { optional: 0, unions: 0, strictTools, unsupported: [] };
+    const out: StrictSchemaComplexity = { optional: 0, unions: 0, strictTools, properties: 0, objects: 0, unsupported: [] };
     schemas.forEach((schema, i) => count(schema, schemas.length > 1 ? `[${i}]` : '', out));
     return out;
 }
@@ -75,10 +95,14 @@ export interface StrictSchemaRefusal {
     message: string;
 }
 
+/** Claude's words for a grammar it compiles too large (2026-10-27, the plan stage — vectoriox/iox-cms#47), verbatim. */
+export const GRAMMAR_TOO_LARGE_MESSAGE = 'The compiled grammar is too large, which would cause performance issues. Simplify your tool schemas or reduce the number of strict tools.';
+
 /**
- * The 400 the Claude API answers a request over its limits with, or null. The optional-parameter message is the one
- * Claude answered on 2026-10-27, verbatim; the union, strict-tool and unsupported messages follow its shape (not yet
- * captured).
+ * The 400 the Claude API answers a request over its limits with, or null. The optional-parameter and the grammar-size
+ * messages are the ones Claude answered on 2026-10-27, verbatim; the union, strict-tool and unsupported messages follow
+ * their shape (not yet captured). The documented limits are checked first: a request over one of them never reaches the
+ * grammar compiler.
  */
 export function strictSchemaRefusal(complexity: StrictSchemaComplexity): StrictSchemaRefusal | null {
     const refuse = (message: string): StrictSchemaRefusal => ({ status: 400, type: 'invalid_request_error', message });
@@ -92,5 +116,6 @@ export function strictSchemaRefusal(complexity: StrictSchemaComplexity): StrictS
     if (complexity.unions > STRICT_SCHEMA_LIMITS.unions) {
         return refuse(`Schemas contains too many parameters with union types (${complexity.unions}), which would make grammar compilation inefficient. Reduce the number of parameters with union types in your tool schemas (limit: ${STRICT_SCHEMA_LIMITS.unions}).`);
     }
+    if (complexity.properties > STRICT_SCHEMA_LIMITS.properties) return refuse(GRAMMAR_TOO_LARGE_MESSAGE);
     return null;
 }