fix(openai): apply strict fallback in the provider-path function-tool converter (#790)

* fix(openai): apply strict fallback in the provider-path function-tool converter

The provider tool dispatcher (convertToolsToProviderFormat) routes MCP and
function tools through convertFunctionToolToAdapterFormat, which still forced
strict:true and 400'd on schemas outside OpenAI's strict subset (e.g. Notion
MCP tools using $defs/oneOf). Apply the same isStrictModeCompatible check used
by the responses/chat-completions converters: emit strict:false and strip
unsupported formats when the schema can't be strict, keeping the tool callable.

* chore: add changeset for openai strict-fallback function-tool fix

Author: AlemTuzlak

.changeset/openai-strict-fallback-function-tool.md

@@ -0,0 +1,5 @@
+---
+'@tanstack/openai-base': patch
+---
+
+Apply the strict-mode fallback in the provider-path `function-tool` converter. A tool whose input JSON Schema can't satisfy OpenAI's strict function-calling constraints now falls back to a non-strict tool definition (matching the converter's other path) instead of emitting an invalid strict tool, so such tools work across the OpenAI-based adapters (`@tanstack/ai-openai`, `@tanstack/ai-grok`, `@tanstack/ai-groq`).

packages/openai-base/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 || [],

packages/openai-base/tests/tool-converter-strict-fallback.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, it } from 'vitest'
 import { convertFunctionToolToResponsesFormat } from '../src/adapters/responses-tool-converter'
 import { convertFunctionToolToChatCompletionsFormat } from '../src/adapters/chat-completions-tool-converter'
+import { convertFunctionToolToAdapterFormat } from '../src/tools/function-tool'
 import type { Tool } from '@tanstack/ai'
 
 /** A schema fully inside OpenAI's strict Structured Outputs subset. */
@@ -74,3 +75,27 @@ describe('chat-completions tool converter — strict fallback', () => {
     expect(params.properties.site.format).toBeUndefined()
   })
 })
+
+// This is the converter the provider tool-dispatcher (`convertToolsToProviderFormat`)
+// actually uses for MCP / function tools on the Responses + Chat Completions
+// adapters, so the same strict fallback must apply here.
+describe('function-tool adapter converter — strict fallback', () => {
+  it('uses strict:true for strict-subset schemas', () => {
+    const out = convertFunctionToolToAdapterFormat(strictSafeTool)
+    expect(out.strict).toBe(true)
+    expect(
+      (out.parameters as Record<string, unknown>).additionalProperties,
+    ).toBe(false)
+  })
+
+  it('falls back to strict:false for schemas with unsupported keywords', () => {
+    const out = convertFunctionToolToAdapterFormat(gnarlyTool)
+    expect(out.strict).toBe(false)
+    // Schema is preserved (not corrupted) so the tool stays callable...
+    const params = out.parameters as any
+    expect(params.$defs.parent.oneOf).toBeDefined()
+    // ...but unsupported `format` keywords are still stripped.
+    expect(params.properties.site.format).toBeUndefined()
+    expect(params.properties.user_id.format).toBe('uuid')
+  })
+})