ai/ai-review-agent-openrouter-1.0.groovy - plugins/scripts - Git at Google

 // Copyright (C) 2026 The Android Open Source Project
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 // http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 import com.gerritforge.gerrit.plugins.ai.provider.api.*

 import com.google.common.flogger.FluentLogger
 import com.google.gerrit.extensions.registration.DynamicSet
 import com.google.inject.*

 import org.apache.http.*
 import org.apache.http.message.*
 import org.apache.http.entity.StringEntity

 import java.nio.charset.StandardCharsets

 import groovy.json.*

 @Singleton
 class AiOpenRouterReviewProvider implements AiReviewProvider {
     private static final FluentLogger logger = FluentLogger.forEnclosingClass()
     private static final String OPENROUTER_API_URL = 'https://openrouter.ai/api/v1/chat/completions'
     private static final String OPENROUTER_MODELS_URL = 'https://openrouter.ai/api/v1/models'
     private static final String ATTRIBUTION_REFERER = 'https://gerrit-review.googlesource.com/'
     private static final String ATTRIBUTION_TITLE = 'Gerrit AI Review'
     private static final int MAX_ERROR_LEN = 500

     // Floating aliases that always resolve to the latest vendor version.
     // DeepSeek (no `~latest` alias) is sourced dynamically below.
     private static final List<String> PAID_LATEST_MODELS = [
             '~anthropic/claude-opus-latest',
             '~anthropic/claude-sonnet-latest',
             '~google/gemini-pro-latest',
             '~openai/gpt-latest',
             '~anthropic/claude-haiku-latest',
             '~google/gemini-flash-latest',
             '~openai/gpt-mini-latest',
     ]

     private static final int FREE_PICK_COUNT = 5

     final String displayName = 'OpenRouter'

     @Inject
     private AiHttpClient http

     @Override
     Set<String> getModels(String notUsed) {
         // On failure, return paid-only fallback. Caching handled by AiProvidersInfoCache.
         try {
             List<Map> catalog = http.get(
                     OPENROUTER_MODELS_URL,
                     [http.acceptApplicationJson()] as Header[],
                     { extractErrorMessage(it) },
                     { extractCatalog(it) }) as List<Map>

             // Paid first (strongest quality), then DeepSeek flagship, then free picks.
             LinkedHashSet<String> merged = new LinkedHashSet<>()
             merged.addAll(PAID_LATEST_MODELS)
             merged.addAll(latestDeepseekProFromCatalog(catalog))
             merged.addAll(topFreeFromCatalog(catalog))

             logger.atInfo().log('OpenRouter catalog refreshed (%d models cached)', merged.size())
             return merged
         } catch (JsonException | IOException e) {
             logger.atWarning().withCause(e).log(
                     'Failed to fetch OpenRouter catalog; falling back to ~latest paid models only')
             return PAID_LATEST_MODELS as LinkedHashSet
         }
     }

     @Override
     String review(String apiKey, String model, String prompt) {
         Header[] headers = [
                 http.contentTypeApplicationJson(),
                 new BasicHeader('Authorization', "Bearer ${apiKey}"),
                 new BasicHeader('HTTP-Referer', ATTRIBUTION_REFERER),
                 new BasicHeader('X-Title', ATTRIBUTION_TITLE),
         ] as Header[]
         def entity = new StringEntity(
                 new JsonBuilder([
                         model   : model,
                         messages: [[role: 'user', content: prompt]],
                 ]).toString(),
                 StandardCharsets.UTF_8)

         try {
             return http.post(
                     OPENROUTER_API_URL,
                     headers,
                     entity,
                     { extractErrorMessage(it) },
                     { extractResponseText(it) }) as String
         } catch (JsonException | IOException e) {
             logger.atWarning().withCause(e).log('Failed to call OpenRouter API (model=%s)', model)
             throw new IllegalStateException('Failed to call OpenRouter API', e)
         }
     }

     private static String extractResponseText(String body) {
         def json = new JsonSlurper().parseText(body)

         def choice = json.choices?.find()
         if (!choice) {
             throw new IOException('OpenRouter API returned no choices')
         }

         def content = choice.message?.content
         if (!content) {
             def reason = choice.finish_reason ? choice.finish_reason : 'unknown'
             throw new IOException("OpenRouter API choice has no content, finish_reason=$reason")
         }

         // Prefix \n so the reply sits below the "Gathering ..." placeholder.
         String text = unwrapOuterMarkdownFence(content as String)
         return text ? "\n${text}" : text
     }

     private static List<Map> extractCatalog(String body) {
         def json = new JsonSlurper().parseText(body)
         return (json?.data ?: []) as List<Map>
     }

     // Empirically more reliable free-tier namespaces (fewer 404 rotations).
     private static final Set<String> BIG_VENDORS = [
             'openai', 'anthropic', 'google', 'meta-llama',
             'deepseek', 'qwen', 'z-ai', 'mistralai', 'nvidia',
     ] as Set

     // Heuristic "good for code review" score (catalog payload lacks benchmarks):
     //   +100  id contains `coder` / `code`           — code-specialized
     //   +60   reasoning mode (supported_parameters or `thinking` in id)
     //   +40   big-vendor namespace (see BIG_VENDORS)
     //   +ctx/10k                                     — tie-breaker
     // Re-tune if real-world picks regress.
     private static long scoreFreeModel(Map entry) {
         String id = (entry.id as String) ?: ''
         long score = 0L
         if (id.contains('coder') || id.contains('code')) score += 100L
         List params = (entry.supported_parameters as List) ?: []
         if (params.contains('reasoning') || id.contains('thinking')) score += 60L
         String vendor = id.contains('/') ? id.substring(0, id.indexOf('/')) : ''
         if (BIG_VENDORS.contains(vendor)) score += 40L
         score += ((entry.context_length ?: 0) as long) / 10_000L
         return score
     }

     // Top FREE_PICK_COUNT by scoreFreeModel(); id sort breaks ties stably.
     private static List<String> topFreeFromCatalog(List<Map> catalog) {
         return catalog
                 .findAll { (it.id as String)?.endsWith(':free') }
                 .sort { a, b ->
                     long sb = scoreFreeModel(b)
                     long sa = scoreFreeModel(a)
                     if (sb != sa) return Long.compare(sb, sa)
                     return ((a.id as String) ?: '').compareTo((b.id as String) ?: '')
                 }
                 .take(FREE_PICK_COUNT)
                 .collect { it.id as String }
     }

     // Approximate "deepseek-latest": highest version `deepseek/deepseek-v<N>-pro`.
     private static List<String> latestDeepseekProFromCatalog(List<Map> catalog) {
         def versionRegex = ~/^deepseek\/deepseek-v(\d+)(?:\.\d+)?-pro$/
         def versioned = catalog.findResults { entry ->
             def id = entry.id as String
             if (!id) return null
             def m = versionRegex.matcher(id)
             m.matches() ? [id: id, version: (m.group(1) as int)] : null
         }
         if (versioned.isEmpty()) return []
         return [(versioned.max { it.version }).id as String]
     }

     // Strip outer ```lang ... ``` wrap (gpt-oss-* habit) so the chat panel
     // renders it as markdown, not a literal code block.
     private static String unwrapOuterMarkdownFence(String text) {
         if (!text) return text
         String trimmed = text.trim()
         if (!trimmed.startsWith('```') || !trimmed.endsWith('```')) return text
         int firstNewline = trimmed.indexOf('\n')
         if (firstNewline < 0) return text
         String openFence = trimmed.substring(0, firstNewline).trim()
         if (!(openFence ==~ /```[A-Za-z0-9_+\-]*/)) return text
         String inner = trimmed.substring(firstNewline + 1, trimmed.length() - 3)
         if (inner.contains('```')) return text
         return inner.trim()
     }

     private static String extractErrorMessage(String body) {
         try {
             def json = new JsonSlurper().parseText(body)
             if (json?.error) return "[${json.error.code}] ${json.error.message}"
         } catch (Exception e) {
             logger.atWarning().withCause(e).log('Failed to parse error response')
         }
         return body.length() > MAX_ERROR_LEN ? "${body.take(MAX_ERROR_LEN)}..." : body
     }
 }

 class AiOpenRouterModule extends AbstractModule {
     @Override
     protected void configure() {
         DynamicSet.bind(binder(), AiReviewProvider).to(AiOpenRouterReviewProvider)
     }
 }

 module = AiOpenRouterModule
	// Copyright (C) 2026 The Android Open Source Project
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	import com.gerritforge.gerrit.plugins.ai.provider.api.*

	import com.google.common.flogger.FluentLogger
	import com.google.gerrit.extensions.registration.DynamicSet
	import com.google.inject.*

	import org.apache.http.*
	import org.apache.http.message.*
	import org.apache.http.entity.StringEntity

	import java.nio.charset.StandardCharsets

	import groovy.json.*

	@Singleton
	class AiOpenRouterReviewProvider implements AiReviewProvider {
	private static final FluentLogger logger = FluentLogger.forEnclosingClass()
	private static final String OPENROUTER_API_URL = 'https://openrouter.ai/api/v1/chat/completions'
	private static final String OPENROUTER_MODELS_URL = 'https://openrouter.ai/api/v1/models'
	private static final String ATTRIBUTION_REFERER = 'https://gerrit-review.googlesource.com/'
	private static final String ATTRIBUTION_TITLE = 'Gerrit AI Review'
	private static final int MAX_ERROR_LEN = 500

	// Floating aliases that always resolve to the latest vendor version.
	// DeepSeek (no `~latest` alias) is sourced dynamically below.
	private static final List<String> PAID_LATEST_MODELS = [
	'~anthropic/claude-opus-latest',
	'~anthropic/claude-sonnet-latest',
	'~google/gemini-pro-latest',
	'~openai/gpt-latest',
	'~anthropic/claude-haiku-latest',
	'~google/gemini-flash-latest',
	'~openai/gpt-mini-latest',
	]

	private static final int FREE_PICK_COUNT = 5

	final String displayName = 'OpenRouter'

	@Inject
	private AiHttpClient http

	@Override
	Set<String> getModels(String notUsed) {
	// On failure, return paid-only fallback. Caching handled by AiProvidersInfoCache.
	try {
	List<Map> catalog = http.get(
	OPENROUTER_MODELS_URL,
	[http.acceptApplicationJson()] as Header[],
	{ extractErrorMessage(it) },
	{ extractCatalog(it) }) as List<Map>

	// Paid first (strongest quality), then DeepSeek flagship, then free picks.
	LinkedHashSet<String> merged = new LinkedHashSet<>()
	merged.addAll(PAID_LATEST_MODELS)
	merged.addAll(latestDeepseekProFromCatalog(catalog))
	merged.addAll(topFreeFromCatalog(catalog))

	logger.atInfo().log('OpenRouter catalog refreshed (%d models cached)', merged.size())
	return merged
	} catch (JsonException \| IOException e) {
	logger.atWarning().withCause(e).log(
	'Failed to fetch OpenRouter catalog; falling back to ~latest paid models only')
	return PAID_LATEST_MODELS as LinkedHashSet
	}
	}

	@Override
	String review(String apiKey, String model, String prompt) {
	Header[] headers = [
	http.contentTypeApplicationJson(),
	new BasicHeader('Authorization', "Bearer ${apiKey}"),
	new BasicHeader('HTTP-Referer', ATTRIBUTION_REFERER),
	new BasicHeader('X-Title', ATTRIBUTION_TITLE),
	] as Header[]
	def entity = new StringEntity(
	new JsonBuilder([
	model : model,
	messages: [[role: 'user', content: prompt]],
	]).toString(),
	StandardCharsets.UTF_8)

	try {
	return http.post(
	OPENROUTER_API_URL,
	headers,
	entity,
	{ extractErrorMessage(it) },
	{ extractResponseText(it) }) as String
	} catch (JsonException \| IOException e) {
	logger.atWarning().withCause(e).log('Failed to call OpenRouter API (model=%s)', model)
	throw new IllegalStateException('Failed to call OpenRouter API', e)
	}
	}

	private static String extractResponseText(String body) {
	def json = new JsonSlurper().parseText(body)

	def choice = json.choices?.find()
	if (!choice) {
	throw new IOException('OpenRouter API returned no choices')
	}

	def content = choice.message?.content
	if (!content) {
	def reason = choice.finish_reason ? choice.finish_reason : 'unknown'
	throw new IOException("OpenRouter API choice has no content, finish_reason=$reason")
	}

	// Prefix \n so the reply sits below the "Gathering ..." placeholder.
	String text = unwrapOuterMarkdownFence(content as String)
	return text ? "\n${text}" : text
	}

	private static List<Map> extractCatalog(String body) {
	def json = new JsonSlurper().parseText(body)
	return (json?.data ?: []) as List<Map>
	}

	// Empirically more reliable free-tier namespaces (fewer 404 rotations).
	private static final Set<String> BIG_VENDORS = [
	'openai', 'anthropic', 'google', 'meta-llama',
	'deepseek', 'qwen', 'z-ai', 'mistralai', 'nvidia',
	] as Set

	// Heuristic "good for code review" score (catalog payload lacks benchmarks):
	// +100 id contains `coder` / `code` — code-specialized
	// +60 reasoning mode (supported_parameters or `thinking` in id)
	// +40 big-vendor namespace (see BIG_VENDORS)
	// +ctx/10k — tie-breaker
	// Re-tune if real-world picks regress.
	private static long scoreFreeModel(Map entry) {
	String id = (entry.id as String) ?: ''
	long score = 0L
	if (id.contains('coder') \|\| id.contains('code')) score += 100L
	List params = (entry.supported_parameters as List) ?: []
	if (params.contains('reasoning') \|\| id.contains('thinking')) score += 60L
	String vendor = id.contains('/') ? id.substring(0, id.indexOf('/')) : ''
	if (BIG_VENDORS.contains(vendor)) score += 40L
	score += ((entry.context_length ?: 0) as long) / 10_000L
	return score
	}

	// Top FREE_PICK_COUNT by scoreFreeModel(); id sort breaks ties stably.
	private static List<String> topFreeFromCatalog(List<Map> catalog) {
	return catalog
	.findAll { (it.id as String)?.endsWith(':free') }
	.sort { a, b ->
	long sb = scoreFreeModel(b)
	long sa = scoreFreeModel(a)
	if (sb != sa) return Long.compare(sb, sa)
	return ((a.id as String) ?: '').compareTo((b.id as String) ?: '')
	}
	.take(FREE_PICK_COUNT)
	.collect { it.id as String }
	}

	// Approximate "deepseek-latest": highest version `deepseek/deepseek-v<N>-pro`.
	private static List<String> latestDeepseekProFromCatalog(List<Map> catalog) {
	def versionRegex = ~/^deepseek\/deepseek-v(\d+)(?:\.\d+)?-pro$/
	def versioned = catalog.findResults { entry ->
	def id = entry.id as String
	if (!id) return null
	def m = versionRegex.matcher(id)
	m.matches() ? [id: id, version: (m.group(1) as int)] : null
	}
	if (versioned.isEmpty()) return []
	return [(versioned.max { it.version }).id as String]
	}

	// Strip outer ```lang ... ``` wrap (gpt-oss-* habit) so the chat panel
	// renders it as markdown, not a literal code block.
	private static String unwrapOuterMarkdownFence(String text) {
	if (!text) return text
	String trimmed = text.trim()
	if (!trimmed.startsWith('```') \|\| !trimmed.endsWith('```')) return text
	int firstNewline = trimmed.indexOf('\n')
	if (firstNewline < 0) return text
	String openFence = trimmed.substring(0, firstNewline).trim()
	if (!(openFence ==~ /```[A-Za-z0-9_+\-]*/)) return text
	String inner = trimmed.substring(firstNewline + 1, trimmed.length() - 3)
	if (inner.contains('```')) return text
	return inner.trim()
	}

	private static String extractErrorMessage(String body) {
	try {
	def json = new JsonSlurper().parseText(body)
	if (json?.error) return "[${json.error.code}] ${json.error.message}"
	} catch (Exception e) {
	logger.atWarning().withCause(e).log('Failed to parse error response')
	}
	return body.length() > MAX_ERROR_LEN ? "${body.take(MAX_ERROR_LEN)}..." : body
	}
	}

	class AiOpenRouterModule extends AbstractModule {
	@Override
	protected void configure() {
	DynamicSet.bind(binder(), AiReviewProvider).to(AiOpenRouterReviewProvider)
	}
	}

	module = AiOpenRouterModule