refactor: streamline Gemini tool configuration and parsing logic with new utility methods

Author: Noxiven

backend/internal/infra/llm/gemini.go

@@ -153,7 +153,7 @@ func buildGeminiRequestBody(input GenerateInput) (map[string]interface{}, error)
 		webSearchTools = append(webSearchTools, map[string]interface{}{"google_search": map[string]interface{}{}})
 	}
 	appendToolDeclarations(payload, providerTools, webSearchTools, buildGeminiTools(toolDefinitions))
-	applyGeminiToolConfigDefaults(payload, len(providerTools)+len(webSearchTools) > 0, len(toolDefinitions) > 0)
+	applyGeminiToolConfigDefaults(payload, len(providerTools)+len(webSearchTools) > 0)
 
 	if len(systemTextParts) > 0 {
 		payload["systemInstruction"] = map[string]interface{}{
@@ -167,8 +167,8 @@ func buildGeminiRequestBody(input GenerateInput) (map[string]interface{}, error)
 	return payload, nil
 }
 
-func applyGeminiToolConfigDefaults(payload map[string]interface{}, hasServerSideTools bool, hasFunctionDeclarations bool) {
-	if !hasServerSideTools || !hasFunctionDeclarations {
+func applyGeminiToolConfigDefaults(payload map[string]interface{}, hasServerSideTools bool) {
+	if !hasServerSideTools {
 		return
 	}
 	toolConfig := asMap(payload["toolConfig"])
@@ -925,26 +925,52 @@ func parseGeminiServerToolCalls(parsed map[string]interface{}) []ToolCall {
 	}
 	result := make([]ToolCall, 0)
 	for _, call := range parseGeminiExplicitServerToolCalls(parsed, -1) {
-		appendUniqueToolCall(&result, call)
+		appendGeminiServerToolCallForParse(&result, call)
 	}
 	for candidateIndex, rawCandidate := range asSlice(parsed["candidates"]) {
 		candidate := asMap(rawCandidate)
 		for _, call := range parseGeminiExplicitServerToolCalls(candidate, candidateIndex) {
-			appendUniqueToolCall(&result, call)
+			appendGeminiServerToolCallForParse(&result, call)
 		}
 		if call, ok := parseGeminiGoogleSearchServerToolCall(candidate, candidateIndex); ok {
-			appendUniqueToolCall(&result, call)
+			appendGeminiServerToolCallForParse(&result, call)
 		}
 		if call, ok := parseGeminiURLContextServerToolCall(candidate, candidateIndex); ok {
-			appendUniqueToolCall(&result, call)
+			appendGeminiServerToolCallForParse(&result, call)
 		}
 		for _, call := range parseGeminiCodeExecutionServerToolCalls(candidate, candidateIndex) {
-			appendUniqueToolCall(&result, call)
+			appendGeminiServerToolCallForParse(&result, call)
 		}
 	}
 	return result
 }
 
+func appendGeminiServerToolCallForParse(calls *[]ToolCall, call ToolCall) {
+	if calls == nil {
+		return
+	}
+	if isGeminiSingletonServerToolCall(call) {
+		for idx, existing := range *calls {
+			if sameToolCallKind(existing, call) {
+				incoming := call
+				incoming.ToolCallID = ""
+				(*calls)[idx] = mergeToolCall(existing, incoming)
+				return
+			}
+		}
+	}
+	appendUniqueToolCall(calls, call)
+}
+
+func isGeminiSingletonServerToolCall(call ToolCall) bool {
+	switch normalizeGeminiServerToolName(firstNonEmptyString(call.ToolName, call.ToolType)) {
+	case "google_search", "url_context":
+		return true
+	default:
+		return false
+	}
+}
+
 func parseGeminiExplicitServerToolCalls(payload map[string]interface{}, candidateIndex int) []ToolCall {
 	if len(payload) == 0 {
 		return nil
@@ -963,9 +989,8 @@ func parseGeminiExplicitServerToolCalls(payload map[string]interface{}, candidat
 			}
 		}
 	}
-	content := asMap(payload["content"])
-	for partIndex, raw := range asSlice(content["parts"]) {
-		part := asMap(raw)
+	for partIndex, raw := range geminiContentParts(payload) {
+		part := geminiContentPart(raw)
 		for _, key := range []string{"serverSideToolInvocation", "server_side_tool_invocation", "toolInvocation", "tool_invocation"} {
 			if call, ok := parseGeminiExplicitServerToolCall(asMap(part[key]), candidateIndex, partIndex); ok {
 				result = append(result, call)
@@ -1036,7 +1061,7 @@ func normalizeGeminiExplicitServerToolStatus(status string) string {
 }
 
 func parseGeminiGoogleSearchServerToolCall(candidate map[string]interface{}, candidateIndex int) (ToolCall, bool) {
-	grounding := asMap(candidate["groundingMetadata"])
+	grounding := geminiGroundingMetadata(candidate)
 	if !hasGeminiSearchGroundingMetadata(grounding) {
 		return ToolCall{}, false
 	}
@@ -1062,15 +1087,15 @@ func parseGeminiGoogleSearchServerToolCall(candidate map[string]interface{}, can
 }
 
 func parseGeminiURLContextServerToolCall(candidate map[string]interface{}, candidateIndex int) (ToolCall, bool) {
-	metadata := asMap(candidate["urlContextMetadata"])
+	metadata := geminiURLContextMetadata(candidate)
 	urlMetadata := asSlice(metadata["urlMetadata"])
 	if len(urlMetadata) == 0 {
 		return ToolCall{}, false
 	}
 	urls := make([]string, 0, len(urlMetadata))
 	for _, raw := range urlMetadata {
 		item := asMap(raw)
-		if uri := firstNonEmptyString(getString(item["retrievedUrl"]), getString(item["url"]), getString(item["uri"])); uri != "" {
+		if uri := geminiURLContextItemURL(item); uri != "" {
 			urls = append(urls, uri)
 		}
 	}
@@ -1092,12 +1117,11 @@ func parseGeminiURLContextServerToolCall(candidate map[string]interface{}, candi
 }
 
 func parseGeminiCodeExecutionServerToolCalls(candidate map[string]interface{}, candidateIndex int) []ToolCall {
-	content := asMap(candidate["content"])
-	parts := asSlice(content["parts"])
+	parts := geminiContentParts(candidate)
 	result := make([]ToolCall, 0)
 	currentIndex := -1
 	for _, raw := range parts {
-		part := asMap(raw)
+		part := geminiContentPart(raw)
 		executableCode := asMap(part["executableCode"])
 		if len(executableCode) > 0 {
 			currentIndex++
@@ -1132,6 +1156,65 @@ func parseGeminiCodeExecutionServerToolCalls(candidate map[string]interface{}, c
 	return result
 }
 
+func geminiGroundingMetadata(candidate map[string]interface{}) map[string]interface{} {
+	grounding := asMap(candidate["groundingMetadata"])
+	if len(grounding) == 0 {
+		grounding = asMap(candidate["grounding_metadata"])
+	}
+	return normalizeGeminiMapAliases(grounding, map[string]string{
+		"grounding_chunks":   "groundingChunks",
+		"grounding_supports": "groundingSupports",
+		"retrieval_metadata": "retrievalMetadata",
+		"search_entry_point": "searchEntryPoint",
+		"web_search_queries": "webSearchQueries",
+	})
+}
+
+func geminiURLContextMetadata(candidate map[string]interface{}) map[string]interface{} {
+	metadata := asMap(candidate["urlContextMetadata"])
+	if len(metadata) == 0 {
+		metadata = asMap(candidate["url_context_metadata"])
+	}
+	return normalizeGeminiMapAliases(metadata, map[string]string{
+		"url_metadata": "urlMetadata",
+	})
+}
+
+func geminiContentParts(candidate map[string]interface{}) []interface{} {
+	content := asMap(candidate["content"])
+	return asSlice(content["parts"])
+}
+
+func geminiContentPart(raw interface{}) map[string]interface{} {
+	return normalizeGeminiMapAliases(asMap(raw), map[string]string{
+		"code_execution_result": "codeExecutionResult",
+		"executable_code":       "executableCode",
+	})
+}
+
+func normalizeGeminiMapAliases(item map[string]interface{}, aliases map[string]string) map[string]interface{} {
+	if len(item) == 0 || len(aliases) == 0 {
+		return item
+	}
+	normalized := item
+	cloned := false
+	for alias, canonical := range aliases {
+		if _, ok := normalized[canonical]; ok {
+			continue
+		}
+		value, ok := item[alias]
+		if !ok {
+			continue
+		}
+		if !cloned {
+			normalized = cloneMap(item)
+			cloned = true
+		}
+		normalized[canonical] = value
+	}
+	return normalized
+}
+
 func geminiGroundingSources(grounding map[string]interface{}) []map[string]interface{} {
 	chunks := asSlice(grounding["groundingChunks"])
 	if len(chunks) == 0 {
@@ -1140,7 +1223,7 @@ func geminiGroundingSources(grounding map[string]interface{}) []map[string]inter
 	result := make([]map[string]interface{}, 0, len(chunks))
 	for _, raw := range chunks {
 		chunk := asMap(raw)
-		for _, key := range []string{"web", "retrievedContext"} {
+		for _, key := range []string{"web", "retrievedContext", "retrieved_context"} {
 			source := asMap(chunk[key])
 			uri := firstNonEmptyString(getString(source["uri"]), getString(source["url"]))
 			if uri == "" {
@@ -1163,19 +1246,28 @@ func geminiURLContextItems(items []interface{}) []map[string]interface{} {
 	result := make([]map[string]interface{}, 0, len(items))
 	for _, raw := range items {
 		item := asMap(raw)
-		url := firstNonEmptyString(getString(item["retrievedUrl"]), getString(item["url"]), getString(item["uri"]))
+		url := geminiURLContextItemURL(item)
 		if url == "" {
 			continue
 		}
 		next := map[string]interface{}{"url": url}
-		if status := strings.TrimSpace(getString(item["urlRetrievalStatus"])); status != "" {
+		if status := strings.TrimSpace(firstNonEmptyString(getString(item["urlRetrievalStatus"]), getString(item["url_retrieval_status"]))); status != "" {
 			next["status"] = status
 		}
 		result = append(result, next)
 	}
 	return result
 }
 
+func geminiURLContextItemURL(item map[string]interface{}) string {
+	return firstNonEmptyString(
+		getString(item["retrievedUrl"]),
+		getString(item["retrieved_url"]),
+		getString(item["url"]),
+		getString(item["uri"]),
+	)
+}
+
 func compactGeminiServerToolPayload(payload map[string]interface{}) map[string]interface{} {
 	if len(payload) == 0 {
 		return nil
@@ -1230,20 +1322,20 @@ func parseGeminiCitations(parsed map[string]interface{}) []string {
 	citations := make([]string, 0)
 	for _, rawCandidate := range asSlice(parsed["candidates"]) {
 		candidate := asMap(rawCandidate)
-		grounding := asMap(candidate["groundingMetadata"])
+		grounding := geminiGroundingMetadata(candidate)
 		for _, raw := range asSlice(grounding["groundingChunks"]) {
 			chunk := asMap(raw)
-			for _, key := range []string{"web", "retrievedContext"} {
+			for _, key := range []string{"web", "retrievedContext", "retrieved_context"} {
 				source := asMap(chunk[key])
 				if uri := firstNonEmptyString(getString(source["uri"]), getString(source["url"])); uri != "" {
 					citations = append(citations, uri)
 				}
 			}
 		}
-		urlContext := asMap(candidate["urlContextMetadata"])
+		urlContext := geminiURLContextMetadata(candidate)
 		for _, raw := range asSlice(urlContext["urlMetadata"]) {
 			item := asMap(raw)
-			if uri := firstNonEmptyString(getString(item["retrievedUrl"]), getString(item["url"]), getString(item["uri"])); uri != "" {
+			if uri := geminiURLContextItemURL(item); uri != "" {
 				citations = append(citations, uri)
 			}
 		}
@@ -1256,17 +1348,14 @@ func parseGeminiServerSideToolUsage(parsed map[string]interface{}) map[string]in
 		return nil
 	}
 	result := make(map[string]int64)
-	for _, rawCandidate := range asSlice(parsed["candidates"]) {
-		candidate := asMap(rawCandidate)
-		if hasGeminiSearchGroundingMetadata(asMap(candidate["groundingMetadata"])) {
+	for _, call := range parseGeminiServerToolCalls(parsed) {
+		switch normalizeGeminiServerToolName(firstNonEmptyString(call.ToolName, call.ToolType)) {
+		case "google_search":
 			result["google_search"] = 1
-		}
-		if len(asSlice(asMap(candidate["urlContextMetadata"])["urlMetadata"])) > 0 {
+		case "url_context":
 			result["url_context"] = 1
-		}
-		codeExecutionCount := int64(len(parseGeminiCodeExecutionServerToolCalls(candidate, 0)))
-		if codeExecutionCount > 0 {
-			result["code_execution"] += codeExecutionCount
+		case "code_execution":
+			result["code_execution"]++
 		}
 	}
 	if len(result) == 0 {