@tanstack/openai-base 0.9.3 → 0.9.5

package/dist/esm/usage.js

@@ -0,0 +1,83 @@
+import { buildBaseUsage } from "@tanstack/ai";
+function buildChatCompletionsUsage(usage) {
+  if (!usage) return void 0;
+  const result = buildBaseUsage({
+    promptTokens: usage.prompt_tokens || 0,
+    completionTokens: usage.completion_tokens || 0,
+    totalTokens: usage.total_tokens || 0
+  });
+  const completionDetails = usage.completion_tokens_details;
+  const completionTokensDetails = {
+    ...completionDetails?.reasoning_tokens ? { reasoningTokens: completionDetails.reasoning_tokens } : {},
+    ...completionDetails?.audio_tokens ? { audioTokens: completionDetails.audio_tokens } : {}
+  };
+  const promptDetails = usage.prompt_tokens_details;
+  const promptTokensDetails = {
+    ...promptDetails?.cached_tokens ? { cachedTokens: promptDetails.cached_tokens } : {},
+    ...promptDetails?.audio_tokens ? { audioTokens: promptDetails.audio_tokens } : {}
+  };
+  if (Object.keys(completionTokensDetails).length > 0) {
+    result.completionTokensDetails = completionTokensDetails;
+  }
+  if (Object.keys(promptTokensDetails).length > 0) {
+    result.promptTokensDetails = promptTokensDetails;
+  }
+  const providerUsageDetails = {
+    ...completionDetails?.accepted_prediction_tokens ? {
+      acceptedPredictionTokens: completionDetails.accepted_prediction_tokens
+    } : {},
+    ...completionDetails?.rejected_prediction_tokens ? {
+      rejectedPredictionTokens: completionDetails.rejected_prediction_tokens
+    } : {}
+  };
+  if (Object.keys(providerUsageDetails).length > 0) {
+    result.providerUsageDetails = providerUsageDetails;
+  }
+  return result;
+}
+function buildResponsesUsage(usage) {
+  if (!usage) return void 0;
+  const result = buildBaseUsage({
+    promptTokens: usage.input_tokens || 0,
+    completionTokens: usage.output_tokens || 0,
+    totalTokens: usage.total_tokens || 0
+  });
+  const cachedTokens = usage.input_tokens_details?.cached_tokens;
+  if (cachedTokens && cachedTokens > 0) {
+    result.promptTokensDetails = {
+      ...result.promptTokensDetails,
+      cachedTokens
+    };
+  }
+  const reasoningTokens = usage.output_tokens_details?.reasoning_tokens;
+  if (reasoningTokens && reasoningTokens > 0) {
+    result.completionTokensDetails = {
+      ...result.completionTokensDetails,
+      reasoningTokens
+    };
+  }
+  return result;
+}
+function buildImagesUsage(usage) {
+  if (!usage) return void 0;
+  const result = buildBaseUsage({
+    promptTokens: usage.input_tokens || 0,
+    completionTokens: usage.output_tokens || 0,
+    totalTokens: usage.total_tokens || 0
+  });
+  const inputDetails = usage.input_tokens_details;
+  const promptTokensDetails = {
+    ...inputDetails?.text_tokens ? { textTokens: inputDetails.text_tokens } : {},
+    ...inputDetails?.image_tokens ? { imageTokens: inputDetails.image_tokens } : {}
+  };
+  if (Object.keys(promptTokensDetails).length > 0) {
+    result.promptTokensDetails = promptTokensDetails;
+  }
+  return result;
+}
+export {
+  buildChatCompletionsUsage,
+  buildImagesUsage,
+  buildResponsesUsage
+};
+//# sourceMappingURL=usage.js.map

package/dist/esm/usage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"usage.js","sources":["../../src/usage.ts"],"sourcesContent":["import { buildBaseUsage } from '@tanstack/ai'\nimport type { TokenUsage } from '@tanstack/ai'\nimport type OpenAI from 'openai'\n\n/**\n * Build normalized {@link TokenUsage} from an OpenAI-compatible Chat\n * Completions `usage` object.\n *\n * Shared by every provider that routes through\n * {@link OpenAIBaseChatCompletionsTextAdapter} (OpenAI Chat Completions, Grok,\n * Groq). Surfaces cached prompt tokens and reasoning/audio detail tokens when\n * the provider reports them. Returns `undefined` when the provider reported no\n * usage object, so callers omit the field rather than fabricating zeroed totals.\n */\nexport function buildChatCompletionsUsage(\n  usage: OpenAI.Chat.Completions.ChatCompletion['usage'] | undefined | null,\n): TokenUsage | undefined {\n  if (!usage) return undefined\n\n  const result = buildBaseUsage({\n    promptTokens: usage.prompt_tokens || 0,\n    completionTokens: usage.completion_tokens || 0,\n    totalTokens: usage.total_tokens || 0,\n  })\n\n  const completionDetails = usage.completion_tokens_details\n  const completionTokensDetails = {\n    ...(completionDetails?.reasoning_tokens\n      ? { reasoningTokens: completionDetails.reasoning_tokens }\n      : {}),\n    ...(completionDetails?.audio_tokens\n      ? { audioTokens: completionDetails.audio_tokens }\n      : {}),\n  }\n\n  const promptDetails = usage.prompt_tokens_details\n  const promptTokensDetails = {\n    ...(promptDetails?.cached_tokens\n      ? { cachedTokens: promptDetails.cached_tokens }\n      : {}),\n    ...(promptDetails?.audio_tokens\n      ? { audioTokens: promptDetails.audio_tokens }\n      : {}),\n  }\n\n  if (Object.keys(completionTokensDetails).length > 0) {\n    result.completionTokensDetails = completionTokensDetails\n  }\n  if (Object.keys(promptTokensDetails).length > 0) {\n    result.promptTokensDetails = promptTokensDetails\n  }\n\n  // Predicted Outputs accepted/rejected counts have no canonical TokenUsage\n  // slot but are still billed (rejected tokens included), so surface them under\n  // providerUsageDetails — matching how the OpenRouter adapter exposes them.\n  const providerUsageDetails = {\n    ...(completionDetails?.accepted_prediction_tokens\n      ? {\n          acceptedPredictionTokens:\n            completionDetails.accepted_prediction_tokens,\n        }\n      : {}),\n    ...(completionDetails?.rejected_prediction_tokens\n      ? {\n          rejectedPredictionTokens:\n            completionDetails.rejected_prediction_tokens,\n        }\n      : {}),\n  }\n  if (Object.keys(providerUsageDetails).length > 0) {\n    result.providerUsageDetails = providerUsageDetails\n  }\n\n  return result\n}\n\n/**\n * Build normalized {@link TokenUsage} from an OpenAI Responses API\n * `ResponseUsage` object.\n *\n * Shared by every provider that routes through\n * {@link OpenAIBaseResponsesTextAdapter}. Surfaces cached prompt tokens and\n * reasoning detail tokens when present. Returns `undefined` when the provider\n * reported no usage object, so callers omit the field rather than fabricating\n * zeroed totals.\n */\nexport function buildResponsesUsage(\n  usage: OpenAI.Responses.ResponseUsage | undefined | null,\n): TokenUsage | undefined {\n  if (!usage) return undefined\n\n  const result = buildBaseUsage({\n    promptTokens: usage.input_tokens || 0,\n    completionTokens: usage.output_tokens || 0,\n    totalTokens: usage.total_tokens || 0,\n  })\n\n  // Despite the SDK types marking these required, they can be undefined at runtime.\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n  const cachedTokens = usage.input_tokens_details?.cached_tokens\n  if (cachedTokens && cachedTokens > 0) {\n    result.promptTokensDetails = {\n      ...result.promptTokensDetails,\n      cachedTokens,\n    }\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n  const reasoningTokens = usage.output_tokens_details?.reasoning_tokens\n  if (reasoningTokens && reasoningTokens > 0) {\n    result.completionTokensDetails = {\n      ...result.completionTokensDetails,\n      reasoningTokens,\n    }\n  }\n\n  return result\n}\n\n/**\n * Build normalized {@link TokenUsage} from an OpenAI Images API `usage` object.\n *\n * Shared by every provider that generates images through the OpenAI Images SDK\n * (OpenAI, Grok). Token-billed image models (e.g. gpt-image-1) report an input\n * breakdown of text vs image tokens, which is surfaced on `promptTokensDetails`.\n * Models that don't return usage (e.g. DALL·E) yield `undefined` so callers can\n * omit the field rather than emit zeroed totals.\n */\nexport function buildImagesUsage(\n  usage: OpenAI.Images.ImagesResponse['usage'] | undefined | null,\n): TokenUsage | undefined {\n  if (!usage) return undefined\n\n  const result = buildBaseUsage({\n    promptTokens: usage.input_tokens || 0,\n    completionTokens: usage.output_tokens || 0,\n    totalTokens: usage.total_tokens || 0,\n  })\n\n  // The SDK types input_tokens_details (and its numeric fields) as required, but\n  // real responses — e.g. from DALL·E or other non-token-billed models — can\n  // omit them, so treat the breakdown as optional.\n  const inputDetails = usage.input_tokens_details as\n    | { text_tokens?: number; image_tokens?: number }\n    | undefined\n  const promptTokensDetails = {\n    ...(inputDetails?.text_tokens\n      ? { textTokens: inputDetails.text_tokens }\n      : {}),\n    ...(inputDetails?.image_tokens\n      ? { imageTokens: inputDetails.image_tokens }\n      : {}),\n  }\n  if (Object.keys(promptTokensDetails).length > 0) {\n    result.promptTokensDetails = promptTokensDetails\n  }\n\n  return result\n}\n"],"names":[],"mappings":";AAcO,SAAS,0BACd,OACwB;AACxB,MAAI,CAAC,MAAO,QAAO;AAEnB,QAAM,SAAS,eAAe;AAAA,IAC5B,cAAc,MAAM,iBAAiB;AAAA,IACrC,kBAAkB,MAAM,qBAAqB;AAAA,IAC7C,aAAa,MAAM,gBAAgB;AAAA,EAAA,CACpC;AAED,QAAM,oBAAoB,MAAM;AAChC,QAAM,0BAA0B;AAAA,IAC9B,GAAI,mBAAmB,mBACnB,EAAE,iBAAiB,kBAAkB,iBAAA,IACrC,CAAA;AAAA,IACJ,GAAI,mBAAmB,eACnB,EAAE,aAAa,kBAAkB,aAAA,IACjC,CAAA;AAAA,EAAC;AAGP,QAAM,gBAAgB,MAAM;AAC5B,QAAM,sBAAsB;AAAA,IAC1B,GAAI,eAAe,gBACf,EAAE,cAAc,cAAc,cAAA,IAC9B,CAAA;AAAA,IACJ,GAAI,eAAe,eACf,EAAE,aAAa,cAAc,aAAA,IAC7B,CAAA;AAAA,EAAC;AAGP,MAAI,OAAO,KAAK,uBAAuB,EAAE,SAAS,GAAG;AACnD,WAAO,0BAA0B;AAAA,EACnC;AACA,MAAI,OAAO,KAAK,mBAAmB,EAAE,SAAS,GAAG;AAC/C,WAAO,sBAAsB;AAAA,EAC/B;AAKA,QAAM,uBAAuB;AAAA,IAC3B,GAAI,mBAAmB,6BACnB;AAAA,MACE,0BACE,kBAAkB;AAAA,IAAA,IAEtB,CAAA;AAAA,IACJ,GAAI,mBAAmB,6BACnB;AAAA,MACE,0BACE,kBAAkB;AAAA,IAAA,IAEtB,CAAA;AAAA,EAAC;AAEP,MAAI,OAAO,KAAK,oBAAoB,EAAE,SAAS,GAAG;AAChD,WAAO,uBAAuB;AAAA,EAChC;AAEA,SAAO;AACT;AAYO,SAAS,oBACd,OACwB;AACxB,MAAI,CAAC,MAAO,QAAO;AAEnB,QAAM,SAAS,eAAe;AAAA,IAC5B,cAAc,MAAM,gBAAgB;AAAA,IACpC,kBAAkB,MAAM,iBAAiB;AAAA,IACzC,aAAa,MAAM,gBAAgB;AAAA,EAAA,CACpC;AAID,QAAM,eAAe,MAAM,sBAAsB;AACjD,MAAI,gBAAgB,eAAe,GAAG;AACpC,WAAO,sBAAsB;AAAA,MAC3B,GAAG,OAAO;AAAA,MACV;AAAA,IAAA;AAAA,EAEJ;AAGA,QAAM,kBAAkB,MAAM,uBAAuB;AACrD,MAAI,mBAAmB,kBAAkB,GAAG;AAC1C,WAAO,0BAA0B;AAAA,MAC/B,GAAG,OAAO;AAAA,MACV;AAAA,IAAA;AAAA,EAEJ;AAEA,SAAO;AACT;AAWO,SAAS,iBACd,OACwB;AACxB,MAAI,CAAC,MAAO,QAAO;AAEnB,QAAM,SAAS,eAAe;AAAA,IAC5B,cAAc,MAAM,gBAAgB;AAAA,IACpC,kBAAkB,MAAM,iBAAiB;AAAA,IACzC,aAAa,MAAM,gBAAgB;AAAA,EAAA,CACpC;AAKD,QAAM,eAAe,MAAM;AAG3B,QAAM,sBAAsB;AAAA,IAC1B,GAAI,cAAc,cACd,EAAE,YAAY,aAAa,YAAA,IAC3B,CAAA;AAAA,IACJ,GAAI,cAAc,eACd,EAAE,aAAa,aAAa,aAAA,IAC5B,CAAA;AAAA,EAAC;AAEP,MAAI,OAAO,KAAK,mBAAmB,EAAE,SAAS,GAAG;AAC/C,WAAO,sBAAsB;AAAA,EAC/B;AAEA,SAAO;AACT;"}

package/dist/esm/utils/request-options.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Extract `headers` and `signal` from a `Request | RequestInit` for the OpenAI
+ * SDK's per-call `RequestOptions`. `Request` exposes `headers` as a `Headers`
+ * instance (HeadersInit-compatible) while `RequestInit` exposes `HeadersInit`
+ * directly — this helper accepts either shape so callers don't need to cast.
+ *
+ * Always returns an object (possibly empty) rather than `undefined` so test
+ * assertions that match the second argument shape via `expect.anything()` /
+ * `expect.objectContaining()` keep working when no request override was set.
+ */
+export declare function extractRequestOptions(request: Request | RequestInit | undefined): {
+    headers?: HeadersInit;
+    signal?: AbortSignal | null;
+};

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

@@ -0,0 +1,11 @@
+function extractRequestOptions(request) {
+  if (!request) return {};
+  return {
+    ...request.headers !== void 0 && { headers: request.headers },
+    ...request.signal != null && { signal: request.signal }
+  };
+}
+export {
+  extractRequestOptions
+};
+//# sourceMappingURL=request-options.js.map

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

@@ -0,0 +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;"}

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

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

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

@@ -0,0 +1,145 @@
+const SUPPORTED_STRING_FORMATS = /* @__PURE__ */ new Set([
+  "date-time",
+  "time",
+  "date",
+  "duration",
+  "email",
+  "hostname",
+  "ipv4",
+  "ipv6",
+  "uuid"
+]);
+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;
+}
+function makeStructuredOutputCompatible(schema, originalRequired) {
+  return stripUnsupportedFormats(coerceStrictSchema(schema, originalRequired));
+}
+const STRICT_UNSUPPORTED_KEYWORDS = [
+  "oneOf",
+  "allOf",
+  "not",
+  "$ref",
+  "$defs",
+  "definitions"
+];
+const TYPE_INDICATOR_KEYWORDS = [
+  "type",
+  "enum",
+  "const",
+  "anyOf",
+  "oneOf",
+  "allOf",
+  "$ref"
+];
+function isStrictModeCompatible(schema) {
+  return !containsStrictUnsupportedKeyword(schema) && !containsTypelessSchema(schema);
+}
+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;
+}
+function isTypelessSchema(node) {
+  if (node === null || typeof node !== "object" || Array.isArray(node)) {
+    return false;
+  }
+  return !TYPE_INDICATOR_KEYWORDS.some((key) => key in node);
+}
+function containsTypelessSchema(node) {
+  if (node === null || typeof node !== "object" || Array.isArray(node)) {
+    return false;
+  }
+  const schema = node;
+  const children = [];
+  if (schema.properties && typeof schema.properties === "object") {
+    children.push(...Object.values(schema.properties));
+  }
+  if (schema.items !== void 0) {
+    children.push(
+      ...Array.isArray(schema.items) ? schema.items : [schema.items]
+    );
+  }
+  if (Array.isArray(schema.anyOf)) {
+    children.push(...schema.anyOf);
+  }
+  return children.some(
+    (child) => isTypelessSchema(child) || containsTypelessSchema(child)
+  );
+}
+function coerceStrictSchema(schema, originalRequired) {
+  const result = { ...schema };
+  const required = originalRequired ?? (Array.isArray(result["required"]) ? result["required"] : []);
+  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

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

@@ -0,0 +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 *\n * Conservative by design: for (1) keywords are matched as object keys, so a\n * property literally named e.g. `oneOf` also trips it. That only costs that one\n * tool its strict mode, which is strictly safer than a false \"compatible\"\n * verdict that 400s the whole request.\n */\nexport function isStrictModeCompatible(schema: unknown): boolean {\n  return (\n    !containsStrictUnsupportedKeyword(schema) && !containsTypelessSchema(schema)\n  )\n}\n\nfunction containsStrictUnsupportedKeyword(node: unknown): boolean {\n  if (Array.isArray(node)) {\n    return node.some(containsStrictUnsupportedKeyword)\n  }\n  if (node === null || typeof node !== 'object') return false\n  for (const [key, value] of Object.entries(node)) {\n    if (STRICT_UNSUPPORTED_KEYWORDS.includes(key)) return true\n    if (containsStrictUnsupportedKeyword(value)) return true\n  }\n  return false\n}\n\n/** A schema-position node that declares no type and so 400s strict mode. */\nfunction isTypelessSchema(node: unknown): boolean {\n  if (node === null || typeof node !== 'object' || Array.isArray(node)) {\n    // boolean schemas (`true`/`false`) and non-objects aren't typeless props.\n    return false\n  }\n  return !TYPE_INDICATOR_KEYWORDS.some((key) => key in node)\n}\n\n/**\n * Walks the genuine schema positions (property values, `items`, `anyOf`\n * variants) and reports whether any is typeless. Unlike the keyword walk this\n * must respect structure: an empty `{}` is only a problem at a schema position,\n * not e.g. an empty `properties` map.\n */\nfunction containsTypelessSchema(node: unknown): boolean {\n  if (node === null || typeof node !== 'object' || Array.isArray(node)) {\n    return false\n  }\n  const schema = node as Record<string, any>\n\n  const children: Array<unknown> = []\n  if (schema.properties && typeof schema.properties === 'object') {\n    children.push(...Object.values(schema.properties))\n  }\n  if (schema.items !== undefined) {\n    children.push(\n      ...(Array.isArray(schema.items) ? schema.items : [schema.items]),\n    )\n  }\n  if (Array.isArray(schema.anyOf)) {\n    children.push(...schema.anyOf)\n  }\n\n  return children.some(\n    (child) => isTypelessSchema(child) || containsTypelessSchema(child),\n  )\n}\n\n/**\n * Strict-mode structural rewrite (required widening, nullability,\n * additionalProperties). Kept private so the public entry point can apply the\n * format-stripping pass exactly once over the fully-rewritten tree.\n */\nfunction coerceStrictSchema(\n  schema: Record<string, any>,\n  originalRequired?: Array<string>,\n): Record<string, any> {\n  const result = { ...schema }\n  const required =\n    originalRequired ??\n    (Array.isArray(result['required']) ? result['required'] : [])\n\n  if (result.type === 'object' && result.properties) {\n    const properties = { ...result.properties }\n    const allPropertyNames = Object.keys(properties)\n\n    for (const propName of allPropertyNames) {\n      let prop = properties[propName]\n      const wasOptional = !required.includes(propName)\n\n      // Step 1: Recurse into nested structures\n      if (prop.type === 'object' && prop.properties) {\n        prop = coerceStrictSchema(prop, prop.required || [])\n      } else if (prop.type === 'array' && prop.items) {\n        prop = {\n          ...prop,\n          items: coerceStrictSchema(prop.items, prop.items.required || []),\n        }\n      } else if (prop.anyOf) {\n        prop = coerceStrictSchema(prop, prop.required || [])\n      } else if (prop.oneOf) {\n        throw new Error(\n          'oneOf is not supported in OpenAI structured output schemas. Check the supported outputs here: https://platform.openai.com/docs/guides/structured-outputs#supported-types',\n        )\n      }\n\n      // Step 2: Apply null-widening for optional properties (after recursion)\n      if (wasOptional) {\n        if (prop.anyOf) {\n          // For anyOf, add a null variant if not already present\n          if (!prop.anyOf.some((v: any) => v.type === 'null')) {\n            prop = { ...prop, anyOf: [...prop.anyOf, { type: 'null' }] }\n          }\n        } else if (prop.type && !Array.isArray(prop.type)) {\n          prop = { ...prop, type: [prop.type, 'null'] }\n        } else if (Array.isArray(prop.type) && !prop.type.includes('null')) {\n          prop = { ...prop, type: [...prop.type, 'null'] }\n        }\n      }\n\n      properties[propName] = prop\n    }\n\n    result.properties = properties\n    result.required = allPropertyNames\n    result.additionalProperties = false\n  }\n\n  if (result.type === 'array' && result.items) {\n    result.items = coerceStrictSchema(result.items, result.items.required || [])\n  }\n\n  if (result.anyOf && Array.isArray(result.anyOf)) {\n    result.anyOf = result.anyOf.map((variant) =>\n      coerceStrictSchema(variant, variant.required || []),\n    )\n  }\n\n  if (result.oneOf) {\n    throw new Error(\n      'oneOf is not supported in OpenAI structured output schemas. Check the supported outputs here: https://platform.openai.com/docs/guides/structured-outputs#supported-types',\n    )\n  }\n\n  return result\n}\n"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/openai-base",
-  "version": "0.9.3",
+  "version": "0.9.5",
   "description": "Shared OpenAI SDK base adapters for TanStack AI providers using Chat Completions and Responses APIs.",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -44,16 +44,16 @@
   ],
   "dependencies": {
     "openai": "^6.41.0",
-    "@tanstack/ai-utils": "0.3.0"
+    "@tanstack/ai-utils": "0.3.1"
   },
   "peerDependencies": {
-    "@tanstack/ai": "^0.36.0"
+    "@tanstack/ai": "^0.38.0"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "4.0.14",
     "vite": "^7.3.3",
     "zod": "^4.2.0",
-    "@tanstack/ai": "0.36.0"
+    "@tanstack/ai": "0.38.0"
   },
   "scripts": {
     "build": "vite build",