@tanstack/openai-base 0.9.9 → 0.9.10

package/dist/esm/utils/request-options.js.map

@@ -1 +1 @@
-{"version":3,"file":"request-options.js","sources":["../../../src/utils/request-options.ts"],"sourcesContent":["/**\n * Extract `headers` and `signal` from a `Request | RequestInit` for the OpenAI\n * SDK's per-call `RequestOptions`. `Request` exposes `headers` as a `Headers`\n * instance (HeadersInit-compatible) while `RequestInit` exposes `HeadersInit`\n * directly — this helper accepts either shape so callers don't need to cast.\n *\n * Always returns an object (possibly empty) rather than `undefined` so test\n * assertions that match the second argument shape via `expect.anything()` /\n * `expect.objectContaining()` keep working when no request override was set.\n */\nexport function extractRequestOptions(\n  request: Request | RequestInit | undefined,\n): { headers?: HeadersInit; signal?: AbortSignal | null } {\n  if (!request) return {}\n  // Conditional spread: under exactOptionalPropertyTypes the target's\n  // `headers?: HeadersInit` and `signal?: AbortSignal | null` forbid an\n  // explicit `undefined`. Omit the keys entirely when the source values\n  // are absent so the OpenAI SDK sees `headers: undefined` as \"not set\"\n  // rather than a present-but-undefined value.\n  return {\n    ...(request.headers !== undefined && { headers: request.headers }),\n    ...(request.signal != null && { signal: request.signal }),\n  }\n}\n"],"names":[],"mappings":"AAUO,SAAS,sBACd,SACwD;AACxD,MAAI,CAAC,QAAS,QAAO,CAAA;AAMrB,SAAO;AAAA,IACL,GAAI,QAAQ,YAAY,UAAa,EAAE,SAAS,QAAQ,QAAA;AAAA,IACxD,GAAI,QAAQ,UAAU,QAAQ,EAAE,QAAQ,QAAQ,OAAA;AAAA,EAAO;AAE3D;"}
+{"version":3,"file":"request-options.js","names":[],"sources":["../../../src/utils/request-options.ts"],"sourcesContent":["/**\n * Extract `headers` and `signal` from a `Request | RequestInit` for the OpenAI\n * SDK's per-call `RequestOptions`. `Request` exposes `headers` as a `Headers`\n * instance (HeadersInit-compatible) while `RequestInit` exposes `HeadersInit`\n * directly — this helper accepts either shape so callers don't need to cast.\n *\n * Always returns an object (possibly empty) rather than `undefined` so test\n * assertions that match the second argument shape via `expect.anything()` /\n * `expect.objectContaining()` keep working when no request override was set.\n */\nexport function extractRequestOptions(\n  request: Request | RequestInit | undefined,\n): { headers?: HeadersInit; signal?: AbortSignal | null } {\n  if (!request) return {}\n  // Conditional spread: under exactOptionalPropertyTypes the target's\n  // `headers?: HeadersInit` and `signal?: AbortSignal | null` forbid an\n  // explicit `undefined`. Omit the keys entirely when the source values\n  // are absent so the OpenAI SDK sees `headers: undefined` as \"not set\"\n  // rather than a present-but-undefined value.\n  return {\n    ...(request.headers !== undefined && { headers: request.headers }),\n    ...(request.signal != null && { signal: request.signal }),\n  }\n}\n"],"mappings":";;;;;;;;;;;AAUA,SAAgB,sBACd,SACwD;CACxD,IAAI,CAAC,SAAS,OAAO,CAAC;CAMtB,OAAO;EACL,GAAI,QAAQ,YAAY,KAAA,KAAa,EAAE,SAAS,QAAQ,QAAQ;EAChE,GAAI,QAAQ,UAAU,QAAQ,EAAE,QAAQ,QAAQ,OAAO;CACzD;AACF"}

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

@@ -1,165 +1,212 @@
-const SUPPORTED_STRING_FORMATS = /* @__PURE__ */ new Set([
-  "date-time",
-  "time",
-  "date",
-  "duration",
-  "email",
-  "hostname",
-  "ipv4",
-  "ipv6",
-  "uuid"
+//#region src/utils/schema-converter.ts
+/**
+* String `format` values accepted by OpenAI's strict Structured Outputs subset.
+* Any other format (e.g. "uri", "uri-reference", "regex") causes the API to
+* reject the whole request with `400 ... '<format>' is not a valid format`.
+* MCP servers and hand-written tools routinely declare such formats, so we strip
+* the unsupported ones before sending. See:
+* https://platform.openai.com/docs/guides/structured-outputs#supported-properties
+*/
+var SUPPORTED_STRING_FORMATS = /* @__PURE__ */ new Set([
+	"date-time",
+	"time",
+	"date",
+	"duration",
+	"email",
+	"hostname",
+	"ipv4",
+	"ipv6",
+	"uuid"
 ]);
+/**
+* Recursively drop JSON-Schema `format` keywords whose value isn't in OpenAI's
+* strict-mode allowlist. Pure — returns a fresh tree and never mutates `node`,
+* so the caller's original tool definition is left intact.
+*
+* A property *named* `format` always has a schema (object/boolean) value, never
+* a bare string, so it is preserved and recursed into; only the `format`
+* *keyword* (whose value is a string) is subject to removal.
+*/
 function stripUnsupportedFormats(node) {
-  if (Array.isArray(node)) return node.map(stripUnsupportedFormats);
-  if (node === null || typeof node !== "object") return node;
-  const out = {};
-  for (const [key, value] of Object.entries(node)) {
-    if (key === "format" && typeof value === "string" && !SUPPORTED_STRING_FORMATS.has(value)) {
-      continue;
-    }
-    out[key] = stripUnsupportedFormats(value);
-  }
-  return out;
+	if (Array.isArray(node)) return node.map(stripUnsupportedFormats);
+	if (node === null || typeof node !== "object") return node;
+	const out = {};
+	for (const [key, value] of Object.entries(node)) {
+		if (key === "format" && typeof value === "string" && !SUPPORTED_STRING_FORMATS.has(value)) continue;
+		out[key] = stripUnsupportedFormats(value);
+	}
+	return out;
 }
+/**
+* Transform a JSON schema to be compatible with OpenAI's structured output requirements.
+* OpenAI requires:
+* - All properties must be in the `required` array
+* - Optional fields should have null added to their type union
+* - additionalProperties must be false for objects
+* - String `format` keywords must be from a fixed allowlist (others are stripped)
+*
+* @param schema - JSON schema to transform
+* @param originalRequired - Original required array (to know which fields were optional)
+* @returns Transformed schema compatible with OpenAI structured output
+*/
 function makeStructuredOutputCompatible(schema, originalRequired) {
-  return stripUnsupportedFormats(coerceStrictSchema(schema, originalRequired));
+	return stripUnsupportedFormats(coerceStrictSchema(schema, originalRequired));
 }
-const STRICT_UNSUPPORTED_KEYWORDS = [
-  "oneOf",
-  "allOf",
-  "not",
-  "$ref",
-  "$defs",
-  "definitions"
+/**
+* JSON-Schema keywords outside OpenAI's strict Structured Outputs subset. A
+* schema using any of these can't be coerced into a strict-valid shape, and
+* sending it with `strict: true` makes the API reject the ENTIRE request
+* (e.g. `400 Invalid schema ... 'additionalProperties' is required to be ...`).
+* Tools with such schemas are emitted with `strict: false` instead (see the
+* tool converters) so they remain callable. MCP servers (e.g. Notion) routinely
+* emit these.
+*
+* - `oneOf` / `allOf` / `not` — combinator keywords strict mode rejects
+* - `$ref` / `$defs` / `definitions` — references and definition pools whose
+*   object subschemas escape the `additionalProperties: false` normalization
+*   strict mode requires
+*/
+var STRICT_UNSUPPORTED_KEYWORDS = [
+	"oneOf",
+	"allOf",
+	"not",
+	"$ref",
+	"$defs",
+	"definitions"
 ];
-const TYPE_INDICATOR_KEYWORDS = [
-  "type",
-  "enum",
-  "const",
-  "anyOf",
-  "oneOf",
-  "allOf",
-  "$ref"
+/**
+* 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.)
+*/
+var TYPE_INDICATOR_KEYWORDS = [
+	"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.
+* 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.
+*
+* 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.
+*/
 function isStrictModeCompatible(schema) {
-  return !containsStrictUnsupportedKeyword(schema) && !containsTypelessSchema(schema) && !containsOpenObject(schema);
+	return !containsStrictUnsupportedKeyword(schema) && !containsTypelessSchema(schema) && !containsOpenObject(schema);
 }
+/**
+* Reports object schemas that cannot be closed without changing their input
+* semantics. Objects with `properties` and no explicit
+* `additionalProperties` are safe because `coerceStrictSchema` closes them.
+*/
 function containsOpenObject(node) {
-  if (Array.isArray(node)) {
-    return node.some(containsOpenObject);
-  }
-  if (node === null || typeof node !== "object") return false;
-  const schema = node;
-  const type = schema["type"];
-  const isObjectSchema = type === "object" || Array.isArray(type) && type.includes("object");
-  if (isObjectSchema) {
-    if ("additionalProperties" in schema && schema["additionalProperties"] !== false) {
-      return true;
-    }
-    const properties = schema["properties"];
-    const hasProperties = properties !== null && typeof properties === "object" && !Array.isArray(properties);
-    if (!hasProperties && schema["additionalProperties"] !== false) {
-      return true;
-    }
-  }
-  return Object.values(schema).some(containsOpenObject);
+	if (Array.isArray(node)) return node.some(containsOpenObject);
+	if (node === null || typeof node !== "object") return false;
+	const schema = node;
+	const type = schema["type"];
+	if (type === "object" || Array.isArray(type) && type.includes("object")) {
+		if ("additionalProperties" in schema && schema["additionalProperties"] !== false) return true;
+		const properties = schema["properties"];
+		if (!(properties !== null && typeof properties === "object" && !Array.isArray(properties)) && schema["additionalProperties"] !== false) return true;
+	}
+	return Object.values(schema).some(containsOpenObject);
 }
 function containsStrictUnsupportedKeyword(node) {
-  if (Array.isArray(node)) {
-    return node.some(containsStrictUnsupportedKeyword);
-  }
-  if (node === null || typeof node !== "object") return false;
-  for (const [key, value] of Object.entries(node)) {
-    if (STRICT_UNSUPPORTED_KEYWORDS.includes(key)) return true;
-    if (containsStrictUnsupportedKeyword(value)) return true;
-  }
-  return false;
+	if (Array.isArray(node)) return node.some(containsStrictUnsupportedKeyword);
+	if (node === null || typeof node !== "object") return false;
+	for (const [key, value] of Object.entries(node)) {
+		if (STRICT_UNSUPPORTED_KEYWORDS.includes(key)) return true;
+		if (containsStrictUnsupportedKeyword(value)) return true;
+	}
+	return false;
 }
+/** 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;
-  }
-  return !TYPE_INDICATOR_KEYWORDS.some((key) => key in node);
+	if (node === null || typeof node !== "object" || Array.isArray(node)) 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) {
-  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)
-  );
+	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));
 }
+/**
+* Strict-mode structural rewrite (required widening, nullability,
+* additionalProperties). Kept private so the public entry point can apply the
+* format-stripping pass exactly once over the fully-rewritten tree.
+*/
 function coerceStrictSchema(schema, originalRequired) {
-  const result = { ...schema };
-  const required = originalRequired ?? (Array.isArray(result["required"]) ? result["required"] : []);
-  if (result.type === "object" && result.properties) {
-    const properties = { ...result.properties };
-    const allPropertyNames = Object.keys(properties);
-    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"
-        );
-      }
-      if (wasOptional) {
-        if (prop.anyOf) {
-          if (!prop.anyOf.some((v) => v.type === "null")) {
-            prop = { ...prop, anyOf: [...prop.anyOf, { type: "null" }] };
-          }
-        } else if (prop.type && !Array.isArray(prop.type)) {
-          prop = { ...prop, type: [prop.type, "null"] };
-        } else if (Array.isArray(prop.type) && !prop.type.includes("null")) {
-          prop = { ...prop, type: [...prop.type, "null"] };
-        }
-      }
-      properties[propName] = prop;
-    }
-    result.properties = properties;
-    result.required = allPropertyNames;
-    result.additionalProperties = false;
-  }
-  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;
+	const result = { ...schema };
+	const required = originalRequired ?? (Array.isArray(result["required"]) ? result["required"] : []);
+	if (result.type === "object" && result.properties) {
+		const properties = { ...result.properties };
+		const allPropertyNames = Object.keys(properties);
+		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");
+			if (wasOptional) {
+				if (prop.anyOf) {
+					if (!prop.anyOf.some((v) => v.type === "null")) prop = {
+						...prop,
+						anyOf: [...prop.anyOf, { type: "null" }]
+					};
+				} else if (prop.type && !Array.isArray(prop.type)) prop = {
+					...prop,
+					type: [prop.type, "null"]
+				};
+				else if (Array.isArray(prop.type) && !prop.type.includes("null")) prop = {
+					...prop,
+					type: [...prop.type, "null"]
+				};
+			}
+			properties[propName] = prop;
+		}
+		result.properties = properties;
+		result.required = allPropertyNames;
+		result.additionalProperties = false;
+	}
+	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;
 }
-export {
-  isStrictModeCompatible,
-  makeStructuredOutputCompatible,
-  stripUnsupportedFormats
-};
-//# sourceMappingURL=schema-converter.js.map
+//#endregion
+export { isStrictModeCompatible, makeStructuredOutputCompatible, stripUnsupportedFormats };
+
+//# sourceMappingURL=schema-converter.js.map

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 * 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"],"names":[],"mappings":"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"}
+{"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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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/openai-base",
-  "version": "0.9.9",
+  "version": "0.9.10",
   "description": "Shared OpenAI SDK base adapters for TanStack AI providers using Chat Completions and Responses APIs.",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -44,23 +44,23 @@
   ],
   "dependencies": {
     "openai": "^6.41.0",
-    "@tanstack/ai-utils": "0.3.1"
+    "@tanstack/ai-utils": "0.4.0"
   },
   "peerDependencies": {
-    "@tanstack/ai": "^0.42.0"
+    "@tanstack/ai": "^0.43.0"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "4.0.14",
-    "vite": "^7.3.3",
+    "vite": "^8.1.4",
     "zod": "^4.2.0",
-    "@tanstack/ai": "0.42.0"
+    "@tanstack/ai": "0.43.0"
   },
   "scripts": {
     "build": "vite build",
     "clean": "premove ./build ./dist",
-    "lint:fix": "eslint ./src --fix",
+    "lint:fix": "oxlint src --type-aware --fix",
     "test:build": "publint --strict",
-    "test:eslint": "eslint ./src",
+    "test:oxlint": "oxlint src --type-aware",
     "test:lib": "vitest run",
     "test:lib:dev": "pnpm test:lib --watch",
     "test:types": "tsc"

package/src/adapters/responses-text.ts

@@ -85,9 +85,12 @@ export abstract class OpenAIBaseResponsesTextAdapter<
       }
     >()
 
-    // AG-UI lifecycle tracking
+    // AG-UI lifecycle tracking. Honor a caller-supplied `runId` (as `threadId`
+    // already does) so the emitted RUN_STARTED matches the id the caller keys
+    // durability by — e.g. a summarize run threading the client's runId through
+    // for mid-run reload resumability. Falls back to a generated id.
     const aguiState = {
-      runId: generateId(this.name),
+      runId: options.runId ?? generateId(this.name),
       threadId: options.threadId ?? generateId(this.name),
       messageId: generateId(this.name),
       hasEmittedRunStarted: false,

package/dist/esm/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;"}