@tanstack/ai-groq 0.5.2 → 0.5.4

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

@@ -1,73 +1,73 @@
 import { makeStructuredOutputCompatible } from "@tanstack/openai-base";
-import { transformNullsToUndefined } from "@tanstack/ai-utils";
+//#region src/utils/schema-converter.ts
+/**
+* Recursively removes `required: []` from a schema object.
+* Groq rejects `required` when it is an empty array, even though
+* OpenAI-compatible schemas allow it.
+*/
 function removeEmptyRequired(schema) {
-  const result = { ...schema };
-  if (Array.isArray(result.required) && result.required.length === 0) {
-    delete result.required;
-  }
-  if (result.properties && typeof result.properties === "object") {
-    const properties = {};
-    for (const [key, value] of Object.entries(
-      result.properties
-    )) {
-      properties[key] = typeof value === "object" && value !== null && !Array.isArray(value) ? removeEmptyRequired(value) : value;
-    }
-    result.properties = properties;
-  }
-  if (result.items && typeof result.items === "object" && !Array.isArray(result.items)) {
-    result.items = removeEmptyRequired(result.items);
-  }
-  for (const keyword of ["anyOf", "oneOf", "allOf"]) {
-    if (Array.isArray(result[keyword])) {
-      result[keyword] = result[keyword].map(
-        (entry) => removeEmptyRequired(entry)
-      );
-    }
-  }
-  if (result.additionalProperties && typeof result.additionalProperties === "object" && !Array.isArray(result.additionalProperties)) {
-    result.additionalProperties = removeEmptyRequired(
-      result.additionalProperties
-    );
-  }
-  return result;
+	const result = { ...schema };
+	if (Array.isArray(result.required) && result.required.length === 0) delete result.required;
+	if (result.properties && typeof result.properties === "object") {
+		const properties = {};
+		for (const [key, value] of Object.entries(result.properties)) properties[key] = typeof value === "object" && value !== null && !Array.isArray(value) ? removeEmptyRequired(value) : value;
+		result.properties = properties;
+	}
+	if (result.items && typeof result.items === "object" && !Array.isArray(result.items)) result.items = removeEmptyRequired(result.items);
+	for (const keyword of [
+		"anyOf",
+		"oneOf",
+		"allOf"
+	]) if (Array.isArray(result[keyword])) result[keyword] = result[keyword].map((entry) => removeEmptyRequired(entry));
+	if (result.additionalProperties && typeof result.additionalProperties === "object" && !Array.isArray(result.additionalProperties)) result.additionalProperties = removeEmptyRequired(result.additionalProperties);
+	return result;
 }
+/**
+* Recursively normalise object schemas so any `{ type: 'object' }` node
+* without `properties` gets an empty `properties: {}` object. The
+* ai-openai-base transformer only descends into objects that already have
+* `properties` set, so a Zod `z.object({})` nested inside `properties`,
+* `items`, `additionalProperties`, or a combinator branch would otherwise
+* skip the strict-mode rewrite and fail Groq validation.
+*/
 function normalizeObjectSchemas(schema) {
-  const result = schema.type === "object" && !schema.properties ? { ...schema, properties: {} } : { ...schema };
-  if (result.properties && typeof result.properties === "object") {
-    result.properties = Object.fromEntries(
-      Object.entries(result.properties).map(
-        ([key, value]) => [
-          key,
-          typeof value === "object" && value !== null && !Array.isArray(value) ? normalizeObjectSchemas(value) : value
-        ]
-      )
-    );
-  }
-  if (result.items && typeof result.items === "object" && !Array.isArray(result.items)) {
-    result.items = normalizeObjectSchemas(result.items);
-  }
-  for (const keyword of ["anyOf", "oneOf", "allOf"]) {
-    const branch = result[keyword];
-    if (Array.isArray(branch)) {
-      result[keyword] = branch.map(
-        (entry) => typeof entry === "object" && entry !== null ? normalizeObjectSchemas(entry) : entry
-      );
-    }
-  }
-  if (result.additionalProperties && typeof result.additionalProperties === "object" && !Array.isArray(result.additionalProperties)) {
-    result.additionalProperties = normalizeObjectSchemas(
-      result.additionalProperties
-    );
-  }
-  return result;
+	const result = schema.type === "object" && !schema.properties ? {
+		...schema,
+		properties: {}
+	} : { ...schema };
+	if (result.properties && typeof result.properties === "object") result.properties = Object.fromEntries(Object.entries(result.properties).map(([key, value]) => [key, typeof value === "object" && value !== null && !Array.isArray(value) ? normalizeObjectSchemas(value) : value]));
+	if (result.items && typeof result.items === "object" && !Array.isArray(result.items)) result.items = normalizeObjectSchemas(result.items);
+	for (const keyword of [
+		"anyOf",
+		"oneOf",
+		"allOf"
+	]) {
+		const branch = result[keyword];
+		if (Array.isArray(branch)) result[keyword] = branch.map((entry) => typeof entry === "object" && entry !== null ? normalizeObjectSchemas(entry) : entry);
+	}
+	if (result.additionalProperties && typeof result.additionalProperties === "object" && !Array.isArray(result.additionalProperties)) result.additionalProperties = normalizeObjectSchemas(result.additionalProperties);
+	return result;
 }
+/**
+* Transform a JSON schema to be compatible with Groq's structured output requirements.
+*
+* Groq 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
+* - `required` must be omitted (not empty array) when there are no properties
+*
+* Delegates to the shared OpenAI-compatible transformer and applies the
+* Groq-specific quirk of removing empty `required` arrays.
+*
+* @param schema - JSON schema to transform
+* @param originalRequired - Original required array (to know which fields were optional)
+* @returns Transformed schema compatible with Groq structured output
+*/
 function makeGroqStructuredOutputCompatible(schema, originalRequired = []) {
-  const normalised = normalizeObjectSchemas(schema);
-  const result = makeStructuredOutputCompatible(normalised, originalRequired);
-  return removeEmptyRequired(result);
+	return removeEmptyRequired(makeStructuredOutputCompatible(normalizeObjectSchemas(schema), originalRequired));
 }
-export {
-  makeGroqStructuredOutputCompatible,
-  transformNullsToUndefined
-};
-//# sourceMappingURL=schema-converter.js.map
+//#endregion
+export { makeGroqStructuredOutputCompatible };
+
+//# 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":["import { makeStructuredOutputCompatible } from '@tanstack/openai-base'\nimport { transformNullsToUndefined } from '@tanstack/ai-utils'\n\nexport { transformNullsToUndefined }\n\n/**\n * Recursively removes `required: []` from a schema object.\n * Groq rejects `required` when it is an empty array, even though\n * OpenAI-compatible schemas allow it.\n */\nfunction removeEmptyRequired(schema: Record<string, any>): Record<string, any> {\n  const result = { ...schema }\n\n  if (Array.isArray(result.required) && result.required.length === 0) {\n    delete result.required\n  }\n\n  if (result.properties && typeof result.properties === 'object') {\n    const properties: Record<string, any> = {}\n    for (const [key, value] of Object.entries(\n      result.properties as Record<string, any>,\n    )) {\n      properties[key] =\n        typeof value === 'object' && value !== null && !Array.isArray(value)\n          ? removeEmptyRequired(value)\n          : value\n    }\n    result.properties = properties\n  }\n\n  if (\n    result.items &&\n    typeof result.items === 'object' &&\n    !Array.isArray(result.items)\n  ) {\n    result.items = removeEmptyRequired(result.items)\n  }\n\n  // Recurse into combinator arrays (anyOf, oneOf, allOf)\n  for (const keyword of ['anyOf', 'oneOf', 'allOf'] as const) {\n    if (Array.isArray(result[keyword])) {\n      result[keyword] = result[keyword].map((entry: Record<string, any>) =>\n        removeEmptyRequired(entry),\n      )\n    }\n  }\n\n  // Recurse into additionalProperties if it's a schema object\n  if (\n    result.additionalProperties &&\n    typeof result.additionalProperties === 'object' &&\n    !Array.isArray(result.additionalProperties)\n  ) {\n    result.additionalProperties = removeEmptyRequired(\n      result.additionalProperties,\n    )\n  }\n\n  return result\n}\n\n/**\n * Recursively normalise object schemas so any `{ type: 'object' }` node\n * without `properties` gets an empty `properties: {}` object. The\n * ai-openai-base transformer only descends into objects that already have\n * `properties` set, so a Zod `z.object({})` nested inside `properties`,\n * `items`, `additionalProperties`, or a combinator branch would otherwise\n * skip the strict-mode rewrite and fail Groq validation.\n */\nfunction normalizeObjectSchemas(\n  schema: Record<string, any>,\n): Record<string, any> {\n  const result: Record<string, any> =\n    schema.type === 'object' && !schema.properties\n      ? { ...schema, properties: {} }\n      : { ...schema }\n\n  if (result.properties && typeof result.properties === 'object') {\n    result.properties = Object.fromEntries(\n      Object.entries(result.properties as Record<string, any>).map(\n        ([key, value]) => [\n          key,\n          typeof value === 'object' && value !== null && !Array.isArray(value)\n            ? normalizeObjectSchemas(value)\n            : value,\n        ],\n      ),\n    )\n  }\n\n  if (\n    result.items &&\n    typeof result.items === 'object' &&\n    !Array.isArray(result.items)\n  ) {\n    result.items = normalizeObjectSchemas(result.items)\n  }\n\n  for (const keyword of ['anyOf', 'oneOf', 'allOf'] as const) {\n    const branch = result[keyword]\n    if (Array.isArray(branch)) {\n      result[keyword] = branch.map((entry) =>\n        typeof entry === 'object' && entry !== null\n          ? normalizeObjectSchemas(entry as Record<string, any>)\n          : entry,\n      )\n    }\n  }\n\n  if (\n    result.additionalProperties &&\n    typeof result.additionalProperties === 'object' &&\n    !Array.isArray(result.additionalProperties)\n  ) {\n    result.additionalProperties = normalizeObjectSchemas(\n      result.additionalProperties as Record<string, any>,\n    )\n  }\n\n  return result\n}\n\n/**\n * Transform a JSON schema to be compatible with Groq's structured output requirements.\n *\n * Groq 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 * - `required` must be omitted (not empty array) when there are no properties\n *\n * Delegates to the shared OpenAI-compatible transformer and applies the\n * Groq-specific quirk of removing empty `required` arrays.\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 Groq structured output\n */\nexport function makeGroqStructuredOutputCompatible(\n  schema: Record<string, any>,\n  originalRequired: Array<string> = [],\n): Record<string, any> {\n  // Recursively patch every `{ type: 'object' }` node so the ai-openai-base\n  // transformer descends into nested empty objects too.\n  const normalised = normalizeObjectSchemas(schema)\n\n  const result = makeStructuredOutputCompatible(normalised, originalRequired)\n\n  // Groq rejects `required` when it is an empty array\n  return removeEmptyRequired(result)\n}\n"],"names":[],"mappings":";;AAUA,SAAS,oBAAoB,QAAkD;AAC7E,QAAM,SAAS,EAAE,GAAG,OAAA;AAEpB,MAAI,MAAM,QAAQ,OAAO,QAAQ,KAAK,OAAO,SAAS,WAAW,GAAG;AAClE,WAAO,OAAO;AAAA,EAChB;AAEA,MAAI,OAAO,cAAc,OAAO,OAAO,eAAe,UAAU;AAC9D,UAAM,aAAkC,CAAA;AACxC,eAAW,CAAC,KAAK,KAAK,KAAK,OAAO;AAAA,MAChC,OAAO;AAAA,IAAA,GACN;AACD,iBAAW,GAAG,IACZ,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK,IAC/D,oBAAoB,KAAK,IACzB;AAAA,IACR;AACA,WAAO,aAAa;AAAA,EACtB;AAEA,MACE,OAAO,SACP,OAAO,OAAO,UAAU,YACxB,CAAC,MAAM,QAAQ,OAAO,KAAK,GAC3B;AACA,WAAO,QAAQ,oBAAoB,OAAO,KAAK;AAAA,EACjD;AAGA,aAAW,WAAW,CAAC,SAAS,SAAS,OAAO,GAAY;AAC1D,QAAI,MAAM,QAAQ,OAAO,OAAO,CAAC,GAAG;AAClC,aAAO,OAAO,IAAI,OAAO,OAAO,EAAE;AAAA,QAAI,CAAC,UACrC,oBAAoB,KAAK;AAAA,MAAA;AAAA,IAE7B;AAAA,EACF;AAGA,MACE,OAAO,wBACP,OAAO,OAAO,yBAAyB,YACvC,CAAC,MAAM,QAAQ,OAAO,oBAAoB,GAC1C;AACA,WAAO,uBAAuB;AAAA,MAC5B,OAAO;AAAA,IAAA;AAAA,EAEX;AAEA,SAAO;AACT;AAUA,SAAS,uBACP,QACqB;AACrB,QAAM,SACJ,OAAO,SAAS,YAAY,CAAC,OAAO,aAChC,EAAE,GAAG,QAAQ,YAAY,CAAA,EAAC,IAC1B,EAAE,GAAG,OAAA;AAEX,MAAI,OAAO,cAAc,OAAO,OAAO,eAAe,UAAU;AAC9D,WAAO,aAAa,OAAO;AAAA,MACzB,OAAO,QAAQ,OAAO,UAAiC,EAAE;AAAA,QACvD,CAAC,CAAC,KAAK,KAAK,MAAM;AAAA,UAChB;AAAA,UACA,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK,IAC/D,uBAAuB,KAAK,IAC5B;AAAA,QAAA;AAAA,MACN;AAAA,IACF;AAAA,EAEJ;AAEA,MACE,OAAO,SACP,OAAO,OAAO,UAAU,YACxB,CAAC,MAAM,QAAQ,OAAO,KAAK,GAC3B;AACA,WAAO,QAAQ,uBAAuB,OAAO,KAAK;AAAA,EACpD;AAEA,aAAW,WAAW,CAAC,SAAS,SAAS,OAAO,GAAY;AAC1D,UAAM,SAAS,OAAO,OAAO;AAC7B,QAAI,MAAM,QAAQ,MAAM,GAAG;AACzB,aAAO,OAAO,IAAI,OAAO;AAAA,QAAI,CAAC,UAC5B,OAAO,UAAU,YAAY,UAAU,OACnC,uBAAuB,KAA4B,IACnD;AAAA,MAAA;AAAA,IAER;AAAA,EACF;AAEA,MACE,OAAO,wBACP,OAAO,OAAO,yBAAyB,YACvC,CAAC,MAAM,QAAQ,OAAO,oBAAoB,GAC1C;AACA,WAAO,uBAAuB;AAAA,MAC5B,OAAO;AAAA,IAAA;AAAA,EAEX;AAEA,SAAO;AACT;AAkBO,SAAS,mCACd,QACA,mBAAkC,IACb;AAGrB,QAAM,aAAa,uBAAuB,MAAM;AAEhD,QAAM,SAAS,+BAA+B,YAAY,gBAAgB;AAG1E,SAAO,oBAAoB,MAAM;AACnC;"}
+{"version":3,"file":"schema-converter.js","names":[],"sources":["../../../src/utils/schema-converter.ts"],"sourcesContent":["import { makeStructuredOutputCompatible } from '@tanstack/openai-base'\n\n/**\n * Recursively removes `required: []` from a schema object.\n * Groq rejects `required` when it is an empty array, even though\n * OpenAI-compatible schemas allow it.\n */\nfunction removeEmptyRequired(schema: Record<string, any>): Record<string, any> {\n  const result = { ...schema }\n\n  if (Array.isArray(result.required) && result.required.length === 0) {\n    delete result.required\n  }\n\n  if (result.properties && typeof result.properties === 'object') {\n    const properties: Record<string, any> = {}\n    for (const [key, value] of Object.entries(\n      result.properties as Record<string, any>,\n    )) {\n      properties[key] =\n        typeof value === 'object' && value !== null && !Array.isArray(value)\n          ? removeEmptyRequired(value)\n          : value\n    }\n    result.properties = properties\n  }\n\n  if (\n    result.items &&\n    typeof result.items === 'object' &&\n    !Array.isArray(result.items)\n  ) {\n    result.items = removeEmptyRequired(result.items)\n  }\n\n  // Recurse into combinator arrays (anyOf, oneOf, allOf)\n  for (const keyword of ['anyOf', 'oneOf', 'allOf'] as const) {\n    if (Array.isArray(result[keyword])) {\n      result[keyword] = result[keyword].map((entry: Record<string, any>) =>\n        removeEmptyRequired(entry),\n      )\n    }\n  }\n\n  // Recurse into additionalProperties if it's a schema object\n  if (\n    result.additionalProperties &&\n    typeof result.additionalProperties === 'object' &&\n    !Array.isArray(result.additionalProperties)\n  ) {\n    result.additionalProperties = removeEmptyRequired(\n      result.additionalProperties,\n    )\n  }\n\n  return result\n}\n\n/**\n * Recursively normalise object schemas so any `{ type: 'object' }` node\n * without `properties` gets an empty `properties: {}` object. The\n * ai-openai-base transformer only descends into objects that already have\n * `properties` set, so a Zod `z.object({})` nested inside `properties`,\n * `items`, `additionalProperties`, or a combinator branch would otherwise\n * skip the strict-mode rewrite and fail Groq validation.\n */\nfunction normalizeObjectSchemas(\n  schema: Record<string, any>,\n): Record<string, any> {\n  const result: Record<string, any> =\n    schema.type === 'object' && !schema.properties\n      ? { ...schema, properties: {} }\n      : { ...schema }\n\n  if (result.properties && typeof result.properties === 'object') {\n    result.properties = Object.fromEntries(\n      Object.entries(result.properties as Record<string, any>).map(\n        ([key, value]) => [\n          key,\n          typeof value === 'object' && value !== null && !Array.isArray(value)\n            ? normalizeObjectSchemas(value)\n            : value,\n        ],\n      ),\n    )\n  }\n\n  if (\n    result.items &&\n    typeof result.items === 'object' &&\n    !Array.isArray(result.items)\n  ) {\n    result.items = normalizeObjectSchemas(result.items)\n  }\n\n  for (const keyword of ['anyOf', 'oneOf', 'allOf'] as const) {\n    const branch = result[keyword]\n    if (Array.isArray(branch)) {\n      result[keyword] = branch.map((entry) =>\n        typeof entry === 'object' && entry !== null\n          ? normalizeObjectSchemas(entry as Record<string, any>)\n          : entry,\n      )\n    }\n  }\n\n  if (\n    result.additionalProperties &&\n    typeof result.additionalProperties === 'object' &&\n    !Array.isArray(result.additionalProperties)\n  ) {\n    result.additionalProperties = normalizeObjectSchemas(\n      result.additionalProperties as Record<string, any>,\n    )\n  }\n\n  return result\n}\n\n/**\n * Transform a JSON schema to be compatible with Groq's structured output requirements.\n *\n * Groq 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 * - `required` must be omitted (not empty array) when there are no properties\n *\n * Delegates to the shared OpenAI-compatible transformer and applies the\n * Groq-specific quirk of removing empty `required` arrays.\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 Groq structured output\n */\nexport function makeGroqStructuredOutputCompatible(\n  schema: Record<string, any>,\n  originalRequired: Array<string> = [],\n): Record<string, any> {\n  // Recursively patch every `{ type: 'object' }` node so the ai-openai-base\n  // transformer descends into nested empty objects too.\n  const normalised = normalizeObjectSchemas(schema)\n\n  const result = makeStructuredOutputCompatible(normalised, originalRequired)\n\n  // Groq rejects `required` when it is an empty array\n  return removeEmptyRequired(result)\n}\n"],"mappings":";;;;;;;AAOA,SAAS,oBAAoB,QAAkD;CAC7E,MAAM,SAAS,EAAE,GAAG,OAAO;CAE3B,IAAI,MAAM,QAAQ,OAAO,QAAQ,KAAK,OAAO,SAAS,WAAW,GAC/D,OAAO,OAAO;CAGhB,IAAI,OAAO,cAAc,OAAO,OAAO,eAAe,UAAU;EAC9D,MAAM,aAAkC,CAAC;EACzC,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAChC,OAAO,UACT,GACE,WAAW,OACT,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK,IAC/D,oBAAoB,KAAK,IACzB;EAER,OAAO,aAAa;CACtB;CAEA,IACE,OAAO,SACP,OAAO,OAAO,UAAU,YACxB,CAAC,MAAM,QAAQ,OAAO,KAAK,GAE3B,OAAO,QAAQ,oBAAoB,OAAO,KAAK;CAIjD,KAAK,MAAM,WAAW;EAAC;EAAS;EAAS;CAAO,GAC9C,IAAI,MAAM,QAAQ,OAAO,QAAQ,GAC/B,OAAO,WAAW,OAAO,QAAQ,CAAC,KAAK,UACrC,oBAAoB,KAAK,CAC3B;CAKJ,IACE,OAAO,wBACP,OAAO,OAAO,yBAAyB,YACvC,CAAC,MAAM,QAAQ,OAAO,oBAAoB,GAE1C,OAAO,uBAAuB,oBAC5B,OAAO,oBACT;CAGF,OAAO;AACT;;;;;;;;;AAUA,SAAS,uBACP,QACqB;CACrB,MAAM,SACJ,OAAO,SAAS,YAAY,CAAC,OAAO,aAChC;EAAE,GAAG;EAAQ,YAAY,CAAC;CAAE,IAC5B,EAAE,GAAG,OAAO;CAElB,IAAI,OAAO,cAAc,OAAO,OAAO,eAAe,UACpD,OAAO,aAAa,OAAO,YACzB,OAAO,QAAQ,OAAO,UAAiC,CAAC,CAAC,KACtD,CAAC,KAAK,WAAW,CAChB,KACA,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK,IAC/D,uBAAuB,KAAK,IAC5B,KACN,CACF,CACF;CAGF,IACE,OAAO,SACP,OAAO,OAAO,UAAU,YACxB,CAAC,MAAM,QAAQ,OAAO,KAAK,GAE3B,OAAO,QAAQ,uBAAuB,OAAO,KAAK;CAGpD,KAAK,MAAM,WAAW;EAAC;EAAS;EAAS;CAAO,GAAY;EAC1D,MAAM,SAAS,OAAO;EACtB,IAAI,MAAM,QAAQ,MAAM,GACtB,OAAO,WAAW,OAAO,KAAK,UAC5B,OAAO,UAAU,YAAY,UAAU,OACnC,uBAAuB,KAA4B,IACnD,KACN;CAEJ;CAEA,IACE,OAAO,wBACP,OAAO,OAAO,yBAAyB,YACvC,CAAC,MAAM,QAAQ,OAAO,oBAAoB,GAE1C,OAAO,uBAAuB,uBAC5B,OAAO,oBACT;CAGF,OAAO;AACT;;;;;;;;;;;;;;;;;AAkBA,SAAgB,mCACd,QACA,mBAAkC,CAAC,GACd;CAQrB,OAAO,oBAHQ,+BAFI,uBAAuB,MAEI,GAAY,gBAG/B,CAAM;AACnC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/ai-groq",
-  "version": "0.5.2",
+  "version": "0.5.4",
   "description": "Groq adapter for TanStack AI low-latency chat, tool calling, and structured outputs.",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -49,23 +49,23 @@
   ],
   "devDependencies": {
     "@vitest/coverage-v8": "4.0.14",
-    "vite": "^7.3.3"
+    "vite": "^8.1.4"
   },
   "peerDependencies": {
     "zod": "^4.0.0",
-    "@tanstack/ai": "^0.41.0"
+    "@tanstack/ai": "^0.43.0"
   },
   "dependencies": {
     "openai": "^6.41.0",
-    "@tanstack/ai-utils": "0.3.1",
-    "@tanstack/openai-base": "0.9.8"
+    "@tanstack/ai-utils": "0.4.0",
+    "@tanstack/openai-base": "0.9.10"
   },
   "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/utils/schema-converter.ts

@@ -1,7 +1,4 @@
 import { makeStructuredOutputCompatible } from '@tanstack/openai-base'
-import { transformNullsToUndefined } from '@tanstack/ai-utils'
-
-export { transformNullsToUndefined }
 
 /**
  * Recursively removes `required: []` from a schema object.

package/dist/esm/index.js.map

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

package/dist/esm/tools/index.js.map

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