Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
♊ fix: Strip remaining unsupported JSON Schema keywords for Gemini MCP tools (#13850)
Danny Avila8969034ad10e
diff --git a/packages/api/src/mcp/__tests__/zod.spec.ts b/packages/api/src/mcp/__tests__/zod.spec.tsindex 5c948c388d..03ff634097 100644--- a/packages/api/src/mcp/__tests__/zod.spec.ts+++ b/packages/api/src/mcp/__tests__/zod.spec.ts@@ -2636,7 +2636,7 @@ describe('sanitizeGeminiSchema', () => {expect(sanitizeGeminiSchema(schema)).toEqual({ type: 'string', enum: ['a', 'b'] });});- it('strips unsupported keywords (additionalProperties, default, $schema)', () => {+ it('strips unsupported keywords (additionalProperties, $schema) but keeps Gemini-supported default', () => {const schema = {$schema: 'http://json-schema.org/draft-07/schema#',type: 'object',@@ -2649,7 +2649,7 @@ describe('sanitizeGeminiSchema', () => {const result = sanitizeGeminiSchema(schema);expect(result).not.toHaveProperty('$schema');expect(result).not.toHaveProperty('additionalProperties');- expect(result.properties.name).toEqual({ type: 'string' });+ expect(result.properties.name).toEqual({ type: 'string', default: 'anon' });});it('folds exclusive bounds into inclusive minimum/maximum', () => {@@ -2710,4 +2710,201 @@ describe('sanitizeGeminiSchema', () => {const schema = { type: 'integer', enum: [1, 2, 3] } as any;expect(sanitizeGeminiSchema(schema)).toEqual({ type: 'integer' });});++ it('strips annotation keywords Gemini rejects (examples, readOnly, writeOnly, deprecated, $comment)', () => {+ const schema = {+ type: 'object',+ properties: {+ token: {+ type: 'string',+ examples: ['abc'],+ readOnly: true,+ writeOnly: false,+ deprecated: true,+ $comment: 'internal',+ },+ },+ } as any;+ expect(sanitizeGeminiSchema(schema)).toEqual({+ type: 'object',+ properties: { token: { type: 'string' } },+ });+ });++ it('strips numeric/array validators Gemini rejects (multipleOf, uniqueItems)', () => {+ const schema = {+ type: 'object',+ properties: {+ count: { type: 'integer', multipleOf: 2 },+ tags: { type: 'array', items: { type: 'string' }, uniqueItems: true },+ },+ } as any;+ expect(sanitizeGeminiSchema(schema)).toEqual({+ type: 'object',+ properties: {+ count: { type: 'integer' },+ tags: { type: 'array', items: { type: 'string' } },+ },+ });+ });++ it('strips object-composition keywords Gemini rejects (patternProperties, propertyNames, dependentRequired)', () => {+ const schema = {+ type: 'object',+ properties: { a: { type: 'string' } },+ patternProperties: { '^x': { type: 'string' } },+ propertyNames: { pattern: '^[a-z]+$' },+ dependentRequired: { a: ['b'] },+ } as any;+ expect(sanitizeGeminiSchema(schema)).toEqual({+ type: 'object',+ properties: { a: { type: 'string' } },+ });+ });++ it('strips tuple/array-extension keywords Gemini rejects (prefixItems, additionalItems)', () => {+ const schema = {+ type: 'array',+ items: { type: 'string' },+ prefixItems: [{ type: 'string' }, { type: 'number' }],+ additionalItems: false,+ } as any;+ expect(sanitizeGeminiSchema(schema)).toEqual({+ type: 'array',+ items: { type: 'string' },+ });+ });++ it('synthesizes `items` from `prefixItems` when a tuple array has none (Gemini requires items)', () => {+ const schema = {+ type: 'array',+ prefixItems: [{ type: 'string', readOnly: true }, { type: 'number' }],+ } as any;+ expect(sanitizeGeminiSchema(schema)).toEqual({+ type: 'array',+ items: { type: 'string' },+ });+ });++ it('preserves an existing `items` over a `prefixItems`-derived one', () => {+ const schema = {+ type: 'array',+ items: { type: 'boolean' },+ prefixItems: [{ type: 'string' }],+ } as any;+ expect(sanitizeGeminiSchema(schema)).toEqual({+ type: 'array',+ items: { type: 'boolean' },+ });+ });++ it('synthesizes `items` from `prefixItems` when `items` is boolean false (Draft 2020 tuple)', () => {+ const schema = {+ type: 'array',+ prefixItems: [{ type: 'number' }],+ items: false,+ } as any;+ expect(sanitizeGeminiSchema(schema)).toEqual({+ type: 'array',+ items: { type: 'number' },+ });+ });++ it('falls back to an empty `items` schema for a boolean `items` with no prefixItems', () => {+ expect(sanitizeGeminiSchema({ type: 'array', items: false } as any)).toEqual({+ type: 'array',+ items: {},+ });+ expect(sanitizeGeminiSchema({ type: 'array', items: true } as any)).toEqual({+ type: 'array',+ items: {},+ });+ });++ it('falls back to an empty `items` schema for an array missing items entirely', () => {+ expect(sanitizeGeminiSchema({ type: 'array' } as any)).toEqual({+ type: 'array',+ items: {},+ });+ });++ it('drops a tuple-array `items: [...]` form and falls back rather than emit an array items', () => {+ const schema = { type: 'array', items: [{ type: 'string' }, { type: 'number' }] } as any;+ expect(sanitizeGeminiSchema(schema)).toEqual({ type: 'array', items: {} });+ });++ it('preserves an object `default` verbatim without sanitizing its data keys', () => {+ const schema = {+ type: 'object',+ properties: {+ cfg: {+ type: 'object',+ default: { id: 'abc', readOnly: true, deprecated: false, nested: { id: 'x' } },+ properties: { id: { type: 'string' } },+ },+ },+ } as any;+ const result = sanitizeGeminiSchema(schema);+ expect(result.properties.cfg.default).toEqual({+ id: 'abc',+ readOnly: true,+ deprecated: false,+ nested: { id: 'x' },+ });+ expect(result.properties.cfg.properties).toEqual({ id: { type: 'string' } });+ });++ it('preserves an array `default` verbatim', () => {+ const schema = {+ type: 'array',+ items: { type: 'string' },+ default: ['id', 'readOnly'],+ } as any;+ expect(sanitizeGeminiSchema(schema)).toEqual({+ type: 'array',+ items: { type: 'string' },+ default: ['id', 'readOnly'],+ });+ });++ it('strips content keywords and the bare `id` alias Gemini rejects', () => {+ const schema = {+ id: 'urn:example',+ type: 'object',+ properties: {+ blob: { type: 'string', contentEncoding: 'base64', contentMediaType: 'image/png' },+ },+ } as any;+ expect(sanitizeGeminiSchema(schema)).toEqual({+ type: 'object',+ properties: { blob: { type: 'string' } },+ });+ });++ it('strips deeply nested unsupported keywords through arrays, items, and properties', () => {+ const schema = {+ type: 'object',+ properties: {+ ranges: {+ type: 'array',+ items: {+ type: 'object',+ properties: { score: { type: 'number', exclusiveMinimum: 0, multipleOf: 0.5 } },+ },+ },+ },+ } as any;+ expect(sanitizeGeminiSchema(schema)).toEqual({+ type: 'object',+ properties: {+ ranges: {+ type: 'array',+ items: {+ type: 'object',+ properties: { score: { type: 'number', minimum: 0 } },+ },+ },+ },+ });+ });});diff --git a/packages/api/src/mcp/zod.ts b/packages/api/src/mcp/zod.tsindex c6df45b6a0..767c1919a5 100644--- a/packages/api/src/mcp/zod.ts+++ b/packages/api/src/mcp/zod.ts@@ -352,9 +352,40 @@ function mergeRequired(a: unknown, b: unknown): string[] | undefined {/*** JSON Schema keywords absent from Gemini's function-calling Schema subset- * (https://ai.google.dev/api/caching#Schema); they trigger 400s and are stripped.+ * (https://ai.google.dev/api/caching#Schema); they trigger `Unknown name "<key>"`+ * 400s and are stripped. Every entry below was verified to be rejected through+ * `FunctionDeclaration.parameters` against the live Gemini API (`gemini-2.5-flash`,+ * `gemini-3.5-flash`) and/or Vertex AI — e.g. `additionalProperties` is rejected+ * only by the Gemini API but accepted by Vertex, so the union is stripped for both.+ * `@langchain/google-genai` only removes `additionalProperties`/`$schema`, so the+ * rest must be stripped here.+ *+ * Not listed (handled elsewhere in `sanitizeGeminiSchema`): `default` is preserved+ * (part of Gemini's Schema, accepted live by both endpoints); `prefixItems` is+ * dropped but synthesized into `items` so the array keeps a required element schema.*/-const GEMINI_UNSUPPORTED_KEYS = new Set(['additionalProperties', 'default', '$schema', '$id']);+const GEMINI_UNSUPPORTED_KEYS = new Set([+ 'additionalProperties',+ '$schema',+ '$id',+ 'id',+ '$comment',+ 'examples',+ 'readOnly',+ 'writeOnly',+ 'deprecated',+ 'multipleOf',+ 'uniqueItems',+ 'additionalItems',+ 'propertyNames',+ 'patternProperties',+ 'dependencies',+ 'dependentRequired',+ 'dependentSchemas',+ 'contentEncoding',+ 'contentMediaType',+ 'contentSchema',+]);/*** Merges the members of an `allOf` (schema intersection) into the parent: combines@@ -441,6 +472,11 @@ function collapseSchemaUnion(schema: Record<string, unknown>): Record<string, unreturn current;}+/** True when the value is a usable JSON Schema object (not a boolean or array). */+function isObjectSchema(value: unknown): value is Record<string, unknown> {+ return value != null && typeof value === 'object' && !Array.isArray(value);+}+/*** Collapses a multi-entry `type` array (e.g. `['string', 'null']`) into a single* type, reporting whether a `null` entry made the field nullable.@@ -470,7 +506,9 @@ function collapseTypeArray(types: unknown[]): { type?: string; nullable: boolean* drops the keyword entirely for non-string types (e.g. a boolean `const`* normalized to `enum: [true]`).* - Folds `exclusiveMinimum`/`exclusiveMaximum` into `minimum`/`maximum`.- * - Strips unsupported keywords (`additionalProperties`, `default`, `const`, `$schema`, `$id`).+ * - Strips `const` (after enum conversion) and every keyword in `GEMINI_UNSUPPORTED_KEYS`+ * (`additionalProperties`, `examples`, `readOnly`, `multipleOf`, `uniqueItems`,+ * `patternProperties`, `prefixItems`, etc.) that the Gemini schema validator rejects.** @param schema - The JSON schema to sanitize* @returns The Gemini-compatible schema@@ -517,6 +555,38 @@ export function sanitizeGeminiSchema<T extends Record<string, unknown>>(schema:continue;}+ // `default` holds a literal data value (Gemini-supported), not a subschema —+ // copy it verbatim so object/array defaults aren't recursively sanitized+ // (which would strip ordinary data keys like `id`/`readOnly`).+ if (key === 'default') {+ result['default'] = value;+ continue;+ }++ // Gemini has no tuple validation, so drop `prefixItems`; but Gemini requires+ // `items` to be a schema object on every array, so synthesize one from the+ // first tuple member unless a real object `items` is already present (a+ // boolean `items: false` does not count).+ if (key === 'prefixItems') {+ if (!isObjectSchema(collapsed.items) && Array.isArray(value)) {+ const first = value.find((member) => member && typeof member === 'object');+ if (first) {+ result['items'] = sanitizeGeminiSchema(first as Record<string, unknown>);+ }+ }+ continue;+ }++ // Gemini requires `items` to be a schema object; drop the boolean+ // (`items: false`) and tuple-array (`items: [...]`) forms — a+ // `prefixItems`-derived or empty fallback is emitted instead.+ if (key === 'items') {+ if (isObjectSchema(value)) {+ result['items'] = sanitizeGeminiSchema(value as Record<string, unknown>);+ }+ continue;+ }+// Gemini has no `const`; a string const becomes a single-value (string) enum,// a non-string const is dropped (Gemini enum is string-only).if (key === 'const') {@@ -577,6 +647,13 @@ export function sanitizeGeminiSchema<T extends Record<string, unknown>>(schema:result['type'] = 'string';}+ // Gemini rejects an array whose `items` is missing or not a schema object; fall+ // back to a permissive empty schema (verified accepted by the API) so tuple/+ // itemless arrays don't 400 after their unsupported item forms are dropped.+ if (result['type'] === 'array' && !isObjectSchema(result['items'])) {+ result['items'] = {};+ }+if (nullable) {result['nullable'] = true;}