aljaz/goose
1
0
Fork 0
mirror of https://github.com/aljazceru/goose.git synced 2025-12-19 07:04:21 +01:00
Code Issues Packages Projects Releases Wiki Activity

feat: update config endpoints for use with providers (#1563)

Browse Source
This commit is contained in:
Lily Delalande
2025-03-10 09:51:54 -07:00
committed by GitHub
parent 3b36591cb5
commit 5df2875c1c
43 changed files with 945 additions and 428 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
Cargo.lock generated
View File

@@ -2312,6 +2312,7 @@ dependencies = [
"tracing",
"tracing-subscriber",
"url",
"utoipa",
"uuid",
"webbrowser",
"winapi",

4
crates/goose-cli/src/commands/bench.rs
View File

@@ -140,10 +140,10 @@ pub async fn run_benchmark(
let config = Config::global();
let goose_model: String = config
.get("GOOSE_MODEL")
.get_param("GOOSE_MODEL")
.expect("No model configured. Run 'goose configure' first");
let provider_name: String = config
.get("GOOSE_PROVIDER")
.get_param("GOOSE_PROVIDER")
.expect("No provider configured. Run 'goose configure' first");
let mut results = BenchmarkResults::new(provider_name.clone());

26
crates/goose-cli/src/commands/configure.rs
View File

@@ -184,7 +184,7 @@ pub async fn configure_provider_dialog() -> Result<bool, Box<dyn Error>> {
.collect();
// Get current default provider if it exists
let current_provider: Option<String> = config.get("GOOSE_PROVIDER").ok();
let current_provider: Option<String> = config.get_param("GOOSE_PROVIDER").ok();
let default_provider = current_provider.unwrap_or_default();
// Select provider
@@ -219,7 +219,7 @@ pub async fn configure_provider_dialog() -> Result<bool, Box<dyn Error>> {
if key.secret {
config.set_secret(&key.name, Value::String(env_value))?;
} else {
config.set(&key.name, Value::String(env_value))?;
config.set_param(&key.name, Value::String(env_value))?;
}
let _ = cliclack::log::info(format!("Saved {} to config file", key.name));
}
@@ -229,7 +229,7 @@ pub async fn configure_provider_dialog() -> Result<bool, Box<dyn Error>> {
let existing: Result<String, _> = if key.secret {
config.get_secret(&key.name)
} else {
config.get(&key.name)
config.get_param(&key.name)
};
match existing {
@@ -252,7 +252,7 @@ pub async fn configure_provider_dialog() -> Result<bool, Box<dyn Error>> {
if key.secret {
config.set_secret(&key.name, Value::String(new_value))?;
} else {
config.set(&key.name, Value::String(new_value))?;
config.set_param(&key.name, Value::String(new_value))?;
}
}
}
@@ -278,7 +278,7 @@ pub async fn configure_provider_dialog() -> Result<bool, Box<dyn Error>> {
if key.secret {
config.set_secret(&key.name, Value::String(value))?;
} else {
config.set(&key.name, Value::String(value))?;
config.set_param(&key.name, Value::String(value))?;
}
}
}
@@ -325,8 +325,8 @@ pub async fn configure_provider_dialog() -> Result<bool, Box<dyn Error>> {
match result {
Ok((_message, _usage)) => {
// Update config with new values only if the test succeeds
config.set("GOOSE_PROVIDER", Value::String(provider_name.to_string()))?;
config.set("GOOSE_MODEL", Value::String(model.clone()))?;
config.set_param("GOOSE_PROVIDER", Value::String(provider_name.to_string()))?;
config.set_param("GOOSE_MODEL", Value::String(model.clone()))?;
cliclack::outro("Configuration saved successfully")?;
Ok(true)
}
@@ -708,15 +708,15 @@ pub fn configure_goose_mode_dialog() -> Result<(), Box<dyn Error>> {
match mode {
"auto" => {
config.set("GOOSE_MODE", Value::String("auto".to_string()))?;
config.set_param("GOOSE_MODE", Value::String("auto".to_string()))?;
cliclack::outro("Set to Auto Mode - full file modification enabled")?;
}
"approve" => {
config.set("GOOSE_MODE", Value::String("approve".to_string()))?;
config.set_param("GOOSE_MODE", Value::String("approve".to_string()))?;
cliclack::outro("Set to Approve Mode - modifications require approval")?;
}
"chat" => {
config.set("GOOSE_MODE", Value::String("chat".to_string()))?;
config.set_param("GOOSE_MODE", Value::String("chat".to_string()))?;
cliclack::outro("Set to Chat Mode - no tools or modifications enabled")?;
}
_ => unreachable!(),
@@ -738,15 +738,15 @@ pub fn configure_tool_output_dialog() -> Result<(), Box<dyn Error>> {
match tool_log_level {
"high" => {
config.set("GOOSE_CLI_MIN_PRIORITY", Value::from(0.8))?;
config.set_param("GOOSE_CLI_MIN_PRIORITY", Value::from(0.8))?;
cliclack::outro("Showing tool output of high importance only.")?;
}
"medium" => {
config.set("GOOSE_CLI_MIN_PRIORITY", Value::from(0.2))?;
config.set_param("GOOSE_CLI_MIN_PRIORITY", Value::from(0.2))?;
cliclack::outro("Showing tool output of medium importance.")?;
}
"all" => {
config.set("GOOSE_CLI_MIN_PRIORITY", Value::from(0.0))?;
config.set_param("GOOSE_CLI_MIN_PRIORITY", Value::from(0.0))?;
cliclack::outro("Showing all tool output.")?;
}
_ => unreachable!(),

6
crates/goose-cli/src/session/builder.rs
View File

@@ -21,11 +21,11 @@ pub async fn build_session(
let config = Config::global();
let provider_name: String = config
.get("GOOSE_PROVIDER")
.get_param("GOOSE_PROVIDER")
.expect("No provider configured. Run 'goose configure' first");
let model: String = config
.get("GOOSE_MODEL")
.get_param("GOOSE_MODEL")
.expect("No model configured. Run 'goose configure' first");
let model_config = goose::model::ModelConfig::new(model.clone());
let provider =
@@ -137,7 +137,7 @@ pub async fn build_session(
.await;
// Only override system prompt if a system override exists
let system_prompt_file: Option<String> = config.get("GOOSE_SYSTEM_PROMPT_FILE_PATH").ok();
let system_prompt_file: Option<String> = config.get_param("GOOSE_SYSTEM_PROMPT_FILE_PATH").ok();
if let Some(ref path) = system_prompt_file {
let override_prompt =
std::fs::read_to_string(path).expect("Failed to read system prompt file");

2
crates/goose-cli/src/session/mod.rs
View File

@@ -343,7 +343,7 @@ impl Session {
}
config
.set("GOOSE_MODE", Value::String(mode.to_string()))
.set_param("GOOSE_MODE", Value::String(mode.to_string()))
.unwrap();
println!("Goose mode set to '{}'", mode);
continue;

2
crates/goose-cli/src/session/output.rs
View File

@@ -150,7 +150,7 @@ fn render_tool_response(resp: &ToolResponse, theme: Theme, debug: bool) {
}
let min_priority = config
.get::<f32>("GOOSE_CLI_MIN_PRIORITY")
.get_param::<f32>("GOOSE_CLI_MIN_PRIORITY")
.ok()
.unwrap_or(0.0);

13
crates/goose-server/src/openapi.rs
View File

@@ -1,5 +1,8 @@
use utoipa::OpenApi;
use goose::providers::base::ConfigKey;
use goose::providers::base::ProviderMetadata;
#[allow(dead_code)] // Used by utoipa for OpenAPI generation
#[derive(OpenApi)]
#[openapi(
@@ -10,13 +13,19 @@ use utoipa::OpenApi;
super::routes::config_management::add_extension,
super::routes::config_management::remove_extension,
super::routes::config_management::update_extension,
super::routes::config_management::read_all_config
super::routes::config_management::read_all_config,
super::routes::config_management::providers
),
components(schemas(
super::routes::config_management::UpsertConfigQuery,
super::routes::config_management::ConfigKeyQuery,
super::routes::config_management::ExtensionQuery,
super::routes::config_management::ConfigResponse
super::routes::config_management::ConfigResponse,
super::routes::config_management::ProvidersResponse,
super::routes::config_management::ProvidersResponse,
super::routes::config_management::ProviderDetails,
ProviderMetadata,
ConfigKey
))
)]
pub struct ApiDoc;

2
crates/goose-server/src/routes/agent.rs
View File

@@ -121,7 +121,7 @@ async fn create_agent(
let config = Config::global();
let model = payload.model.unwrap_or_else(|| {
config
.get("GOOSE_MODEL")
.get_param("GOOSE_MODEL")
.expect("Did not find a model on payload or in env")
});
let model_config = ModelConfig::new(model);

180
crates/goose-server/src/routes/config_management.rs
View File

@@ -5,25 +5,42 @@ use axum::{
Json, Router,
};
use goose::config::Config;
use http::StatusCode;
use goose::providers::base::ProviderMetadata;
use goose::providers::providers as get_providers;
use http::{HeaderMap, StatusCode};
use serde::{Deserialize, Serialize};
use serde_json::Value;
use std::{collections::HashMap, sync::Arc};
use tokio::sync::Mutex;
use std::collections::HashMap;
use std::env;
use utoipa::ToSchema;
use crate::state::AppState;
fn verify_secret_key(headers: &HeaderMap, state: &AppState) -> Result<StatusCode, StatusCode> {
// Verify secret key
let secret_key = headers
.get("X-Secret-Key")
.and_then(|value| value.to_str().ok())
.ok_or(StatusCode::UNAUTHORIZED)?;
if secret_key != state.secret_key {
Err(StatusCode::UNAUTHORIZED)
} else {
Ok(StatusCode::OK)
}
}
#[derive(Deserialize, ToSchema)]
pub struct UpsertConfigQuery {
pub key: String,
pub value: Value,
pub is_secret: Option<bool>,
pub is_secret: bool,
}
#[derive(Deserialize, ToSchema)]
pub struct ConfigKeyQuery {
pub key: String,
pub is_secret: bool,
}
#[derive(Deserialize, ToSchema)]
@@ -37,6 +54,22 @@ pub struct ConfigResponse {
pub config: HashMap<String, Value>,
}
// Define a new structure to encapsulate the provider details along with configuration status
#[derive(Debug, Serialize, Deserialize, ToSchema)]
pub struct ProviderDetails {
/// Unique identifier and name of the provider
pub name: String,
/// Metadata about the provider
pub metadata: ProviderMetadata,
/// Indicates whether the provider is fully configured
pub is_configured: bool,
}
#[derive(Serialize, ToSchema)]
pub struct ProvidersResponse {
pub providers: Vec<ProviderDetails>,
}
#[utoipa::path(
post,
path = "/config/upsert",
@@ -47,16 +80,15 @@ pub struct ConfigResponse {
)
)]
pub async fn upsert_config(
State(_state): State<Arc<Mutex<HashMap<String, Value>>>>,
State(state): State<AppState>,
headers: HeaderMap,
Json(query): Json<UpsertConfigQuery>,
) -> Result<Json<Value>, StatusCode> {
let config = Config::global();
// Use the helper function to verify the secret key
verify_secret_key(&headers, &state)?;
let result = if query.is_secret.unwrap_or(false) {
config.set_secret(&query.key, query.value)
} else {
config.set(&query.key, query.value)
};
let config = Config::global();
let result = config.set(&query.key, query.value, query.is_secret);
match result {
Ok(_) => Ok(Json(Value::String(format!("Upserted key {}", query.key)))),
@@ -75,9 +107,13 @@ pub async fn upsert_config(
)
)]
pub async fn remove_config(
State(_state): State<Arc<Mutex<HashMap<String, Value>>>>,
State(state): State<AppState>,
headers: HeaderMap,
Json(query): Json<ConfigKeyQuery>,
) -> Result<Json<String>, StatusCode> {
// Use the helper function to verify the secret key
verify_secret_key(&headers, &state)?;
let config = Config::global();
match config.delete(&query.key) {
@@ -96,13 +132,25 @@ pub async fn remove_config(
)
)]
pub async fn read_config(
State(_state): State<Arc<Mutex<HashMap<String, Value>>>>,
State(state): State<AppState>,
headers: HeaderMap,
Json(query): Json<ConfigKeyQuery>,
) -> Result<Json<Value>, StatusCode> {
verify_secret_key(&headers, &state)?;
let config = Config::global();
match config.get::<Value>(&query.key) {
Ok(value) => Ok(Json(value)),
match config.get(&query.key, query.is_secret) {
// Always get the actual value
Ok(value) => {
if query.is_secret {
// If it's marked as secret, return a boolean indicating presence
Ok(Json(Value::Bool(true)))
} else {
// Return the actual value if not secret
Ok(Json(value))
}
}
Err(_) => Err(StatusCode::NOT_FOUND),
}
}
@@ -118,20 +166,25 @@ pub async fn read_config(
)
)]
pub async fn add_extension(
State(_state): State<Arc<Mutex<HashMap<String, Value>>>>,
State(state): State<AppState>,
headers: HeaderMap,
Json(extension): Json<ExtensionQuery>,
) -> Result<Json<String>, StatusCode> {
// Use the helper function to verify the secret key
verify_secret_key(&headers, &state)?;
let config = Config::global();
// Get current extensions or initialize empty map
let mut extensions: HashMap<String, Value> =
config.get("extensions").unwrap_or_else(|_| HashMap::new());
let mut extensions: HashMap<String, Value> = config
.get_param("extensions")
.unwrap_or_else(|_| HashMap::new());
// Add new extension
extensions.insert(extension.name.clone(), extension.config);
// Save updated extensions
match config.set(
match config.set_param(
"extensions",
Value::Object(extensions.into_iter().collect()),
) {
@@ -151,13 +204,17 @@ pub async fn add_extension(
)
)]
pub async fn remove_extension(
State(_state): State<Arc<Mutex<HashMap<String, Value>>>>,
State(state): State<AppState>,
headers: HeaderMap,
Json(query): Json<ConfigKeyQuery>,
) -> Result<Json<String>, StatusCode> {
// Use the helper function to verify the secret key
verify_secret_key(&headers, &state)?;
let config = Config::global();
// Get current extensions
let mut extensions: HashMap<String, Value> = match config.get("extensions") {
let mut extensions: HashMap<String, Value> = match config.get_param("extensions") {
Ok(exts) => exts,
Err(_) => return Err(StatusCode::NOT_FOUND),
};
@@ -165,7 +222,7 @@ pub async fn remove_extension(
// Remove extension if it exists
if extensions.remove(&query.key).is_some() {
// Save updated extensions
match config.set(
match config.set_param(
"extensions",
Value::Object(extensions.into_iter().collect()),
) {
@@ -185,8 +242,12 @@ pub async fn remove_extension(
)
)]
pub async fn read_all_config(
State(_state): State<Arc<Mutex<HashMap<String, Value>>>>,
State(state): State<AppState>,
headers: HeaderMap,
) -> Result<Json<ConfigResponse>, StatusCode> {
// Use the helper function to verify the secret key
verify_secret_key(&headers, &state)?;
let config = Config::global();
// Load values from config file
@@ -206,13 +267,17 @@ pub async fn read_all_config(
)
)]
pub async fn update_extension(
State(_state): State<Arc<Mutex<HashMap<String, Value>>>>,
State(state): State<AppState>,
headers: HeaderMap,
Json(extension): Json<ExtensionQuery>,
) -> Result<Json<String>, StatusCode> {
// Use the helper function to verify the secret key
verify_secret_key(&headers, &state)?;
let config = Config::global();
// Get current extensions
let mut extensions: HashMap<String, Value> = match config.get("extensions") {
let mut extensions: HashMap<String, Value> = match config.get_param("extensions") {
Ok(exts) => exts,
Err(_) => return Err(StatusCode::NOT_FOUND),
};
@@ -226,7 +291,7 @@ pub async fn update_extension(
extensions.insert(extension.name.clone(), extension.config);
// Save updated extensions
match config.set(
match config.set_param(
"extensions",
Value::Object(extensions.into_iter().collect()),
) {
@@ -235,6 +300,66 @@ pub async fn update_extension(
}
}
// Modified providers function using the new response type
#[utoipa::path(
get,
path = "/config/providers",
responses(
(status = 200, description = "All configuration values retrieved successfully", body = [ProviderDetails])
)
)]
pub async fn providers(
State(state): State<AppState>,
headers: HeaderMap,
) -> Result<Json<Vec<ProviderDetails>>, StatusCode> {
verify_secret_key(&headers, &state)?;
// Fetch the list of providers, which are likely stored in the AppState or can be retrieved via a function call
let providers_metadata = get_providers();
// Construct the response by checking configuration status for each provider
let providers_response: Vec<ProviderDetails> = providers_metadata
.into_iter()
.map(|metadata| {
// Check if the provider is configured (this will depend on how you track configuration status)
let is_configured = check_provider_configured(&metadata);
ProviderDetails {
name: metadata.name.clone(),
metadata,
is_configured,
}
})
.collect();
Ok(Json(providers_response))
}
fn check_provider_configured(metadata: &ProviderMetadata) -> bool {
let config = Config::global();
// Check all required keys for the provider
for key in &metadata.config_keys {
if key.required {
let key_name = &key.name;
// First, check if the key is set in the environment
let is_set_in_env = env::var(key_name).is_ok();
// If not set in environment, check the config file based on whether it's a secret or not
let is_set_in_config = config.get(key_name, key.secret).is_ok();
// If the key is neither in the environment nor in the config, the provider is not configured
if !is_set_in_env && !is_set_in_config {
return false;
}
}
}
// If all required keys are accounted for, the provider is considered configured
true
}
pub fn routes(state: AppState) -> Router {
Router::new()
.route("/config", get(read_all_config))
@@ -244,5 +369,6 @@ pub fn routes(state: AppState) -> Router {
.route("/config/extension", post(add_extension))
.route("/config/extension", put(update_extension))
.route("/config/extension", delete(remove_extension))
.with_state(state.config)
.route("/config/providers", get(providers))
.with_state(state)
}

6
crates/goose-server/src/routes/configs.rs
View File

@@ -43,7 +43,7 @@ async fn store_config(
let result = if request.is_secret {
config.set_secret(&request.key, Value::String(request.value))
} else {
config.set(&request.key, Value::String(request.value))
config.set_param(&request.key, Value::String(request.value))
};
match result {
Ok(_) => Ok(Json(ConfigResponse { error: false })),
@@ -87,7 +87,7 @@ static PROVIDER_ENV_REQUIREMENTS: Lazy<HashMap<String, ProviderConfig>> = Lazy::
fn check_key_status(config: &Config, key: &str) -> (bool, Option<String>) {
if let Ok(_value) = std::env::var(key) {
(true, Some("env".to_string()))
} else if config.get::<String>(key).is_ok() {
} else if config.get_param::<String>(key).is_ok() {
(true, Some("yaml".to_string()))
} else if config.get_secret::<String>(key).is_ok() {
(true, Some("keyring".to_string()))
@@ -171,7 +171,7 @@ pub async fn get_config(
// Fetch the configuration value. Right now we don't allow get a secret.
let config = Config::global();
let value = if let Ok(config_value) = config.get::<String>(&query.key) {
let value = if let Ok(config_value) = config.get_param::<String>(&query.key) {
Some(config_value)
} else if let Ok(env_value) = std::env::var(&query.key) {
Some(env_value)

92
crates/goose-server/src/routes/utils.rs Normal file
View File

@@ -0,0 +1,92 @@
use serde::{Deserialize, Serialize};
use std::error::Error;
use goose::config::Config;
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum KeyLocation {
Environment,
ConfigFile,
Keychain,
NotFound
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct KeyInfo {
pub name: String,
pub is_set: bool,
pub location: KeyLocation,
pub is_secret: bool,
pub value: Option<String>, // Only populated for non-secret keys that are set
}
/// Inspects a configuration key to determine if it's set, its location, and value (for non-secret keys)
pub fn inspect_key(
key_name: &str,
is_secret: bool,
) -> Result<KeyInfo, Box<dyn Error>> {
let config = Config::global();
// Check environment variable first
let env_value = std::env::var(key_name).ok();
if let Some(value) = env_value {
return Ok(KeyInfo {
name: key_name.to_string(),
is_set: true,
location: KeyLocation::Environment,
is_secret,
// Only include value for non-secret keys
value: if !is_secret { Some(value) } else { None },
});
}
// Check config store
let config_result = if is_secret {
config.get_secret(key_name).map(|v| (v, true))
} else {
config.get(key_name).map(|v| (v, false))
};
match config_result {
Ok((value, is_secret_actual)) => {
// Determine location based on whether it's a secret value
let location = if is_secret_actual {
KeyLocation::Keychain
} else {
KeyLocation::ConfigFile
};
Ok(KeyInfo {
name: key_name.to_string(),
is_set: true,
location,
is_secret: is_secret_actual,
// Only include value for non-secret keys
value: if !is_secret_actual { Some(value) } else { None },
})
},
Err(_) => {
Ok(KeyInfo {
name: key_name.to_string(),
is_set: false,
location: KeyLocation::NotFound,
is_secret,
value: None,
})
}
}
}
/// Inspects multiple keys at once
pub fn inspect_keys(
keys: &[(String, bool)], // (name, is_secret) pairs
) -> Result<Vec<KeyInfo>, Box<dyn Error>> {
let mut results = Vec::new();
for (key_name, is_secret) in keys {
let info = inspect_key(key_name, *is_secret)?;
results.push(info);
}
Ok(results)
}

1
crates/goose/Cargo.toml
View File

@@ -60,6 +60,7 @@ serde_yaml = "0.9.34"
once_cell = "1.20.2"
etcetera = "0.8.0"
rand = "0.8.5"
utoipa = { version = "4.1" }
# For Bedrock provider
aws-config = { version = "1.1.7", features = ["behavior-version-latest"] }

2
crates/goose/src/agents/capabilities.rs
View File

@@ -351,7 +351,7 @@ impl Capabilities {
let mut system_prompt_extensions = self.system_prompt_extensions.clone();
let config = Config::global();
let goose_mode = config.get("GOOSE_MODE").unwrap_or("auto".to_string());
let goose_mode = config.get_param("GOOSE_MODE").unwrap_or("auto".to_string());
if goose_mode == "chat" {
system_prompt_extensions.push(
"Right now you are in the chat only mode, no access to any tool use and system."

2
crates/goose/src/agents/factory.rs
View File

@@ -50,7 +50,7 @@ impl AgentFactory {
pub fn configured_version() -> String {
let config = Config::global();
config
.get::<String>("GOOSE_AGENT")
.get_param::<String>("GOOSE_AGENT")
.unwrap_or_else(|_| Self::default_version().to_string())
}

2
crates/goose/src/agents/summarize.rs
View File

@@ -177,7 +177,7 @@ impl Agent for SummarizeAgent {
// Load settings from config
let config = Config::global();
let goose_mode = config.get("GOOSE_MODE").unwrap_or("auto".to_string());
let goose_mode = config.get_param("GOOSE_MODE").unwrap_or("auto".to_string());
// we add in the 2 resource tools if any extensions support resources
// TODO: make sure there is no collision with another extension's tool name

2
crates/goose/src/agents/truncate.rs
View File

@@ -171,7 +171,7 @@ impl Agent for TruncateAgent {
// Load settings from config
let config = Config::global();
let goose_mode = config.get("GOOSE_MODE").unwrap_or("auto".to_string());
let goose_mode = config.get_param("GOOSE_MODE").unwrap_or("auto".to_string());
// we add in the 2 resource tools if any extensions support resources
// TODO: make sure there is no collision with another extension's tool name

52
crates/goose/src/config/base.rs
View File

@@ -78,7 +78,7 @@ impl From<keyring::Error> for ConfigError {
///
/// // Get a string value
/// let config = Config::global();
/// let api_key: String = config.get("OPENAI_API_KEY").unwrap();
/// let api_key: String = config.get_param("OPENAI_API_KEY").unwrap();
///
/// // Get a complex type
/// #[derive(Deserialize)]
@@ -87,7 +87,7 @@ impl From<keyring::Error> for ConfigError {
/// port: u16,
/// }
///
/// let server_config: ServerConfig = config.get("server").unwrap();
/// let server_config: ServerConfig = config.get_param("server").unwrap();
/// ```
///
/// # Naming Convention
@@ -204,7 +204,25 @@ impl Config {
}
}
/// Get a configuration value.
// check all possible places for a parameter
pub fn get(&self, key: &str, is_secret: bool) -> Result<Value, ConfigError> {
if is_secret {
self.get_secret(key)
} else {
self.get_param(key)
}
}
// save a parameter in the appropriate location based on if it's secret or not
pub fn set(&self, key: &str, value: Value, is_secret: bool) -> Result<(), ConfigError> {
if is_secret {
self.set_secret(key, value)
} else {
self.set_param(key, value)
}
}
/// Get a configuration value (non-secret).
///
/// This will attempt to get the value from:
/// 1. Environment variable with the exact key name
@@ -220,7 +238,7 @@ impl Config {
/// - The key doesn't exist in either environment or config file
/// - The value cannot be deserialized into the requested type
/// - There is an error reading the config file
pub fn get<T: for<'de> Deserialize<'de>>(&self, key: &str) -> Result<T, ConfigError> {
pub fn get_param<T: for<'de> Deserialize<'de>>(&self, key: &str) -> Result<T, ConfigError> {
// First check environment variables (convert to uppercase)
let env_key = key.to_uppercase();
if let Ok(val) = env::var(&env_key) {
@@ -239,7 +257,7 @@ impl Config {
.and_then(|v| Ok(serde_json::from_value(v.clone())?))
}
/// Set a configuration value in the config file.
/// Set a configuration value in the config file (non-secret).
///
/// This will immediately write the value to the config file. The value
/// can be any type that can be serialized to JSON/YAML.
@@ -252,7 +270,7 @@ impl Config {
/// Returns a ConfigError if:
/// - There is an error reading or writing the config file
/// - There is an error serializing the value
pub fn set(&self, key: &str, value: Value) -> Result<(), ConfigError> {
pub fn set_param(&self, key: &str, value: Value) -> Result<(), ConfigError> {
let mut values = self.load_values()?;
values.insert(key.to_string(), value);
@@ -377,15 +395,15 @@ mod tests {
let config = Config::new(temp_file.path(), TEST_KEYRING_SERVICE)?;
// Set a simple string value
config.set("test_key", Value::String("test_value".to_string()))?;
config.set_param("test_key", Value::String("test_value".to_string()))?;
// Test simple string retrieval
let value: String = config.get("test_key")?;
let value: String = config.get_param("test_key")?;
assert_eq!(value, "test_value");
// Test with environment variable override
std::env::set_var("TEST_KEY", "env_value");
let value: String = config.get("test_key")?;
let value: String = config.get_param("test_key")?;
assert_eq!(value, "env_value");
Ok(())
@@ -403,7 +421,7 @@ mod tests {
let config = Config::new(temp_file.path(), TEST_KEYRING_SERVICE)?;
// Set a complex value
config.set(
config.set_param(
"complex_key",
serde_json::json!({
"field1": "hello",
@@ -411,7 +429,7 @@ mod tests {
}),
)?;
let value: TestStruct = config.get("complex_key")?;
let value: TestStruct = config.get_param("complex_key")?;
assert_eq!(value.field1, "hello");
assert_eq!(value.field2, 42);
@@ -423,7 +441,7 @@ mod tests {
let temp_file = NamedTempFile::new().unwrap();
let config = Config::new(temp_file.path(), TEST_KEYRING_SERVICE).unwrap();
let result: Result<String, ConfigError> = config.get("nonexistent_key");
let result: Result<String, ConfigError> = config.get_param("nonexistent_key");
assert!(matches!(result, Err(ConfigError::NotFound(_))));
}
@@ -432,8 +450,8 @@ mod tests {
let temp_file = NamedTempFile::new().unwrap();
let config = Config::new(temp_file.path(), TEST_KEYRING_SERVICE)?;
config.set("key1", Value::String("value1".to_string()))?;
config.set("key2", Value::Number(42.into()))?;
config.set_param("key1", Value::String("value1".to_string()))?;
config.set_param("key2", Value::Number(42.into()))?;
// Read the file directly to check YAML formatting
let content = std::fs::read_to_string(temp_file.path())?;
@@ -448,14 +466,14 @@ mod tests {
let temp_file = NamedTempFile::new().unwrap();
let config = Config::new(temp_file.path(), TEST_KEYRING_SERVICE)?;
config.set("key", Value::String("value".to_string()))?;
config.set_param("key", Value::String("value".to_string()))?;
let value: String = config.get("key")?;
let value: String = config.get_param("key")?;
assert_eq!(value, "value");
config.delete("key")?;
let result: Result<String, ConfigError> = config.get("key");
let result: Result<String, ConfigError> = config.get_param("key");
assert!(matches!(result, Err(ConfigError::NotFound(_))));
Ok(())

10
crates/goose/src/config/experiments.rs
View File

@@ -18,7 +18,8 @@ impl ExperimentManager {
/// - Removes experiments not in `ALL_EXPERIMENTS`.
pub fn get_all() -> Result<Vec<(String, bool)>> {
let config = Config::global();
let mut experiments: HashMap<String, bool> = config.get("experiments").unwrap_or_default();
let mut experiments: HashMap<String, bool> =
config.get_param("experiments").unwrap_or_default();
Self::refresh_experiments(&mut experiments);
Ok(experiments.into_iter().collect())
@@ -27,12 +28,13 @@ impl ExperimentManager {
/// Enable or disable an experiment
pub fn set_enabled(name: &str, enabled: bool) -> Result<()> {
let config = Config::global();
let mut experiments: HashMap<String, bool> =
config.get("experiments").unwrap_or_else(|_| HashMap::new());
let mut experiments: HashMap<String, bool> = config
.get_param("experiments")
.unwrap_or_else(|_| HashMap::new());
Self::refresh_experiments(&mut experiments);
experiments.insert(name.to_string(), enabled);
config.set("experiments", serde_json::to_value(experiments)?)?;
config.set_param("experiments", serde_json::to_value(experiments)?)?;
Ok(())
}

34
crates/goose/src/config/extensions.rs
View File

@@ -23,7 +23,7 @@ impl ExtensionManager {
let config = Config::global();
// Try to get the extension entry
let extensions: HashMap<String, ExtensionEntry> = match config.get("extensions") {
let extensions: HashMap<String, ExtensionEntry> = match config.get_param("extensions") {
Ok(exts) => exts,
Err(super::ConfigError::NotFound(_)) => {
// Initialize with default developer extension
@@ -37,7 +37,7 @@ impl ExtensionManager {
},
},
)]);
config.set("extensions", serde_json::to_value(&defaults)?)?;
config.set_param("extensions", serde_json::to_value(&defaults)?)?;
defaults
}
Err(e) => return Err(e.into()),
@@ -56,11 +56,12 @@ impl ExtensionManager {
pub fn set(entry: ExtensionEntry) -> Result<()> {
let config = Config::global();
let mut extensions: HashMap<String, ExtensionEntry> =
config.get("extensions").unwrap_or_else(|_| HashMap::new());
let mut extensions: HashMap<String, ExtensionEntry> = config
.get_param("extensions")
.unwrap_or_else(|_| HashMap::new());
extensions.insert(entry.config.name().parse()?, entry);
config.set("extensions", serde_json::to_value(extensions)?)?;
config.set_param("extensions", serde_json::to_value(extensions)?)?;
Ok(())
}
@@ -68,11 +69,12 @@ impl ExtensionManager {
pub fn remove(name: &str) -> Result<()> {
let config = Config::global();
let mut extensions: HashMap<String, ExtensionEntry> =
config.get("extensions").unwrap_or_else(|_| HashMap::new());
let mut extensions: HashMap<String, ExtensionEntry> = config
.get_param("extensions")
.unwrap_or_else(|_| HashMap::new());
extensions.remove(name);
config.set("extensions", serde_json::to_value(extensions)?)?;
config.set_param("extensions", serde_json::to_value(extensions)?)?;
Ok(())
}
@@ -80,12 +82,13 @@ impl ExtensionManager {
pub fn set_enabled(name: &str, enabled: bool) -> Result<()> {
let config = Config::global();
let mut extensions: HashMap<String, ExtensionEntry> =
config.get("extensions").unwrap_or_else(|_| HashMap::new());
let mut extensions: HashMap<String, ExtensionEntry> = config
.get_param("extensions")
.unwrap_or_else(|_| HashMap::new());
if let Some(entry) = extensions.get_mut(name) {
entry.enabled = enabled;
config.set("extensions", serde_json::to_value(extensions)?)?;
config.set_param("extensions", serde_json::to_value(extensions)?)?;
}
Ok(())
}
@@ -94,7 +97,7 @@ impl ExtensionManager {
pub fn get_all() -> Result<Vec<ExtensionEntry>> {
let config = Config::global();
let extensions: HashMap<String, ExtensionEntry> =
config.get("extensions").unwrap_or_default();
config.get_param("extensions").unwrap_or_default();
Ok(Vec::from_iter(extensions.values().cloned()))
}
@@ -102,15 +105,16 @@ impl ExtensionManager {
pub fn get_all_names() -> Result<Vec<String>> {
let config = Config::global();
Ok(config
.get("extensions")
.get_param("extensions")
.unwrap_or_else(|_| get_keys(Default::default())))
}
/// Check if an extension is enabled
pub fn is_enabled(name: &str) -> Result<bool> {
let config = Config::global();
let extensions: HashMap<String, ExtensionEntry> =
config.get("extensions").unwrap_or_else(|_| HashMap::new());
let extensions: HashMap<String, ExtensionEntry> = config
.get_param("extensions")
.unwrap_or_else(|_| HashMap::new());
Ok(extensions.get(name).map(|e| e.enabled).unwrap_or(false))
}

2
crates/goose/src/providers/anthropic.rs
View File

@@ -45,7 +45,7 @@ impl AnthropicProvider {
let config = crate::config::Config::global();
let api_key: String = config.get_secret("ANTHROPIC_API_KEY")?;
let host: String = config
.get("ANTHROPIC_HOST")
.get_param("ANTHROPIC_HOST")
.unwrap_or_else(|_| "https://api.anthropic.com".to_string());
let client = Client::builder()

20
crates/goose/src/providers/azure.rs
View File

@@ -40,10 +40,10 @@ impl AzureProvider {
pub fn from_env(model: ModelConfig) -> Result<Self> {
let config = crate::config::Config::global();
let api_key: String = config.get_secret("AZURE_OPENAI_API_KEY")?;
let endpoint: String = config.get("AZURE_OPENAI_ENDPOINT")?;
let deployment_name: String = config.get("AZURE_OPENAI_DEPLOYMENT_NAME")?;
let endpoint: String = config.get_param("AZURE_OPENAI_ENDPOINT")?;
let deployment_name: String = config.get_param("AZURE_OPENAI_DEPLOYMENT_NAME")?;
let api_version: String = config
.get("AZURE_OPENAI_API_VERSION")
.get_param("AZURE_OPENAI_API_VERSION")
.unwrap_or_else(|_| AZURE_DEFAULT_API_VERSION.to_string());
let client = Client::builder()
@@ -109,18 +109,8 @@ impl Provider for AzureProvider {
vec![
ConfigKey::new("AZURE_OPENAI_API_KEY", true, true, None),
ConfigKey::new("AZURE_OPENAI_ENDPOINT", true, false, None),
ConfigKey::new(
"AZURE_OPENAI_DEPLOYMENT_NAME",
true,
false,
Some("Name of your Azure OpenAI deployment"),
),
ConfigKey::new(
"AZURE_OPENAI_API_VERSION",
false,
false,
Some("Azure OpenAI API version, default: 2024-10-21"),
),
ConfigKey::new("AZURE_OPENAI_DEPLOYMENT_NAME", true, false, None),
ConfigKey::new("AZURE_OPENAI_API_VERSION", false, false, Some("2024-10-21")),
],
)
}

5
crates/goose/src/providers/base.rs
View File

@@ -5,9 +5,10 @@ use super::errors::ProviderError;
use crate::message::Message;
use crate::model::ModelConfig;
use mcp_core::tool::Tool;
use utoipa::ToSchema;
/// Metadata about a provider's configuration requirements and capabilities
#[derive(Debug, Clone, Serialize, Deserialize)]
#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
pub struct ProviderMetadata {
/// The unique identifier for this provider
pub name: String,
@@ -60,7 +61,7 @@ impl ProviderMetadata {
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
pub struct ConfigKey {
pub name: String,
pub required: bool,

2
crates/goose/src/providers/databricks.rs
View File

@@ -83,7 +83,7 @@ impl DatabricksProvider {
// For compatibility for now we check both config and secret for databricks host
// but it is not actually a secret value
let mut host: Result<String, ConfigError> = config.get("DATABRICKS_HOST");
let mut host: Result<String, ConfigError> = config.get_param("DATABRICKS_HOST");
if host.is_err() {
host = config.get_secret("DATABRICKS_HOST")

12
crates/goose/src/providers/gcpvertexai.rs
View File

@@ -146,7 +146,7 @@ impl GcpVertexAIProvider {
/// * `model` - Configuration for the model to be used
async fn new_async(model: ModelConfig) -> Result<Self> {
let config = crate::config::Config::global();
let project_id = config.get("GCP_PROJECT_ID")?;
let project_id = config.get_param("GCP_PROJECT_ID")?;
let location = Self::determine_location(config)?;
let host = format!("https://{}-aiplatform.googleapis.com", location);
@@ -173,25 +173,25 @@ impl GcpVertexAIProvider {
/// Loads retry configuration from environment variables or uses defaults.
fn load_retry_config(config: &crate::config::Config) -> RetryConfig {
let max_retries = config
.get("GCP_MAX_RETRIES")
.get_param("GCP_MAX_RETRIES")
.ok()
.and_then(|v: String| v.parse::<usize>().ok())
.unwrap_or(DEFAULT_MAX_RETRIES);
let initial_interval_ms = config
.get("GCP_INITIAL_RETRY_INTERVAL_MS")
.get_param("GCP_INITIAL_RETRY_INTERVAL_MS")
.ok()
.and_then(|v: String| v.parse::<u64>().ok())
.unwrap_or(DEFAULT_INITIAL_RETRY_INTERVAL_MS);
let backoff_multiplier = config
.get("GCP_BACKOFF_MULTIPLIER")
.get_param("GCP_BACKOFF_MULTIPLIER")
.ok()
.and_then(|v: String| v.parse::<f64>().ok())
.unwrap_or(DEFAULT_BACKOFF_MULTIPLIER);
let max_interval_ms = config
.get("GCP_MAX_RETRY_INTERVAL_MS")
.get_param("GCP_MAX_RETRY_INTERVAL_MS")
.ok()
.and_then(|v: String| v.parse::<u64>().ok())
.unwrap_or(DEFAULT_MAX_RETRY_INTERVAL_MS);
@@ -211,7 +211,7 @@ impl GcpVertexAIProvider {
/// 2. Global default location (Iowa)
fn determine_location(config: &crate::config::Config) -> Result<String> {
Ok(config
.get("GCP_LOCATION")
.get_param("GCP_LOCATION")
.ok()
.filter(|location: &String| !location.trim().is_empty())
.unwrap_or_else(|| Iowa.to_string()))

2
crates/goose/src/providers/google.rs
View File

@@ -50,7 +50,7 @@ impl GoogleProvider {
let config = crate::config::Config::global();
let api_key: String = config.get_secret("GOOGLE_API_KEY")?;
let host: String = config
.get("GOOGLE_HOST")
.get_param("GOOGLE_HOST")
.unwrap_or_else(|_| GOOGLE_API_HOST.to_string());
let client = Client::builder()

2
crates/goose/src/providers/groq.rs
View File

@@ -39,7 +39,7 @@ impl GroqProvider {
let config = crate::config::Config::global();
let api_key: String = config.get_secret("GROQ_API_KEY")?;
let host: String = config
.get("GROQ_HOST")
.get_param("GROQ_HOST")
.unwrap_or_else(|_| GROQ_API_HOST.to_string());
let client = Client::builder()

2
crates/goose/src/providers/ollama.rs
View File

@@ -39,7 +39,7 @@ impl OllamaProvider {
pub fn from_env(model: ModelConfig) -> Result<Self> {
let config = crate::config::Config::global();
let host: String = config
.get("OLLAMA_HOST")
.get_param("OLLAMA_HOST")
.unwrap_or_else(|_| OLLAMA_HOST.to_string());
let client = Client::builder()

8
crates/goose/src/providers/openai.rs
View File

@@ -47,13 +47,13 @@ impl OpenAiProvider {
let config = crate::config::Config::global();
let api_key: String = config.get_secret("OPENAI_API_KEY")?;
let host: String = config
.get("OPENAI_HOST")
.get_param("OPENAI_HOST")
.unwrap_or_else(|_| "https://api.openai.com".to_string());
let base_path: String = config
.get("OPENAI_BASE_PATH")
.get_param("OPENAI_BASE_PATH")
.unwrap_or_else(|_| "v1/chat/completions".to_string());
let organization: Option<String> = config.get("OPENAI_ORGANIZATION").ok();
let project: Option<String> = config.get("OPENAI_PROJECT").ok();
let organization: Option<String> = config.get_param("OPENAI_ORGANIZATION").ok();
let project: Option<String> = config.get_param("OPENAI_PROJECT").ok();
let client = Client::builder()
.timeout(Duration::from_secs(600))
.build()?;

2
crates/goose/src/providers/openrouter.rs
View File

@@ -44,7 +44,7 @@ impl OpenRouterProvider {
let config = crate::config::Config::global();
let api_key: String = config.get_secret("OPENROUTER_API_KEY")?;
let host: String = config
.get("OPENROUTER_HOST")
.get_param("OPENROUTER_HOST")
.unwrap_or_else(|_| "https://openrouter.ai".to_string());
let client = Client::builder()

142
ui/desktop/openapi.json
View File

@@ -137,6 +137,29 @@
}
}
},
"/config/providers": {
"get": {
"tags": [
"super::routes::config_management"
],
"operationId": "providers",
"responses": {
"200": {
"description": "All configuration values retrieved successfully",
"content": {
"application/json": {
"schema": {
"type": "array",
"items": {
"$ref": "#/components/schemas/ProviderDetails"
}
}
}
}
}
}
}
},
"/config/read": {
"get": {
"tags": [
@@ -240,12 +263,39 @@
},
"components": {
"schemas": {
"ConfigKey": {
"type": "object",
"required": [
"name",
"required",
"secret"
],
"properties": {
"default": {
"type": "string",
"nullable": true
},
"name": {
"type": "string"
},
"required": {
"type": "boolean"
},
"secret": {
"type": "boolean"
}
}
},
"ConfigKeyQuery": {
"type": "object",
"required": [
"key"
"key",
"is_secret"
],
"properties": {
"is_secret": {
"type": "boolean"
},
"key": {
"type": "string"
}
@@ -276,16 +326,100 @@
}
}
},
"ProviderDetails": {
"type": "object",
"required": [
"name",
"metadata",
"is_configured"
],
"properties": {
"is_configured": {
"type": "boolean",
"description": "Indicates whether the provider is fully configured"
},
"metadata": {
"$ref": "#/components/schemas/ProviderMetadata"
},
"name": {
"type": "string",
"description": "Unique identifier and name of the provider"
}
}
},
"ProviderMetadata": {
"type": "object",
"description": "Metadata about a provider's configuration requirements and capabilities",
"required": [
"name",
"display_name",
"description",
"default_model",
"known_models",
"model_doc_link",
"config_keys"
],
"properties": {
"config_keys": {
"type": "array",
"items": {
"$ref": "#/components/schemas/ConfigKey"
},
"description": "Required configuration keys"
},
"default_model": {
"type": "string",
"description": "The default/recommended model for this provider"
},
"description": {
"type": "string",
"description": "Description of the provider's capabilities"
},
"display_name": {
"type": "string",
"description": "Display name for the provider in UIs"
},
"known_models": {
"type": "array",
"items": {
"type": "string"
},
"description": "A list of currently known models\nTODO: eventually query the apis directly"
},
"model_doc_link": {
"type": "string",
"description": "Link to the docs where models can be found"
},
"name": {
"type": "string",
"description": "The unique identifier for this provider"
}
}
},
"ProvidersResponse": {
"type": "object",
"required": [
"providers"
],
"properties": {
"providers": {
"type": "array",
"items": {
"$ref": "#/components/schemas/ProviderDetails"
}
}
}
},
"UpsertConfigQuery": {
"type": "object",
"required": [
"key",
"value"
"value",
"is_secret"
],
"properties": {
"is_secret": {
"type": "boolean",
"nullable": true
"type": "boolean"
},
"key": {
"type": "string"

9
ui/desktop/src/api/sdk.gen.ts
View File

@@ -1,7 +1,7 @@
// This file is auto-generated by @hey-api/openapi-ts
import type { Options as ClientOptions, TDataShape, Client } from '@hey-api/client-fetch';
import type { ReadAllConfigData, ReadAllConfigResponse, RemoveExtensionData, RemoveExtensionResponse, AddExtensionData, AddExtensionResponse, UpdateExtensionData, UpdateExtensionResponse, ReadConfigData, RemoveConfigData, RemoveConfigResponse, UpsertConfigData, UpsertConfigResponse } from './types.gen';
import type { ReadAllConfigData, ReadAllConfigResponse, RemoveExtensionData, RemoveExtensionResponse, AddExtensionData, AddExtensionResponse, UpdateExtensionData, UpdateExtensionResponse, ProvidersData, ProvidersResponse2, ReadConfigData, RemoveConfigData, RemoveConfigResponse, UpsertConfigData, UpsertConfigResponse } from './types.gen';
import { client as _heyApiClient } from './client.gen';
export type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean> = ClientOptions<TData, ThrowOnError> & {
@@ -58,6 +58,13 @@ export const updateExtension = <ThrowOnError extends boolean = false>(options: O
});
};
export const providers = <ThrowOnError extends boolean = false>(options?: Options<ProvidersData, ThrowOnError>) => {
return (options?.client ?? _heyApiClient).get<ProvidersResponse2, unknown, ThrowOnError>({
url: '/config/providers',
...options
});
};
export const readConfig = <ThrowOnError extends boolean = false>(options: Options<ReadConfigData, ThrowOnError>) => {
return (options.client ?? _heyApiClient).get<unknown, unknown, ThrowOnError>({
url: '/config/read',

77
ui/desktop/src/api/types.gen.ts
View File

@@ -1,6 +1,14 @@
// This file is auto-generated by @hey-api/openapi-ts
export type ConfigKey = {
default?: string | null;
name: string;
required: boolean;
secret: boolean;
};
export type ConfigKeyQuery = {
is_secret: boolean;
key: string;
};
@@ -13,8 +21,59 @@ export type ExtensionQuery = {
name: string;
};
export type ProviderDetails = {
/**
* Indicates whether the provider is fully configured
*/
is_configured: boolean;
metadata: ProviderMetadata;
/**
* Unique identifier and name of the provider
*/
name: string;
};
/**
* Metadata about a provider's configuration requirements and capabilities
*/
export type ProviderMetadata = {
/**
* Required configuration keys
*/
config_keys: Array<ConfigKey>;
/**
* The default/recommended model for this provider
*/
default_model: string;
/**
* Description of the provider's capabilities
*/
description: string;
/**
* Display name for the provider in UIs
*/
display_name: string;
/**
* A list of currently known models
* TODO: eventually query the apis directly
*/
known_models: Array<string>;
/**
* Link to the docs where models can be found
*/
model_doc_link: string;
/**
* The unique identifier for this provider
*/
name: string;
};
export type ProvidersResponse = {
providers: Array<ProviderDetails>;
};
export type UpsertConfigQuery = {
is_secret?: boolean | null;
is_secret: boolean;
key: string;
value: unknown;
};
@@ -116,6 +175,22 @@ export type UpdateExtensionResponses = {
export type UpdateExtensionResponse = UpdateExtensionResponses[keyof UpdateExtensionResponses];
export type ProvidersData = {
body?: never;
path?: never;
query?: never;
url: '/config/providers';
};
export type ProvidersResponses = {
/**
* All configuration values retrieved successfully
*/
200: Array<ProviderDetails>;
};
export type ProvidersResponse2 = ProvidersResponses[keyof ProvidersResponses];
export type ReadConfigData = {
body: ConfigKeyQuery;
path?: never;

114
ui/desktop/src/components/ConfigContext.tsx
View File

@@ -1,4 +1,4 @@
import React, { createContext, useContext, useState, useEffect } from 'react';
import React, { createContext, useContext, useState, useEffect, useMemo } from 'react';
import {
readAllConfig,
readConfig,
@@ -7,8 +7,16 @@ import {
addExtension as apiAddExtension,
removeExtension as apiRemoveExtension,
updateExtension as apiUpdateExtension,
providers,
} from '../api';
import { client } from '../api/client.gen';
import type {
ConfigResponse,
UpsertConfigQuery,
ConfigKeyQuery,
ExtensionQuery,
ProviderDetails,
} from '../api/types.gen';
// Initialize client configuration
client.setConfig({
@@ -20,13 +28,15 @@ client.setConfig({
});
interface ConfigContextType {
config: Record<string, any>;
upsert: (key: string, value: any, isSecret?: boolean) => Promise<void>;
read: (key: string) => Promise<any>;
remove: (key: string) => Promise<void>;
addExtension: (name: string, config: any) => Promise<void>;
updateExtension: (name: string, config: any) => Promise<void>;
config: ConfigResponse['config'];
providersList: ProviderDetails[];
upsert: (key: string, value: unknown, is_secret: boolean) => Promise<void>;
read: (key: string, is_secret: boolean) => Promise<unknown>;
remove: (key: string, is_secret: boolean) => Promise<void>;
addExtension: (name: string, config: unknown) => Promise<void>;
updateExtension: (name: string, config: unknown) => Promise<void>;
removeExtension: (name: string) => Promise<void>;
getProviders: (b: boolean) => Promise<ProviderDetails[]>;
}
interface ConfigProviderProps {
@@ -36,13 +46,23 @@ interface ConfigProviderProps {
const ConfigContext = createContext<ConfigContextType | undefined>(undefined);
export const ConfigProvider: React.FC<ConfigProviderProps> = ({ children }) => {
const [config, setConfig] = useState<Record<string, any>>({});
const [config, setConfig] = useState<ConfigResponse['config']>({});
const [providersList, setProvidersList] = useState<ProviderDetails[]>([]);
useEffect(() => {
// Load all configuration data on mount
// Load all configuration data and providers on mount
(async () => {
const response = await readAllConfig();
setConfig(response.data.config || {});
// Load config
const configResponse = await readAllConfig();
setConfig(configResponse.data.config || {});
// Load providers
try {
const providersResponse = await providers();
setProvidersList(providersResponse.data);
} catch (error) {
console.error('Failed to load providers:', error);
}
})();
}, []);
@@ -51,58 +71,86 @@ export const ConfigProvider: React.FC<ConfigProviderProps> = ({ children }) => {
setConfig(response.data.config || {});
};
const upsert = async (key: string, value: any, isSecret?: boolean) => {
await upsertConfig({
body: {
const upsert = async (key: string, value: unknown, isSecret?: boolean) => {
const query: UpsertConfigQuery = {
key,
value,
is_secret: isSecret,
},
is_secret: isSecret || null,
};
await upsertConfig({
body: query,
});
await reloadConfig();
};
const read = async (key: string) => {
return await readConfig({
body: { key },
const read = async (key: string, is_secret: boolean = false) => {
const query: ConfigKeyQuery = { key: key, is_secret: is_secret };
const response = await readConfig({
body: query,
});
return response.data;
};
const remove = async (key: string) => {
const remove = async (key: string, is_secret: boolean) => {
const query: ConfigKeyQuery = { key: key, is_secret: is_secret };
await removeConfig({
body: { key },
body: query,
});
await reloadConfig();
};
const addExtension = async (name: string, config: any) => {
const addExtension = async (name: string, config: unknown) => {
const query: ExtensionQuery = { name, config };
await apiAddExtension({
body: { name, config },
body: query,
});
await reloadConfig();
};
const removeExtension = async (name: string) => {
const query: ConfigKeyQuery = { key: name, is_secret: false };
await apiRemoveExtension({
body: { key: name },
body: query,
});
await reloadConfig();
};
const updateExtension = async (name: string, config: any) => {
const updateExtension = async (name: string, config: unknown) => {
const query: ExtensionQuery = { name, config };
await apiUpdateExtension({
body: { name, config },
body: query,
});
await reloadConfig();
};
return (
<ConfigContext.Provider
value={{ config, upsert, read, remove, addExtension, updateExtension, removeExtension }}
>
{children}
</ConfigContext.Provider>
);
const getProviders = async (forceRefresh = false): Promise<ProviderDetails[]> => {
if (forceRefresh || providersList.length === 0) {
// If a refresh is forced or we don't have providers yet
const response = await providers();
setProvidersList(response.data);
return response.data;
}
// Otherwise return the cached providers
return providersList;
};
const contextValue = useMemo(
() => ({
config,
providersList,
upsert,
read,
remove,
addExtension,
updateExtension,
removeExtension,
getProviders,
}),
[config, providersList]
); // Functions don't need to be dependencies as they don't change
return <ConfigContext.Provider value={contextValue}>{children}</ConfigContext.Provider>;
};
export const useConfig = () => {

84
ui/desktop/src/components/settings_v2/providers/ProviderGrid.tsx
View File

@@ -1,44 +1,48 @@
import React from 'react';
import React, { memo, useMemo, useCallback } from 'react';
import { ProviderCard } from './subcomponents/ProviderCard';
import ProviderState from './interfaces/ProviderState';
import OnRefresh from './callbacks/RefreshActiveProviders';
import { ProviderModalProvider, useProviderModal } from './modal/ProviderModalProvider';
import ProviderConfigurationModal from './modal/ProviderConfiguationModal';
import { ProviderDetails } from '../../../api';
function GridLayout({ children }: { children: React.ReactNode }) {
const GridLayout = memo(function GridLayout({ children }: { children: React.ReactNode }) {
return (
<div className="grid grid-cols-[repeat(auto-fill,_minmax(140px,_1fr))] gap-3 [&_*]:z-20">
{children}
</div>
);
}
});
function ProviderCards({
// Memoize the ProviderCards component
const ProviderCards = memo(function ProviderCards({
providers,
isOnboarding,
}: {
providers: ProviderState[];
providers: ProviderDetails[];
isOnboarding: boolean;
}) {
const { openModal } = useProviderModal();
const configureProviderViaModal = (provider: ProviderState) => {
// Memoize these functions so they don't get recreated on every render
const configureProviderViaModal = useCallback(
(provider: ProviderDetails) => {
openModal(provider, {
onSubmit: (values: any) => {
console.log(`Configuring ${provider.name}:`, values);
// Your logic to save the configuration
},
formProps: {},
});
};
},
[openModal]
);
const handleLaunch = () => {
const handleLaunch = useCallback(() => {
OnRefresh();
};
}, []);
return (
<>
{providers.map((provider) => (
// Use useMemo to memoize the cards array
const providerCards = useMemo(() => {
return providers.map((provider) => (
<ProviderCard
key={provider.name}
provider={provider}
@@ -46,25 +50,55 @@ function ProviderCards({
onLaunch={handleLaunch}
isOnboarding={isOnboarding}
/>
))}
</>
);
}
));
}, [providers, isOnboarding, configureProviderViaModal, handleLaunch]);
export default function ProviderGrid({
return <>{providerCards}</>;
});
// Fix the ProviderModalProvider
export const OptimizedProviderModalProvider = memo(function OptimizedProviderModalProvider({
children,
}: {
children: React.ReactNode;
}) {
const contextValue = useMemo(
() => ({
isOpen: false,
currentProvider: null,
modalProps: {},
openModal: (provider, additionalProps = {}) => {
// Implementation
},
closeModal: () => {
// Implementation
},
}),
[]
);
return <ProviderModalProvider>{children}</ProviderModalProvider>;
});
export default memo(function ProviderGrid({
providers,
isOnboarding,
}: {
providers: ProviderState[];
providers: ProviderDetails[];
isOnboarding: boolean;
}) {
console.log('(1) Provider Grid -- is this the onboarding page?', isOnboarding);
return (
<GridLayout>
// Remove the console.log
console.log('provider grid');
// Memoize the modal provider and its children to avoid recreating on every render
const modalProviderContent = useMemo(
() => (
<ProviderModalProvider>
<ProviderCards providers={providers} isOnboarding={isOnboarding} />
<ProviderConfigurationModal />
</ProviderModalProvider>
</GridLayout>
),
[providers, isOnboarding]
);
}
return <GridLayout>{modalProviderContent}</GridLayout>;
});

98
ui/desktop/src/components/settings_v2/providers/ProviderSettingsPage.tsx
View File

@@ -1,61 +1,45 @@
import React from 'react';
import React, { useEffect, useState } from 'react';
import { ScrollArea } from '../../ui/scroll-area';
import BackButton from '../../ui/BackButton';
import ProviderGrid from './ProviderGrid';
import ProviderState from './interfaces/ProviderState';
const fakeProviderState: ProviderState[] = [
{
id: 'openai',
name: 'OpenAI',
isConfigured: true,
metadata: null,
},
{
id: 'anthropic',
name: 'Anthropic',
isConfigured: false,
metadata: null,
},
{
id: 'groq',
name: 'Groq',
isConfigured: false,
metadata: null,
},
{
id: 'google',
name: 'Google',
isConfigured: false,
metadata: null,
},
{
id: 'openrouter',
name: 'OpenRouter',
isConfigured: false,
metadata: null,
},
{
id: 'databricks',
name: 'Databricks',
isConfigured: false,
metadata: null,
},
{
id: 'ollama',
name: 'Ollama',
isConfigured: false,
metadata: { location: null },
},
{
id: 'gcp_vertex_ai',
name: 'GCP Vertex AI',
isConfigured: true,
metadata: { location: null },
},
];
import { useConfig } from '../../ConfigContext';
import { ProviderDetails } from '../../../api/types.gen';
export default function ProviderSettings({ onClose }: { onClose: () => void }) {
const { getProviders } = useConfig();
const [loading, setLoading] = useState(true);
const [providers, setProviders] = useState<ProviderDetails[]>([]);
// Load providers only once when component mounts
useEffect(() => {
let isMounted = true;
const loadProviders = async () => {
try {
// Force refresh to ensure we have the latest data
const result = await getProviders(true);
// Only update state if component is still mounted
if (isMounted && result) {
setProviders(result);
}
} catch (error) {
console.error('Failed to load providers:', error);
} finally {
if (isMounted) {
setLoading(false);
}
}
};
loadProviders();
// Cleanup function to prevent state updates on unmounted component
return () => {
isMounted = false;
};
}, []); // Empty dependency array ensures this only runs once
console.log(providers);
return (
<div className="h-screen w-full">
<div className="relative flex items-center h-[36px] w-full bg-bgSubtle"></div>
@@ -66,7 +50,7 @@ export default function ProviderSettings({ onClose }: { onClose: () => void }) {
<h1 className="text-3xl font-medium text-textStandard mt-1">Configure</h1>
</div>
<div className=" py-8 pt-[20px]">
<div className="py-8 pt-[20px]">
<div className="flex justify-between items-center mb-6 border-b border-borderSubtle px-8">
<h2 className="text-xl font-medium text-textStandard">Providers</h2>
</div>
@@ -74,7 +58,11 @@ export default function ProviderSettings({ onClose }: { onClose: () => void }) {
{/* Content Area */}
<div className="max-w-5xl pt-4 px-8">
<div className="relative z-10">
<ProviderGrid providers={fakeProviderState} isOnboarding={false} />
{loading ? (
<div>Loading providers...</div>
) : (
<ProviderGrid providers={providers} isOnboarding={false} />
)}
</div>
</div>
</div>

34
ui/desktop/src/components/settings_v2/providers/modal/ProviderConfiguationModal.tsx
View File

@@ -5,10 +5,18 @@ import DefaultProviderSetupForm from './subcomponents/forms/DefaultProviderSetup
import ProviderSetupActions from './subcomponents/ProviderSetupActions';
import ProviderLogo from './subcomponents/ProviderLogo';
import { useProviderModal } from './ProviderModalProvider';
import { toast } from 'react-toastify';
import { PROVIDER_REGISTRY } from '../ProviderRegistry';
import { SecureStorageNotice } from './subcomponents/SecureStorageNotice';
import DefaultSubmitHandler from './subcomponents/handlers/DefaultSubmitHandler';
import OllamaSubmitHandler from './subcomponents/handlers/OllamaSubmitHandler';
import OllamaForm from './subcomponents/forms/OllamaForm';
const customSubmitHandler = {
provider_name: OllamaSubmitHandler, // example
};
const customForms = {
provider_name: OllamaForm, // example
};
export default function ProviderConfigurationModal() {
const { isOpen, currentProvider, modalProps, closeModal } = useProviderModal();
@@ -32,23 +40,11 @@ export default function ProviderConfigurationModal() {
if (!isOpen || !currentProvider) return null;
const headerText = `Configure ${currentProvider.name}`;
const headerText = `Configure ${currentProvider.metadata.display_name}`;
const descriptionText = `Add your API key(s) for this provider to integrate into Goose`;
// Find the provider in the registry to get the details with customForm
const providerEntry = PROVIDER_REGISTRY.find((p) => p.name === currentProvider.name);
// Get the custom submit handler from the provider details
const customSubmitHandler = providerEntry?.details?.customSubmit;
// Use custom submit handler otherwise use default
const SubmitHandler = customSubmitHandler || DefaultSubmitHandler;
// Get the custom form component from the provider details
const CustomForm = providerEntry?.details?.customForm;
// Use custom form component if available, otherwise use default
const FormComponent = CustomForm || DefaultProviderSetupForm;
const SubmitHandler = customSubmitHandler[currentProvider.name] || DefaultSubmitHandler;
const FormComponent = customForms[currentProvider.name] || DefaultProviderSetupForm;
const handleSubmitForm = (e) => {
e.preventDefault();
@@ -74,7 +70,7 @@ export default function ProviderConfigurationModal() {
<Modal>
<div className="space-y-1">
{/* Logo area - centered above title */}
<ProviderLogo providerName={currentProvider.id} />
<ProviderLogo providerName={currentProvider.name} />
{/* Title and some information - centered */}
<ProviderSetupHeader title={headerText} body={descriptionText} />
</div>
@@ -87,7 +83,7 @@ export default function ProviderConfigurationModal() {
{...(modalProps.formProps || {})} // Spread any custom form props
/>
{providerEntry?.details?.parameters && providerEntry.details.parameters.length > 0 && (
{currentProvider.metadata.config_keys && currentProvider.metadata.config_keys.length > 0 && (
<SecureStorageNotice />
)}
<ProviderSetupActions onCancel={handleCancel} onSubmit={handleSubmitForm} />

45
ui/desktop/src/components/settings_v2/providers/modal/ProviderModalProvider.tsx
View File

@@ -1,55 +1,60 @@
import React, { createContext, useContext, useState } from 'react';
import ProviderState from '../interfaces/ProviderState';
import React, { createContext, useContext, useState, useMemo, useCallback } from 'react';
import { ProviderDetails } from '../../../../api';
interface ProviderModalContextType {
isOpen: boolean;
currentProvider: ProviderState | null;
currentProvider: ProviderDetails | null;
modalProps: any;
openModal: (provider: ProviderState, additionalProps: any) => void;
openModal: (provider: ProviderDetails, additionalProps: any) => void;
closeModal: () => void;
}
const ProviderModalContext = createContext({
const defaultContext: ProviderModalContextType = {
isOpen: false,
currentProvider: null,
modalProps: {},
openModal: (provider, additionalProps) => {},
openModal: () => {},
closeModal: () => {},
});
};
const ProviderModalContext = createContext<ProviderModalContextType>(defaultContext);
export const useProviderModal = () => useContext<ProviderModalContextType>(ProviderModalContext);
export const ProviderModalProvider = ({ children }) => {
export const ProviderModalProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
const [isOpen, setIsOpen] = useState(false);
const [currentProvider, setCurrentProvider] = useState(null);
const [currentProvider, setCurrentProvider] = useState<ProviderDetails | null>(null);
const [modalProps, setModalProps] = useState({});
const openModal = (provider, additionalProps = {}) => {
// Use useCallback to prevent function recreation on each render
const openModal = useCallback((provider: ProviderDetails, additionalProps = {}) => {
setCurrentProvider(provider);
setModalProps(additionalProps);
setIsOpen(true);
};
}, []);
const closeModal = () => {
const closeModal = useCallback(() => {
setIsOpen(false);
// Use a small timeout to prevent UI flicker
setTimeout(() => {
setCurrentProvider(null);
setModalProps({});
}, 200);
};
}, []);
return (
<ProviderModalContext.Provider
value={{
// Memoize the context value to prevent unnecessary re-renders
const contextValue = useMemo(
() => ({
isOpen,
currentProvider,
modalProps,
openModal,
closeModal,
}}
>
{children}
</ProviderModalContext.Provider>
}),
[isOpen, currentProvider, modalProps, openModal, closeModal]
);
return (
<ProviderModalContext.Provider value={contextValue}>{children}</ProviderModalContext.Provider>
);
};

6
ui/desktop/src/components/settings_v2/providers/modal/subcomponents/ProviderLogo.tsx
View File

@@ -20,7 +20,11 @@ const providerLogos = {
default: DefaultLogo,
};
export default function ProviderLogo({ providerName }) {
interface ProviderLogoProps {
providerName: string;
}
export default function ProviderLogo({ providerName }: ProviderLogoProps) {
// Convert provider name to lowercase and fetch the logo
const logoKey = providerName.toLowerCase();
const logo = providerLogos[logoKey] || DefaultLogo;

61
ui/desktop/src/components/settings_v2/providers/modal/subcomponents/forms/DefaultProviderSetupForm.tsx
View File

@@ -1,16 +1,29 @@
import React, { useEffect } from 'react';
import React, { useEffect, useMemo } from 'react';
import { Input } from '../../../../../ui/input';
import { PROVIDER_REGISTRY } from '../../../ProviderRegistry';
export default function DefaultProviderSetupForm({ configValues, setConfigValues, provider }) {
const providerEntry = PROVIDER_REGISTRY.find((p) => p.name === provider.name);
const parameters = providerEntry?.details?.parameters || [];
interface DefaultProviderSetupFormProps {
configValues: Record<string, any>;
setConfigValues: React.Dispatch<React.SetStateAction<Record<string, any>>>;
provider: any;
}
export default function DefaultProviderSetupForm({
configValues,
setConfigValues,
provider,
}: DefaultProviderSetupFormProps) {
const parameters = provider.metadata.config_keys || [];
// Initialize default values when the component mounts or provider changes
useEffect(() => {
const defaultValues = {};
parameters.forEach((parameter) => {
if (parameter.default !== undefined && !configValues[parameter.name]) {
if (
parameter.required &&
parameter.default !== undefined &&
parameter.default !== null &&
!configValues[parameter.name]
) {
defaultValues[parameter.name] = parameter.default;
}
});
@@ -24,12 +37,37 @@ export default function DefaultProviderSetupForm({ configValues, setConfigValues
}
}, [provider.name, parameters, setConfigValues, configValues]);
// Filter parameters to only show required ones
const requiredParameters = useMemo(() => {
return parameters.filter((param) => param.required === true);
}, [parameters]);
// Helper function to generate appropriate placeholder text
const getPlaceholder = (parameter) => {
// If default is defined and not null, show it
if (parameter.default !== undefined && parameter.default !== null) {
return `Default: ${parameter.default}`;
}
// Otherwise, use the parameter name as a hint
return parameter.name.toUpperCase();
};
return (
<div className="mt-4 space-y-4">
{parameters.map((parameter) => (
{requiredParameters.length === 0 ? (
<div className="text-center text-gray-500">
No required configuration for this provider.
</div>
) : (
requiredParameters.map((parameter) => (
<div key={parameter.name}>
<label className="block text-sm font-medium text-gray-700 mb-1">
{parameter.name}
<span className="text-red-500 ml-1">*</span>
</label>
<Input
type={parameter.is_secret ? 'password' : 'text'}
type={parameter.secret ? 'password' : 'text'}
value={configValues[parameter.name] || ''}
onChange={(e) =>
setConfigValues((prev) => ({
@@ -37,12 +75,13 @@ export default function DefaultProviderSetupForm({ configValues, setConfigValues
[parameter.name]: e.target.value,
}))
}
placeholder={parameter.name}
placeholder={getPlaceholder(parameter)}
className="w-full h-14 px-4 font-regular rounded-lg border shadow-none border-gray-300 bg-white text-lg placeholder:text-gray-400 font-regular text-gray-900"
required
required={true}
/>
</div>
))}
))
)}
</div>
);
}

30
ui/desktop/src/components/settings_v2/providers/subcomponents/CardHeader.tsx
View File

@@ -1,10 +1,6 @@
import React from 'react';
import { ExclamationButton, GreenCheckButton } from './buttons/CardButtons';
import {
ConfiguredProviderTooltipMessage,
OllamaNotConfiguredTooltipMessage,
ProviderDescription,
} from './utils/StringUtils';
import React, { memo } from 'react';
import { GreenCheckButton } from './buttons/CardButtons';
import { ConfiguredProviderTooltipMessage, ProviderDescription } from './utils/StringUtils';
interface CardHeaderProps {
name: string;
@@ -13,9 +9,10 @@ interface CardHeaderProps {
}
// Make CardTitle a proper React component
function CardTitle({ name }: { name: string }) {
const CardTitle = memo(({ name }: { name: string }) => {
return <h3 className="text-base font-medium text-textStandard truncate mr-2">{name}</h3>;
}
});
CardTitle.displayName = 'CardTitle';
// Properly type ProviderNameAndStatus props
interface ProviderNameAndStatusProps {
@@ -23,9 +20,8 @@ interface ProviderNameAndStatusProps {
isConfigured: boolean;
}
function ProviderNameAndStatus({ name, isConfigured }: ProviderNameAndStatusProps) {
console.log(`Provider Name: ${name}, Is Configured: ${isConfigured}`);
const ProviderNameAndStatus = memo(({ name, isConfigured }: ProviderNameAndStatusProps) => {
// Remove the console.log completely
return (
<div className="flex items-center justify-between w-full">
<CardTitle name={name} />
@@ -34,14 +30,18 @@ function ProviderNameAndStatus({ name, isConfigured }: ProviderNameAndStatusProp
{isConfigured && <GreenCheckButton tooltip={ConfiguredProviderTooltipMessage(name)} />}
</div>
);
}
});
ProviderNameAndStatus.displayName = 'ProviderNameAndStatus';
// Add a container div to the CardHeader
export default function CardHeader({ name, description, isConfigured }: CardHeaderProps) {
const CardHeader = memo(function CardHeader({ name, description, isConfigured }: CardHeaderProps) {
return (
<>
<ProviderNameAndStatus name={name} isConfigured={isConfigured} />
<ProviderDescription description={description} />
</>
);
}
});
CardHeader.displayName = 'CardHeader';
export default CardHeader;

74
ui/desktop/src/components/settings_v2/providers/subcomponents/ProviderCard.tsx
View File

@@ -1,74 +1,42 @@
import React from 'react';
import React, { memo, useMemo } from 'react';
import CardContainer from './CardContainer';
import CardHeader from './CardHeader';
import ProviderState from '../interfaces/ProviderState';
import CardBody from './CardBody';
import { PROVIDER_REGISTRY } from '../ProviderRegistry';
import DefaultCardButtons from './buttons/DefaultCardButtons';
import { ProviderDetails, ProviderMetadata } from '../../../../api';
type ProviderCardProps = {
provider: ProviderState;
provider: ProviderDetails;
onConfigure: () => void;
onLaunch: () => void;
isOnboarding: boolean;
};
// export function ProviderCard({ provider, buttonCallbacks, isOnboarding }: ProviderCardProps) {
// const providerEntry = PROVIDER_REGISTRY.find((p) => p.name === provider.name);
//
// // Add safety check
// if (!providerEntry) {
// console.error(`Provider ${provider.name} not found in registry`);
// return null;
// }
//
// const providerDetails = providerEntry.details;
// // Add another safety check
// if (!providerDetails) {
// console.error(`Provider ${provider.name} has no details`);
// return null;
// }
// console.log('provider details', providerDetails);
//
// try {
// const actions = providerDetails.getActions(provider, buttonCallbacks, isOnboarding);
//
// return (
// <CardContainer
// header={
// <CardHeader
// name={providerDetails.name}
// description={providerDetails.description}
// isConfigured={provider.isConfigured}
// />
// }
// body={<CardBody actions={actions} />}
// />
// );
// } catch (error) {
// console.error(`Error rendering provider card for ${provider.name}:`, error);
// return null;
// }
// }
export const ProviderCard = memo(function ProviderCard({
provider,
onConfigure,
onLaunch,
isOnboarding,
}: ProviderCardProps) {
// Safely access metadata with null checks
const providerMetadata: ProviderMetadata | null = provider?.metadata || null;
export function ProviderCard({ provider, onConfigure, onLaunch, isOnboarding }: ProviderCardProps) {
const providerEntry = PROVIDER_REGISTRY.find((p) => p.name === provider.name);
// Instead of useEffect for logging, use useMemo to memoize the metadata
const metadata = useMemo(() => providerMetadata, [provider]);
// Add safety check
if (!providerEntry?.details) {
console.error(`Provider ${provider.name} not found in registry or has no details`);
return null;
// Remove the logging completely
if (!metadata) {
return <div>ProviderCard error: No metadata provided</div>;
}
const providerDetails = providerEntry.details;
return (
<CardContainer
header={
<CardHeader
name={providerDetails.name}
description={providerDetails.description}
isConfigured={provider.isConfigured}
name={metadata.display_name || provider?.name || 'Unknown Provider'}
description={metadata.description || ''}
isConfigured={provider?.is_configured || false}
/>
}
body={
@@ -83,4 +51,4 @@ export function ProviderCard({ provider, onConfigure, onLaunch, isOnboarding }:
}
/>
);
}
});

14
ui/desktop/src/components/settings_v2/providers/subcomponents/buttons/DefaultCardButtons.tsx
View File

@@ -1,13 +1,13 @@
import React from 'react';
import { ConfigureSettingsButton, RocketButton } from './CardButtons';
import ProviderState from '@/src/components/settings_v2/providers/interfaces/ProviderState';
import { ProviderDetails } from '../../../../../api';
// can define other optional callbacks as needed
interface CardButtonsProps {
provider: ProviderState;
provider: ProviderDetails;
isOnboardingPage: boolean;
onConfigure: (provider: ProviderState) => void;
onLaunch: (provider: ProviderState) => void;
onConfigure: (provider: ProviderDetails) => void;
onLaunch: (provider: ProviderDetails) => void;
}
function getDefaultTooltipMessages(name: string, actionType: string) {
@@ -32,7 +32,7 @@ export default function DefaultCardButtons({
return (
<>
{/*Set up an unconfigured provider */}
{!provider.isConfigured && (
{!provider.is_configured && (
<ConfigureSettingsButton
tooltip={getDefaultTooltipMessages(provider.name, 'add')}
onClick={(e) => {
@@ -42,7 +42,7 @@ export default function DefaultCardButtons({
/>
)}
{/*show edit tooltip instead when hovering over button for configured providers*/}
{provider.isConfigured && !isOnboardingPage && (
{provider.is_configured && !isOnboardingPage && (
<ConfigureSettingsButton
tooltip={getDefaultTooltipMessages(provider.name, 'edit')}
onClick={(e) => {
@@ -52,7 +52,7 @@ export default function DefaultCardButtons({
/>
)}
{/*show Launch button for configured providers on onboarding page*/}
{provider.isConfigured && isOnboardingPage && (
{provider.is_configured && isOnboardingPage && (
<RocketButton
onClick={(e) => {
e.stopPropagation();

27
ui/desktop/src/utils.ts
View File

@@ -14,30 +14,5 @@ export function snakeToTitleCase(snake: string): string {
export function patchConsoleLogging() {
// Intercept console methods
const originalConsole = {
log: console.log,
error: console.error,
warn: console.warn,
info: console.info,
};
console.log = (...args: any[]) => {
window.electron.logInfo(`[LOG] ${args.join(' ')}`);
originalConsole.log(...args);
};
console.error = (...args: any[]) => {
window.electron.logInfo(`[ERROR] ${args.join(' ')}`);
originalConsole.error(...args);
};
console.warn = (...args: any[]) => {
window.electron.logInfo(`[WARN] ${args.join(' ')}`);
originalConsole.warn(...args);
};
console.info = (...args: any[]) => {
window.electron.logInfo(`[INFO] ${args.join(' ')}`);
originalConsole.info(...args);
};
return;
}