feat(tools): implement comprehensive schema normalization

Adds anyOf flattening, nullable type normalization, and strict keyword filtering to tool definitions. Enhances backend compatibility with strict models (Claude/Gemini) by porting logic from opencode-antigravity-auth.

Author: ndycode

lib/request/helpers/tool-utils.ts

@@ -17,11 +17,12 @@ export interface Tool {
 /**
  * Cleans up tool definitions to ensure strict JSON Schema compliance.
  *
- * Implements "require" logic:
+ * Implements "require" logic and advanced normalization:
  * 1. Filters 'required' array to remove properties that don't exist in 'properties'.
- *    (Fixes "property is not defined" errors from strict validators)
- * 2. Injects a placeholder property for empty parameter objects if needed.
- * 3. Handles nested object schemas recursively.
+ * 2. Injects a placeholder property for empty parameter objects.
+ * 3. Flattens 'anyOf' with 'const' values into 'enum'.
+ * 4. Normalizes nullable types (array types) to single type + description.
+ * 5. Removes unsupported keywords (additionalProperties, const, etc.).
  *
  * @param tools - Array of tool definitions
  * @returns Cleaned array of tool definitions
@@ -50,7 +51,45 @@ export function cleanupToolDefinitions(tools: unknown): unknown {
 function cleanupSchema(schema: Record<string, unknown>): void {
 	if (!schema || typeof schema !== "object") return;
 
-	// 1. Filter 'required' array
+	// 1. Flatten Unions (anyOf -> enum)
+	if (Array.isArray(schema.anyOf)) {
+		const anyOf = schema.anyOf as Record<string, unknown>[];
+		const allConst = anyOf.every((opt) => "const" in opt);
+		if (allConst && anyOf.length > 0) {
+			const enumValues = anyOf.map((opt) => opt.const);
+			schema.enum = enumValues;
+			delete schema.anyOf;
+
+			// Infer type from first value if missing
+			if (!schema.type) {
+				const firstVal = enumValues[0];
+				if (typeof firstVal === "string") schema.type = "string";
+				else if (typeof firstVal === "number") schema.type = "number";
+				else if (typeof firstVal === "boolean") schema.type = "boolean";
+			}
+		}
+	}
+
+	// 2. Flatten Nullable Types (["string", "null"] -> "string")
+	if (Array.isArray(schema.type)) {
+		const types = schema.type as string[];
+		const isNullable = types.includes("null");
+		const nonNullTypes = types.filter((t) => t !== "null");
+
+		if (nonNullTypes.length > 0) {
+			// Use the first non-null type (most strict models expect a single string type)
+			schema.type = nonNullTypes[0];
+			if (isNullable) {
+				const desc = (schema.description as string) || "";
+				// Only append if not already present
+				if (!desc.toLowerCase().includes("nullable")) {
+					schema.description = desc ? `${desc} (nullable)` : "(nullable)";
+				}
+			}
+		}
+	}
+
+	// 3. Filter 'required' array
 	if (
 		Array.isArray(schema.required) &&
 		schema.properties &&
@@ -70,9 +109,7 @@ function cleanupSchema(schema: Record<string, unknown>): void {
 		}
 	}
 
-	// 2. Handle empty object parameters (Claude/Gemini compatibility)
-	// If properties is empty but type is object, some models fail.
-	// We inject a placeholder to make it a valid non-empty object.
+	// 4. Handle empty object parameters
 	if (
 		schema.type === "object" &&
 		(!schema.properties || Object.keys(schema.properties as object).length === 0)
@@ -83,19 +120,23 @@ function cleanupSchema(schema: Record<string, unknown>): void {
 				description: "This property is a placeholder and should be ignored.",
 			},
 		};
-		// Ideally we shouldn't make it required unless necessary, but some validators want it.
-		// For now, we'll leave it optional to avoid forcing the model to generate it.
 	}
 
-	// 3. Recurse into properties
+	// 5. Remove unsupported keywords
+	delete schema.additionalProperties;
+	delete schema.const;
+	delete schema.title;
+	delete schema.$schema;
+
+	// 6. Recurse into properties
 	if (schema.properties && typeof schema.properties === "object") {
 		const props = schema.properties as Record<string, Record<string, unknown>>;
 		for (const key in props) {
 			cleanupSchema(props[key]);
 		}
 	}
 
-	// 4. Recurse into array items
+	// 7. Recurse into array items
 	if (schema.items && typeof schema.items === "object") {
 		cleanupSchema(schema.items as Record<string, unknown>);
 	}

package.json

@@ -1,6 +1,6 @@
 {
   "name": "oc-chatgpt-multi-auth",
-  "version": "4.9.4",
+  "version": "4.9.5",
   "description": "Multi-account rotation plugin for ChatGPT Plus/Pro (OAuth / Codex backend)",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

test/request-transformer.test.ts

@@ -1556,6 +1556,99 @@ describe('Request Transformer Module', () => {
 					const tool = (result.tools as any)[0];
 					expect(tool.function.parameters.properties).toHaveProperty('_placeholder');
 				});
+
+				it('should flatten anyOf with const values to enum', async () => {
+					const body: RequestBody = {
+						model: 'gpt-5-codex',
+						input: [],
+						tools: [
+							{
+								type: 'function',
+								function: {
+									name: 'enum_tool',
+									parameters: {
+										type: 'object',
+										properties: {
+											choice: {
+												anyOf: [
+													{ const: 'A' },
+													{ const: 'B' }
+												]
+											}
+										}
+									}
+								}
+							}
+						]
+					};
+
+					const result = await transformRequestBody(body, codexInstructions);
+					const tool = (result.tools as any)[0];
+					const prop = tool.function.parameters.properties.choice;
+					expect(prop.anyOf).toBeUndefined();
+					expect(prop.enum).toEqual(['A', 'B']);
+					expect(prop.type).toBe('string');
+				});
+
+				it('should normalize nullable array types to single type + description', async () => {
+					const body: RequestBody = {
+						model: 'gpt-5-codex',
+						input: [],
+						tools: [
+							{
+								type: 'function',
+								function: {
+									name: 'null_tool',
+									parameters: {
+										type: 'object',
+										properties: {
+											optional_str: {
+												type: ['string', 'null'],
+												description: 'An optional string'
+											}
+										}
+									}
+								}
+							}
+						]
+					};
+
+					const result = await transformRequestBody(body, codexInstructions);
+					const tool = (result.tools as any)[0];
+					const prop = tool.function.parameters.properties.optional_str;
+					expect(prop.type).toBe('string');
+					expect(prop.description).toBe('An optional string (nullable)');
+				});
+
+				it('should remove unsupported keywords', async () => {
+					const body: RequestBody = {
+						model: 'gpt-5-codex',
+						input: [],
+						tools: [
+							{
+								type: 'function',
+								function: {
+									name: 'clean_tool',
+									parameters: {
+										type: 'object',
+										properties: {
+											prop: { type: 'string', const: 'fixed' }
+										},
+										additionalProperties: false,
+										$schema: 'http://json-schema.org/draft-07/schema#'
+									}
+								}
+							}
+						]
+					};
+
+					const result = await transformRequestBody(body, codexInstructions);
+					const tool = (result.tools as any)[0];
+					const params = tool.function.parameters;
+					expect(params.additionalProperties).toBeUndefined();
+					expect(params.$schema).toBeUndefined();
+					expect(params.properties.prop.const).toBeUndefined();
+				});
 			});
 		});
 	});