feat: add first-class OpenRouter provider support (#1975)

## Summary

First-class `Provider::OpenRouter` support joining the existing
anthropic/openai/databricks providers. Reuses the Chat Completions path
with targeted mutations for OpenRouter's routing contract.

**Core (`crates/buzz-agent`):**
- `Provider::OpenRouter` enum variant with `OPENROUTER_API_KEY`,
`BUZZ_AGENT_MODEL` → `OPENROUTER_MODEL` fallback, `OPENROUTER_BASE_URL`
env convention
- Body mutator: `reasoning: {effort}` when effort is configured, and
`max_completion_tokens` translated to OpenRouter's `max_tokens`
spelling; no `provider.require_parameters` filter (it routes only to
endpoints advertising every parameter in the body, which hard-404s a
valid model id); summaries get neither. `openai_body` is always called
with `effort=None` on the OpenRouter path — the `reasoning` object is
added by the mutator directly, so `reasoning_effort` is structurally
absent.
- Attribution headers: `HTTP-Referer: https://github.com/block/buzz`,
`X-OpenRouter-Title: Buzz`
- Error-inside-200 check in shared `parse_openai` (`finish_reason ==
"error"`)
- 401 auth handling: static API keys (`refresh_now` returns the same
token) fail terminal immediately with one wire request; PKCE/minting
sources get one retry with the fresh token.
- Status+`error_type` retry matrix (4-arm collapsed form): 429 (honor
`Retry-After`), 502 (retry), 503/`provider_overloaded` (honor
`Retry-After`), everything else including untyped 503 (bounded retries →
actionable routing message). 499 included matching shared `post()`
(#2175) for turn-timeout stall surfacing. Terminal failures wrapped in
`terminal_llm_error` for duration+attempt-count context.
- `anthropic/*` `cache_control` injection (model-gated, mixed-content
safe)
- Provider-agnostic `reasoning_details` opaque round-trip on
`HistoryItem::Assistant` for tool-call continuations — captured verbatim
in `parse_openai_with_reasoning_details`, replayed verbatim in
`openai_body`, byte-accounting charged. `provider_extra` passthrough
from `make_tool_call` composes independently.

**Desktop:**
- Readiness arms checking `OPENROUTER_API_KEY` + `OPENROUTER_MODEL`
- Model discovery via `{OPENROUTER_BASE_URL}/models` filtered on
`supported_parameters` contains `tools`
- Picker entry, credential config, effort table 3-file sync

**`desktop/src/features/agents/AGENTS.md`: no rules changed** — the
scoped rule requiring an explicit note is satisfied here.

Implements the gate-cleared plan from
`PLANS/OPENROUTER_PROVIDER_PLAN.md` (rev 3).

Signed-off-by: Will Pfleger <pfleger.will@gmail.com>
Co-authored-by: npub1mn7jgtj4w2pd0g0zeuhxsa6jy6p0rewxz4kujt98my82ahfmp72sxjexk7 <dcfd242e557282d7a1e2cf2e6877522682f1e5c6156dc92ca7d90eaedd3b0f95@buzz.block.builderlab.xyz>
This commit is contained in:
Will Pfleger
2026-07-29 23:08:35 +00:00
committed by GitHub
co-authored by npub1mn7jgtj4w2pd0g0zeuhxsa6jy6p0rewxz4kujt98my82ahfmp72sxjexk7
parent f95fdc1a10
commit ab55fee818
15 changed files with 2958 additions and 304 deletions
+38 -88
View File
@@ -99,6 +99,17 @@ pub async fn get_agent_models(
// so a build-provided provider still gets live discovery.
let effective_provider =
effective_discovery_provider(saved_provider.as_deref(), provider_env_var, &merged_env);
if let Some(models) = discover_openrouter_models(
&state.http_client,
&effective_provider,
&merged_env,
persisted_model.clone(),
)
.await?
{
return Ok(models);
}
if let Some(models) = discover_openai_compatible_models(
&state.http_client,
&effective_provider,
@@ -154,69 +165,11 @@ fn model_discovery_error(pubkey: &str, error: &str) -> String {
)
}
/// Everything `get_agent_models` needs from the record + context, resolved in
/// one pure step so the linked-agent regression test can bind the exact values
/// the command consumes.
#[derive(Debug, PartialEq, Eq)]
struct AgentModelDiscoveryConfig {
/// Effective harness command (descriptor-resolved), for `resolve_command`.
command: String,
/// Effective harness args (descriptor-resolved).
args: Vec<String>,
/// Model from the authoritative resolver spawn uses — linked instances
/// read their definition, never stale `record.model` bytes.
model: Option<String>,
/// Provider from the same authoritative resolver — never stale
/// `record.provider` bytes for linked instances.
provider: Option<String>,
/// The runtime's provider env var (e.g. `GOOSE_PROVIDER`), so discovery
/// can recover the provider from the env when the resolver yields none.
/// `None` for runtimes that do not take a provider, or an unknown command.
provider_env_var: Option<&'static str>,
/// The descriptor's fully layered env (definition/persona/global/agent).
env: BTreeMap<String, String>,
}
/// Resolve the model-discovery config for a saved agent — the descriptor-backed
/// successor to the old `saved_agent_model_discovery_config`.
///
/// Command/args/env come from `resolve_effective_harness_descriptor` (the same
/// resolver as `spawn_agent_child`); model/provider come from
/// `resolve_effective_model_provider` (#1968's definition-authoritative
/// contract) — linked instances read their definition, never a stale
/// materialized `record.model`/`record.provider`, so discovery cannot query a
/// provider this agent will not actually launch with. Definition-less
/// instances keep their own record values, matching spawn's
/// `resolve_definition_less` arm. When the resolver yields no provider,
/// `effective_discovery_provider` recovers the provider the agent will
/// actually launch with from the runtime's own provider env var, read out of
/// the descriptor env (which already layers definition/persona/global values
/// the same way spawn does).
///
/// Returns `Err("DANGLING_HARNESS_ID:<id>")` from the descriptor resolver when
/// the harness id no longer exists; the caller routes it through
/// `model_discovery_error`.
fn agent_model_discovery_config(
record: &crate::managed_agents::ManagedAgentRecord,
personas: &[crate::managed_agents::AgentDefinition],
global: &crate::managed_agents::GlobalAgentConfig,
) -> Result<AgentModelDiscoveryConfig, String> {
let descriptor =
crate::managed_agents::resolve_effective_harness_descriptor(record, personas, global)?;
let (model, provider) =
crate::managed_agents::resolve_effective_model_provider(record, personas, global);
let provider_env_var =
known_acp_runtime(&descriptor.command).and_then(|meta| meta.provider_env_var);
Ok(AgentModelDiscoveryConfig {
command: descriptor.command,
args: descriptor.args,
model,
provider,
provider_env_var,
env: descriptor.env,
})
}
#[path = "agent_models_discovery_config.rs"]
mod discovery_config;
use discovery_config::{
agent_model_discovery_config, draft_agent_model_discovery_env, AgentModelDiscoveryConfig,
};
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
@@ -269,31 +222,12 @@ pub async fn discover_agent_models(
.unwrap_or_else(|| agent_command.to_string());
let runtime_meta = known_acp_runtime(agent_command);
let mut derived_env = BTreeMap::new();
if let Some(meta) = runtime_meta {
let provider = input
.provider
.as_deref()
.map(str::trim)
.filter(|value| !value.is_empty());
if !meta.provider_locked {
if let (Some(env_key), Some(provider)) = (meta.provider_env_var, provider) {
derived_env.insert(env_key.to_string(), provider.to_string());
}
}
}
// Layer definition_env below user env_vars so user overrides always win.
// Reserved keys are stripped, matching the same filter applied at spawn.
let mut filtered_definition_env = BTreeMap::new();
for (key, value) in &input.definition_env {
if !crate::managed_agents::is_reserved_env_key(key) {
filtered_definition_env.insert(key.clone(), value.clone());
}
}
// Merge: derived (metadata) → definition env → user env_vars.
let merged_with_def =
crate::managed_agents::merged_user_env(&derived_env, &filtered_definition_env);
let merged_env = crate::managed_agents::merged_user_env(&merged_with_def, &input.env_vars);
let merged_env = draft_agent_model_discovery_env(
agent_command,
input.provider.as_deref(),
&input.definition_env,
&input.env_vars,
);
let merged_env = discovery_env_with_baked_floor(merged_env);
// Recover a build-provided provider when the form has none, so the create
// dialog discovers live models instead of falling through to the subprocess.
@@ -348,6 +282,13 @@ pub async fn discover_agent_models(
return Err("Buzz shared compute is not available in this build".to_string());
}
if let Some(models) =
discover_openrouter_models(&state.http_client, &effective_provider, &merged_env, None)
.await?
{
return Ok(models);
}
if let Some(models) = discover_openai_compatible_models(
&state.http_client,
&effective_provider,
@@ -388,6 +329,15 @@ struct OpenAiModelListItem {
created: Option<i64>,
}
#[path = "agent_models_openrouter.rs"]
mod openrouter;
use openrouter::discover_openrouter_models;
#[cfg(test)]
use openrouter::{
filter_openrouter_models, is_openrouter_provider, openrouter_models_url,
OpenRouterModelListItem, OpenRouterModelListResponse,
};
fn is_openai_compatible_provider(provider: Option<&str>) -> bool {
matches!(
provider
@@ -0,0 +1,112 @@
//! Model-discovery configuration resolution for the agent-models commands.
//!
//! Two entry points, one per call shape: [`agent_model_discovery_config`]
//! resolves a *saved* agent through the same descriptor/model resolvers spawn
//! uses, and [`draft_agent_model_discovery_env`] derives the env for an unsaved
//! form. Both are pure so the regression tests can bind the exact values the
//! commands consume.
//!
//! Included from `agent_models.rs` via `#[path]`, so `super::*` resolves
//! against that module (the `agent_models_tests.rs` convention).
use std::collections::BTreeMap;
use crate::managed_agents::known_acp_runtime;
/// Everything `get_agent_models` needs from the record + context, resolved in
/// one pure step so the linked-agent regression test can bind the exact values
/// the command consumes.
#[derive(Debug, PartialEq, Eq)]
pub(super) struct AgentModelDiscoveryConfig {
/// Effective harness command (descriptor-resolved), for `resolve_command`.
pub(super) command: String,
/// Effective harness args (descriptor-resolved).
pub(super) args: Vec<String>,
/// Model from the authoritative resolver spawn uses — linked instances
/// read their definition, never stale `record.model` bytes.
pub(super) model: Option<String>,
/// Provider from the same authoritative resolver — never stale
/// `record.provider` bytes for linked instances.
pub(super) provider: Option<String>,
/// The runtime's provider env var (e.g. `GOOSE_PROVIDER`), so discovery
/// can recover the provider from the env when the resolver yields none.
/// `None` for runtimes that do not take a provider, or an unknown command.
pub(super) provider_env_var: Option<&'static str>,
/// The descriptor's fully layered env (definition/persona/global/agent).
pub(super) env: BTreeMap<String, String>,
}
/// Resolve the model-discovery config for a saved agent — the descriptor-backed
/// successor to the old `saved_agent_model_discovery_config`.
///
/// Command/args/env come from `resolve_effective_harness_descriptor` (the same
/// resolver as `spawn_agent_child`); model/provider come from
/// `resolve_effective_model_provider` (#1968's definition-authoritative
/// contract) — linked instances read their definition, never a stale
/// materialized `record.model`/`record.provider`, so discovery cannot query a
/// provider this agent will not actually launch with. Definition-less
/// instances keep their own record values, matching spawn's
/// `resolve_definition_less` arm. When the resolver yields no provider,
/// `effective_discovery_provider` recovers the provider the agent will
/// actually launch with from the runtime's own provider env var, read out of
/// the descriptor env (which already layers definition/persona/global values
/// the same way spawn does).
///
/// Returns `Err("DANGLING_HARNESS_ID:<id>")` from the descriptor resolver when
/// the harness id no longer exists; the caller routes it through
/// `model_discovery_error`.
pub(super) fn agent_model_discovery_config(
record: &crate::managed_agents::ManagedAgentRecord,
personas: &[crate::managed_agents::AgentDefinition],
global: &crate::managed_agents::GlobalAgentConfig,
) -> Result<AgentModelDiscoveryConfig, String> {
let descriptor =
crate::managed_agents::resolve_effective_harness_descriptor(record, personas, global)?;
let (model, provider) =
crate::managed_agents::resolve_effective_model_provider(record, personas, global);
let provider_env_var =
known_acp_runtime(&descriptor.command).and_then(|meta| meta.provider_env_var);
Ok(AgentModelDiscoveryConfig {
command: descriptor.command,
args: descriptor.args,
model,
provider,
provider_env_var,
env: descriptor.env,
})
}
/// Derive the discovery env for an unsaved ("draft") agent configuration.
///
/// Mirrors the layering `agent_model_discovery_config` takes from the harness
/// descriptor, but sources the provider from form input: runtime-derived
/// provider env var → definition env → user env vars, so user overrides always
/// win. Extracted so the draft path has the same tested seam as the saved one.
pub(super) fn draft_agent_model_discovery_env(
agent_command: &str,
provider: Option<&str>,
definition_env: &BTreeMap<String, String>,
env_vars: &BTreeMap<String, String>,
) -> BTreeMap<String, String> {
let mut derived_env = BTreeMap::new();
if let Some(meta) = known_acp_runtime(agent_command) {
let provider = provider.map(str::trim).filter(|value| !value.is_empty());
if !meta.provider_locked {
if let (Some(env_key), Some(provider)) = (meta.provider_env_var, provider) {
derived_env.insert(env_key.to_string(), provider.to_string());
}
}
}
// Reserved keys are stripped from definition env, matching the same filter
// applied at spawn.
let mut filtered_definition_env = BTreeMap::new();
for (key, value) in definition_env {
if !crate::managed_agents::is_reserved_env_key(key) {
filtered_definition_env.insert(key.clone(), value.clone());
}
}
let merged_with_def =
crate::managed_agents::merged_user_env(&derived_env, &filtered_definition_env);
crate::managed_agents::merged_user_env(&merged_with_def, env_vars)
}
@@ -0,0 +1,112 @@
use std::collections::BTreeMap;
use serde::Deserialize;
use crate::managed_agents::{AgentModelInfo, AgentModelsResponse};
#[cfg(test)]
use super::env_value;
use super::{env_or_process_value, redaction_env_with_value, DiscoveryProvider};
#[derive(Debug, Deserialize)]
#[cfg_attr(test, derive(Clone))]
pub(super) struct OpenRouterModelListResponse {
pub data: Vec<OpenRouterModelListItem>,
}
#[derive(Debug, Deserialize)]
#[cfg_attr(test, derive(Clone))]
pub(super) struct OpenRouterModelListItem {
pub id: String,
#[serde(default)]
pub supported_parameters: Vec<String>,
}
pub(super) fn is_openrouter_provider(provider: Option<&str>) -> bool {
matches!(
provider
.map(str::trim)
.map(str::to_ascii_lowercase)
.as_deref(),
Some("openrouter")
)
}
#[cfg(test)]
pub(super) fn openrouter_models_url(env: &BTreeMap<String, String>) -> String {
let base_url = env_value(env, "OPENROUTER_BASE_URL")
.unwrap_or_else(|| "https://openrouter.ai/api/v1".to_string());
format!("{}/models", base_url.trim_end_matches('/'))
}
fn openrouter_models_url_for_discovery(env: &BTreeMap<String, String>) -> String {
let base_url = env_or_process_value(env, "OPENROUTER_BASE_URL")
.unwrap_or_else(|| "https://openrouter.ai/api/v1".to_string());
format!("{}/models", base_url.trim_end_matches('/'))
}
pub(super) async fn discover_openrouter_models(
client: &reqwest::Client,
provider: &DiscoveryProvider,
env: &BTreeMap<String, String>,
selected_model: Option<String>,
) -> Result<Option<AgentModelsResponse>, String> {
if !is_openrouter_provider(provider.as_deref()) {
return Ok(None);
}
let api_key = match provider.required_env(env, "OPENROUTER_API_KEY")? {
Some(api_key) => api_key,
None => return Ok(None),
};
let redaction_env = redaction_env_with_value(env, "OPENROUTER_API_KEY", &api_key);
let url = openrouter_models_url_for_discovery(env);
let response = client
.get(&url)
.bearer_auth(&api_key)
.send()
.await
.map_err(|error| format!("OpenRouter model discovery request failed: {error}"))?;
let status = response.status();
if !status.is_success() {
let body = response.text().await.unwrap_or_default();
let body = crate::managed_agents::redact_env_values_in(&body, &redaction_env);
return Err(format!("OpenRouter model discovery HTTP {status}: {body}"));
}
let response = response
.json::<OpenRouterModelListResponse>()
.await
.map_err(|error| format!("OpenRouter model discovery response parse failed: {error}"))?;
filter_openrouter_models(response, selected_model)
}
pub(super) fn filter_openrouter_models(
response: OpenRouterModelListResponse,
selected_model: Option<String>,
) -> Result<Option<AgentModelsResponse>, String> {
let models: Vec<AgentModelInfo> = response
.data
.into_iter()
.filter(|m| m.supported_parameters.iter().any(|p| p == "tools"))
.map(|m| AgentModelInfo {
id: m.id.clone(),
name: Some(m.id),
description: None,
})
.collect();
if models.is_empty() {
return Err("OpenRouter model discovery returned no tools-capable models".to_string());
}
Ok(Some(AgentModelsResponse {
agent_name: "openrouter".to_string(),
agent_version: "models-api".to_string(),
models,
agent_default_model: None,
selected_model,
supports_switching: true,
}))
}
@@ -590,3 +590,294 @@ fn model_discovery_error_converts_dangling_sentinel_to_sentence() {
let plain = model_discovery_error("agent-pk", "plain failure");
assert_eq!(plain, "cannot discover models for agent-pk: plain failure");
}
// ---------------------------------------------------------------------------
// OpenRouter provider
// ---------------------------------------------------------------------------
#[test]
fn is_openrouter_provider_matches() {
assert!(is_openrouter_provider(Some("openrouter")));
assert!(is_openrouter_provider(Some(" OpenRouter ")));
assert!(!is_openrouter_provider(Some("openai")));
assert!(!is_openrouter_provider(Some("anthropic")));
assert!(!is_openrouter_provider(None));
}
#[test]
fn openrouter_models_url_uses_default_base_url() {
assert_eq!(
openrouter_models_url(&BTreeMap::new()),
"https://openrouter.ai/api/v1/models"
);
}
#[test]
fn openrouter_models_url_respects_custom_base_url() {
let env = BTreeMap::from([(
"OPENROUTER_BASE_URL".to_string(),
"https://eu.openrouter.ai/api/v1".to_string(),
)]);
assert_eq!(
openrouter_models_url(&env),
"https://eu.openrouter.ai/api/v1/models"
);
}
#[test]
fn openrouter_models_url_strips_trailing_slash() {
let env = BTreeMap::from([(
"OPENROUTER_BASE_URL".to_string(),
"https://proxy.example.com/api/v1/".to_string(),
)]);
assert_eq!(
openrouter_models_url(&env),
"https://proxy.example.com/api/v1/models"
);
}
#[test]
fn openrouter_filter_keeps_tools_capable_models() {
let response = OpenRouterModelListResponse {
data: vec![
OpenRouterModelListItem {
id: "anthropic/claude-opus-4-7".to_string(),
supported_parameters: vec!["tools".to_string(), "reasoning".to_string()],
},
OpenRouterModelListItem {
id: "openai/gpt-5.5-pro".to_string(),
supported_parameters: vec!["tools".to_string()],
},
OpenRouterModelListItem {
id: "meta-llama/llama-no-tools".to_string(),
supported_parameters: vec!["temperature".to_string()],
},
],
};
let result = filter_openrouter_models(response, None).unwrap().unwrap();
let ids: Vec<_> = result.models.iter().map(|m| m.id.as_str()).collect();
assert_eq!(ids, vec!["anthropic/claude-opus-4-7", "openai/gpt-5.5-pro"]);
}
#[test]
fn openrouter_filter_excludes_absent_supported_parameters() {
let response: OpenRouterModelListResponse =
serde_json::from_str(r#"{"data": [{"id": "model-no-params"}]}"#).unwrap();
assert!(
response.data[0].supported_parameters.is_empty(),
"absent supported_parameters must default to empty vec"
);
let result = filter_openrouter_models(response, None);
assert!(
result.is_err(),
"models with no supported_parameters must be excluded"
);
assert!(
result.unwrap_err().contains("no tools-capable models"),
"error must indicate no tools-capable models"
);
}
#[test]
fn openrouter_filter_excludes_empty_supported_parameters() {
let response = OpenRouterModelListResponse {
data: vec![OpenRouterModelListItem {
id: "model-empty-params".to_string(),
supported_parameters: Vec::new(),
}],
};
let result = filter_openrouter_models(response, None);
assert!(result.is_err());
assert!(result.unwrap_err().contains("no tools-capable models"));
}
#[test]
fn openrouter_filter_empty_result_returns_error() {
let response = OpenRouterModelListResponse { data: Vec::new() };
let result = filter_openrouter_models(response, None);
assert!(result.is_err());
assert!(result.unwrap_err().contains("no tools-capable models"));
}
#[test]
fn openrouter_filter_preserves_selected_model() {
let response = OpenRouterModelListResponse {
data: vec![OpenRouterModelListItem {
id: "openai/gpt-5.5-pro".to_string(),
supported_parameters: vec!["tools".to_string()],
}],
};
let result = filter_openrouter_models(response, Some("openai/gpt-5.5-pro".to_string()))
.unwrap()
.unwrap();
assert_eq!(result.selected_model.as_deref(), Some("openai/gpt-5.5-pro"));
}
#[test]
fn openrouter_credential_redaction_env_records_key() {
let env = BTreeMap::from([(
"OPENROUTER_API_KEY".to_string(),
"sk-or-v1-secret-key-12345".to_string(),
)]);
let redaction =
redaction_env_with_value(&env, "OPENROUTER_API_KEY", "sk-or-v1-secret-key-12345");
assert_eq!(
redaction.get("OPENROUTER_API_KEY").map(String::as_str),
Some("sk-or-v1-secret-key-12345"),
"redaction env must record the API key for error body redaction"
);
}
#[test]
fn openrouter_saved_agent_model_discovery_resolves_provider() {
let record: crate::managed_agents::ManagedAgentRecord = serde_json::from_str(
r#"{
"pubkey": "abcd1234",
"name": "test-agent",
"private_key_nsec": "nsec1fake",
"relay_url": "wss://localhost:3000",
"acp_command": "buzz-acp",
"agent_command": "buzz-agent",
"agent_command_override": "buzz-agent",
"agent_args": [],
"mcp_command": "",
"turn_timeout_seconds": 320,
"system_prompt": null,
"model": "anthropic/claude-sonnet-4",
"provider": "openrouter",
"env_vars": {
"OPENROUTER_API_KEY": "sk-or-test-key",
"BUZZ_PRIVATE_KEY": "must-not-leak"
},
"created_at": "2026-01-01T00:00:00Z",
"updated_at": "2026-01-01T00:00:00Z",
"last_started_at": null,
"last_stopped_at": null,
"last_exit_code": null,
"last_error": null
}"#,
)
.expect("sample openrouter managed agent record");
let discovery = agent_model_discovery_config(
&record,
&[],
&crate::managed_agents::GlobalAgentConfig::default(),
)
.expect("discovery config should resolve for an openrouter record");
assert_eq!(discovery.provider.as_deref(), Some("openrouter"));
assert_eq!(
discovery.model.as_deref(),
Some("anthropic/claude-sonnet-4")
);
assert_eq!(
discovery.env.get("OPENROUTER_API_KEY").map(String::as_str),
Some("sk-or-test-key")
);
assert!(!discovery.env.contains_key("BUZZ_PRIVATE_KEY"));
}
/// B5/T4: unsaved-agent ("draft") discovery mirrors the saved-agent path —
/// `draft_agent_model_discovery_env` must derive the provider env var from
/// form input the same way `agent_model_discovery_config` derives it from a
/// persisted record's harness descriptor, and preserve caller-supplied env
/// (including the OpenRouter API key) unmodified.
#[test]
fn openrouter_draft_agent_model_discovery_derives_provider_env() {
let env_vars = BTreeMap::from([(
"OPENROUTER_API_KEY".to_string(),
"sk-or-draft-key".to_string(),
)]);
let merged = draft_agent_model_discovery_env(
"buzz-agent",
Some("openrouter"),
&BTreeMap::new(),
&env_vars,
);
assert_eq!(
merged.get("BUZZ_AGENT_PROVIDER").map(String::as_str),
Some("openrouter"),
"provider env var must be derived from form input for a known ACP runtime"
);
assert_eq!(
merged.get("OPENROUTER_API_KEY").map(String::as_str),
Some("sk-or-draft-key"),
"caller-supplied env vars must survive the merge"
);
}
#[test]
fn draft_agent_model_discovery_env_omits_provider_when_absent() {
let merged =
draft_agent_model_discovery_env("buzz-agent", None, &BTreeMap::new(), &BTreeMap::new());
assert!(
!merged.contains_key("BUZZ_AGENT_PROVIDER"),
"no provider must be derived when the caller supplies none"
);
}
/// The three-tier precedence this merge exists to preserve: main's inline
/// `derived → definition_env → env_vars` layering was folded into
/// `draft_agent_model_discovery_env`, so pin the order at every collision
/// boundary rather than trusting the two single-tier tests above.
///
/// `SHARED` collides across all three tiers, so the user value proves the
/// full chain; the pairwise keys prove each adjacent boundary independently
/// (a merge that dropped only the middle tier would still satisfy `SHARED`).
/// `BUZZ_PRIVATE_KEY` proves a reserved key cannot ride in on a harness
/// definition, which is the tier a user never types.
#[test]
fn draft_agent_model_discovery_env_layers_all_three_tiers_in_order() {
// Tier 2 (middle): harness definition env — overlays the runtime-derived
// floor, loses to user env.
let definition_env = BTreeMap::from([
("SHARED".to_string(), "from-definition".to_string()),
// Collides with tier 1: `buzz-agent`'s own provider env var, which the
// `provider` argument derives below.
("BUZZ_AGENT_PROVIDER".to_string(), "openai".to_string()),
("USER_OVER_DEF".to_string(), "from-definition".to_string()),
("DEFINITION_ONLY".to_string(), "from-definition".to_string()),
// Reserved: must never reach the child, even from a definition.
("BUZZ_PRIVATE_KEY".to_string(), "must-not-leak".to_string()),
]);
// Tier 3 (top): user-entered env — wins over everything.
let env_vars = BTreeMap::from([
("SHARED".to_string(), "from-user".to_string()),
("USER_OVER_DEF".to_string(), "from-user".to_string()),
("USER_ONLY".to_string(), "from-user".to_string()),
]);
// Tier 1 (floor): `Some("openrouter")` derives BUZZ_AGENT_PROVIDER.
let merged = draft_agent_model_discovery_env(
"buzz-agent",
Some("openrouter"),
&definition_env,
&env_vars,
);
let expected: &[(&str, Option<&str>)] = &[
// Collides in all three tiers — the top tier wins.
("SHARED", Some("from-user")),
// Tier 2 over tier 1: the definition's value survives, proving the
// derived provider is the floor and not layered on top.
("BUZZ_AGENT_PROVIDER", Some("openai")),
// Tier 3 over tier 2.
("USER_OVER_DEF", Some("from-user")),
// Single-tier keys pass through untouched.
("DEFINITION_ONLY", Some("from-definition")),
("USER_ONLY", Some("from-user")),
// Reserved keys never survive the definition tier. Doubly enforced —
// the explicit `is_reserved_env_key` filter here and `merged_user_env`'s
// own `retain` — so this pins the contract, not either mechanism.
("BUZZ_PRIVATE_KEY", None),
];
for (key, want) in expected {
assert_eq!(
merged.get(*key).map(String::as_str),
*want,
"env key `{key}` must resolve to {want:?} after three-tier layering"
);
}
}
+70 -189
View File
@@ -481,6 +481,7 @@ fn buzz_agent_requirements(effective: &EffectiveAgentEnv) -> Vec<Requirement> {
}
Some("anthropic") => Some("ANTHROPIC_MODEL"),
Some("openai") | Some("openai-compat") => Some("OPENAI_COMPAT_MODEL"),
Some("openrouter") => Some("OPENROUTER_MODEL"),
_ => None,
};
let model_present = effective
@@ -523,6 +524,12 @@ fn buzz_agent_requirements(effective: &EffectiveAgentEnv) -> Vec<Requirement> {
key: "DATABRICKS_HOST".to_string(),
});
}
Some("openrouter")
if env_key_missing("OPENROUTER_API_KEY") => {
missing.push(Requirement::EnvKey {
key: "OPENROUTER_API_KEY".to_string(),
});
}
_ => {
// Unknown provider or no provider yet — only the NormalizedField
// requirement above captures this gap.
@@ -630,6 +637,13 @@ fn goose_requirements(
key: "DATABRICKS_HOST".to_string(),
});
}
Some("openrouter")
if env_key_missing("OPENROUTER_API_KEY") && !file_key_present("OPENROUTER_API_KEY") =>
{
missing.push(Requirement::EnvKey {
key: "OPENROUTER_API_KEY".to_string(),
});
}
_ => {}
}
@@ -1668,195 +1682,62 @@ mod tests {
field: "model".to_string()
}));
}
// ── OpenRouter readiness ─────────────────────────────────────────────
#[test]
fn buzz_agent_openrouter_with_all_fields_is_ready() {
let env = make_env(
"buzz-agent",
env_with(&[
("BUZZ_AGENT_PROVIDER", "openrouter"),
("BUZZ_AGENT_MODEL", "anthropic/claude-sonnet-4"),
("OPENROUTER_API_KEY", "sk-or-test-key"),
]),
);
let result = agent_readiness(&env);
assert!(
result.is_ready(),
"openrouter with all fields should be ready"
);
}
#[test]
fn buzz_agent_openrouter_missing_key_returns_not_ready() {
let env = make_env(
"buzz-agent",
env_with(&[
("BUZZ_AGENT_PROVIDER", "openrouter"),
("BUZZ_AGENT_MODEL", "anthropic/claude-sonnet-4"),
]),
);
let result = agent_readiness(&env);
assert!(!result.is_ready());
assert!(result.requirements().contains(&Requirement::EnvKey {
key: "OPENROUTER_API_KEY".to_string()
}));
}
#[test]
fn buzz_agent_openrouter_with_provider_model_fallback_is_ready() {
let env = make_env(
"buzz-agent",
env_with(&[
("BUZZ_AGENT_PROVIDER", "openrouter"),
("OPENROUTER_MODEL", "google/gemini-2.5-flash"),
("OPENROUTER_API_KEY", "sk-or-test-key"),
]),
);
let result = agent_readiness(&env);
assert!(
result.is_ready(),
"OPENROUTER_MODEL fallback should satisfy model requirement"
);
}
}
// ── goose file-config–aware requirement tests ─────────────────────────────
//
// These tests call `goose_requirements` directly, injecting a synthetic
// `RuntimeFileConfig` so there is no disk I/O and tests are deterministic.
// Goose file-config-aware requirement tests live in a sibling file so this
// module stays under the desktop file-size ratchet.
#[cfg(test)]
mod goose_file_config_tests {
use std::collections::BTreeMap;
use super::*;
use crate::managed_agents::config_bridge::RuntimeFileConfig;
fn empty_env() -> EffectiveAgentEnv {
EffectiveAgentEnv {
env: BTreeMap::new(),
config_file_path: Some("~/.config/goose/config.yaml"),
effective_command: "goose".to_string(),
}
}
fn env_with(pairs: &[(&str, &str)]) -> EffectiveAgentEnv {
EffectiveAgentEnv {
env: pairs
.iter()
.map(|(k, v)| (k.to_string(), v.to_string()))
.collect(),
config_file_path: Some("~/.config/goose/config.yaml"),
effective_command: "goose".to_string(),
}
}
fn databricks_file_config() -> RuntimeFileConfig {
let mut extra = BTreeMap::new();
extra.insert(
"DATABRICKS_HOST".to_string(),
"https://dbc.example.com".to_string(),
);
RuntimeFileConfig {
provider: Some("databricks_v2".to_string()),
model: Some("goose-claude-4-6-opus".to_string()),
extra,
..Default::default()
}
}
#[test]
fn goose_file_config_silences_databricks_host_requirement() {
// File has provider, model, and DATABRICKS_HOST — all requirements silenced.
let env = empty_env();
let cfg = databricks_file_config();
let result = goose_requirements(&env, Some(&cfg));
assert!(
result.is_empty(),
"all requirements should be silenced by goose file config; \
got: {:?}",
result
);
}
#[test]
fn goose_env_empty_file_absent_still_not_ready() {
// No env, no file config → provider and model both required.
let env = empty_env();
let result = goose_requirements(&env, None);
assert!(
result.contains(&Requirement::NormalizedField {
field: "provider".to_string()
}),
"provider must be required when absent from both env and file"
);
assert!(
result.contains(&Requirement::NormalizedField {
field: "model".to_string()
}),
"model must be required when absent from both env and file"
);
}
#[test]
fn goose_file_config_silences_provider_and_model_but_not_anthropic_key() {
// File has provider=anthropic and model, but ANTHROPIC_API_KEY is not
// in the file's `extra` map — it must still be required.
let cfg = RuntimeFileConfig {
provider: Some("anthropic".to_string()),
model: Some("claude-opus-4-5".to_string()),
extra: BTreeMap::new(),
..Default::default()
};
let env = empty_env();
let result = goose_requirements(&env, Some(&cfg));
// Provider and model silenced.
assert!(
!result.contains(&Requirement::NormalizedField {
field: "provider".to_string()
}),
"provider silenced by file config"
);
assert!(
!result.contains(&Requirement::NormalizedField {
field: "model".to_string()
}),
"model silenced by file config"
);
// ANTHROPIC_API_KEY not in file extra → still required.
assert!(
result.contains(&Requirement::EnvKey {
key: "ANTHROPIC_API_KEY".to_string()
}),
"ANTHROPIC_API_KEY must remain required when not in file extra"
);
}
#[test]
fn goose_env_provider_wins_over_file_provider_for_cred_check() {
// Env has GOOSE_PROVIDER=anthropic (different from file's databricks_v2).
// The env provider must win for credential checking.
let env = env_with(&[
("GOOSE_PROVIDER", "anthropic"),
("GOOSE_MODEL", "claude-opus-4-5"),
]);
let cfg = databricks_file_config(); // has provider=databricks_v2
let result = goose_requirements(&env, Some(&cfg));
// anthropic requires ANTHROPIC_API_KEY, not DATABRICKS_HOST.
assert!(
result.contains(&Requirement::EnvKey {
key: "ANTHROPIC_API_KEY".to_string()
}),
"env provider=anthropic must require ANTHROPIC_API_KEY"
);
assert!(
!result.contains(&Requirement::EnvKey {
key: "DATABRICKS_HOST".to_string()
}),
"env provider=anthropic must NOT require DATABRICKS_HOST"
);
}
#[test]
fn goose_flat_databricks_host_in_file_config_silences_requirement() {
// Will's typical goose config: flat DATABRICKS_HOST at the top level,
// no active_provider — provider inferred as "databricks".
// The parser must store extra["DATABRICKS_HOST"] = value (canonical key),
// and goose_requirements must then silence the DATABRICKS_HOST requirement.
let mut extra = BTreeMap::new();
extra.insert(
"DATABRICKS_HOST".to_string(),
"https://block.cloud.databricks.com".to_string(),
);
let cfg = RuntimeFileConfig {
provider: Some("databricks".to_string()),
model: Some("goose-claude-4-5".to_string()),
extra,
..Default::default()
};
let env = empty_env();
let result = goose_requirements(&env, Some(&cfg));
// All requirements silenced — provider (file), model (file), DATABRICKS_HOST (file).
assert!(
result.is_empty(),
"flat DATABRICKS_HOST in file config must silence all requirements; \
got: {:?}",
result
);
}
#[test]
fn goose_goose_provider_databricks_flat_host_silences_databricks_host() {
// GOOSE_PROVIDER=databricks (not active_provider) + flat DATABRICKS_HOST.
// The parser canonicalizes to extra["DATABRICKS_HOST"]; readiness must silence it.
let mut extra = BTreeMap::new();
extra.insert(
"DATABRICKS_HOST".to_string(),
"https://dbc.example.com".to_string(),
);
let cfg = RuntimeFileConfig {
provider: Some("databricks".to_string()),
model: Some("some-model".to_string()),
extra,
..Default::default()
};
let env = empty_env();
let result = goose_requirements(&env, Some(&cfg));
assert!(
!result.contains(&Requirement::EnvKey {
key: "DATABRICKS_HOST".to_string()
}),
"DATABRICKS_HOST must be silenced when canonical key is in file extra"
);
}
}
#[path = "readiness_goose_file_config_tests.rs"]
mod goose_file_config_tests;
@@ -0,0 +1,190 @@
//! Goose file-config-aware requirement tests.
//!
//! These tests call `goose_requirements` directly, injecting a synthetic
//! `RuntimeFileConfig` so there is no disk I/O and tests are deterministic.
//!
//! Included from `readiness.rs` via `#[path]`; `super::*` therefore resolves
//! against that module, matching the `storage_tests.rs` convention.
use std::collections::BTreeMap;
use super::*;
use crate::managed_agents::config_bridge::RuntimeFileConfig;
fn empty_env() -> EffectiveAgentEnv {
EffectiveAgentEnv {
env: BTreeMap::new(),
config_file_path: Some("~/.config/goose/config.yaml"),
effective_command: "goose".to_string(),
}
}
fn env_with(pairs: &[(&str, &str)]) -> EffectiveAgentEnv {
EffectiveAgentEnv {
env: pairs
.iter()
.map(|(k, v)| (k.to_string(), v.to_string()))
.collect(),
config_file_path: Some("~/.config/goose/config.yaml"),
effective_command: "goose".to_string(),
}
}
fn databricks_file_config() -> RuntimeFileConfig {
let mut extra = BTreeMap::new();
extra.insert(
"DATABRICKS_HOST".to_string(),
"https://dbc.example.com".to_string(),
);
RuntimeFileConfig {
provider: Some("databricks_v2".to_string()),
model: Some("goose-claude-4-6-opus".to_string()),
extra,
..Default::default()
}
}
#[test]
fn goose_file_config_silences_databricks_host_requirement() {
// File has provider, model, and DATABRICKS_HOST — all requirements silenced.
let env = empty_env();
let cfg = databricks_file_config();
let result = goose_requirements(&env, Some(&cfg));
assert!(
result.is_empty(),
"all requirements should be silenced by goose file config; \
got: {:?}",
result
);
}
#[test]
fn goose_env_empty_file_absent_still_not_ready() {
// No env, no file config → provider and model both required.
let env = empty_env();
let result = goose_requirements(&env, None);
assert!(
result.contains(&Requirement::NormalizedField {
field: "provider".to_string()
}),
"provider must be required when absent from both env and file"
);
assert!(
result.contains(&Requirement::NormalizedField {
field: "model".to_string()
}),
"model must be required when absent from both env and file"
);
}
#[test]
fn goose_file_config_silences_provider_and_model_but_not_anthropic_key() {
// File has provider=anthropic and model, but ANTHROPIC_API_KEY is not
// in the file's `extra` map — it must still be required.
let cfg = RuntimeFileConfig {
provider: Some("anthropic".to_string()),
model: Some("claude-opus-4-5".to_string()),
extra: BTreeMap::new(),
..Default::default()
};
let env = empty_env();
let result = goose_requirements(&env, Some(&cfg));
// Provider and model silenced.
assert!(
!result.contains(&Requirement::NormalizedField {
field: "provider".to_string()
}),
"provider silenced by file config"
);
assert!(
!result.contains(&Requirement::NormalizedField {
field: "model".to_string()
}),
"model silenced by file config"
);
// ANTHROPIC_API_KEY not in file extra → still required.
assert!(
result.contains(&Requirement::EnvKey {
key: "ANTHROPIC_API_KEY".to_string()
}),
"ANTHROPIC_API_KEY must remain required when not in file extra"
);
}
#[test]
fn goose_env_provider_wins_over_file_provider_for_cred_check() {
// Env has GOOSE_PROVIDER=anthropic (different from file's databricks_v2).
// The env provider must win for credential checking.
let env = env_with(&[
("GOOSE_PROVIDER", "anthropic"),
("GOOSE_MODEL", "claude-opus-4-5"),
]);
let cfg = databricks_file_config(); // has provider=databricks_v2
let result = goose_requirements(&env, Some(&cfg));
// anthropic requires ANTHROPIC_API_KEY, not DATABRICKS_HOST.
assert!(
result.contains(&Requirement::EnvKey {
key: "ANTHROPIC_API_KEY".to_string()
}),
"env provider=anthropic must require ANTHROPIC_API_KEY"
);
assert!(
!result.contains(&Requirement::EnvKey {
key: "DATABRICKS_HOST".to_string()
}),
"env provider=anthropic must NOT require DATABRICKS_HOST"
);
}
#[test]
fn goose_flat_databricks_host_in_file_config_silences_requirement() {
// Will's typical goose config: flat DATABRICKS_HOST at the top level,
// no active_provider — provider inferred as "databricks".
// The parser must store extra["DATABRICKS_HOST"] = value (canonical key),
// and goose_requirements must then silence the DATABRICKS_HOST requirement.
let mut extra = BTreeMap::new();
extra.insert(
"DATABRICKS_HOST".to_string(),
"https://block.cloud.databricks.com".to_string(),
);
let cfg = RuntimeFileConfig {
provider: Some("databricks".to_string()),
model: Some("goose-claude-4-5".to_string()),
extra,
..Default::default()
};
let env = empty_env();
let result = goose_requirements(&env, Some(&cfg));
// All requirements silenced — provider (file), model (file), DATABRICKS_HOST (file).
assert!(
result.is_empty(),
"flat DATABRICKS_HOST in file config must silence all requirements; \
got: {:?}",
result
);
}
#[test]
fn goose_goose_provider_databricks_flat_host_silences_databricks_host() {
// GOOSE_PROVIDER=databricks (not active_provider) + flat DATABRICKS_HOST.
// The parser canonicalizes to extra["DATABRICKS_HOST"]; readiness must silence it.
let mut extra = BTreeMap::new();
extra.insert(
"DATABRICKS_HOST".to_string(),
"https://dbc.example.com".to_string(),
);
let cfg = RuntimeFileConfig {
provider: Some("databricks".to_string()),
model: Some("some-model".to_string()),
extra,
..Default::default()
};
let env = empty_env();
let result = goose_requirements(&env, Some(&cfg));
assert!(
!result.contains(&Requirement::EnvKey {
key: "DATABRICKS_HOST".to_string()
}),
"DATABRICKS_HOST must be silenced when canonical key is in file extra"
);
}