feat: openrouter provider

crates/goose-server/src/configuration.rs

@@ -1,8 +1,11 @@
 use crate::error::{to_env_var, ConfigError};
 use config::{Config, Environment};
-use goose::providers::configs::{GoogleProviderConfig, GroqProviderConfig};
+use goose::providers::configs::{
+    AnthropicProviderConfig, GoogleProviderConfig, GroqProviderConfig,
+};
 use goose::providers::openai::OPEN_AI_DEFAULT_MODEL;
 use goose::providers::{
+    anthropic,
     configs::{
         DatabricksAuth, DatabricksProviderConfig, ModelConfig, OllamaProviderConfig,
         OpenAiProviderConfig, ProviderConfig,
@@ -48,6 +51,21 @@ pub enum ProviderSettings {
         #[serde(default)]
         estimate_factor: Option<f32>,
     },
+    OpenRouter {
+        #[serde(default = "default_openrouter_host")]
+        host: String,
+        api_key: String,
+        #[serde(default = "default_model")]
+        model: String,
+        #[serde(default)]
+        temperature: Option<f32>,
+        #[serde(default)]
+        max_tokens: Option<i32>,
+        #[serde(default)]
+        context_limit: Option<usize>,
+        #[serde(default)]
+        estimate_factor: Option<f32>,
+    },
     Databricks {
         #[serde(default = "default_databricks_host")]
         host: String,
@@ -108,6 +126,21 @@ pub enum ProviderSettings {
         #[serde(default)]
         estimate_factor: Option<f32>,
     },
+    Anthropic {
+        #[serde(default = "default_anthropic_host")]
+        host: String,
+        api_key: String,
+        #[serde(default = "default_anthropic_model")]
+        model: String,
+        #[serde(default)]
+        temperature: Option<f32>,
+        #[serde(default)]
+        max_tokens: Option<i32>,
+        #[serde(default)]
+        context_limit: Option<usize>,
+        #[serde(default)]
+        estimate_factor: Option<f32>,
+    },
 }
 
 impl ProviderSettings {
@@ -120,6 +153,8 @@ impl ProviderSettings {
             ProviderSettings::Ollama { .. } => ProviderType::Ollama,
             ProviderSettings::Google { .. } => ProviderType::Google,
             ProviderSettings::Groq { .. } => ProviderType::Groq,
+            ProviderSettings::Anthropic { .. } => ProviderType::Anthropic,
+            ProviderSettings::OpenRouter { .. } => ProviderType::OpenRouter,
         }
     }
 
@@ -143,6 +178,23 @@ impl ProviderSettings {
                     .with_context_limit(context_limit)
                     .with_estimate_factor(estimate_factor),
             }),
+            ProviderSettings::OpenRouter {
+                host,
+                api_key,
+                model,
+                temperature,
+                max_tokens,
+                context_limit,
+                estimate_factor,
+            } => ProviderConfig::OpenRouter(OpenAiProviderConfig {
+                host,
+                api_key,
+                model: ModelConfig::new(model)
+                    .with_temperature(temperature)
+                    .with_max_tokens(max_tokens)
+                    .with_context_limit(context_limit)
+                    .with_estimate_factor(estimate_factor),
+            }),
             ProviderSettings::Databricks {
                 host,
                 model,
@@ -210,6 +262,23 @@ impl ProviderSettings {
                     .with_context_limit(context_limit)
                     .with_estimate_factor(estimate_factor),
             }),
+            ProviderSettings::Anthropic {
+                host,
+                api_key,
+                model,
+                temperature,
+                max_tokens,
+                context_limit,
+                estimate_factor,
+            } => ProviderConfig::Anthropic(AnthropicProviderConfig {
+                host,
+                api_key,
+                model: ModelConfig::new(model)
+                    .with_temperature(temperature)
+                    .with_max_tokens(max_tokens)
+                    .with_context_limit(context_limit)
+                    .with_estimate_factor(estimate_factor),
+            }),
         }
     }
 }
@@ -281,6 +350,10 @@ fn default_port() -> u16 {
     3000
 }
 
+pub fn default_openrouter_host() -> String {
+    "https://openrouter.ai".to_string()
+}
+
 fn default_model() -> String {
     OPEN_AI_DEFAULT_MODEL.to_string()
 }
@@ -317,6 +390,14 @@ fn default_groq_model() -> String {
     groq::GROQ_DEFAULT_MODEL.to_string()
 }
 
+fn default_anthropic_host() -> String {
+    "https://api.anthropic.com".to_string()
+}
+
+fn default_anthropic_model() -> String {
+    anthropic::ANTHROPIC_DEFAULT_MODEL.to_string()
+}
+
 fn default_image_format() -> ImageFormat {
     ImageFormat::Anthropic
 }

crates/goose-server/src/state.rs

@@ -1,5 +1,4 @@
 use anyhow::Result;
-use goose::providers::configs::GroqProviderConfig;
 use goose::{
     agent::Agent,
     developer::DeveloperSystem,
@@ -11,6 +10,8 @@ use std::{env, sync::Arc};
 use tokio::sync::Mutex;
 
 /// Shared application state
+#[allow(dead_code)]
+#[derive(Clone)]
 pub struct AppState {
     pub provider_config: ProviderConfig,
     pub agent: Arc<Mutex<Agent>>,
@@ -60,55 +61,3 @@ impl AppState {
         })
     }
 }
-
-// Manual Clone implementation since we know ProviderConfig variants can be cloned
-impl Clone for AppState {
-    fn clone(&self) -> Self {
-        Self {
-            provider_config: match &self.provider_config {
-                ProviderConfig::OpenAi(config) => {
-                    ProviderConfig::OpenAi(goose::providers::configs::OpenAiProviderConfig {
-                        host: config.host.clone(),
-                        api_key: config.api_key.clone(),
-                        model: config.model.clone(),
-                    })
-                }
-                ProviderConfig::Databricks(config) => ProviderConfig::Databricks(
-                    goose::providers::configs::DatabricksProviderConfig {
-                        host: config.host.clone(),
-                        auth: config.auth.clone(),
-                        model: config.model.clone(),
-                        image_format: config.image_format,
-                    },
-                ),
-                ProviderConfig::Ollama(config) => {
-                    ProviderConfig::Ollama(goose::providers::configs::OllamaProviderConfig {
-                        host: config.host.clone(),
-                        model: config.model.clone(),
-                    })
-                }
-                ProviderConfig::Anthropic(config) => {
-                    ProviderConfig::Anthropic(goose::providers::configs::AnthropicProviderConfig {
-                        host: config.host.clone(),
-                        api_key: config.api_key.clone(),
-                        model: config.model.clone(),
-                    })
-                }
-                ProviderConfig::Google(config) => {
-                    ProviderConfig::Google(goose::providers::configs::GoogleProviderConfig {
-                        host: config.host.clone(),
-                        api_key: config.api_key.clone(),
-                        model: config.model.clone(),
-                    })
-                }
-                ProviderConfig::Groq(config) => ProviderConfig::Groq(GroqProviderConfig {
-                    host: config.host.clone(),
-                    api_key: config.api_key.clone(),
-                    model: config.model.clone(),
-                }),
-            },
-            agent: self.agent.clone(),
-            secret_key: self.secret_key.clone(),
-        }
-    }
-}

crates/goose/src/providers.rs

@@ -12,6 +12,7 @@ pub mod utils;
 
 pub mod google;
 pub mod groq;
+pub mod openrouter;
 
 #[cfg(test)]
 pub mod mock;

crates/goose/src/providers/configs.rs

@@ -15,6 +15,7 @@ pub enum ProviderConfig {
     Anthropic(AnthropicProviderConfig),
     Google(GoogleProviderConfig),
     Groq(GroqProviderConfig),
+    OpenRouter(OpenAiProviderConfig),
 }
 
 /// Configuration for model-specific settings and limits

crates/goose/src/providers/factory.rs

@@ -1,7 +1,7 @@
 use super::{
     anthropic::AnthropicProvider, base::Provider, configs::ProviderConfig,
     databricks::DatabricksProvider, google::GoogleProvider, groq::GroqProvider,
-    ollama::OllamaProvider, openai::OpenAiProvider,
+    ollama::OllamaProvider, openai::OpenAiProvider, openrouter::OpenRouterProvider,
 };
 use anyhow::Result;
 use strum_macros::EnumIter;
@@ -14,6 +14,7 @@ pub enum ProviderType {
     Anthropic,
     Google,
     Groq,
+    OpenRouter,
 }
 
 pub fn get_provider(config: ProviderConfig) -> Result<Box<dyn Provider + Send + Sync>> {
@@ -28,5 +29,8 @@ pub fn get_provider(config: ProviderConfig) -> Result<Box<dyn Provider + Send +
         }
         ProviderConfig::Google(google_config) => Ok(Box::new(GoogleProvider::new(google_config)?)),
         ProviderConfig::Groq(groq_config) => Ok(Box::new(GroqProvider::new(groq_config)?)),
+        ProviderConfig::OpenRouter(openrouter_config) => {
+            Ok(Box::new(OpenRouterProvider::new(openrouter_config)?))
+        }
     }
 }

crates/goose/src/providers/model_pricing.rs

@@ -61,11 +61,24 @@ lazy_static::lazy_static! {
             input_token_price: dec!(15.00),
             output_token_price: dec!(75.00),
         });
+        // OpenRouter Models
+        m.insert("anthropic/claude-3-sonnet".to_string(), Pricing {
+            input_token_price: dec!(3.00),
+            output_token_price: dec!(15.00),
+        });
+        m.insert("claude-3-sonnet".to_string(), Pricing {
+            input_token_price: dec!(3.00),
+            output_token_price: dec!(15.00),
+        });
         // OpenAI
         m.insert("gpt-4o".to_string(), Pricing {
             input_token_price: dec!(2.50),
             output_token_price: dec!(10.00),
         });
+        m.insert("gpt-4".to_string(), Pricing {
+            input_token_price: dec!(2.50),
+            output_token_price: dec!(10.00),
+        });
         m.insert("gpt-4o-2024-11-20".to_string(), Pricing {
             input_token_price: dec!(2.50),
             output_token_price: dec!(10.00),