@tanstack/openai-base 0.10.1 → 0.10.3

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

@@ -50,7 +50,19 @@ function stripUnsupportedFormats(node) {
 * @returns Transformed schema compatible with OpenAI structured output
 */
 function makeStructuredOutputCompatible(schema, originalRequired) {
-	return stripUnsupportedFormats(coerceStrictSchema(schema, originalRequired));
+	return makeStructuredOutputCompatibleWithMap(schema, originalRequired).schema;
+}
+/**
+* Strict-schema conversion plus an exact map of the nullability introduced by
+* that conversion. Consumers can pass provider output through
+* `undoNullWidening` before validating it against the original schema.
+*/
+function makeStructuredOutputCompatibleWithMap(schema, originalRequired) {
+	const { schema: strictSchema, nullWideningMap } = coerceStrictSchema(schema, originalRequired);
+	return {
+		schema: stripUnsupportedFormats(strictSchema),
+		nullWideningMap
+	};
 }
 /**
 * JSON-Schema keywords outside OpenAI's strict Structured Outputs subset. A
@@ -104,6 +116,9 @@ var TYPE_INDICATOR_KEYWORDS = [
 * 3. It contains an open object schema. OpenAI strict mode requires objects to
 *    set `additionalProperties: false`, which would change the semantics of a
 *    free-form map rather than merely normalizing it.
+* 4. An `anyOf` variant itself needs null widening. The inverse map is
+*    intentionally schema-blind, so it cannot select a variant without risking
+*    removal of a genuine nullable value accepted by another variant.
 *
 * 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
@@ -111,7 +126,16 @@ var TYPE_INDICATOR_KEYWORDS = [
 * verdict that 400s the whole request.
 */
 function isStrictModeCompatible(schema) {
-	return !containsStrictUnsupportedKeyword(schema) && !containsTypelessSchema(schema) && !containsOpenObject(schema);
+	return !containsStrictUnsupportedKeyword(schema) && !containsTypelessSchema(schema) && !containsOpenObject(schema) && !containsUntrackableAnyOfWidening(schema);
+}
+/**
+* Reports strict conversions whose synthesized nulls cannot be represented by
+* the schema-blind inverse map. Optional `anyOf` wrappers remain supported:
+* only widening introduced inside one of their variants triggers fallback.
+*/
+function containsUntrackableAnyOfWidening(schema) {
+	if (schema === null || typeof schema !== "object" || Array.isArray(schema)) return false;
+	return coerceStrictSchema(schema).hasUntrackableAnyOfWidening;
 }
 /**
 * Reports object schemas that cannot be closed without changing their input
@@ -141,7 +165,7 @@ function containsStrictUnsupportedKeyword(node) {
 }
 /** A schema-position node that declares no type and so 400s strict mode. */
 function isTypelessSchema(node) {
-	if (node === null || typeof node !== "object" || Array.isArray(node)) return false;
+	if (node === null || typeof node !== "object" || Array.isArray(node)) return true;
 	return !TYPE_INDICATOR_KEYWORDS.some((key) => key in node);
 }
 /**
@@ -164,49 +188,113 @@ function containsTypelessSchema(node) {
 * additionalProperties). Kept private so the public entry point can apply the
 * format-stripping pass exactly once over the fully-rewritten tree.
 */
+function pruneMap(map) {
+	return Object.keys(map).length > 0 ? map : void 0;
+}
+function isSchemaObject(schema) {
+	return typeof schema === "object" && schema !== null && !Array.isArray(schema);
+}
+/** Whether every active JSON Schema constraint at this node admits null. */
+function acceptsNull(schema) {
+	if (schema === true) return true;
+	if (!isSchemaObject(schema)) return false;
+	if ("const" in schema && schema.const !== null) return false;
+	if (Array.isArray(schema.enum) && !schema.enum.includes(null)) return false;
+	if (typeof schema.type === "string" && schema.type !== "null") return false;
+	if (Array.isArray(schema.type) && !schema.type.includes("null")) return false;
+	if (Array.isArray(schema.anyOf) && !schema.anyOf.some((variant) => acceptsNull(variant))) return false;
+	return true;
+}
 function coerceStrictSchema(schema, originalRequired) {
 	const result = { ...schema };
+	const nullWideningMap = {};
+	let hasUntrackableAnyOfWidening = false;
 	const required = originalRequired ?? (Array.isArray(result["required"]) ? result["required"] : []);
 	if (result.type === "object" && result.properties) {
 		const properties = { ...result.properties };
 		const allPropertyNames = Object.keys(properties);
+		const propertyMaps = {};
 		for (const propName of allPropertyNames) {
 			let prop = properties[propName];
 			const wasOptional = !required.includes(propName);
-			if (prop.type === "object" && prop.properties) prop = coerceStrictSchema(prop, prop.required || []);
-			else if (prop.type === "array" && prop.items) prop = {
-				...prop,
-				items: coerceStrictSchema(prop.items, prop.items.required || [])
-			};
-			else if (prop.anyOf) prop = coerceStrictSchema(prop, prop.required || []);
-			else if (prop.oneOf) throw new Error("oneOf is not supported in OpenAI structured output schemas. Check the supported outputs here: https://platform.openai.com/docs/guides/structured-outputs#supported-types");
+			let childMap;
+			let widenedHere = false;
+			if (isSchemaObject(prop) && prop.type === "object" && prop.properties) {
+				const nested = coerceStrictSchema(prop, prop.required || []);
+				prop = nested.schema;
+				childMap = nested.nullWideningMap;
+				hasUntrackableAnyOfWidening ||= nested.hasUntrackableAnyOfWidening;
+			} else if (isSchemaObject(prop) && prop.type === "array" && prop.items) {
+				const nested = coerceStrictSchema(prop.items, prop.items.required || []);
+				prop = {
+					...prop,
+					items: nested.schema
+				};
+				childMap = nested.nullWideningMap ? { items: nested.nullWideningMap } : void 0;
+				hasUntrackableAnyOfWidening ||= nested.hasUntrackableAnyOfWidening;
+			} else if (isSchemaObject(prop) && prop.anyOf) {
+				const nested = coerceStrictSchema(prop, prop.required || []);
+				prop = nested.schema;
+				childMap = nested.nullWideningMap;
+				hasUntrackableAnyOfWidening ||= nested.hasUntrackableAnyOfWidening;
+			} else if (isSchemaObject(prop) && prop.oneOf) throw new Error("oneOf is not supported in OpenAI structured output schemas. Check the supported outputs here: https://platform.openai.com/docs/guides/structured-outputs#supported-types");
 			if (wasOptional) {
-				if (prop.anyOf) {
-					if (!prop.anyOf.some((v) => v.type === "null")) prop = {
+				const originallyAcceptedNull = acceptsNull(prop);
+				if (isSchemaObject(prop) && "const" in prop && prop.const !== null) {
+					const { const: constValue, ...withoutConst } = prop;
+					prop = {
+						...withoutConst,
+						enum: [constValue, null]
+					};
+				} else if (isSchemaObject(prop) && Array.isArray(prop.enum) && !prop.enum.includes(null)) prop = {
+					...prop,
+					enum: [...prop.enum, null]
+				};
+				if (isSchemaObject(prop) && prop.anyOf) {
+					if (!acceptsNull(prop)) prop = {
 						...prop,
 						anyOf: [...prop.anyOf, { type: "null" }]
 					};
-				} else if (prop.type && !Array.isArray(prop.type)) prop = {
+				} else if (isSchemaObject(prop) && prop.type && !Array.isArray(prop.type)) prop = {
 					...prop,
 					type: [prop.type, "null"]
 				};
-				else if (Array.isArray(prop.type) && !prop.type.includes("null")) prop = {
+				else if (isSchemaObject(prop) && Array.isArray(prop.type) && !prop.type.includes("null")) prop = {
 					...prop,
 					type: [...prop.type, "null"]
 				};
+				widenedHere = !originallyAcceptedNull && acceptsNull(prop);
 			}
 			properties[propName] = prop;
+			if (childMap || widenedHere) propertyMaps[propName] = {
+				...childMap ?? {},
+				...widenedHere ? { widened: true } : {}
+			};
 		}
 		result.properties = properties;
 		result.required = allPropertyNames;
 		result.additionalProperties = false;
+		if (Object.keys(propertyMaps).length > 0) nullWideningMap.properties = propertyMaps;
+	}
+	if (result.type === "array" && result.items) {
+		const nested = coerceStrictSchema(result.items, result.items.required || []);
+		result.items = nested.schema;
+		if (nested.nullWideningMap) nullWideningMap.items = nested.nullWideningMap;
+		hasUntrackableAnyOfWidening ||= nested.hasUntrackableAnyOfWidening;
+	}
+	if (result.anyOf && Array.isArray(result.anyOf)) {
+		const variants = result.anyOf.map((variant) => coerceStrictSchema(variant, variant.required || []));
+		result.anyOf = variants.map((variant) => variant.schema);
+		hasUntrackableAnyOfWidening ||= variants.some((variant) => variant.nullWideningMap !== void 0 || variant.hasUntrackableAnyOfWidening);
 	}
-	if (result.type === "array" && result.items) result.items = coerceStrictSchema(result.items, result.items.required || []);
-	if (result.anyOf && Array.isArray(result.anyOf)) result.anyOf = result.anyOf.map((variant) => coerceStrictSchema(variant, variant.required || []));
 	if (result.oneOf) throw new Error("oneOf is not supported in OpenAI structured output schemas. Check the supported outputs here: https://platform.openai.com/docs/guides/structured-outputs#supported-types");
-	return result;
+	return {
+		schema: result,
+		nullWideningMap: pruneMap(nullWideningMap),
+		hasUntrackableAnyOfWidening
+	};
 }
 //#endregion
-export { isStrictModeCompatible, makeStructuredOutputCompatible, stripUnsupportedFormats };
+export { isStrictModeCompatible, makeStructuredOutputCompatible, makeStructuredOutputCompatibleWithMap, stripUnsupportedFormats };
 
 //# sourceMappingURL=schema-converter.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"schema-converter.js","names":[],"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 * 3. It contains an open object schema. OpenAI strict mode requires objects to\n *    set `additionalProperties: false`, which would change the semantics of a\n *    free-form map rather than merely normalizing it.\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) &&\n    !containsTypelessSchema(schema) &&\n    !containsOpenObject(schema)\n  )\n}\n\n/**\n * Reports object schemas that cannot be closed without changing their input\n * semantics. Objects with `properties` and no explicit\n * `additionalProperties` are safe because `coerceStrictSchema` closes them.\n */\nfunction containsOpenObject(node: unknown): boolean {\n  if (Array.isArray(node)) {\n    return node.some(containsOpenObject)\n  }\n  if (node === null || typeof node !== 'object') return false\n\n  const schema = node as Record<string, unknown>\n  const type = schema['type']\n  const isObjectSchema =\n    type === 'object' || (Array.isArray(type) && type.includes('object'))\n\n  if (isObjectSchema) {\n    if (\n      'additionalProperties' in schema &&\n      schema['additionalProperties'] !== false\n    ) {\n      return true\n    }\n\n    const properties = schema['properties']\n    const hasProperties =\n      properties !== null &&\n      typeof properties === 'object' &&\n      !Array.isArray(properties)\n    if (!hasProperties && schema['additionalProperties'] !== false) {\n      return true\n    }\n  }\n\n  return Object.values(schema).some(containsOpenObject)\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"],"mappings":"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"}
+{"version":3,"file":"schema-converter.js","names":[],"sources":["../../../src/utils/schema-converter.ts"],"sourcesContent":["import type { NullWideningMap } from '@tanstack/ai-utils'\n\n/**\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 makeStructuredOutputCompatibleWithMap(schema, originalRequired).schema\n}\n\nexport interface StructuredOutputCompatibility {\n  schema: Record<string, any>\n  nullWideningMap: NullWideningMap | undefined\n}\n\ninterface CoercedStrictSchema extends StructuredOutputCompatibility {\n  hasUntrackableAnyOfWidening: boolean\n}\n\n/**\n * Strict-schema conversion plus an exact map of the nullability introduced by\n * that conversion. Consumers can pass provider output through\n * `undoNullWidening` before validating it against the original schema.\n */\nexport function makeStructuredOutputCompatibleWithMap(\n  schema: Record<string, any>,\n  originalRequired?: Array<string>,\n): StructuredOutputCompatibility {\n  const { schema: strictSchema, nullWideningMap } = coerceStrictSchema(\n    schema,\n    originalRequired,\n  )\n  return {\n    schema: stripUnsupportedFormats(strictSchema),\n    nullWideningMap,\n  }\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 * 3. It contains an open object schema. OpenAI strict mode requires objects to\n *    set `additionalProperties: false`, which would change the semantics of a\n *    free-form map rather than merely normalizing it.\n * 4. An `anyOf` variant itself needs null widening. The inverse map is\n *    intentionally schema-blind, so it cannot select a variant without risking\n *    removal of a genuine nullable value accepted by another variant.\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) &&\n    !containsTypelessSchema(schema) &&\n    !containsOpenObject(schema) &&\n    !containsUntrackableAnyOfWidening(schema)\n  )\n}\n\n/**\n * Reports strict conversions whose synthesized nulls cannot be represented by\n * the schema-blind inverse map. Optional `anyOf` wrappers remain supported:\n * only widening introduced inside one of their variants triggers fallback.\n */\nfunction containsUntrackableAnyOfWidening(schema: unknown): boolean {\n  if (schema === null || typeof schema !== 'object' || Array.isArray(schema)) {\n    return false\n  }\n  return coerceStrictSchema(schema as Record<string, any>)\n    .hasUntrackableAnyOfWidening\n}\n\n/**\n * Reports object schemas that cannot be closed without changing their input\n * semantics. Objects with `properties` and no explicit\n * `additionalProperties` are safe because `coerceStrictSchema` closes them.\n */\nfunction containsOpenObject(node: unknown): boolean {\n  if (Array.isArray(node)) {\n    return node.some(containsOpenObject)\n  }\n  if (node === null || typeof node !== 'object') return false\n\n  const schema = node as Record<string, unknown>\n  const type = schema['type']\n  const isObjectSchema =\n    type === 'object' || (Array.isArray(type) && type.includes('object'))\n\n  if (isObjectSchema) {\n    if (\n      'additionalProperties' in schema &&\n      schema['additionalProperties'] !== false\n    ) {\n      return true\n    }\n\n    const properties = schema['properties']\n    const hasProperties =\n      properties !== null &&\n      typeof properties === 'object' &&\n      !Array.isArray(properties)\n    if (!hasProperties && schema['additionalProperties'] !== false) {\n      return true\n    }\n  }\n\n  return Object.values(schema).some(containsOpenObject)\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    // JSON Schema permits bare boolean nodes; malformed inputs may contain\n    // other primitives. OpenAI's strict subset requires a declared type, so\n    // preserve the containing tool by sending it in non-strict mode.\n    return true\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 pruneMap(map: NullWideningMap): NullWideningMap | undefined {\n  return Object.keys(map).length > 0 ? map : undefined\n}\n\nfunction isSchemaObject(schema: unknown): schema is Record<string, any> {\n  return typeof schema === 'object' && schema !== null && !Array.isArray(schema)\n}\n\n/** Whether every active JSON Schema constraint at this node admits null. */\nfunction acceptsNull(schema: unknown): boolean {\n  if (schema === true) return true\n  if (!isSchemaObject(schema)) return false\n\n  if ('const' in schema && schema.const !== null) return false\n  if (Array.isArray(schema.enum) && !schema.enum.includes(null)) return false\n\n  if (typeof schema.type === 'string' && schema.type !== 'null') return false\n  if (Array.isArray(schema.type) && !schema.type.includes('null')) return false\n\n  if (\n    Array.isArray(schema.anyOf) &&\n    !schema.anyOf.some((variant: unknown) => acceptsNull(variant))\n  ) {\n    return false\n  }\n\n  return true\n}\n\nfunction coerceStrictSchema(\n  schema: Record<string, any>,\n  originalRequired?: Array<string>,\n): CoercedStrictSchema {\n  const result = { ...schema }\n  const nullWideningMap: NullWideningMap = {}\n  let hasUntrackableAnyOfWidening = false\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    const propertyMaps: Record<string, NullWideningMap> = {}\n\n    for (const propName of allPropertyNames) {\n      let prop = properties[propName]\n      const wasOptional = !required.includes(propName)\n      let childMap: NullWideningMap | undefined\n      let widenedHere = false\n\n      // Step 1: Recurse into nested structures\n      if (isSchemaObject(prop) && prop.type === 'object' && prop.properties) {\n        const nested = coerceStrictSchema(prop, prop.required || [])\n        prop = nested.schema\n        childMap = nested.nullWideningMap\n        hasUntrackableAnyOfWidening ||= nested.hasUntrackableAnyOfWidening\n      } else if (isSchemaObject(prop) && prop.type === 'array' && prop.items) {\n        const nested = coerceStrictSchema(prop.items, prop.items.required || [])\n        prop = {\n          ...prop,\n          items: nested.schema,\n        }\n        childMap = nested.nullWideningMap\n          ? { items: nested.nullWideningMap }\n          : undefined\n        hasUntrackableAnyOfWidening ||= nested.hasUntrackableAnyOfWidening\n      } else if (isSchemaObject(prop) && prop.anyOf) {\n        const nested = coerceStrictSchema(prop, prop.required || [])\n        prop = nested.schema\n        childMap = nested.nullWideningMap\n        hasUntrackableAnyOfWidening ||= nested.hasUntrackableAnyOfWidening\n      } else if (isSchemaObject(prop) && 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        const originallyAcceptedNull = acceptsNull(prop)\n\n        // `type: [..., 'null']` alone does not make null valid when an enum or\n        // const still excludes it; strict decoding would be forced to emit the\n        // original literal instead of the synthetic omission marker.\n        if (isSchemaObject(prop) && 'const' in prop && prop.const !== null) {\n          const { const: constValue, ...withoutConst } = prop\n          prop = { ...withoutConst, enum: [constValue, null] }\n        } else if (\n          isSchemaObject(prop) &&\n          Array.isArray(prop.enum) &&\n          !prop.enum.includes(null)\n        ) {\n          prop = { ...prop, enum: [...prop.enum, null] }\n        }\n\n        if (isSchemaObject(prop) && prop.anyOf) {\n          // A genuine null branch can use type, enum, or const. Only add a\n          // provider omission marker when the original union rejected null.\n          if (!acceptsNull(prop)) {\n            prop = { ...prop, anyOf: [...prop.anyOf, { type: 'null' }] }\n          }\n        } else if (\n          isSchemaObject(prop) &&\n          prop.type &&\n          !Array.isArray(prop.type)\n        ) {\n          prop = { ...prop, type: [prop.type, 'null'] }\n        } else if (\n          isSchemaObject(prop) &&\n          Array.isArray(prop.type) &&\n          !prop.type.includes('null')\n        ) {\n          prop = { ...prop, type: [...prop.type, 'null'] }\n        }\n\n        widenedHere = !originallyAcceptedNull && acceptsNull(prop)\n      }\n\n      properties[propName] = prop\n      if (childMap || widenedHere) {\n        propertyMaps[propName] = {\n          ...(childMap ?? {}),\n          ...(widenedHere ? { widened: true } : {}),\n        }\n      }\n    }\n\n    result.properties = properties\n    result.required = allPropertyNames\n    result.additionalProperties = false\n    if (Object.keys(propertyMaps).length > 0) {\n      nullWideningMap.properties = propertyMaps\n    }\n  }\n\n  if (result.type === 'array' && result.items) {\n    const nested = coerceStrictSchema(result.items, result.items.required || [])\n    result.items = nested.schema\n    if (nested.nullWideningMap) {\n      nullWideningMap.items = nested.nullWideningMap\n    }\n    hasUntrackableAnyOfWidening ||= nested.hasUntrackableAnyOfWidening\n  }\n\n  if (result.anyOf && Array.isArray(result.anyOf)) {\n    const variants = result.anyOf.map((variant) =>\n      coerceStrictSchema(variant, variant.required || []),\n    )\n    result.anyOf = variants.map((variant) => variant.schema)\n    hasUntrackableAnyOfWidening ||= variants.some(\n      (variant) =>\n        variant.nullWideningMap !== undefined ||\n        variant.hasUntrackableAnyOfWidening,\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 {\n    schema: result,\n    nullWideningMap: pruneMap(nullWideningMap),\n    hasUntrackableAnyOfWidening,\n  }\n}\n"],"mappings":"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"}

package/dist/esm/utils/tool-input-normalizer.d.ts

@@ -0,0 +1,12 @@
+import { Tool } from '@tanstack/ai';
+import { StructuredOutputCompatibility } from './schema-converter.js';
+type ToolInputNormalizer = (toolName: string, input: unknown) => unknown;
+type SchemaConverterWithMap = (schema: Record<string, any>, originalRequired?: Array<string>) => StructuredOutputCompatibility;
+/**
+ * Build the inverse transform for the strict tool schemas sent in one request.
+ * Pass the same converter the request used so subclass schema tweaks stay
+ * aligned with undo. Non-strict tools are excluded because they were not
+ * null-widened on the wire.
+ */
+export declare function createToolInputNormalizer(tools: Array<Tool> | undefined, convertSchema?: SchemaConverterWithMap): ToolInputNormalizer;
+export {};

package/dist/esm/utils/tool-input-normalizer.js

@@ -0,0 +1,36 @@
+import { isStrictModeCompatible, makeStructuredOutputCompatibleWithMap } from "./schema-converter.js";
+import { undoNullWidening } from "@tanstack/ai-utils";
+//#region src/utils/tool-input-normalizer.ts
+/**
+* Build the inverse transform for the strict tool schemas sent in one request.
+* Pass the same converter the request used so subclass schema tweaks stay
+* aligned with undo. Non-strict tools are excluded because they were not
+* null-widened on the wire.
+*/
+function createToolInputNormalizer(tools, convertSchema = makeStructuredOutputCompatibleWithMap) {
+	const maps = /* @__PURE__ */ new Map();
+	const seenNames = /* @__PURE__ */ new Set();
+	const ambiguousNames = /* @__PURE__ */ new Set();
+	for (const tool of tools ?? []) {
+		if (ambiguousNames.has(tool.name)) continue;
+		if (seenNames.has(tool.name)) {
+			maps.delete(tool.name);
+			ambiguousNames.add(tool.name);
+			continue;
+		}
+		seenNames.add(tool.name);
+		const inputSchema = tool.inputSchema ?? {
+			type: "object",
+			properties: {},
+			required: []
+		};
+		if (!isStrictModeCompatible(inputSchema)) continue;
+		const { nullWideningMap } = convertSchema(inputSchema, inputSchema.required || []);
+		if (nullWideningMap) maps.set(tool.name, nullWideningMap);
+	}
+	return (toolName, input) => undoNullWidening(input, maps.get(toolName));
+}
+//#endregion
+export { createToolInputNormalizer };
+
+//# sourceMappingURL=tool-input-normalizer.js.map

package/dist/esm/utils/tool-input-normalizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-input-normalizer.js","names":[],"sources":["../../../src/utils/tool-input-normalizer.ts"],"sourcesContent":["import { undoNullWidening } from '@tanstack/ai-utils'\nimport {\n  isStrictModeCompatible,\n  makeStructuredOutputCompatibleWithMap,\n} from './schema-converter'\nimport type { JSONSchema, Tool } from '@tanstack/ai'\nimport type { NullWideningMap } from '@tanstack/ai-utils'\nimport type { StructuredOutputCompatibility } from './schema-converter'\n\ntype ToolInputNormalizer = (toolName: string, input: unknown) => unknown\n\ntype SchemaConverterWithMap = (\n  schema: Record<string, any>,\n  originalRequired?: Array<string>,\n) => StructuredOutputCompatibility\n\n/**\n * Build the inverse transform for the strict tool schemas sent in one request.\n * Pass the same converter the request used so subclass schema tweaks stay\n * aligned with undo. Non-strict tools are excluded because they were not\n * null-widened on the wire.\n */\nexport function createToolInputNormalizer(\n  tools: Array<Tool> | undefined,\n  convertSchema: SchemaConverterWithMap = makeStructuredOutputCompatibleWithMap,\n): ToolInputNormalizer {\n  const maps = new Map<string, NullWideningMap>()\n  const seenNames = new Set<string>()\n  const ambiguousNames = new Set<string>()\n\n  for (const tool of tools ?? []) {\n    if (ambiguousNames.has(tool.name)) continue\n    if (seenNames.has(tool.name)) {\n      maps.delete(tool.name)\n      ambiguousNames.add(tool.name)\n      continue\n    }\n    seenNames.add(tool.name)\n\n    const inputSchema = (tool.inputSchema ?? {\n      type: 'object',\n      properties: {},\n      required: [],\n    }) as JSONSchema\n    if (!isStrictModeCompatible(inputSchema)) continue\n\n    const { nullWideningMap } = convertSchema(\n      inputSchema,\n      inputSchema.required || [],\n    )\n    if (nullWideningMap) maps.set(tool.name, nullWideningMap)\n  }\n\n  return (toolName, input) => undoNullWidening(input, maps.get(toolName))\n}\n"],"mappings":";;;;;;;;;AAsBA,SAAgB,0BACd,OACA,gBAAwC,uCACnB;CACrB,MAAM,uBAAO,IAAI,IAA6B;CAC9C,MAAM,4BAAY,IAAI,IAAY;CAClC,MAAM,iCAAiB,IAAI,IAAY;CAEvC,KAAK,MAAM,QAAQ,SAAS,CAAC,GAAG;EAC9B,IAAI,eAAe,IAAI,KAAK,IAAI,GAAG;EACnC,IAAI,UAAU,IAAI,KAAK,IAAI,GAAG;GAC5B,KAAK,OAAO,KAAK,IAAI;GACrB,eAAe,IAAI,KAAK,IAAI;GAC5B;EACF;EACA,UAAU,IAAI,KAAK,IAAI;EAEvB,MAAM,cAAe,KAAK,eAAe;GACvC,MAAM;GACN,YAAY,CAAC;GACb,UAAU,CAAC;EACb;EACA,IAAI,CAAC,uBAAuB,WAAW,GAAG;EAE1C,MAAM,EAAE,oBAAoB,cAC1B,aACA,YAAY,YAAY,CAAC,CAC3B;EACA,IAAI,iBAAiB,KAAK,IAAI,KAAK,MAAM,eAAe;CAC1D;CAEA,QAAQ,UAAU,UAAU,iBAAiB,OAAO,KAAK,IAAI,QAAQ,CAAC;AACxE"}

package/dist/esm/utils/tool-input-normalizer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/openai-base",
-  "version": "0.10.1",
+  "version": "0.10.3",
   "description": "Shared OpenAI SDK base adapters for TanStack AI providers using Chat Completions and Responses APIs.",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -47,13 +47,13 @@
     "@tanstack/ai-utils": "^0.4.0"
   },
   "peerDependencies": {
-    "@tanstack/ai": "^0.47.2"
+    "@tanstack/ai": "^0.48.0"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "4.1.10",
     "vite": "^8.2.1",
     "zod": "^4.2.0",
-    "@tanstack/ai": "0.47.2"
+    "@tanstack/ai": "0.48.0"
   },
   "scripts": {
     "build": "vite build",

package/src/adapters/chat-completions-text.ts

@@ -6,7 +6,9 @@ import {
 } from '@tanstack/ai/adapter-internals'
 import { generateId } from '@tanstack/ai-utils'
 import { extractRequestOptions } from '../utils/request-options'
-import { makeStructuredOutputCompatible } from '../utils/schema-converter'
+import { makeStructuredOutputCompatibleWithMap } from '../utils/schema-converter'
+import { createToolInputNormalizer } from '../utils/tool-input-normalizer'
+import type { StructuredOutputCompatibility } from '../utils/schema-converter'
 import { buildChatCompletionsUsage } from '../usage'
 import { convertToolsToChatCompletionsFormat } from './chat-completions-tool-converter'
 import type OpenAI from 'openai'
@@ -25,8 +27,7 @@ import type {
   DefaultMessageMetadataByModality,
   Modality,
   ModelMessage,
-  RunFinishedEvent,
-  StreamChunk,
+  AdapterYieldChunk,
   TextOptions,
 } from '@tanstack/ai'
 
@@ -69,7 +70,7 @@ export abstract class OpenAIBaseChatCompletionsTextAdapter<
 
   async *chatStream(
     options: TextOptions<TProviderOptions>,
-  ): AsyncIterable<StreamChunk> {
+  ): AsyncIterable<AdapterYieldChunk> {
     // AG-UI lifecycle tracking (mutable state object for ESLint compatibility)
     const aguiState = {
       runId: generateId(this.name),
@@ -110,7 +111,7 @@ export abstract class OpenAIBaseChatCompletionsTextAdapter<
     options: TextOptions,
     aguiState: ChatStreamState,
     source: 'chatStream' | 'processStreamChunks',
-  ): AsyncIterable<StreamChunk> {
+  ): AsyncIterable<AdapterYieldChunk> {
     // Narrow before logging: raw SDK errors can carry request metadata
     // (including auth headers) which we must never surface to user loggers.
     const errorPayload = toRunErrorPayload(
@@ -185,6 +186,8 @@ export abstract class OpenAIBaseChatCompletionsTextAdapter<
 
     yield {
       type: EventType.RUN_ERROR,
+      runId: aguiState.runId,
+      threadId: aguiState.threadId,
       model: options.model,
       timestamp: Date.now(),
       message: errorPayload.message,
@@ -320,7 +323,7 @@ export abstract class OpenAIBaseChatCompletionsTextAdapter<
    */
   async *structuredOutputStream(
     options: StructuredOutputOptions<TProviderOptions>,
-  ): AsyncIterable<StreamChunk> {
+  ): AsyncIterable<AdapterYieldChunk> {
     const { chatOptions, outputSchema } = options
     const requestParams = this.mapOptionsToRequest(chatOptions)
 
@@ -349,7 +352,7 @@ export abstract class OpenAIBaseChatCompletionsTextAdapter<
 
     const closeReasoningLifecycle = function* (this: {
       name: string
-    }): Generator<StreamChunk> {
+    }): Generator<AdapterYieldChunk> {
       if (reasoningMessageId && !hasClosedReasoning) {
         hasClosedReasoning = true
         yield {
@@ -374,6 +377,9 @@ export abstract class OpenAIBaseChatCompletionsTextAdapter<
             content: accumulatedReasoning,
           }
         }
+        reasoningMessageId = undefined
+        stepId = undefined
+        hasClosedReasoning = false
       }
     }.bind(this)
 
@@ -644,15 +650,29 @@ export abstract class OpenAIBaseChatCompletionsTextAdapter<
     )
   }
 
+  /**
+   * Strict conversion plus the inverse null-widening map for this request.
+   * Override this when schema conversion changes, so tool-input undo matches
+   * the wire schema.
+   */
+  protected makeStructuredOutputCompatibleWithMap(
+    schema: Record<string, any>,
+    originalRequired?: Array<string>,
+  ): StructuredOutputCompatibility {
+    return makeStructuredOutputCompatibleWithMap(schema, originalRequired)
+  }
+
   /**
    * Applies provider-specific transformations for structured output compatibility.
-   * Override this in subclasses to handle provider-specific quirks.
+   * Override `makeStructuredOutputCompatibleWithMap` when you need the inverse map
+   * to match the wire schema.
    */
   protected makeStructuredOutputCompatible(
     schema: Record<string, any>,
     originalRequired?: Array<string>,
   ): Record<string, any> {
-    return makeStructuredOutputCompatible(schema, originalRequired)
+    return this.makeStructuredOutputCompatibleWithMap(schema, originalRequired)
+      .schema
   }
 
   /**
@@ -689,7 +709,12 @@ export abstract class OpenAIBaseChatCompletionsTextAdapter<
     stream: AsyncIterable<ChatCompletionChunk>,
     options: TextOptions,
     aguiState: ChatStreamState,
-  ): AsyncIterable<StreamChunk> {
+  ): AsyncIterable<AdapterYieldChunk> {
+    const normalizeToolInput = createToolInputNormalizer(
+      options.tools,
+      (schema, required) =>
+        this.makeStructuredOutputCompatibleWithMap(schema, required),
+    )
     let accumulatedContent = ''
     let hasEmittedTextMessageStart = false
     let lastModel: string | undefined
@@ -958,8 +983,10 @@ export abstract class OpenAIBaseChatCompletionsTextAdapter<
               if (toolCall.arguments) {
                 try {
                   const parsed: unknown = JSON.parse(toolCall.arguments)
-                  parsedInput =
-                    parsed && typeof parsed === 'object' ? parsed : {}
+                  parsedInput = normalizeToolInput(
+                    toolCall.name,
+                    parsed && typeof parsed === 'object' ? parsed : {},
+                  )
                 } catch (parseError) {
                   options.logger.errors(
                     `${this.name}.processStreamChunks tool-args JSON parse failed`,
@@ -1030,7 +1057,10 @@ export abstract class OpenAIBaseChatCompletionsTextAdapter<
           if (toolCall.arguments) {
             try {
               const parsed: unknown = JSON.parse(toolCall.arguments)
-              parsedInput = parsed && typeof parsed === 'object' ? parsed : {}
+              parsedInput = normalizeToolInput(
+                toolCall.name,
+                parsed && typeof parsed === 'object' ? parsed : {},
+              )
             } catch (parseError) {
               // Mirror the finish_reason path's logger call — a truncated
               // stream emitting malformed tool-call JSON would otherwise
@@ -1114,7 +1144,7 @@ export abstract class OpenAIBaseChatCompletionsTextAdapter<
         // tool results that would never arrive. OpenAI's legacy
         // `function_call` value (from the v1 function-calling API) is
         // normalized to `tool_calls` — semantically the same termination.
-        const finishReason: NonNullable<RunFinishedEvent['finishReason']> =
+        const finishReason: NonNullable<AdapterYieldChunk['finishReason']> =
           emittedAnyToolCallEnd
             ? 'tool_calls'
             : pendingFinishReason === 'tool_calls'
@@ -1401,9 +1431,9 @@ export abstract class OpenAIBaseChatCompletionsTextAdapter<
    * Handles backward compatibility with string content.
    */
   protected normalizeContent(
-    content: string | null | Array<ContentPart>,
+    content: string | null | undefined | Array<ContentPart>,
   ): Array<ContentPart> {
-    if (content === null) {
+    if (content === null || content === undefined) {
       return []
     }
     if (typeof content === 'string') {
@@ -1416,9 +1446,12 @@ export abstract class OpenAIBaseChatCompletionsTextAdapter<
    * Extracts text content from a content value that may be string, null, or ContentPart array.
    */
   protected extractTextContent(
-    content: string | null | Array<ContentPart>,
+    content: string | null | undefined | Array<ContentPart>,
   ): string {
-    if (content === null) {
+    // Tool-call-only assistant turns (e.g. an approval resume replaying the
+    // pending call) carry no text and arrive as `null` or `undefined`; both
+    // must collapse to '' rather than crash on `.filter`.
+    if (content === null || content === undefined) {
       return ''
     }
     if (typeof content === 'string') {

package/src/adapters/chat-completions-tool-converter.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from 'vitest'
+import { convertFunctionToolToChatCompletionsFormat } from './chat-completions-tool-converter'
+import type { Tool } from '@tanstack/ai'
+
+describe('chat-completions tool converter', () => {
+  it('falls back from strict mode when an anyOf variant needs null widening', () => {
+    const out = convertFunctionToolToChatCompletionsFormat(
+      anyOfOptionalVariantTool,
+    )
+
+    expect(out.function.strict).toBe(false)
+  })
+
+  it('falls back from strict mode for boolean schema nodes', () => {
+    const out = convertFunctionToolToChatCompletionsFormat(booleanSchemaTool)
+
+    expect(out.function.strict).toBe(false)
+    expect(out.function.parameters).toEqual(booleanSchemaTool.inputSchema)
+  })
+})
+
+const booleanSchemaInput = {
+  type: 'object',
+  properties: {},
+  required: [],
+}
+Reflect.set(booleanSchemaInput.properties, 'acceptAnything', true)
+
+const booleanSchemaTool = {
+  name: 'accept_anything',
+  description: 'Accept any value',
+  inputSchema: booleanSchemaInput,
+} satisfies Tool
+
+const anyOfOptionalVariantTool: Tool = {
+  name: 'store_variant',
+  description: 'Store a union variant',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      value: {
+        anyOf: [
+          {
+            type: 'object',
+            properties: {
+              kind: { const: 'optional' },
+              note: { type: 'string' },
+            },
+            required: ['kind'],
+          },
+          {
+            type: 'object',
+            properties: {
+              kind: { const: 'nullable' },
+              note: { type: ['string', 'null'] },
+            },
+            required: ['kind', 'note'],
+          },
+        ],
+      },
+    },
+    required: ['value'],
+  },
+}