Skip to content

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

♊ 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.ts
index 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.ts
index 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, un
return 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;
}