mirror of
https://github.com/block/buzz.git
synced 2026-08-18 06:50:31 +02:00
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:
co-authored by
npub1mn7jgtj4w2pd0g0zeuhxsa6jy6p0rewxz4kujt98my82ahfmp72sxjexk7
parent
f95fdc1a10
commit
ab55fee818
@@ -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"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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"
|
||||
);
|
||||
}
|
||||
Reference in New Issue
Block a user