@tanstack/openai-base 0.8.4 → 0.8.7

package/dist/esm/adapters/chat-completions-tool-converter.d.ts

@@ -18,7 +18,14 @@ export type ChatCompletionFunctionTool = Extract<ChatCompletionTool, {
  * - Optional fields made nullable
  * - additionalProperties: false
  *
- * This enables strict mode for all tools automatically.
+ * This enables strict mode for tools whose schemas fit OpenAI's strict subset.
+ *
+ * Schemas using keywords outside that subset (`oneOf`/`allOf`/`not`/`$ref`/
+ * `$defs` — common with MCP servers like Notion) can't be coerced to a
+ * strict-valid shape, and `strict: true` would make the API reject the ENTIRE
+ * request with a 400. Such tools are emitted with `strict: false` (their schema
+ * passed through, only unsupported `format` keywords stripped) so they stay
+ * callable.
  */
 export declare function convertFunctionToolToChatCompletionsFormat(tool: Tool, schemaConverter?: (schema: Record<string, any>, required: Array<string>) => Record<string, any>): ChatCompletionFunctionTool;
 /**

package/dist/esm/adapters/chat-completions-tool-converter.js

@@ -1,10 +1,21 @@
-import { makeStructuredOutputCompatible } from "../utils/schema-converter.js";
+import { makeStructuredOutputCompatible, isStrictModeCompatible, stripUnsupportedFormats } from "../utils/schema-converter.js";
 function convertFunctionToolToChatCompletionsFormat(tool, schemaConverter = makeStructuredOutputCompatible) {
   const inputSchema = tool.inputSchema ?? {
     type: "object",
     properties: {},
     required: []
   };
+  if (!isStrictModeCompatible(inputSchema)) {
+    return {
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: stripUnsupportedFormats(inputSchema),
+        strict: false
+      }
+    };
+  }
   const jsonSchema = {
     ...schemaConverter(inputSchema, inputSchema.required || [])
   };

package/dist/esm/adapters/chat-completions-tool-converter.js.map

@@ -1 +1 @@
-{"version":3,"file":"chat-completions-tool-converter.js","sources":["../../../src/adapters/chat-completions-tool-converter.ts"],"sourcesContent":["import { makeStructuredOutputCompatible } from '../utils/schema-converter'\nimport type { ChatCompletionTool } from 'openai/resources/chat/completions/completions'\nimport type { JSONSchema, Tool } from '@tanstack/ai'\n\n/**\n * Chat Completions API tool format. The SDK's `ChatCompletionTool` is the\n * union `ChatCompletionFunctionTool | ChatCompletionCustomTool`; we only\n * emit the function variant here. Re-exported as our own alias so consumers\n * importing the converter's output don't have to reach into the SDK.\n */\nexport type ChatCompletionFunctionTool = Extract<\n  ChatCompletionTool,\n  { type: 'function' }\n>\n\n/**\n * Converts a standard Tool to OpenAI Chat Completions ChatCompletionTool format.\n *\n * Tool schemas are already converted to JSON Schema in the ai layer.\n * We apply OpenAI-compatible transformations for strict mode:\n * - All properties in required array\n * - Optional fields made nullable\n * - additionalProperties: false\n *\n * This enables strict mode for all tools automatically.\n */\nexport function convertFunctionToolToChatCompletionsFormat(\n  tool: Tool,\n  schemaConverter: (\n    schema: Record<string, any>,\n    required: Array<string>,\n  ) => Record<string, any> = makeStructuredOutputCompatible,\n): ChatCompletionFunctionTool {\n  const inputSchema = (tool.inputSchema ?? {\n    type: 'object',\n    properties: {},\n    required: [],\n  }) as JSONSchema\n\n  // Shallow-copy the converter's result before mutating: a subclass-supplied\n  // schemaConverter has no contract requirement to return a fresh object,\n  // and a passthrough `(s) => s` would otherwise have its caller's schema\n  // mutated by the `additionalProperties = false` assignment below.\n  const jsonSchema = {\n    ...schemaConverter(inputSchema, inputSchema.required || []),\n  }\n  jsonSchema.additionalProperties = false\n\n  return {\n    type: 'function',\n    function: {\n      name: tool.name,\n      description: tool.description,\n      parameters: jsonSchema,\n      strict: true,\n    },\n  } satisfies ChatCompletionFunctionTool\n}\n\n/**\n * Converts an array of standard Tools to Chat Completions format.\n * Chat Completions API primarily supports function tools.\n */\nexport function convertToolsToChatCompletionsFormat(\n  tools: Array<Tool>,\n  schemaConverter?: (\n    schema: Record<string, any>,\n    required: Array<string>,\n  ) => Record<string, any>,\n): Array<ChatCompletionFunctionTool> {\n  return tools.map((tool) =>\n    convertFunctionToolToChatCompletionsFormat(tool, schemaConverter),\n  )\n}\n"],"names":[],"mappings":";AA0BO,SAAS,2CACd,MACA,kBAG2B,gCACC;AAC5B,QAAM,cAAe,KAAK,eAAe;AAAA,IACvC,MAAM;AAAA,IACN,YAAY,CAAA;AAAA,IACZ,UAAU,CAAA;AAAA,EAAC;AAOb,QAAM,aAAa;AAAA,IACjB,GAAG,gBAAgB,aAAa,YAAY,YAAY,CAAA,CAAE;AAAA,EAAA;AAE5D,aAAW,uBAAuB;AAElC,SAAO;AAAA,IACL,MAAM;AAAA,IACN,UAAU;AAAA,MACR,MAAM,KAAK;AAAA,MACX,aAAa,KAAK;AAAA,MAClB,YAAY;AAAA,MACZ,QAAQ;AAAA,IAAA;AAAA,EACV;AAEJ;AAMO,SAAS,oCACd,OACA,iBAImC;AACnC,SAAO,MAAM;AAAA,IAAI,CAAC,SAChB,2CAA2C,MAAM,eAAe;AAAA,EAAA;AAEpE;"}
+{"version":3,"file":"chat-completions-tool-converter.js","sources":["../../../src/adapters/chat-completions-tool-converter.ts"],"sourcesContent":["import {\n  isStrictModeCompatible,\n  makeStructuredOutputCompatible,\n  stripUnsupportedFormats,\n} from '../utils/schema-converter'\nimport type { ChatCompletionTool } from 'openai/resources/chat/completions/completions'\nimport type { JSONSchema, Tool } from '@tanstack/ai'\n\n/**\n * Chat Completions API tool format. The SDK's `ChatCompletionTool` is the\n * union `ChatCompletionFunctionTool | ChatCompletionCustomTool`; we only\n * emit the function variant here. Re-exported as our own alias so consumers\n * importing the converter's output don't have to reach into the SDK.\n */\nexport type ChatCompletionFunctionTool = Extract<\n  ChatCompletionTool,\n  { type: 'function' }\n>\n\n/**\n * Converts a standard Tool to OpenAI Chat Completions ChatCompletionTool format.\n *\n * Tool schemas are already converted to JSON Schema in the ai layer.\n * We apply OpenAI-compatible transformations for strict mode:\n * - All properties in required array\n * - Optional fields made nullable\n * - additionalProperties: false\n *\n * This enables strict mode for tools whose schemas fit OpenAI's strict subset.\n *\n * Schemas using keywords outside that subset (`oneOf`/`allOf`/`not`/`$ref`/\n * `$defs` — common with MCP servers like Notion) can't be coerced to a\n * strict-valid shape, and `strict: true` would make the API reject the ENTIRE\n * request with a 400. Such tools are emitted with `strict: false` (their schema\n * passed through, only unsupported `format` keywords stripped) so they stay\n * callable.\n */\nexport function convertFunctionToolToChatCompletionsFormat(\n  tool: Tool,\n  schemaConverter: (\n    schema: Record<string, any>,\n    required: Array<string>,\n  ) => Record<string, any> = makeStructuredOutputCompatible,\n): ChatCompletionFunctionTool {\n  const inputSchema = (tool.inputSchema ?? {\n    type: 'object',\n    properties: {},\n    required: [],\n  }) as JSONSchema\n\n  // Schema outside OpenAI's strict subset: send non-strict so the tool still\n  // works instead of 400-ing the whole request.\n  if (!isStrictModeCompatible(inputSchema)) {\n    return {\n      type: 'function',\n      function: {\n        name: tool.name,\n        description: tool.description,\n        parameters: stripUnsupportedFormats(inputSchema),\n        strict: false,\n      },\n    } satisfies ChatCompletionFunctionTool\n  }\n\n  // Shallow-copy the converter's result before mutating: a subclass-supplied\n  // schemaConverter has no contract requirement to return a fresh object,\n  // and a passthrough `(s) => s` would otherwise have its caller's schema\n  // mutated by the `additionalProperties = false` assignment below.\n  const jsonSchema = {\n    ...schemaConverter(inputSchema, inputSchema.required || []),\n  }\n  jsonSchema.additionalProperties = false\n\n  return {\n    type: 'function',\n    function: {\n      name: tool.name,\n      description: tool.description,\n      parameters: jsonSchema,\n      strict: true,\n    },\n  } satisfies ChatCompletionFunctionTool\n}\n\n/**\n * Converts an array of standard Tools to Chat Completions format.\n * Chat Completions API primarily supports function tools.\n */\nexport function convertToolsToChatCompletionsFormat(\n  tools: Array<Tool>,\n  schemaConverter?: (\n    schema: Record<string, any>,\n    required: Array<string>,\n  ) => Record<string, any>,\n): Array<ChatCompletionFunctionTool> {\n  return tools.map((tool) =>\n    convertFunctionToolToChatCompletionsFormat(tool, schemaConverter),\n  )\n}\n"],"names":[],"mappings":";AAqCO,SAAS,2CACd,MACA,kBAG2B,gCACC;AAC5B,QAAM,cAAe,KAAK,eAAe;AAAA,IACvC,MAAM;AAAA,IACN,YAAY,CAAA;AAAA,IACZ,UAAU,CAAA;AAAA,EAAC;AAKb,MAAI,CAAC,uBAAuB,WAAW,GAAG;AACxC,WAAO;AAAA,MACL,MAAM;AAAA,MACN,UAAU;AAAA,QACR,MAAM,KAAK;AAAA,QACX,aAAa,KAAK;AAAA,QAClB,YAAY,wBAAwB,WAAW;AAAA,QAC/C,QAAQ;AAAA,MAAA;AAAA,IACV;AAAA,EAEJ;AAMA,QAAM,aAAa;AAAA,IACjB,GAAG,gBAAgB,aAAa,YAAY,YAAY,CAAA,CAAE;AAAA,EAAA;AAE5D,aAAW,uBAAuB;AAElC,SAAO;AAAA,IACL,MAAM;AAAA,IACN,UAAU;AAAA,MACR,MAAM,KAAK;AAAA,MACX,aAAa,KAAK;AAAA,MAClB,YAAY;AAAA,MACZ,QAAQ;AAAA,IAAA;AAAA,EACV;AAEJ;AAMO,SAAS,oCACd,OACA,iBAImC;AACnC,SAAO,MAAM;AAAA,IAAI,CAAC,SAChB,2CAA2C,MAAM,eAAe;AAAA,EAAA;AAEpE;"}

package/dist/esm/adapters/responses-tool-converter.d.ts

@@ -25,7 +25,14 @@ export interface ResponsesFunctionTool {
  * - Optional fields made nullable
  * - additionalProperties: false
  *
- * This enables strict mode for all tools automatically.
+ * This enables strict mode for tools whose schemas fit OpenAI's strict subset.
+ *
+ * Schemas using keywords outside that subset (`oneOf`/`allOf`/`not`/`$ref`/
+ * `$defs` — common with MCP servers like Notion) can't be coerced to a
+ * strict-valid shape, and `strict: true` would make the Responses API reject
+ * the ENTIRE request with a 400. Such tools are emitted with `strict: false`
+ * (their schema passed through, only unsupported `format` keywords stripped) so
+ * they stay callable.
  */
 export declare function convertFunctionToolToResponsesFormat(tool: Tool, schemaConverter?: (schema: Record<string, any>, required: Array<string>) => Record<string, any>): ResponsesFunctionTool;
 /**

package/dist/esm/adapters/responses-tool-converter.js

@@ -1,10 +1,19 @@
-import { makeStructuredOutputCompatible } from "../utils/schema-converter.js";
+import { makeStructuredOutputCompatible, isStrictModeCompatible, stripUnsupportedFormats } from "../utils/schema-converter.js";
 function convertFunctionToolToResponsesFormat(tool, schemaConverter = makeStructuredOutputCompatible) {
   const inputSchema = tool.inputSchema ?? {
     type: "object",
     properties: {},
     required: []
   };
+  if (!isStrictModeCompatible(inputSchema)) {
+    return {
+      type: "function",
+      name: tool.name,
+      description: tool.description,
+      parameters: stripUnsupportedFormats(inputSchema),
+      strict: false
+    };
+  }
   const jsonSchema = {
     ...schemaConverter(inputSchema, inputSchema.required || [])
   };

package/dist/esm/adapters/responses-tool-converter.js.map

@@ -1 +1 @@
-{"version":3,"file":"responses-tool-converter.js","sources":["../../../src/adapters/responses-tool-converter.ts"],"sourcesContent":["import { makeStructuredOutputCompatible } from '../utils/schema-converter'\nimport type { JSONSchema, Tool } from '@tanstack/ai'\n\n/**\n * Responses API function tool format.\n * This is distinct from the Chat Completions API tool format.\n *\n * The Responses API uses a flatter structure:\n *   { type: 'function', name: string, description?: string, parameters: object, strict?: boolean }\n *\n * vs. Chat Completions:\n *   { type: 'function', function: { name, description, parameters }, strict?: boolean }\n */\nexport interface ResponsesFunctionTool {\n  type: 'function'\n  name: string\n  description?: string | null\n  parameters: Record<string, any> | null\n  strict: boolean | null\n}\n\n/**\n * Converts a standard Tool to the Responses API FunctionTool format.\n *\n * Tool schemas are already converted to JSON Schema in the ai layer.\n * We apply OpenAI-compatible transformations for strict mode:\n * - All properties in required array\n * - Optional fields made nullable\n * - additionalProperties: false\n *\n * This enables strict mode for all tools automatically.\n */\nexport function convertFunctionToolToResponsesFormat(\n  tool: Tool,\n  schemaConverter: (\n    schema: Record<string, any>,\n    required: Array<string>,\n  ) => Record<string, any> = makeStructuredOutputCompatible,\n): ResponsesFunctionTool {\n  const inputSchema = (tool.inputSchema ?? {\n    type: 'object',\n    properties: {},\n    required: [],\n  }) as JSONSchema\n\n  // Shallow-copy the converter's result before mutating — a subclass-supplied\n  // schemaConverter has no contract requirement to return a fresh object;\n  // mutating in place could corrupt the caller's tool definition.\n  const jsonSchema = {\n    ...schemaConverter(inputSchema, inputSchema.required || []),\n  }\n  jsonSchema.additionalProperties = false\n\n  return {\n    type: 'function',\n    name: tool.name,\n    description: tool.description,\n    parameters: jsonSchema,\n    strict: true,\n  }\n}\n\n/**\n * Converts an array of standard Tools to Responses API format.\n * The Responses API primarily supports function tools at the base level.\n */\nexport function convertToolsToResponsesFormat(\n  tools: Array<Tool>,\n  schemaConverter?: (\n    schema: Record<string, any>,\n    required: Array<string>,\n  ) => Record<string, any>,\n): Array<ResponsesFunctionTool> {\n  return tools.map((tool) =>\n    convertFunctionToolToResponsesFormat(tool, schemaConverter),\n  )\n}\n"],"names":[],"mappings":";AAgCO,SAAS,qCACd,MACA,kBAG2B,gCACJ;AACvB,QAAM,cAAe,KAAK,eAAe;AAAA,IACvC,MAAM;AAAA,IACN,YAAY,CAAA;AAAA,IACZ,UAAU,CAAA;AAAA,EAAC;AAMb,QAAM,aAAa;AAAA,IACjB,GAAG,gBAAgB,aAAa,YAAY,YAAY,CAAA,CAAE;AAAA,EAAA;AAE5D,aAAW,uBAAuB;AAElC,SAAO;AAAA,IACL,MAAM;AAAA,IACN,MAAM,KAAK;AAAA,IACX,aAAa,KAAK;AAAA,IAClB,YAAY;AAAA,IACZ,QAAQ;AAAA,EAAA;AAEZ;AAMO,SAAS,8BACd,OACA,iBAI8B;AAC9B,SAAO,MAAM;AAAA,IAAI,CAAC,SAChB,qCAAqC,MAAM,eAAe;AAAA,EAAA;AAE9D;"}
+{"version":3,"file":"responses-tool-converter.js","sources":["../../../src/adapters/responses-tool-converter.ts"],"sourcesContent":["import {\n  isStrictModeCompatible,\n  makeStructuredOutputCompatible,\n  stripUnsupportedFormats,\n} from '../utils/schema-converter'\nimport type { JSONSchema, Tool } from '@tanstack/ai'\n\n/**\n * Responses API function tool format.\n * This is distinct from the Chat Completions API tool format.\n *\n * The Responses API uses a flatter structure:\n *   { type: 'function', name: string, description?: string, parameters: object, strict?: boolean }\n *\n * vs. Chat Completions:\n *   { type: 'function', function: { name, description, parameters }, strict?: boolean }\n */\nexport interface ResponsesFunctionTool {\n  type: 'function'\n  name: string\n  description?: string | null\n  parameters: Record<string, any> | null\n  strict: boolean | null\n}\n\n/**\n * Converts a standard Tool to the Responses API FunctionTool format.\n *\n * Tool schemas are already converted to JSON Schema in the ai layer.\n * We apply OpenAI-compatible transformations for strict mode:\n * - All properties in required array\n * - Optional fields made nullable\n * - additionalProperties: false\n *\n * This enables strict mode for tools whose schemas fit OpenAI's strict subset.\n *\n * Schemas using keywords outside that subset (`oneOf`/`allOf`/`not`/`$ref`/\n * `$defs` — common with MCP servers like Notion) can't be coerced to a\n * strict-valid shape, and `strict: true` would make the Responses API reject\n * the ENTIRE request with a 400. Such tools are emitted with `strict: false`\n * (their schema passed through, only unsupported `format` keywords stripped) so\n * they stay callable.\n */\nexport function convertFunctionToolToResponsesFormat(\n  tool: Tool,\n  schemaConverter: (\n    schema: Record<string, any>,\n    required: Array<string>,\n  ) => Record<string, any> = makeStructuredOutputCompatible,\n): ResponsesFunctionTool {\n  const inputSchema = (tool.inputSchema ?? {\n    type: 'object',\n    properties: {},\n    required: [],\n  }) as JSONSchema\n\n  // Schema outside OpenAI's strict subset: send non-strict so the tool still\n  // works instead of 400-ing the whole request.\n  if (!isStrictModeCompatible(inputSchema)) {\n    return {\n      type: 'function',\n      name: tool.name,\n      description: tool.description,\n      parameters: stripUnsupportedFormats(inputSchema),\n      strict: false,\n    }\n  }\n\n  // Shallow-copy the converter's result before mutating — a subclass-supplied\n  // schemaConverter has no contract requirement to return a fresh object;\n  // mutating in place could corrupt the caller's tool definition.\n  const jsonSchema = {\n    ...schemaConverter(inputSchema, inputSchema.required || []),\n  }\n  jsonSchema.additionalProperties = false\n\n  return {\n    type: 'function',\n    name: tool.name,\n    description: tool.description,\n    parameters: jsonSchema,\n    strict: true,\n  }\n}\n\n/**\n * Converts an array of standard Tools to Responses API format.\n * The Responses API primarily supports function tools at the base level.\n */\nexport function convertToolsToResponsesFormat(\n  tools: Array<Tool>,\n  schemaConverter?: (\n    schema: Record<string, any>,\n    required: Array<string>,\n  ) => Record<string, any>,\n): Array<ResponsesFunctionTool> {\n  return tools.map((tool) =>\n    convertFunctionToolToResponsesFormat(tool, schemaConverter),\n  )\n}\n"],"names":[],"mappings":";AA2CO,SAAS,qCACd,MACA,kBAG2B,gCACJ;AACvB,QAAM,cAAe,KAAK,eAAe;AAAA,IACvC,MAAM;AAAA,IACN,YAAY,CAAA;AAAA,IACZ,UAAU,CAAA;AAAA,EAAC;AAKb,MAAI,CAAC,uBAAuB,WAAW,GAAG;AACxC,WAAO;AAAA,MACL,MAAM;AAAA,MACN,MAAM,KAAK;AAAA,MACX,aAAa,KAAK;AAAA,MAClB,YAAY,wBAAwB,WAAW;AAAA,MAC/C,QAAQ;AAAA,IAAA;AAAA,EAEZ;AAKA,QAAM,aAAa;AAAA,IACjB,GAAG,gBAAgB,aAAa,YAAY,YAAY,CAAA,CAAE;AAAA,EAAA;AAE5D,aAAW,uBAAuB;AAElC,SAAO;AAAA,IACL,MAAM;AAAA,IACN,MAAM,KAAK;AAAA,IACX,aAAa,KAAK;AAAA,IAClB,YAAY;AAAA,IACZ,QAAQ;AAAA,EAAA;AAEZ;AAMO,SAAS,8BACd,OACA,iBAI8B;AAC9B,SAAO,MAAM;AAAA,IAAI,CAAC,SAChB,qCAAqC,MAAM,eAAe;AAAA,EAAA;AAE9D;"}

package/dist/esm/tools/function-tool.d.ts

@@ -13,5 +13,11 @@ export type FunctionTool = FunctionToolConfig;
  * - additionalProperties: false
  *
  * This enables strict mode for all tools automatically.
+ *
+ * Some tool schemas (e.g. MCP server tools that use `oneOf`, `$ref`, or
+ * `$defs`) cannot be expressed under OpenAI's strict Structured Outputs
+ * subset. For those we fall back to a non-strict tool definition — stripping
+ * only the formats OpenAI rejects — so the tool is still usable instead of
+ * failing the request with a 400 "Invalid schema" error.
  */
 export declare function convertFunctionToolToAdapterFormat(tool: Tool): FunctionToolConfig;

package/dist/esm/tools/function-tool.js

@@ -1,10 +1,19 @@
-import { makeStructuredOutputCompatible } from "../utils/schema-converter.js";
+import { isStrictModeCompatible, stripUnsupportedFormats, makeStructuredOutputCompatible } from "../utils/schema-converter.js";
 function convertFunctionToolToAdapterFormat(tool) {
   const inputSchema = tool.inputSchema ?? {
     type: "object",
     properties: {},
     required: []
   };
+  if (!isStrictModeCompatible(inputSchema)) {
+    return {
+      type: "function",
+      name: tool.name,
+      description: tool.description,
+      parameters: stripUnsupportedFormats(inputSchema),
+      strict: false
+    };
+  }
   const jsonSchema = makeStructuredOutputCompatible(
     inputSchema,
     inputSchema.required || []

package/dist/esm/tools/function-tool.js.map

@@ -1 +1 @@
-{"version":3,"file":"function-tool.js","sources":["../../../src/tools/function-tool.ts"],"sourcesContent":["import { makeStructuredOutputCompatible } from '../utils/schema-converter'\nimport type { FunctionTool as FunctionToolConfig } from 'openai/resources/responses/responses'\nimport type { JSONSchema, Tool } from '@tanstack/ai'\n\nexport type { FunctionToolConfig }\n\n/** @deprecated Renamed to `FunctionToolConfig`. Will be removed in a future release. */\nexport type FunctionTool = FunctionToolConfig\n\n/**\n * Converts a standard Tool to OpenAI FunctionTool format.\n *\n * Tool schemas are already converted to JSON Schema in the ai layer.\n * We apply OpenAI-specific transformations for strict mode:\n * - All properties in required array\n * - Optional fields made nullable\n * - additionalProperties: false\n *\n * This enables strict mode for all tools automatically.\n */\nexport function convertFunctionToolToAdapterFormat(\n  tool: Tool,\n): FunctionToolConfig {\n  const inputSchema = (tool.inputSchema ?? {\n    type: 'object',\n    properties: {},\n    required: [],\n  }) as JSONSchema\n\n  const jsonSchema = makeStructuredOutputCompatible(\n    inputSchema,\n    inputSchema.required || [],\n  )\n\n  jsonSchema.additionalProperties = false\n\n  return {\n    type: 'function',\n    name: tool.name,\n    description: tool.description,\n    parameters: jsonSchema,\n    strict: true,\n  } satisfies FunctionToolConfig\n}\n"],"names":[],"mappings":";AAoBO,SAAS,mCACd,MACoB;AACpB,QAAM,cAAe,KAAK,eAAe;AAAA,IACvC,MAAM;AAAA,IACN,YAAY,CAAA;AAAA,IACZ,UAAU,CAAA;AAAA,EAAC;AAGb,QAAM,aAAa;AAAA,IACjB;AAAA,IACA,YAAY,YAAY,CAAA;AAAA,EAAC;AAG3B,aAAW,uBAAuB;AAElC,SAAO;AAAA,IACL,MAAM;AAAA,IACN,MAAM,KAAK;AAAA,IACX,aAAa,KAAK;AAAA,IAClB,YAAY;AAAA,IACZ,QAAQ;AAAA,EAAA;AAEZ;"}
+{"version":3,"file":"function-tool.js","sources":["../../../src/tools/function-tool.ts"],"sourcesContent":["import {\n  isStrictModeCompatible,\n  makeStructuredOutputCompatible,\n  stripUnsupportedFormats,\n} from '../utils/schema-converter'\nimport type { FunctionTool as FunctionToolConfig } from 'openai/resources/responses/responses'\nimport type { JSONSchema, Tool } from '@tanstack/ai'\n\nexport type { FunctionToolConfig }\n\n/** @deprecated Renamed to `FunctionToolConfig`. Will be removed in a future release. */\nexport type FunctionTool = FunctionToolConfig\n\n/**\n * Converts a standard Tool to OpenAI FunctionTool format.\n *\n * Tool schemas are already converted to JSON Schema in the ai layer.\n * We apply OpenAI-specific transformations for strict mode:\n * - All properties in required array\n * - Optional fields made nullable\n * - additionalProperties: false\n *\n * This enables strict mode for all tools automatically.\n *\n * Some tool schemas (e.g. MCP server tools that use `oneOf`, `$ref`, or\n * `$defs`) cannot be expressed under OpenAI's strict Structured Outputs\n * subset. For those we fall back to a non-strict tool definition — stripping\n * only the formats OpenAI rejects — so the tool is still usable instead of\n * failing the request with a 400 \"Invalid schema\" error.\n */\nexport function convertFunctionToolToAdapterFormat(\n  tool: Tool,\n): FunctionToolConfig {\n  const inputSchema = (tool.inputSchema ?? {\n    type: 'object',\n    properties: {},\n    required: [],\n  }) as JSONSchema\n\n  if (!isStrictModeCompatible(inputSchema)) {\n    return {\n      type: 'function',\n      name: tool.name,\n      description: tool.description,\n      parameters: stripUnsupportedFormats(inputSchema),\n      strict: false,\n    } satisfies FunctionToolConfig\n  }\n\n  const jsonSchema = makeStructuredOutputCompatible(\n    inputSchema,\n    inputSchema.required || [],\n  )\n\n  jsonSchema.additionalProperties = false\n\n  return {\n    type: 'function',\n    name: tool.name,\n    description: tool.description,\n    parameters: jsonSchema,\n    strict: true,\n  } satisfies FunctionToolConfig\n}\n"],"names":[],"mappings":";AA8BO,SAAS,mCACd,MACoB;AACpB,QAAM,cAAe,KAAK,eAAe;AAAA,IACvC,MAAM;AAAA,IACN,YAAY,CAAA;AAAA,IACZ,UAAU,CAAA;AAAA,EAAC;AAGb,MAAI,CAAC,uBAAuB,WAAW,GAAG;AACxC,WAAO;AAAA,MACL,MAAM;AAAA,MACN,MAAM,KAAK;AAAA,MACX,aAAa,KAAK;AAAA,MAClB,YAAY,wBAAwB,WAAW;AAAA,MAC/C,QAAQ;AAAA,IAAA;AAAA,EAEZ;AAEA,QAAM,aAAa;AAAA,IACjB;AAAA,IACA,YAAY,YAAY,CAAA;AAAA,EAAC;AAG3B,aAAW,uBAAuB;AAElC,SAAO;AAAA,IACL,MAAM;AAAA,IACN,MAAM,KAAK;AAAA,IACX,aAAa,KAAK;AAAA,IAClB,YAAY;AAAA,IACZ,QAAQ;AAAA,EAAA;AAEZ;"}

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

@@ -1,3 +1,13 @@
+/**
+ * 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:
@@ -11,3 +21,14 @@
  * @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` (anywhere in the tree) uses a JSON-Schema
+ * keyword outside OpenAI's strict Structured Outputs subset — i.e. it cannot be
+ * made strict-compatible and must be sent with `strict: false`.
+ *
+ * Conservative by design: keywords are matched as object keys, so a property
+ * literally named e.g. `oneOf` also trips it. That only costs that one tool its
+ * strict mode, which is strictly safer than a false "compatible" verdict that
+ * 400s the whole request.
+ */
+export declare function isStrictModeCompatible(schema: unknown): boolean;

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/openai-base",
-  "version": "0.8.4",
+  "version": "0.8.7",
   "description": "Shared OpenAI SDK base adapters for TanStack AI providers using Chat Completions and Responses APIs.",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -47,13 +47,13 @@
     "@tanstack/ai-utils": "0.2.2"
   },
   "peerDependencies": {
-    "@tanstack/ai": "^0.31.0"
+    "@tanstack/ai": "^0.32.0"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "4.0.14",
     "vite": "^7.3.3",
     "zod": "^4.2.0",
-    "@tanstack/ai": "0.31.0"
+    "@tanstack/ai": "0.32.0"
   },
   "scripts": {
     "build": "vite build",

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

@@ -1,4 +1,8 @@
-import { makeStructuredOutputCompatible } from '../utils/schema-converter'
+import {
+  isStrictModeCompatible,
+  makeStructuredOutputCompatible,
+  stripUnsupportedFormats,
+} from '../utils/schema-converter'
 import type { ChatCompletionTool } from 'openai/resources/chat/completions/completions'
 import type { JSONSchema, Tool } from '@tanstack/ai'
 
@@ -22,7 +26,14 @@ export type ChatCompletionFunctionTool = Extract<
  * - Optional fields made nullable
  * - additionalProperties: false
  *
- * This enables strict mode for all tools automatically.
+ * This enables strict mode for tools whose schemas fit OpenAI's strict subset.
+ *
+ * Schemas using keywords outside that subset (`oneOf`/`allOf`/`not`/`$ref`/
+ * `$defs` — common with MCP servers like Notion) can't be coerced to a
+ * strict-valid shape, and `strict: true` would make the API reject the ENTIRE
+ * request with a 400. Such tools are emitted with `strict: false` (their schema
+ * passed through, only unsupported `format` keywords stripped) so they stay
+ * callable.
  */
 export function convertFunctionToolToChatCompletionsFormat(
   tool: Tool,
@@ -37,6 +48,20 @@ export function convertFunctionToolToChatCompletionsFormat(
     required: [],
   }) as JSONSchema
 
+  // Schema outside OpenAI's strict subset: send non-strict so the tool still
+  // works instead of 400-ing the whole request.
+  if (!isStrictModeCompatible(inputSchema)) {
+    return {
+      type: 'function',
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: stripUnsupportedFormats(inputSchema),
+        strict: false,
+      },
+    } satisfies ChatCompletionFunctionTool
+  }
+
   // Shallow-copy the converter's result before mutating: a subclass-supplied
   // schemaConverter has no contract requirement to return a fresh object,
   // and a passthrough `(s) => s` would otherwise have its caller's schema

package/src/adapters/responses-tool-converter.ts

@@ -1,4 +1,8 @@
-import { makeStructuredOutputCompatible } from '../utils/schema-converter'
+import {
+  isStrictModeCompatible,
+  makeStructuredOutputCompatible,
+  stripUnsupportedFormats,
+} from '../utils/schema-converter'
 import type { JSONSchema, Tool } from '@tanstack/ai'
 
 /**
@@ -28,7 +32,14 @@ export interface ResponsesFunctionTool {
  * - Optional fields made nullable
  * - additionalProperties: false
  *
- * This enables strict mode for all tools automatically.
+ * This enables strict mode for tools whose schemas fit OpenAI's strict subset.
+ *
+ * Schemas using keywords outside that subset (`oneOf`/`allOf`/`not`/`$ref`/
+ * `$defs` — common with MCP servers like Notion) can't be coerced to a
+ * strict-valid shape, and `strict: true` would make the Responses API reject
+ * the ENTIRE request with a 400. Such tools are emitted with `strict: false`
+ * (their schema passed through, only unsupported `format` keywords stripped) so
+ * they stay callable.
  */
 export function convertFunctionToolToResponsesFormat(
   tool: Tool,
@@ -43,6 +54,18 @@ export function convertFunctionToolToResponsesFormat(
     required: [],
   }) as JSONSchema
 
+  // Schema outside OpenAI's strict subset: send non-strict so the tool still
+  // works instead of 400-ing the whole request.
+  if (!isStrictModeCompatible(inputSchema)) {
+    return {
+      type: 'function',
+      name: tool.name,
+      description: tool.description,
+      parameters: stripUnsupportedFormats(inputSchema),
+      strict: false,
+    }
+  }
+
   // Shallow-copy the converter's result before mutating — a subclass-supplied
   // schemaConverter has no contract requirement to return a fresh object;
   // mutating in place could corrupt the caller's tool definition.

package/src/tools/function-tool.ts

@@ -1,4 +1,8 @@
-import { makeStructuredOutputCompatible } from '../utils/schema-converter'
+import {
+  isStrictModeCompatible,
+  makeStructuredOutputCompatible,
+  stripUnsupportedFormats,
+} from '../utils/schema-converter'
 import type { FunctionTool as FunctionToolConfig } from 'openai/resources/responses/responses'
 import type { JSONSchema, Tool } from '@tanstack/ai'
 
@@ -17,6 +21,12 @@ export type FunctionTool = FunctionToolConfig
  * - additionalProperties: false
  *
  * This enables strict mode for all tools automatically.
+ *
+ * Some tool schemas (e.g. MCP server tools that use `oneOf`, `$ref`, or
+ * `$defs`) cannot be expressed under OpenAI's strict Structured Outputs
+ * subset. For those we fall back to a non-strict tool definition — stripping
+ * only the formats OpenAI rejects — so the tool is still usable instead of
+ * failing the request with a 400 "Invalid schema" error.
  */
 export function convertFunctionToolToAdapterFormat(
   tool: Tool,
@@ -27,6 +37,16 @@ export function convertFunctionToolToAdapterFormat(
     required: [],
   }) as JSONSchema
 
+  if (!isStrictModeCompatible(inputSchema)) {
+    return {
+      type: 'function',
+      name: tool.name,
+      description: tool.description,
+      parameters: stripUnsupportedFormats(inputSchema),
+      strict: false,
+    } satisfies FunctionToolConfig
+  }
+
   const jsonSchema = makeStructuredOutputCompatible(
     inputSchema,
     inputSchema.required || [],

package/src/utils/schema-converter.ts

@@ -27,7 +27,7 @@ const SUPPORTED_STRING_FORMATS = new Set([
  * 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: any): any {
+export function stripUnsupportedFormats(node: any): any {
   if (Array.isArray(node)) return node.map(stripUnsupportedFormats)
   if (node === null || typeof node !== 'object') return node
 
@@ -64,6 +64,55 @@ export function makeStructuredOutputCompatible(
   return stripUnsupportedFormats(coerceStrictSchema(schema, originalRequired))
 }
 
+/**
+ * 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
+ */
+const STRICT_UNSUPPORTED_KEYWORDS: ReadonlyArray<string> = [
+  'oneOf',
+  'allOf',
+  'not',
+  '$ref',
+  '$defs',
+  'definitions',
+]
+
+/**
+ * Returns `false` when `schema` (anywhere in the tree) uses a JSON-Schema
+ * keyword outside OpenAI's strict Structured Outputs subset — i.e. it cannot be
+ * made strict-compatible and must be sent with `strict: false`.
+ *
+ * Conservative by design: keywords are matched as object keys, so a property
+ * literally named e.g. `oneOf` also trips it. That only costs that one tool its
+ * strict mode, which is strictly safer than a false "compatible" verdict that
+ * 400s the whole request.
+ */
+export function isStrictModeCompatible(schema: unknown): boolean {
+  return !containsStrictUnsupportedKeyword(schema)
+}
+
+function containsStrictUnsupportedKeyword(node: unknown): boolean {
+  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
+}
+
 /**
  * Strict-mode structural rewrite (required widening, nullability,
  * additionalProperties). Kept private so the public entry point can apply the