@tanstack/openai-base 0.9.1 → 0.9.2

package/dist/esm/utils/schema-converter.d.ts

@@ -22,13 +22,18 @@ export declare function stripUnsupportedFormats(node: any): any;
  */
 export declare function makeStructuredOutputCompatible(schema: Record<string, any>, originalRequired?: Array<string>): Record<string, any>;
 /**
- * Returns `false` when `schema` (anywhere in the tree) uses a JSON-Schema
- * keyword outside OpenAI's strict Structured Outputs subset — i.e. it cannot be
- * made strict-compatible and must be sent with `strict: false`.
+ * Returns `false` when `schema` cannot be made strict-compatible and must be
+ * sent with `strict: false`. Two ways that happens:
  *
- * Conservative by design: keywords are matched as object keys, so a property
- * literally named e.g. `oneOf` also trips it. That only costs that one tool its
- * strict mode, which is strictly safer than a false "compatible" verdict that
- * 400s the whole request.
+ * 1. It uses a JSON-Schema keyword outside OpenAI's strict subset anywhere in
+ *    the tree (`oneOf`/`allOf`/`not`/`$ref`/`$defs`).
+ * 2. It contains a *typeless* schema node — a property/items/anyOf entry with
+ *    no `type` (nor `enum`/`const`/combinator), e.g. the `{}` that `z.any()`
+ *    produces. Strict mode rejects typeless schemas.
+ *
+ * Conservative by design: for (1) keywords are matched as object keys, so a
+ * property literally named e.g. `oneOf` also trips it. That only costs that one
+ * tool its strict mode, which is strictly safer than a false "compatible"
+ * verdict that 400s the whole request.
  */
 export declare function isStrictModeCompatible(schema: unknown): boolean;

package/dist/esm/utils/schema-converter.js

@@ -32,8 +32,17 @@ const STRICT_UNSUPPORTED_KEYWORDS = [
   "$defs",
   "definitions"
 ];
+const TYPE_INDICATOR_KEYWORDS = [
+  "type",
+  "enum",
+  "const",
+  "anyOf",
+  "oneOf",
+  "allOf",
+  "$ref"
+];
 function isStrictModeCompatible(schema) {
-  return !containsStrictUnsupportedKeyword(schema);
+  return !containsStrictUnsupportedKeyword(schema) && !containsTypelessSchema(schema);
 }
 function containsStrictUnsupportedKeyword(node) {
   if (Array.isArray(node)) {
@@ -46,6 +55,33 @@ function containsStrictUnsupportedKeyword(node) {
   }
   return false;
 }
+function isTypelessSchema(node) {
+  if (node === null || typeof node !== "object" || Array.isArray(node)) {
+    return false;
+  }
+  return !TYPE_INDICATOR_KEYWORDS.some((key) => key in node);
+}
+function containsTypelessSchema(node) {
+  if (node === null || typeof node !== "object" || Array.isArray(node)) {
+    return false;
+  }
+  const schema = node;
+  const children = [];
+  if (schema.properties && typeof schema.properties === "object") {
+    children.push(...Object.values(schema.properties));
+  }
+  if (schema.items !== void 0) {
+    children.push(
+      ...Array.isArray(schema.items) ? schema.items : [schema.items]
+    );
+  }
+  if (Array.isArray(schema.anyOf)) {
+    children.push(...schema.anyOf);
+  }
+  return children.some(
+    (child) => isTypelessSchema(child) || containsTypelessSchema(child)
+  );
+}
 function coerceStrictSchema(schema, originalRequired) {
   const result = { ...schema };
   const required = originalRequired ?? (Array.isArray(result["required"]) ? result["required"] : []);

package/dist/esm/utils/schema-converter.js.map

@@ -1 +1 @@
-{"version":3,"file":"schema-converter.js","sources":["../../../src/utils/schema-converter.ts"],"sourcesContent":["/**\n * String `format` values accepted by OpenAI's strict Structured Outputs subset.\n * Any other format (e.g. \"uri\", \"uri-reference\", \"regex\") causes the API to\n * reject the whole request with `400 ... '<format>' is not a valid format`.\n * MCP servers and hand-written tools routinely declare such formats, so we strip\n * the unsupported ones before sending. See:\n * https://platform.openai.com/docs/guides/structured-outputs#supported-properties\n */\nconst SUPPORTED_STRING_FORMATS = new Set([\n  'date-time',\n  'time',\n  'date',\n  'duration',\n  'email',\n  'hostname',\n  'ipv4',\n  'ipv6',\n  'uuid',\n])\n\n/**\n * Recursively drop JSON-Schema `format` keywords whose value isn't in OpenAI's\n * strict-mode allowlist. Pure — returns a fresh tree and never mutates `node`,\n * so the caller's original tool definition is left intact.\n *\n * A property *named* `format` always has a schema (object/boolean) value, never\n * a bare string, so it is preserved and recursed into; only the `format`\n * *keyword* (whose value is a string) is subject to removal.\n */\nexport function stripUnsupportedFormats(node: any): any {\n  if (Array.isArray(node)) return node.map(stripUnsupportedFormats)\n  if (node === null || typeof node !== 'object') return node\n\n  const out: Record<string, any> = {}\n  for (const [key, value] of Object.entries(node)) {\n    if (\n      key === 'format' &&\n      typeof value === 'string' &&\n      !SUPPORTED_STRING_FORMATS.has(value)\n    ) {\n      continue\n    }\n    out[key] = stripUnsupportedFormats(value)\n  }\n  return out\n}\n\n/**\n * Transform a JSON schema to be compatible with OpenAI's structured output requirements.\n * OpenAI requires:\n * - All properties must be in the `required` array\n * - Optional fields should have null added to their type union\n * - additionalProperties must be false for objects\n * - String `format` keywords must be from a fixed allowlist (others are stripped)\n *\n * @param schema - JSON schema to transform\n * @param originalRequired - Original required array (to know which fields were optional)\n * @returns Transformed schema compatible with OpenAI structured output\n */\nexport function makeStructuredOutputCompatible(\n  schema: Record<string, any>,\n  originalRequired?: Array<string>,\n): Record<string, any> {\n  return stripUnsupportedFormats(coerceStrictSchema(schema, originalRequired))\n}\n\n/**\n * JSON-Schema keywords outside OpenAI's strict Structured Outputs subset. A\n * schema using any of these can't be coerced into a strict-valid shape, and\n * sending it with `strict: true` makes the API reject the ENTIRE request\n * (e.g. `400 Invalid schema ... 'additionalProperties' is required to be ...`).\n * Tools with such schemas are emitted with `strict: false` instead (see the\n * tool converters) so they remain callable. MCP servers (e.g. Notion) routinely\n * emit these.\n *\n * - `oneOf` / `allOf` / `not` — combinator keywords strict mode rejects\n * - `$ref` / `$defs` / `definitions` — references and definition pools whose\n *   object subschemas escape the `additionalProperties: false` normalization\n *   strict mode requires\n */\nconst STRICT_UNSUPPORTED_KEYWORDS: ReadonlyArray<string> = [\n  'oneOf',\n  'allOf',\n  'not',\n  '$ref',\n  '$defs',\n  'definitions',\n]\n\n/**\n * Returns `false` when `schema` (anywhere in the tree) uses a JSON-Schema\n * keyword outside OpenAI's strict Structured Outputs subset — i.e. it cannot be\n * made strict-compatible and must be sent with `strict: false`.\n *\n * Conservative by design: keywords are matched as object keys, so a property\n * literally named e.g. `oneOf` also trips it. That only costs that one tool its\n * strict mode, which is strictly safer than a false \"compatible\" verdict that\n * 400s the whole request.\n */\nexport function isStrictModeCompatible(schema: unknown): boolean {\n  return !containsStrictUnsupportedKeyword(schema)\n}\n\nfunction containsStrictUnsupportedKeyword(node: unknown): boolean {\n  if (Array.isArray(node)) {\n    return node.some(containsStrictUnsupportedKeyword)\n  }\n  if (node === null || typeof node !== 'object') return false\n  for (const [key, value] of Object.entries(node)) {\n    if (STRICT_UNSUPPORTED_KEYWORDS.includes(key)) return true\n    if (containsStrictUnsupportedKeyword(value)) return true\n  }\n  return false\n}\n\n/**\n * Strict-mode structural rewrite (required widening, nullability,\n * additionalProperties). Kept private so the public entry point can apply the\n * format-stripping pass exactly once over the fully-rewritten tree.\n */\nfunction coerceStrictSchema(\n  schema: Record<string, any>,\n  originalRequired?: Array<string>,\n): Record<string, any> {\n  const result = { ...schema }\n  const required =\n    originalRequired ??\n    (Array.isArray(result['required']) ? result['required'] : [])\n\n  if (result.type === 'object' && result.properties) {\n    const properties = { ...result.properties }\n    const allPropertyNames = Object.keys(properties)\n\n    for (const propName of allPropertyNames) {\n      let prop = properties[propName]\n      const wasOptional = !required.includes(propName)\n\n      // Step 1: Recurse into nested structures\n      if (prop.type === 'object' && prop.properties) {\n        prop = coerceStrictSchema(prop, prop.required || [])\n      } else if (prop.type === 'array' && prop.items) {\n        prop = {\n          ...prop,\n          items: coerceStrictSchema(prop.items, prop.items.required || []),\n        }\n      } else if (prop.anyOf) {\n        prop = coerceStrictSchema(prop, prop.required || [])\n      } else if (prop.oneOf) {\n        throw new Error(\n          'oneOf is not supported in OpenAI structured output schemas. Check the supported outputs here: https://platform.openai.com/docs/guides/structured-outputs#supported-types',\n        )\n      }\n\n      // Step 2: Apply null-widening for optional properties (after recursion)\n      if (wasOptional) {\n        if (prop.anyOf) {\n          // For anyOf, add a null variant if not already present\n          if (!prop.anyOf.some((v: any) => v.type === 'null')) {\n            prop = { ...prop, anyOf: [...prop.anyOf, { type: 'null' }] }\n          }\n        } else if (prop.type && !Array.isArray(prop.type)) {\n          prop = { ...prop, type: [prop.type, 'null'] }\n        } else if (Array.isArray(prop.type) && !prop.type.includes('null')) {\n          prop = { ...prop, type: [...prop.type, 'null'] }\n        }\n      }\n\n      properties[propName] = prop\n    }\n\n    result.properties = properties\n    result.required = allPropertyNames\n    result.additionalProperties = false\n  }\n\n  if (result.type === 'array' && result.items) {\n    result.items = coerceStrictSchema(result.items, result.items.required || [])\n  }\n\n  if (result.anyOf && Array.isArray(result.anyOf)) {\n    result.anyOf = result.anyOf.map((variant) =>\n      coerceStrictSchema(variant, variant.required || []),\n    )\n  }\n\n  if (result.oneOf) {\n    throw new Error(\n      'oneOf is not supported in OpenAI structured output schemas. Check the supported outputs here: https://platform.openai.com/docs/guides/structured-outputs#supported-types',\n    )\n  }\n\n  return result\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"schema-converter.js","sources":["../../../src/utils/schema-converter.ts"],"sourcesContent":["/**\n * String `format` values accepted by OpenAI's strict Structured Outputs subset.\n * Any other format (e.g. \"uri\", \"uri-reference\", \"regex\") causes the API to\n * reject the whole request with `400 ... '<format>' is not a valid format`.\n * MCP servers and hand-written tools routinely declare such formats, so we strip\n * the unsupported ones before sending. See:\n * https://platform.openai.com/docs/guides/structured-outputs#supported-properties\n */\nconst SUPPORTED_STRING_FORMATS = new Set([\n  'date-time',\n  'time',\n  'date',\n  'duration',\n  'email',\n  'hostname',\n  'ipv4',\n  'ipv6',\n  'uuid',\n])\n\n/**\n * Recursively drop JSON-Schema `format` keywords whose value isn't in OpenAI's\n * strict-mode allowlist. Pure — returns a fresh tree and never mutates `node`,\n * so the caller's original tool definition is left intact.\n *\n * A property *named* `format` always has a schema (object/boolean) value, never\n * a bare string, so it is preserved and recursed into; only the `format`\n * *keyword* (whose value is a string) is subject to removal.\n */\nexport function stripUnsupportedFormats(node: any): any {\n  if (Array.isArray(node)) return node.map(stripUnsupportedFormats)\n  if (node === null || typeof node !== 'object') return node\n\n  const out: Record<string, any> = {}\n  for (const [key, value] of Object.entries(node)) {\n    if (\n      key === 'format' &&\n      typeof value === 'string' &&\n      !SUPPORTED_STRING_FORMATS.has(value)\n    ) {\n      continue\n    }\n    out[key] = stripUnsupportedFormats(value)\n  }\n  return out\n}\n\n/**\n * Transform a JSON schema to be compatible with OpenAI's structured output requirements.\n * OpenAI requires:\n * - All properties must be in the `required` array\n * - Optional fields should have null added to their type union\n * - additionalProperties must be false for objects\n * - String `format` keywords must be from a fixed allowlist (others are stripped)\n *\n * @param schema - JSON schema to transform\n * @param originalRequired - Original required array (to know which fields were optional)\n * @returns Transformed schema compatible with OpenAI structured output\n */\nexport function makeStructuredOutputCompatible(\n  schema: Record<string, any>,\n  originalRequired?: Array<string>,\n): Record<string, any> {\n  return stripUnsupportedFormats(coerceStrictSchema(schema, originalRequired))\n}\n\n/**\n * JSON-Schema keywords outside OpenAI's strict Structured Outputs subset. A\n * schema using any of these can't be coerced into a strict-valid shape, and\n * sending it with `strict: true` makes the API reject the ENTIRE request\n * (e.g. `400 Invalid schema ... 'additionalProperties' is required to be ...`).\n * Tools with such schemas are emitted with `strict: false` instead (see the\n * tool converters) so they remain callable. MCP servers (e.g. Notion) routinely\n * emit these.\n *\n * - `oneOf` / `allOf` / `not` — combinator keywords strict mode rejects\n * - `$ref` / `$defs` / `definitions` — references and definition pools whose\n *   object subschemas escape the `additionalProperties: false` normalization\n *   strict mode requires\n */\nconst STRICT_UNSUPPORTED_KEYWORDS: ReadonlyArray<string> = [\n  'oneOf',\n  'allOf',\n  'not',\n  '$ref',\n  '$defs',\n  'definitions',\n]\n\n/**\n * Keys that give a schema node a resolvable type under OpenAI's strict subset.\n * A schema-position node carrying none of these is *typeless* (e.g. the empty\n * `{}` that `z.any()` / `z.unknown()` emit). Strict mode requires every schema\n * to declare a type, so a typeless node 400s the whole request — such tools\n * must be sent with `strict: false` instead. (`oneOf`/`allOf`/`$ref` count as\n * type indicators here even though they're independently strict-unsupported;\n * the keyword check below already rejects them.)\n */\nconst TYPE_INDICATOR_KEYWORDS: ReadonlyArray<string> = [\n  'type',\n  'enum',\n  'const',\n  'anyOf',\n  'oneOf',\n  'allOf',\n  '$ref',\n]\n\n/**\n * Returns `false` when `schema` cannot be made strict-compatible and must be\n * sent with `strict: false`. Two ways that happens:\n *\n * 1. It uses a JSON-Schema keyword outside OpenAI's strict subset anywhere in\n *    the tree (`oneOf`/`allOf`/`not`/`$ref`/`$defs`).\n * 2. It contains a *typeless* schema node — a property/items/anyOf entry with\n *    no `type` (nor `enum`/`const`/combinator), e.g. the `{}` that `z.any()`\n *    produces. Strict mode rejects typeless schemas.\n *\n * Conservative by design: for (1) keywords are matched as object keys, so a\n * property literally named e.g. `oneOf` also trips it. That only costs that one\n * tool its strict mode, which is strictly safer than a false \"compatible\"\n * verdict that 400s the whole request.\n */\nexport function isStrictModeCompatible(schema: unknown): boolean {\n  return (\n    !containsStrictUnsupportedKeyword(schema) && !containsTypelessSchema(schema)\n  )\n}\n\nfunction containsStrictUnsupportedKeyword(node: unknown): boolean {\n  if (Array.isArray(node)) {\n    return node.some(containsStrictUnsupportedKeyword)\n  }\n  if (node === null || typeof node !== 'object') return false\n  for (const [key, value] of Object.entries(node)) {\n    if (STRICT_UNSUPPORTED_KEYWORDS.includes(key)) return true\n    if (containsStrictUnsupportedKeyword(value)) return true\n  }\n  return false\n}\n\n/** A schema-position node that declares no type and so 400s strict mode. */\nfunction isTypelessSchema(node: unknown): boolean {\n  if (node === null || typeof node !== 'object' || Array.isArray(node)) {\n    // boolean schemas (`true`/`false`) and non-objects aren't typeless props.\n    return false\n  }\n  return !TYPE_INDICATOR_KEYWORDS.some((key) => key in node)\n}\n\n/**\n * Walks the genuine schema positions (property values, `items`, `anyOf`\n * variants) and reports whether any is typeless. Unlike the keyword walk this\n * must respect structure: an empty `{}` is only a problem at a schema position,\n * not e.g. an empty `properties` map.\n */\nfunction containsTypelessSchema(node: unknown): boolean {\n  if (node === null || typeof node !== 'object' || Array.isArray(node)) {\n    return false\n  }\n  const schema = node as Record<string, any>\n\n  const children: Array<unknown> = []\n  if (schema.properties && typeof schema.properties === 'object') {\n    children.push(...Object.values(schema.properties))\n  }\n  if (schema.items !== undefined) {\n    children.push(\n      ...(Array.isArray(schema.items) ? schema.items : [schema.items]),\n    )\n  }\n  if (Array.isArray(schema.anyOf)) {\n    children.push(...schema.anyOf)\n  }\n\n  return children.some(\n    (child) => isTypelessSchema(child) || containsTypelessSchema(child),\n  )\n}\n\n/**\n * Strict-mode structural rewrite (required widening, nullability,\n * additionalProperties). Kept private so the public entry point can apply the\n * format-stripping pass exactly once over the fully-rewritten tree.\n */\nfunction coerceStrictSchema(\n  schema: Record<string, any>,\n  originalRequired?: Array<string>,\n): Record<string, any> {\n  const result = { ...schema }\n  const required =\n    originalRequired ??\n    (Array.isArray(result['required']) ? result['required'] : [])\n\n  if (result.type === 'object' && result.properties) {\n    const properties = { ...result.properties }\n    const allPropertyNames = Object.keys(properties)\n\n    for (const propName of allPropertyNames) {\n      let prop = properties[propName]\n      const wasOptional = !required.includes(propName)\n\n      // Step 1: Recurse into nested structures\n      if (prop.type === 'object' && prop.properties) {\n        prop = coerceStrictSchema(prop, prop.required || [])\n      } else if (prop.type === 'array' && prop.items) {\n        prop = {\n          ...prop,\n          items: coerceStrictSchema(prop.items, prop.items.required || []),\n        }\n      } else if (prop.anyOf) {\n        prop = coerceStrictSchema(prop, prop.required || [])\n      } else if (prop.oneOf) {\n        throw new Error(\n          'oneOf is not supported in OpenAI structured output schemas. Check the supported outputs here: https://platform.openai.com/docs/guides/structured-outputs#supported-types',\n        )\n      }\n\n      // Step 2: Apply null-widening for optional properties (after recursion)\n      if (wasOptional) {\n        if (prop.anyOf) {\n          // For anyOf, add a null variant if not already present\n          if (!prop.anyOf.some((v: any) => v.type === 'null')) {\n            prop = { ...prop, anyOf: [...prop.anyOf, { type: 'null' }] }\n          }\n        } else if (prop.type && !Array.isArray(prop.type)) {\n          prop = { ...prop, type: [prop.type, 'null'] }\n        } else if (Array.isArray(prop.type) && !prop.type.includes('null')) {\n          prop = { ...prop, type: [...prop.type, 'null'] }\n        }\n      }\n\n      properties[propName] = prop\n    }\n\n    result.properties = properties\n    result.required = allPropertyNames\n    result.additionalProperties = false\n  }\n\n  if (result.type === 'array' && result.items) {\n    result.items = coerceStrictSchema(result.items, result.items.required || [])\n  }\n\n  if (result.anyOf && Array.isArray(result.anyOf)) {\n    result.anyOf = result.anyOf.map((variant) =>\n      coerceStrictSchema(variant, variant.required || []),\n    )\n  }\n\n  if (result.oneOf) {\n    throw new Error(\n      'oneOf is not supported in OpenAI structured output schemas. Check the supported outputs here: https://platform.openai.com/docs/guides/structured-outputs#supported-types',\n    )\n  }\n\n  return result\n}\n"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/openai-base",
-  "version": "0.9.1",
+  "version": "0.9.2",
   "description": "Shared OpenAI SDK base adapters for TanStack AI providers using Chat Completions and Responses APIs.",
   "author": "Tanner Linsley",
   "license": "MIT",

package/src/utils/schema-converter.ts

@@ -88,17 +88,43 @@ const STRICT_UNSUPPORTED_KEYWORDS: ReadonlyArray<string> = [
 ]
 
 /**
- * Returns `false` when `schema` (anywhere in the tree) uses a JSON-Schema
- * keyword outside OpenAI's strict Structured Outputs subset — i.e. it cannot be
- * made strict-compatible and must be sent with `strict: false`.
+ * Keys that give a schema node a resolvable type under OpenAI's strict subset.
+ * A schema-position node carrying none of these is *typeless* (e.g. the empty
+ * `{}` that `z.any()` / `z.unknown()` emit). Strict mode requires every schema
+ * to declare a type, so a typeless node 400s the whole request — such tools
+ * must be sent with `strict: false` instead. (`oneOf`/`allOf`/`$ref` count as
+ * type indicators here even though they're independently strict-unsupported;
+ * the keyword check below already rejects them.)
+ */
+const TYPE_INDICATOR_KEYWORDS: ReadonlyArray<string> = [
+  'type',
+  'enum',
+  'const',
+  'anyOf',
+  'oneOf',
+  'allOf',
+  '$ref',
+]
+
+/**
+ * Returns `false` when `schema` cannot be made strict-compatible and must be
+ * sent with `strict: false`. Two ways that happens:
+ *
+ * 1. It uses a JSON-Schema keyword outside OpenAI's strict subset anywhere in
+ *    the tree (`oneOf`/`allOf`/`not`/`$ref`/`$defs`).
+ * 2. It contains a *typeless* schema node — a property/items/anyOf entry with
+ *    no `type` (nor `enum`/`const`/combinator), e.g. the `{}` that `z.any()`
+ *    produces. Strict mode rejects typeless schemas.
  *
- * Conservative by design: keywords are matched as object keys, so a property
- * literally named e.g. `oneOf` also trips it. That only costs that one tool its
- * strict mode, which is strictly safer than a false "compatible" verdict that
- * 400s the whole request.
+ * Conservative by design: for (1) keywords are matched as object keys, so a
+ * property literally named e.g. `oneOf` also trips it. That only costs that one
+ * tool its strict mode, which is strictly safer than a false "compatible"
+ * verdict that 400s the whole request.
  */
 export function isStrictModeCompatible(schema: unknown): boolean {
-  return !containsStrictUnsupportedKeyword(schema)
+  return (
+    !containsStrictUnsupportedKeyword(schema) && !containsTypelessSchema(schema)
+  )
 }
 
 function containsStrictUnsupportedKeyword(node: unknown): boolean {
@@ -113,6 +139,45 @@ function containsStrictUnsupportedKeyword(node: unknown): boolean {
   return false
 }
 
+/** A schema-position node that declares no type and so 400s strict mode. */
+function isTypelessSchema(node: unknown): boolean {
+  if (node === null || typeof node !== 'object' || Array.isArray(node)) {
+    // boolean schemas (`true`/`false`) and non-objects aren't typeless props.
+    return false
+  }
+  return !TYPE_INDICATOR_KEYWORDS.some((key) => key in node)
+}
+
+/**
+ * Walks the genuine schema positions (property values, `items`, `anyOf`
+ * variants) and reports whether any is typeless. Unlike the keyword walk this
+ * must respect structure: an empty `{}` is only a problem at a schema position,
+ * not e.g. an empty `properties` map.
+ */
+function containsTypelessSchema(node: unknown): boolean {
+  if (node === null || typeof node !== 'object' || Array.isArray(node)) {
+    return false
+  }
+  const schema = node as Record<string, any>
+
+  const children: Array<unknown> = []
+  if (schema.properties && typeof schema.properties === 'object') {
+    children.push(...Object.values(schema.properties))
+  }
+  if (schema.items !== undefined) {
+    children.push(
+      ...(Array.isArray(schema.items) ? schema.items : [schema.items]),
+    )
+  }
+  if (Array.isArray(schema.anyOf)) {
+    children.push(...schema.anyOf)
+  }
+
+  return children.some(
+    (child) => isTypelessSchema(child) || containsTypelessSchema(child),
+  )
+}
+
 /**
  * Strict-mode structural rewrite (required widening, nullability,
  * additionalProperties). Kept private so the public entry point can apply the