Fix code review issues: allOf determinism, field preservation, number precision, JSON Schema support

- Fix non-deterministic allOf merging by processing before main iteration
- Preserve all schema fields in mergeAllOf (description, title, enum, etc.)
- Use json.NewDecoder with UseNumber() to preserve number precision
- Change response_schema to responseJsonSchema for full JSON Schema support
- Preserve additionalProperties constraints instead of removing them

Author: ER-EPR

internal/translator/gemini/openai/responses/gemini_openai-responses_request.go

@@ -415,12 +415,12 @@ func ConvertOpenAIResponsesRequestToGemini(modelName string, inputRawJSON []byte
 			}
 			out, _ = sjson.SetBytes(out, "generationConfig.response_mime_type", "application/json")
 
-			// Set response_schema from the schema field, normalizing it for Gemini's
-			// supported JSON Schema subset (removes unsupported keywords like additionalProperties,
-			// pattern, minLength, multipleOf, etc.)
+			// Set responseJsonSchema from the schema field, normalizing it for Gemini's
+			// supported JSON Schema subset (removes unsupported keywords like pattern,
+			// minLength, multipleOf, etc. but preserves additionalProperties, $defs, $ref)
 			if schema := textFormat.Get("schema"); schema.Exists() {
 				schemaStr := normalizeJSONSchema(schema.Raw)
-				out, _ = sjson.SetRawBytes(out, "generationConfig.response_schema", []byte(schemaStr))
+				out, _ = sjson.SetRawBytes(out, "generationConfig.responseJsonSchema", []byte(schemaStr))
 			}
 		}
 	}
@@ -514,14 +514,61 @@ func openAIResponsesGeminiThoughtSignature(rawSignature string) string {
 func normalizeSchemaForGemini(schema interface{}) interface{} {
 	switch v := schema.(type) {
 	case map[string]interface{}:
+		// If allOf exists, merge it first to avoid non-deterministic overwrites during map iteration
+		if allOf, exists := v["allOf"]; exists {
+			if allOfArray, ok := allOf.([]interface{}); ok {
+				merged := mergeAllOf(allOfArray)
+				for k, val := range v {
+					if k == "allOf" {
+						continue
+					}
+					if k == "properties" {
+						mergedProps, _ := merged["properties"].(map[string]interface{})
+						if mergedProps == nil {
+							mergedProps = make(map[string]interface{})
+						} else {
+							// Copy to avoid mutating original
+							newProps := make(map[string]interface{})
+							for pk, pv := range mergedProps {
+								newProps[pk] = pv
+							}
+							mergedProps = newProps
+						}
+						if vProps, ok := val.(map[string]interface{}); ok {
+							for pk, pv := range vProps {
+								mergedProps[pk] = pv
+							}
+						}
+						merged["properties"] = mergedProps
+					} else if k == "required" {
+						var mergedReq []interface{}
+						if mr, ok := merged["required"].([]interface{}); ok {
+							mergedReq = append(mergedReq, mr...)
+						}
+						if vr, ok := val.([]interface{}); ok {
+							mergedReq = append(mergedReq, vr...)
+						}
+						merged["required"] = mergedReq
+					} else {
+						merged[k] = val
+					}
+				}
+				v = merged
+			}
+		}
+
 		result := make(map[string]interface{})
 
 		for key, val := range v {
 			switch key {
-			case "additionalProperties":
-				// Remove this - Gemini rejects it in some contexts
+			case "allOf":
+				// Already merged pre-iteration
 				continue
 
+			case "additionalProperties":
+				// Preserve additionalProperties - Gemini JSON Schema mode supports it
+				result[key] = val
+
 			case "type":
 				// Handle nullable types: convert ["string", "null"] to "string" + "nullable": true
 				if typeArray, ok := val.([]interface{}); ok {
@@ -587,16 +634,8 @@ func normalizeSchemaForGemini(schema interface{}) interface{} {
 				}
 
 			case "allOf":
-				// Merge all schemas in allOf into a single schema
-				if allOfArray, ok := val.([]interface{}); ok {
-					mergedSchema := mergeAllOf(allOfArray)
-					normalized := normalizeSchemaForGemini(mergedSchema)
-					if normalizedMap, ok := normalized.(map[string]interface{}); ok {
-						for k, v := range normalizedMap {
-							result[k] = v
-						}
-					}
-				}
+				// Already merged pre-iteration
+				continue
 
 			case "oneOf":
 				// Convert oneOf to anyOf
@@ -678,24 +717,20 @@ func mergeAllOf(schemas []interface{}) map[string]interface{} {
 
 	for _, schema := range schemas {
 		if schemaMap, ok := schema.(map[string]interface{}); ok {
-			// Merge type
-			if typ, exists := schemaMap["type"]; exists {
-				merged["type"] = typ
-			}
-
-			// Merge properties
-			if props, exists := schemaMap["properties"]; exists {
-				if propsMap, ok := props.(map[string]interface{}); ok {
-					for k, v := range propsMap {
-						properties[k] = v
+			for k, v := range schemaMap {
+				switch k {
+				case "properties":
+					if propsMap, ok := v.(map[string]interface{}); ok {
+						for pk, pv := range propsMap {
+							properties[pk] = pv
+						}
 					}
-				}
-			}
-
-			// Merge required fields
-			if req, exists := schemaMap["required"]; exists {
-				if reqArray, ok := req.([]interface{}); ok {
-					required = append(required, reqArray...)
+				case "required":
+					if reqArray, ok := v.([]interface{}); ok {
+						required = append(required, reqArray...)
+					}
+				default:
+					merged[k] = v
 				}
 			}
 		}
@@ -730,15 +765,18 @@ func mergeAllOf(schemas []interface{}) map[string]interface{} {
 //
 // The function handles the complete conversion from OpenAI's JSON Schema format to Gemini's
 // supported subset, including:
-// - Removing unsupported keywords (additionalProperties, pattern, minLength, multipleOf, etc.)
+// - Removing unsupported keywords (pattern, minLength, multipleOf, etc.)
 // - Preserving nullable type arrays ["string", "null"]
+// - Preserving additionalProperties constraints
 // - Filtering format values to only date-time, date, time
 // - Recursively processing all nested schemas
 //
 // If parsing fails, the original schema is returned unchanged.
 func normalizeJSONSchema(schemaJSON string) string {
 	var schema interface{}
-	if err := json.Unmarshal([]byte(schemaJSON), &schema); err != nil {
+	decoder := json.NewDecoder(strings.NewReader(schemaJSON))
+	decoder.UseNumber()
+	if err := decoder.Decode(&schema); err != nil {
 		return schemaJSON
 	}