From ddd35f6d47f5b8e1cf7ad1dd3003fdce3c6ffca6 Mon Sep 17 00:00:00 2001 From: Douwe Osinga Date: Thu, 19 Feb 2026 18:30:05 +0000 Subject: [PATCH 01/21] feat: add local inference provider with llama.cpp backend and HuggingFace model management (#6933) Co-authored-by: Douwe Osinga Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> Co-authored-by: jh-block Co-authored-by: Spence Co-authored-by: Michael Neale --- Cargo.lock | 59 ++ crates/goose-cli/src/cli.rs | 205 +++++ crates/goose-server/src/openapi.rs | 20 +- crates/goose-server/src/routes/dictation.rs | 7 +- .../src/routes/local_inference.rs | 466 ++++++++++++ crates/goose-server/src/routes/mod.rs | 2 + crates/goose-server/src/routes/utils.rs | 5 + crates/goose-server/src/state.rs | 3 + crates/goose/Cargo.toml | 8 +- crates/goose/src/agents/extension_manager.rs | 18 +- crates/goose/src/dictation/mod.rs | 1 - .../src/{dictation => }/download_manager.rs | 48 +- crates/goose/src/lib.rs | 1 + crates/goose/src/prompt_template.rs | 8 + crates/goose/src/prompts/session_name.md | 6 + crates/goose/src/prompts/tiny_model_system.md | 22 + crates/goose/src/providers/base.rs | 94 ++- crates/goose/src/providers/init.rs | 2 + crates/goose/src/providers/local_inference.rs | 647 ++++++++++++++++ .../providers/local_inference/hf_models.rs | 486 ++++++++++++ .../inference_emulated_tools.rs | 685 +++++++++++++++++ .../local_inference/inference_engine.rs | 387 ++++++++++ .../local_inference/inference_native_tools.rs | 197 +++++ .../local_inference/local_model_registry.rs | 319 ++++++++ .../providers/local_inference/tool_parsing.rs | 601 +++++++++++++++ crates/goose/src/providers/mod.rs | 1 + crates/goose/src/providers/ollama.rs | 67 -- .../tests/local_inference_integration.rs | 128 ++++ ui/desktop/openapi.json | 700 ++++++++++++++++++ ui/desktop/src/api/index.ts | 4 +- ui/desktop/src/api/sdk.gen.ts | 34 +- ui/desktop/src/api/types.gen.ts | 314 ++++++++ ui/desktop/src/components/LocalModelSetup.tsx | 397 ++++++++++ .../src/components/McpApps/McpAppRenderer.tsx | 49 +- ui/desktop/src/components/ProviderGuard.tsx | 74 ++ .../src/components/settings/SettingsView.tsx | 19 +- .../settings/dictation/LocalModelManager.tsx | 25 +- .../localInference/HuggingFaceModelSearch.tsx | 358 +++++++++ .../localInference/LocalInferenceSection.tsx | 9 + .../localInference/LocalInferenceSettings.tsx | 410 ++++++++++ .../localInference/ModelSettingsPanel.tsx | 415 +++++++++++ .../settings/models/modelInterface.ts | 12 +- .../models/subcomponents/SwitchModelModal.tsx | 31 +- ui/desktop/src/utils/analytics.ts | 8 +- 44 files changed, 7171 insertions(+), 181 deletions(-) create mode 100644 crates/goose-server/src/routes/local_inference.rs rename crates/goose/src/{dictation => }/download_manager.rs (82%) create mode 100644 crates/goose/src/prompts/session_name.md create mode 100644 crates/goose/src/prompts/tiny_model_system.md create mode 100644 crates/goose/src/providers/local_inference.rs create mode 100644 crates/goose/src/providers/local_inference/hf_models.rs create mode 100644 crates/goose/src/providers/local_inference/inference_emulated_tools.rs create mode 100644 crates/goose/src/providers/local_inference/inference_engine.rs create mode 100644 crates/goose/src/providers/local_inference/inference_native_tools.rs create mode 100644 crates/goose/src/providers/local_inference/local_model_registry.rs create mode 100644 crates/goose/src/providers/local_inference/tool_parsing.rs create mode 100644 crates/goose/tests/local_inference_integration.rs create mode 100644 ui/desktop/src/components/LocalModelSetup.tsx create mode 100644 ui/desktop/src/components/settings/localInference/HuggingFaceModelSearch.tsx create mode 100644 ui/desktop/src/components/settings/localInference/LocalInferenceSection.tsx create mode 100644 ui/desktop/src/components/settings/localInference/LocalInferenceSettings.tsx create mode 100644 ui/desktop/src/components/settings/localInference/ModelSettingsPanel.tsx diff --git a/Cargo.lock b/Cargo.lock index 6e3ec2ba5a..c4252b9ea5 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3307,6 +3307,26 @@ dependencies = [ "syn 2.0.114", ] +[[package]] +name = "enumflags2" +version = "0.7.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1027f7680c853e056ebcec683615fb6fbbc07dbaa13b4d5d9442b146ded4ecef" +dependencies = [ + "enumflags2_derive", +] + +[[package]] +name = "enumflags2_derive" +version = "0.7.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67c78a4d8fdf9953a5c9d458f9efe940fd97a0cab0941c075a813ac594733827" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.114", +] + [[package]] name = "env-lock" version = "1.0.2" @@ -3533,6 +3553,15 @@ version = "0.1.9" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582" +[[package]] +name = "find_cuda_helper" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9f9e65c593dd01ac77daad909ea4ad17f0d6d1776193fc8ea766356177abdad" +dependencies = [ + "glob", +] + [[package]] name = "fixedbitset" version = "0.5.7" @@ -4224,6 +4253,7 @@ dependencies = [ "dashmap 6.1.0", "dirs 5.0.1", "dotenvy", + "encoding_rs", "env-lock", "etcetera 0.11.0", "fs2", @@ -4240,6 +4270,7 @@ dependencies = [ "jsonwebtoken", "keyring", "lazy_static", + "llama-cpp-2", "lru", "minijinja", "mockall", @@ -5702,6 +5733,34 @@ version = "1.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "11d3d7f243d5c5a8b9bb5d6dd2b1602c0cb0b9db1621bafc7ed66e35ff9fe092" +[[package]] +name = "llama-cpp-2" +version = "0.1.133" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "888c8805527f4c35ec16f26003d54a318cde1629e7439da8e9ef2d6d3883e106" +dependencies = [ + "encoding_rs", + "enumflags2", + "llama-cpp-sys-2", + "thiserror 1.0.69", + "tracing", + "tracing-core", +] + +[[package]] +name = "llama-cpp-sys-2" +version = "0.1.133" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a180dfa6d6f9d1df1e031bcdf0464bbad4f9b326395bfd28f2fa539d8cbc9c2b" +dependencies = [ + "bindgen", + "cc", + "cmake", + "find_cuda_helper", + "glob", + "walkdir", +] + [[package]] name = "lock_api" version = "0.4.14" diff --git a/crates/goose-cli/src/cli.rs b/crates/goose-cli/src/cli.rs index 4ac9eb2cab..26487713ae 100644 --- a/crates/goose-cli/src/cli.rs +++ b/crates/goose-cli/src/cli.rs @@ -854,6 +854,13 @@ enum Command { #[command(subcommand)] command: TermCommand, }, + /// Manage local inference models + #[command(about = "Manage local inference models", visible_alias = "lm")] + LocalModels { + #[command(subcommand)] + command: LocalModelsCommand, + }, + /// Generate completions for various shells #[command(about = "Generate the autocompletion script for the specified shell")] Completion { @@ -875,6 +882,38 @@ enum Command { }, } +#[derive(Subcommand)] +enum LocalModelsCommand { + /// Search HuggingFace for GGUF models + #[command(about = "Search HuggingFace for GGUF models")] + Search { + /// Search query + query: String, + + /// Maximum number of results + #[arg(short, long, default_value = "10")] + limit: usize, + }, + + /// Download a model from HuggingFace + #[command(about = "Download a GGUF model (e.g. bartowski/Llama-3.2-1B-Instruct-GGUF:Q4_K_M)")] + Download { + /// Model spec in user/repo:quantization format + spec: String, + }, + + /// List downloaded local models + #[command(about = "List downloaded local models")] + List, + + /// Delete a downloaded model + #[command(about = "Delete a downloaded local model")] + Delete { + /// Model ID to delete + id: String, + }, +} + #[derive(Subcommand)] enum TermCommand { /// Print shell initialization script @@ -964,6 +1003,7 @@ fn get_command_name(command: &Option) -> &'static str { Some(Command::Recipe { .. }) => "recipe", Some(Command::Web { .. }) => "web", Some(Command::Term { .. }) => "term", + Some(Command::LocalModels { .. }) => "local-models", Some(Command::Completion { .. }) => "completion", Some(Command::ValidateExtensions { .. }) => "validate-extensions", None => "default_session", @@ -1400,6 +1440,170 @@ async fn handle_term_subcommand(command: TermCommand) -> Result<()> { } } +async fn handle_local_models_command(command: LocalModelsCommand) -> Result<()> { + use goose::providers::local_inference::hf_models; + use goose::providers::local_inference::local_model_registry::{ + display_name_from_repo, get_registry, model_id_from_repo, LocalModelEntry, + }; + + match command { + LocalModelsCommand::Search { query, limit } => { + println!("Searching HuggingFace for '{}'...", query); + let results = hf_models::search_gguf_models(&query, limit).await?; + + if results.is_empty() { + println!("No GGUF models found."); + return Ok(()); + } + + for model in &results { + println!( + "\n{} (by {}) — {} downloads", + model.model_name, model.author, model.downloads + ); + for file in &model.gguf_files { + let size = if file.size_bytes > 0 { + format!( + "{:.1}GB", + file.size_bytes as f64 / (1024.0 * 1024.0 * 1024.0) + ) + } else { + "unknown".to_string() + }; + println!(" {} — {}", file.quantization, size); + } + println!( + " Download: goose local-models download {}:", + model.repo_id + ); + } + } + LocalModelsCommand::Download { spec } => { + println!("Resolving {}...", spec); + let (repo_id, file) = hf_models::resolve_model_spec(&spec).await?; + let model_id = model_id_from_repo(&repo_id, &file.quantization); + let display_name = display_name_from_repo(&repo_id, &file.quantization); + let local_path = + goose::config::paths::Paths::in_data_dir("models").join(&file.filename); + + println!( + "Downloading {} ({})...", + display_name, + if file.size_bytes > 0 { + format!( + "{:.1}GB", + file.size_bytes as f64 / (1024.0 * 1024.0 * 1024.0) + ) + } else { + "unknown size".to_string() + } + ); + + // Register + let entry = LocalModelEntry { + id: model_id.clone(), + display_name: display_name.clone(), + repo_id: repo_id.clone(), + filename: file.filename.clone(), + quantization: file.quantization.clone(), + local_path: local_path.clone(), + source_url: file.download_url.clone(), + settings: Default::default(), + size_bytes: file.size_bytes, + }; + + { + let mut registry = get_registry() + .lock() + .map_err(|_| anyhow::anyhow!("Failed to acquire registry lock"))?; + registry.add_model(entry)?; + } + + // Download + let manager = goose::download_manager::get_download_manager(); + manager + .download_model( + format!("{}-model", model_id), + file.download_url, + local_path, + None, + ) + .await?; + + // Poll progress + loop { + if let Some(progress) = manager.get_progress(&format!("{}-model", model_id)) { + match progress.status { + goose::download_manager::DownloadStatus::Downloading => { + print!( + "\r {:.1}% ({:.0}MB / {:.0}MB)", + progress.progress_percent, + progress.bytes_downloaded as f64 / (1024.0 * 1024.0), + progress.total_bytes as f64 / (1024.0 * 1024.0), + ); + use std::io::Write; + std::io::stdout().flush().ok(); + } + goose::download_manager::DownloadStatus::Completed => { + println!("\nDownloaded: {} (id: {})", display_name, model_id); + break; + } + goose::download_manager::DownloadStatus::Failed => { + let err = progress.error.unwrap_or_default(); + anyhow::bail!("Download failed: {}", err); + } + goose::download_manager::DownloadStatus::Cancelled => { + println!("\nDownload cancelled."); + break; + } + } + } + tokio::time::sleep(std::time::Duration::from_millis(500)).await; + } + } + LocalModelsCommand::List => { + let registry = get_registry() + .lock() + .map_err(|_| anyhow::anyhow!("Failed to acquire registry lock"))?; + let models = registry.list_models(); + + if models.is_empty() { + println!("No local models downloaded."); + return Ok(()); + } + + println!("{:<40} {:<20} {:<10} Downloaded", "ID", "Name", "Quant"); + println!("{}", "-".repeat(80)); + for m in models { + println!( + "{:<40} {:<20} {:<10} {}", + m.id, + m.display_name, + m.quantization, + if m.is_downloaded() { "✓" } else { "✗" } + ); + } + } + LocalModelsCommand::Delete { id } => { + let mut registry = get_registry() + .lock() + .map_err(|_| anyhow::anyhow!("Failed to acquire registry lock"))?; + + if let Some(entry) = registry.get_model(&id) { + if entry.local_path.exists() { + std::fs::remove_file(&entry.local_path)?; + } + registry.remove_model(&id)?; + println!("Deleted model: {}", id); + } else { + println!("Model not found: {}", id); + } + } + } + + Ok(()) +} + async fn handle_default_session() -> Result<()> { if !Config::global().exists() { return handle_configure().await; @@ -1530,6 +1734,7 @@ pub async fn cli() -> anyhow::Result<()> { no_auth, }) => crate::commands::web::handle_web(port, host, open, auth_token, no_auth).await, Some(Command::Term { command }) => handle_term_subcommand(command).await, + Some(Command::LocalModels { command }) => handle_local_models_command(command).await, Some(Command::ValidateExtensions { file }) => { use goose::agents::validate_extensions::validate_bundled_extensions; match validate_bundled_extensions(&file) { diff --git a/crates/goose-server/src/openapi.rs b/crates/goose-server/src/openapi.rs index f33db83520..e128289bad 100644 --- a/crates/goose-server/src/openapi.rs +++ b/crates/goose-server/src/openapi.rs @@ -4,7 +4,7 @@ use goose::agents::ExtensionConfig; use goose::config::permission::PermissionLevel; use goose::config::ExtensionEntry; use goose::conversation::Conversation; -use goose::dictation::download_manager::{DownloadProgress, DownloadStatus}; +use goose::download_manager::{DownloadProgress, DownloadStatus}; use goose::model::ModelConfig; use goose::permission::permission_confirmation::{Permission, PrincipalType}; use goose::providers::base::{ConfigKey, ModelInfo, ProviderMetadata, ProviderType}; @@ -424,6 +424,15 @@ derive_utoipa!(Icon as IconSchema); super::routes::dictation::get_download_progress, super::routes::dictation::cancel_download, super::routes::dictation::delete_model, + super::routes::local_inference::list_local_models, + super::routes::local_inference::search_hf_models, + super::routes::local_inference::get_repo_files, + super::routes::local_inference::download_hf_model, + super::routes::local_inference::get_local_model_download_progress, + super::routes::local_inference::cancel_local_model_download, + super::routes::local_inference::delete_local_model, + super::routes::local_inference::get_model_settings, + super::routes::local_inference::update_model_settings, ), components(schemas( super::routes::config_management::UpsertConfigQuery, @@ -592,6 +601,15 @@ derive_utoipa!(Icon as IconSchema); goose::dictation::providers::DictationProvider, super::routes::dictation::DictationProviderStatus, super::routes::dictation::WhisperModelResponse, + super::routes::local_inference::LocalModelResponse, + super::routes::local_inference::ModelDownloadStatus, + super::routes::local_inference::DownloadModelRequest, + goose::providers::local_inference::hf_models::HfModelInfo, + goose::providers::local_inference::hf_models::HfGgufFile, + goose::providers::local_inference::hf_models::HfQuantVariant, + super::routes::local_inference::RepoVariantsResponse, + goose::providers::local_inference::local_model_registry::ModelSettings, + goose::providers::local_inference::local_model_registry::SamplingConfig, DownloadProgress, DownloadStatus, )) diff --git a/crates/goose-server/src/routes/dictation.rs b/crates/goose-server/src/routes/dictation.rs index fb1c97aa71..8530d2b1c7 100644 --- a/crates/goose-server/src/routes/dictation.rs +++ b/crates/goose-server/src/routes/dictation.rs @@ -7,11 +7,11 @@ use axum::{ Json, Router, }; use base64::{engine::general_purpose::STANDARD as BASE64, Engine}; -use goose::dictation::download_manager::{get_download_manager, DownloadProgress}; use goose::dictation::providers::{ is_configured, transcribe_local, transcribe_with_provider, DictationProvider, PROVIDERS, }; use goose::dictation::whisper; +use goose::download_manager::{get_download_manager, DownloadProgress}; use serde::{Deserialize, Serialize}; use std::collections::HashMap; use std::sync::Arc; @@ -257,11 +257,16 @@ pub async fn download_model(Path(model_id): Path) -> Result, + }, + Downloaded, +} + +#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)] +pub struct LocalModelResponse { + pub id: String, + pub display_name: String, + pub repo_id: String, + pub filename: String, + pub quantization: String, + pub size_bytes: u64, + pub status: ModelDownloadStatus, + pub recommended: bool, + pub settings: ModelSettings, +} + +async fn ensure_featured_models_in_registry() -> Result<(), ErrorResponse> { + let mut entries_to_add = Vec::new(); + + for spec in FEATURED_MODELS { + let (repo_id, quantization) = match hf_models::parse_model_spec(spec) { + Ok(parts) => parts, + Err(_) => continue, + }; + + let model_id = model_id_from_repo(&repo_id, &quantization); + + { + let registry = get_registry() + .lock() + .map_err(|_| ErrorResponse::internal("Failed to acquire registry lock"))?; + if registry.has_model(&model_id) { + continue; + } + } + + let hf_file = match resolve_model_spec(spec).await { + Ok((_repo, file)) => file, + Err(_) => { + let filename = format!( + "{}-{}.gguf", + repo_id.split('/').next_back().unwrap_or("model"), + quantization + ); + HfGgufFile { + filename: filename.clone(), + size_bytes: 0, + quantization: quantization.to_string(), + download_url: format!( + "https://huggingface.co/{}/resolve/main/{}", + repo_id, filename + ), + } + } + }; + + let local_path = Paths::in_data_dir("models").join(&hf_file.filename); + + entries_to_add.push(LocalModelEntry { + id: model_id, + display_name: display_name_from_repo(&repo_id, &quantization), + repo_id, + filename: hf_file.filename, + quantization, + local_path, + source_url: hf_file.download_url, + settings: ModelSettings::default(), + size_bytes: hf_file.size_bytes, + }); + } + + if !entries_to_add.is_empty() { + let mut registry = get_registry() + .lock() + .map_err(|_| ErrorResponse::internal("Failed to acquire registry lock"))?; + registry.sync_with_featured(entries_to_add); + } + + Ok(()) +} + +#[utoipa::path( + get, + path = "/local-inference/models", + responses( + (status = 200, description = "List of available local LLM models", body = Vec) + ) +)] +pub async fn list_local_models( + axum::extract::State(state): axum::extract::State>, +) -> Result>, ErrorResponse> { + ensure_featured_models_in_registry().await?; + + let recommended_id = recommend_local_model(&state.inference_runtime); + + let registry = get_registry() + .lock() + .map_err(|_| ErrorResponse::internal("Failed to acquire registry lock"))?; + + let mut models: Vec = Vec::new(); + + for entry in registry.list_models() { + let goose_status = entry.download_status(); + + let status = match goose_status { + RegistryDownloadStatus::NotDownloaded => ModelDownloadStatus::NotDownloaded, + RegistryDownloadStatus::Downloading { + progress_percent, + bytes_downloaded, + total_bytes, + speed_bps, + } => ModelDownloadStatus::Downloading { + progress_percent, + bytes_downloaded, + total_bytes, + speed_bps: Some(speed_bps), + }, + RegistryDownloadStatus::Downloaded => ModelDownloadStatus::Downloaded, + }; + + let size_bytes = entry.file_size(); + + models.push(LocalModelResponse { + id: entry.id.clone(), + display_name: entry.display_name.clone(), + repo_id: entry.repo_id.clone(), + filename: entry.filename.clone(), + quantization: entry.quantization.clone(), + size_bytes, + status, + recommended: recommended_id == entry.id, + settings: entry.settings.clone(), + }); + } + + models.sort_by(|a, b| { + let a_downloaded = matches!(a.status, ModelDownloadStatus::Downloaded); + let b_downloaded = matches!(b.status, ModelDownloadStatus::Downloaded); + match (b_downloaded, a_downloaded) { + (true, false) => std::cmp::Ordering::Greater, + (false, true) => std::cmp::Ordering::Less, + _ => a.display_name.cmp(&b.display_name), + } + }); + + Ok(Json(models)) +} + +#[derive(Debug, Deserialize)] +pub struct SearchQuery { + pub q: String, + pub limit: Option, +} + +#[derive(Debug, Serialize, ToSchema)] +pub struct RepoVariantsResponse { + pub variants: Vec, + pub recommended_index: Option, +} + +#[utoipa::path( + get, + path = "/local-inference/search", + params( + ("q" = String, Query, description = "Search query"), + ("limit" = Option, Query, description = "Max results") + ), + responses( + (status = 200, description = "Search results", body = Vec), + (status = 500, description = "Search failed") + ) +)] +pub async fn search_hf_models( + Query(params): Query, +) -> Result>, ErrorResponse> { + let limit = params.limit.unwrap_or(20).min(50); + let results = hf_models::search_gguf_models(¶ms.q, limit) + .await + .map_err(|e| ErrorResponse::internal(format!("Search failed: {}", e)))?; + Ok(Json(results)) +} + +#[utoipa::path( + get, + path = "/local-inference/repo/{author}/{repo}/files", + responses( + (status = 200, description = "GGUF files in the repo", body = RepoVariantsResponse) + ) +)] +pub async fn get_repo_files( + axum::extract::State(state): axum::extract::State>, + Path((author, repo)): Path<(String, String)>, +) -> Result, ErrorResponse> { + let repo_id = format!("{}/{}", author, repo); + let variants = hf_models::get_repo_gguf_variants(&repo_id) + .await + .map_err(|e| ErrorResponse::internal(format!("Failed to fetch repo files: {}", e)))?; + + let available_memory = available_inference_memory_bytes(&state.inference_runtime); + let recommended_index = hf_models::recommend_variant(&variants, available_memory); + + Ok(Json(RepoVariantsResponse { + variants, + recommended_index, + })) +} + +#[derive(Debug, Deserialize, ToSchema)] +pub struct DownloadModelRequest { + /// Model spec like "bartowski/Llama-3.2-3B-Instruct-GGUF:Q4_K_M" + pub spec: String, +} + +#[utoipa::path( + post, + path = "/local-inference/download", + request_body = DownloadModelRequest, + responses( + (status = 202, description = "Download started", body = String), + (status = 400, description = "Invalid request") + ) +)] +pub async fn download_hf_model( + Json(req): Json, +) -> Result<(StatusCode, Json), ErrorResponse> { + let (repo_id, quantization) = hf_models::parse_model_spec(&req.spec) + .map_err(|e| ErrorResponse::bad_request(format!("Invalid spec format: {e}")))?; + + let (_repo, hf_file) = resolve_model_spec(&req.spec) + .await + .map_err(|e| ErrorResponse::bad_request(format!("Invalid spec: {}", e)))?; + + let model_id = model_id_from_repo(&repo_id, &quantization); + let local_path = Paths::in_data_dir("models").join(&hf_file.filename); + let download_url = hf_file.download_url.clone(); + + let entry = LocalModelEntry { + id: model_id.clone(), + display_name: display_name_from_repo(&repo_id, &quantization), + repo_id, + filename: hf_file.filename, + quantization, + local_path: local_path.clone(), + source_url: download_url.clone(), + settings: ModelSettings::default(), + size_bytes: hf_file.size_bytes, + }; + + { + let mut registry = get_registry() + .lock() + .map_err(|_| ErrorResponse::internal("Failed to acquire registry lock"))?; + registry + .add_model(entry) + .map_err(|e| ErrorResponse::internal(format!("{}", e)))?; + } + + let dm = get_download_manager(); + dm.download_model( + format!("{}-model", model_id), + download_url, + local_path, + None, + ) + .await + .map_err(|e| ErrorResponse::internal(format!("Download failed: {}", e)))?; + + Ok((StatusCode::ACCEPTED, Json(model_id))) +} + +#[utoipa::path( + get, + path = "/local-inference/models/{model_id}/download", + responses( + (status = 200, description = "Download progress", body = DownloadProgress), + (status = 404, description = "No active download") + ) +)] +pub async fn get_local_model_download_progress( + Path(model_id): Path, +) -> Result, ErrorResponse> { + let download_id = format!("{}-model", model_id); + debug!(model_id = %model_id, download_id = %download_id, "Getting download progress"); + + let manager = get_download_manager(); + + let model_progress = manager + .get_progress(&download_id) + .ok_or_else(|| ErrorResponse::not_found("No active download"))?; + + Ok(Json(model_progress)) +} + +#[utoipa::path( + delete, + path = "/local-inference/models/{model_id}/download", + responses( + (status = 200, description = "Download cancelled"), + (status = 404, description = "No active download") + ) +)] +pub async fn cancel_local_model_download( + Path(model_id): Path, +) -> Result { + let manager = get_download_manager(); + manager + .cancel_download(&format!("{}-model", model_id)) + .map_err(|e| ErrorResponse::internal(format!("{}", e)))?; + + Ok(StatusCode::OK) +} + +#[utoipa::path( + delete, + path = "/local-inference/models/{model_id}", + responses( + (status = 200, description = "Model deleted"), + (status = 404, description = "Model not found") + ) +)] +pub async fn delete_local_model(Path(model_id): Path) -> Result { + let local_path = { + let registry = get_registry() + .lock() + .map_err(|_| ErrorResponse::internal("Failed to acquire registry lock"))?; + let entry = registry + .get_model(&model_id) + .ok_or_else(|| ErrorResponse::not_found("Model not found"))?; + entry.local_path.clone() + }; + + if local_path.exists() { + tokio::fs::remove_file(&local_path) + .await + .map_err(|e| ErrorResponse::internal(format!("Failed to delete: {}", e)))?; + } + + // Only remove non-featured models from registry (featured ones stay as placeholders) + if !is_featured_model(&model_id) { + let mut registry = get_registry() + .lock() + .map_err(|_| ErrorResponse::internal("Failed to acquire registry lock"))?; + registry + .remove_model(&model_id) + .map_err(|e| ErrorResponse::internal(format!("{}", e)))?; + } + + Ok(StatusCode::OK) +} + +#[utoipa::path( + get, + path = "/local-inference/models/{model_id}/settings", + responses( + (status = 200, description = "Model settings", body = ModelSettings), + (status = 404, description = "Model not found") + ) +)] +pub async fn get_model_settings( + Path(model_id): Path, +) -> Result, ErrorResponse> { + let registry = get_registry() + .lock() + .map_err(|_| ErrorResponse::internal("Failed to acquire registry lock"))?; + + if let Some(settings) = registry.get_model_settings(&model_id) { + return Ok(Json(settings.clone())); + } + + Err(ErrorResponse::not_found("Model not found")) +} + +#[utoipa::path( + put, + path = "/local-inference/models/{model_id}/settings", + request_body = ModelSettings, + responses( + (status = 200, description = "Settings updated", body = ModelSettings), + (status = 404, description = "Model not found"), + (status = 500, description = "Failed to save settings") + ) +)] +pub async fn update_model_settings( + Path(model_id): Path, + Json(settings): Json, +) -> Result, ErrorResponse> { + let mut registry = get_registry() + .lock() + .map_err(|_| ErrorResponse::internal("Failed to acquire registry lock"))?; + + registry + .update_model_settings(&model_id, settings.clone()) + .map_err(|e| ErrorResponse::not_found(format!("{}", e)))?; + + Ok(Json(settings)) +} + +pub fn routes(state: Arc) -> Router { + goose::download_manager::cleanup_partial_downloads(&Paths::in_data_dir("models")); + + Router::new() + .route("/local-inference/models", get(list_local_models)) + .route("/local-inference/search", get(search_hf_models)) + .route( + "/local-inference/repo/{author}/{repo}/files", + get(get_repo_files), + ) + .route("/local-inference/download", post(download_hf_model)) + .route( + "/local-inference/models/{model_id}/download", + get(get_local_model_download_progress), + ) + .route( + "/local-inference/models/{model_id}/download", + delete(cancel_local_model_download), + ) + .route( + "/local-inference/models/{model_id}", + delete(delete_local_model), + ) + .route( + "/local-inference/models/{model_id}/settings", + get(get_model_settings), + ) + .route( + "/local-inference/models/{model_id}/settings", + axum::routing::put(update_model_settings), + ) + .with_state(state) +} diff --git a/crates/goose-server/src/routes/mod.rs b/crates/goose-server/src/routes/mod.rs index 9eb00449f1..cbb956849b 100644 --- a/crates/goose-server/src/routes/mod.rs +++ b/crates/goose-server/src/routes/mod.rs @@ -3,6 +3,7 @@ pub mod agent; pub mod config_management; pub mod dictation; pub mod errors; +pub mod local_inference; pub mod mcp_app_proxy; pub mod mcp_ui_proxy; pub mod prompts; @@ -30,6 +31,7 @@ pub fn configure(state: Arc, secret_key: String) -> Rout .merge(action_required::routes(state.clone())) .merge(agent::routes(state.clone())) .merge(dictation::routes(state.clone())) + .merge(local_inference::routes(state.clone())) .merge(config_management::routes(state.clone())) .merge(prompts::routes()) .merge(recipe::routes(state.clone())) diff --git a/crates/goose-server/src/routes/utils.rs b/crates/goose-server/src/routes/utils.rs index 713280b14a..1e97a0271d 100644 --- a/crates/goose-server/src/routes/utils.rs +++ b/crates/goose-server/src/routes/utils.rs @@ -94,6 +94,11 @@ pub fn inspect_keys( pub fn check_provider_configured(metadata: &ProviderMetadata, provider_type: ProviderType) -> bool { let config = Config::global(); + // Special override + if metadata.name == "local" { + return true; + } + if provider_type == ProviderType::Custom || provider_type == ProviderType::Declarative { if let Ok(loaded_provider) = load_provider(metadata.name.as_str()) { if !loaded_provider.config.requires_auth { diff --git a/crates/goose-server/src/state.rs b/crates/goose-server/src/state.rs index 57f104d47e..4cf836d42d 100644 --- a/crates/goose-server/src/state.rs +++ b/crates/goose-server/src/state.rs @@ -14,6 +14,7 @@ use tokio::task::JoinHandle; use crate::tunnel::TunnelManager; use goose::agents::ExtensionLoadResult; +use goose::providers::local_inference::InferenceRuntime; type ExtensionLoadingTasks = Arc>>>>>>>; @@ -26,6 +27,7 @@ pub struct AppState { recipe_session_tracker: Arc>>, pub tunnel_manager: Arc, pub extension_loading_tasks: ExtensionLoadingTasks, + pub inference_runtime: Arc, } fn spawn_developer(r: tokio::io::DuplexStream, w: tokio::io::DuplexStream) { @@ -57,6 +59,7 @@ impl AppState { recipe_session_tracker: Arc::new(Mutex::new(HashSet::new())), tunnel_manager, extension_loading_tasks: Arc::new(Mutex::new(HashMap::new())), + inference_runtime: InferenceRuntime::get_or_init(), })) } diff --git a/crates/goose/Cargo.toml b/crates/goose/Cargo.toml index ded774e989..a0de55ef8f 100644 --- a/crates/goose/Cargo.toml +++ b/crates/goose/Cargo.toml @@ -9,7 +9,7 @@ description.workspace = true [features] default = [] -cuda = ["candle-core/cuda", "candle-nn/cuda"] +cuda = ["candle-core/cuda", "candle-nn/cuda", "llama-cpp-2/cuda"] [lints] workspace = true @@ -126,14 +126,17 @@ ignore = { workspace = true } which = { workspace = true } pctx_code_mode = "^0.2.3" unbinder = "0.1.7" +llama-cpp-2 = { version = "0.1.133", features = ["sampler"] } +encoding_rs = "0.8.35" [target.'cfg(target_os = "windows")'.dependencies] winapi = { version = "0.3", features = ["wincred"] } -# Platform-specific GPU acceleration for Whisper +# Platform-specific GPU acceleration for Whisper and local inference [target.'cfg(target_os = "macos")'.dependencies] candle-core = { version = "0.9", default-features = false, features = ["metal"] } candle-nn = { version = "0.9", default-features = false, features = ["metal"] } +llama-cpp-2 = { version = "0.1.133", features = ["sampler", "metal"] } [dev-dependencies] serial_test = { workspace = true } @@ -156,6 +159,7 @@ path = "examples/agent.rs" name = "databricks_oauth" path = "examples/databricks_oauth.rs" + [[bin]] name = "build_canonical_models" path = "src/providers/canonical/build_canonical_models.rs" diff --git a/crates/goose/src/agents/extension_manager.rs b/crates/goose/src/agents/extension_manager.rs index d77668cf4d..51981780f8 100644 --- a/crates/goose/src/agents/extension_manager.rs +++ b/crates/goose/src/agents/extension_manager.rs @@ -236,7 +236,12 @@ async fn child_process_client( command.env("PATH", path); } - if let Some(dir) = working_dir { + // Use explicitly passed working_dir, falling back to GOOSE_WORKING_DIR env var + let effective_working_dir = working_dir + .map(|p| p.to_path_buf()) + .or_else(|| std::env::var("GOOSE_WORKING_DIR").ok().map(PathBuf::from)); + + if let Some(ref dir) = effective_working_dir { if dir.exists() && dir.is_dir() { tracing::info!("Setting MCP process working directory: {:?}", dir); command.current_dir(dir); @@ -710,6 +715,7 @@ impl ExtensionManager { })?; let mut context = self.context.clone(); context.extension_manager = Some(Arc::downgrade(self)); + (def.client_factory)(context) } ExtensionConfig::InlinePython { @@ -1584,6 +1590,16 @@ impl ExtensionManager { session_id: &str, working_dir: &std::path::Path, ) -> Option { + // Skip MOIM for models with small context windows to avoid consuming limited context + const MIN_CONTEXT_FOR_MOIM: usize = 32_000; + if let Ok(provider_guard) = self.provider.try_lock() { + if let Some(provider) = provider_guard.as_ref() { + if provider.get_model_config().context_limit() < MIN_CONTEXT_FOR_MOIM { + return None; + } + } + } + // Use minute-level granularity to prevent conversation changes every second let timestamp = chrono::Local::now().format("%Y-%m-%d %H:%M:00").to_string(); let mut content = format!( diff --git a/crates/goose/src/dictation/mod.rs b/crates/goose/src/dictation/mod.rs index 9cef90aa8c..d14fb21642 100644 --- a/crates/goose/src/dictation/mod.rs +++ b/crates/goose/src/dictation/mod.rs @@ -1,3 +1,2 @@ -pub mod download_manager; pub mod providers; pub mod whisper; diff --git a/crates/goose/src/dictation/download_manager.rs b/crates/goose/src/download_manager.rs similarity index 82% rename from crates/goose/src/dictation/download_manager.rs rename to crates/goose/src/download_manager.rs index 8342ab5cc2..6fc4718cbc 100644 --- a/crates/goose/src/dictation/download_manager.rs +++ b/crates/goose/src/download_manager.rs @@ -1,12 +1,33 @@ -use crate::dictation::whisper::LOCAL_WHISPER_MODEL_CONFIG_KEY; use anyhow::Result; use serde::{Deserialize, Serialize}; use std::collections::HashMap; -use std::path::PathBuf; +use std::path::{Path, PathBuf}; use std::sync::{Arc, Mutex}; use tokio::io::AsyncWriteExt; +use tracing::info; use utoipa::ToSchema; +fn partial_path_for(destination: &Path) -> PathBuf { + destination.with_extension( + destination + .extension() + .map(|e| format!("{}.part", e.to_string_lossy())) + .unwrap_or_else(|| "part".to_string()), + ) +} + +/// Remove any leftover `.part` files in the given directory. +pub fn cleanup_partial_downloads(dir: &Path) { + if let Ok(entries) = std::fs::read_dir(dir) { + for entry in entries.flatten() { + let path = entry.path(); + if path.extension().is_some_and(|e| e == "part") { + let _ = std::fs::remove_file(&path); + } + } + } +} + #[derive(Debug, Clone, Serialize, Deserialize, ToSchema)] pub struct DownloadProgress { /// Model ID being downloaded @@ -78,8 +99,9 @@ impl DownloadManager { model_id: String, url: String, destination: PathBuf, + on_complete: Option>, ) -> Result<()> { - // Initialize progress + info!(model_id = %model_id, url = %url, destination = ?destination, "Starting model download"); { let mut downloads = self .downloads @@ -115,10 +137,13 @@ impl DownloadManager { let downloads = self.downloads.clone(); let model_id_clone = model_id.clone(); + let destination_for_cleanup = destination.clone(); + // Download in background task tokio::spawn(async move { match Self::download_file(&url, &destination, &downloads, &model_id_clone).await { Ok(_) => { + info!(model_id = %model_id_clone, "Download completed successfully"); if let Ok(mut downloads) = downloads.lock() { if let Some(progress) = downloads.get_mut(&model_id_clone) { progress.status = DownloadStatus::Completed; @@ -126,10 +151,15 @@ impl DownloadManager { } } - let _ = crate::config::Config::global() - .set_param(LOCAL_WHISPER_MODEL_CONFIG_KEY, model_id_clone.clone()); + if let Some(callback) = on_complete { + callback(); + } } Err(e) => { + // Clean up partial file on failure + let partial = partial_path_for(&destination_for_cleanup); + let _ = tokio::fs::remove_file(&partial).await; + if let Ok(mut downloads) = downloads.lock() { if let Some(progress) = downloads.get_mut(&model_id_clone) { progress.status = DownloadStatus::Failed; @@ -166,7 +196,8 @@ impl DownloadManager { } } - let mut file = tokio::fs::File::create(destination).await?; + let partial_path = partial_path_for(destination); + let mut file = tokio::fs::File::create(&partial_path).await?; let mut bytes_downloaded = 0u64; let start_time = std::time::Instant::now(); @@ -185,8 +216,7 @@ impl DownloadManager { }; if should_cancel { - // Clean up partial download - let _ = tokio::fs::remove_file(destination).await; + let _ = tokio::fs::remove_file(&partial_path).await; return Ok(()); } @@ -226,6 +256,8 @@ impl DownloadManager { } file.flush().await?; + drop(file); + tokio::fs::rename(&partial_path, destination).await?; Ok(()) } diff --git a/crates/goose/src/lib.rs b/crates/goose/src/lib.rs index 579534ab69..322927d093 100644 --- a/crates/goose/src/lib.rs +++ b/crates/goose/src/lib.rs @@ -5,6 +5,7 @@ pub mod config; pub mod context_mgmt; pub mod conversation; pub mod dictation; +pub mod download_manager; pub mod execution; pub mod goose_apps; pub mod hints; diff --git a/crates/goose/src/prompt_template.rs b/crates/goose/src/prompt_template.rs index 1685799c65..d4ec7eb848 100644 --- a/crates/goose/src/prompt_template.rs +++ b/crates/goose/src/prompt_template.rs @@ -39,6 +39,14 @@ static TEMPLATE_REGISTRY: &[(&str, &str)] = &[ "plan.md", "Prompt used when goose creates step-by-step plans. CLI only", ), + ( + "tiny_model_system.md", + "System prompt for tiny local models using shell command emulation", + ), + ( + "session_name.md", + "System prompt for generating short session names from conversation history", + ), ]; /// Information about a template including its content and customization status diff --git a/crates/goose/src/prompts/session_name.md b/crates/goose/src/prompts/session_name.md new file mode 100644 index 0000000000..1a40184a4d --- /dev/null +++ b/crates/goose/src/prompts/session_name.md @@ -0,0 +1,6 @@ +Generate a short title (four words or less) that describes the topic of the user's messages. Reply with only the title, nothing else. + +Examples: +- "how do I reverse a list in python?" → Python list reversal +- "what's the weather in Tokyo?" → Tokyo weather +- "explain how transformers work in ML" → ML transformers explained \ No newline at end of file diff --git a/crates/goose/src/prompts/tiny_model_system.md b/crates/goose/src/prompts/tiny_model_system.md new file mode 100644 index 0000000000..08b1f116c0 --- /dev/null +++ b/crates/goose/src/prompts/tiny_model_system.md @@ -0,0 +1,22 @@ +You are goose, an autonomous AI agent created by Block. You act on the user's +behalf — you do not explain how to do things, you DO them directly. + +The OS is {{os}}, the shell is {{shell}}, and the working directory is {{working_directory}} + +When the user asks you to do something, take action immediately. Do not describe +what you would do or give instructions — execute the commands yourself. + +To run a shell command, start a new line with $: + +$ ls + +Keep your responses brief. State what you are doing, then do it. For example: + +User: how many files are in /tmp? +You: Let me check. +$ ls -1 /tmp | wc -l + +After a command runs, you will see its output. Use the output to answer the user +or take the next step. Do not repeat commands you have already run. + +Do not use shell commands if you already know the answer. \ No newline at end of file diff --git a/crates/goose/src/providers/base.rs b/crates/goose/src/providers/base.rs index 99559dc11f..4a0c4c1bbc 100644 --- a/crates/goose/src/providers/base.rs +++ b/crates/goose/src/providers/base.rs @@ -17,10 +17,22 @@ use rmcp::model::Tool; use utoipa::ToSchema; use once_cell::sync::Lazy; +use regex::Regex; use std::ops::{Add, AddAssign}; use std::pin::Pin; +use std::sync::LazyLock; use std::sync::Mutex; +fn strip_xml_tags(text: &str) -> String { + static BLOCK_RE: LazyLock = LazyLock::new(|| { + Regex::new(r"(?s)<([a-zA-Z][a-zA-Z0-9_]*)[^>]*>.*?").unwrap() + }); + static TAG_RE: LazyLock = + LazyLock::new(|| Regex::new(r"]*>").unwrap()); + let pass1 = BLOCK_RE.replace_all(text, ""); + TAG_RE.replace_all(&pass1, "").into_owned() +} + /// A global store for the current model being used, we use this as when a provider returns, it tells us the real model, not an alias pub static CURRENT_MODEL: Lazy>> = Lazy::new(|| Mutex::new(None)); @@ -594,20 +606,28 @@ pub trait Provider: Send + Sync { messages: &Conversation, ) -> Result { let context = self.get_initial_user_messages(messages); - let prompt = self.create_session_name_prompt(&context); - let message = Message::user().with_text(&prompt); + let system = crate::prompt_template::render_template( + "session_name.md", + &std::collections::HashMap::::new(), + ) + .map_err(|e| ProviderError::ContextLengthExceeded(e.to_string()))?; + + let user_text = format!( + "---BEGIN USER MESSAGES---\n{}\n---END USER MESSAGES---\n\nGenerate a short title for the above messages.", + context.join("\n") + ); + let message = Message::user().with_text(&user_text); let result = self - .complete_fast( - session_id, - "Reply with only a description in four words or less", - &[message], - &[], - ) + .complete_fast(session_id, &system, &[message], &[]) .await?; - let description = result + let raw: String = result .0 - .as_concat_text() + .content + .iter() + .filter_map(|c| c.as_text()) + .collect(); + let description = strip_xml_tags(&raw) .split_whitespace() .collect::>() .join(" "); @@ -615,21 +635,6 @@ pub trait Provider: Send + Sync { Ok(safe_truncate(&description, 100)) } - // Generate a prompt for a session name based on the conversation history - fn create_session_name_prompt(&self, context: &[String]) -> String { - // Create a prompt for a concise description - let mut prompt = "Based on the conversation so far, provide a concise description of this session in 4 words or less. This will be used for finding the session later in a UI with limited space - reply *ONLY* with the description".to_string(); - - if !context.is_empty() { - prompt = format!( - "Here are the first few user messages:\n{}\n\n{}", - context.join("\n"), - prompt - ); - } - prompt - } - /// Configure OAuth authentication for this provider /// /// This method is called when a provider has configuration keys marked with oauth_flow = true. @@ -719,6 +724,42 @@ mod tests { use test_case::test_case; use serde_json::json; + + #[test] + fn test_strip_xml_tags() { + assert_eq!(strip_xml_tags("reasoninganswer"), "answer"); + assert_eq!(strip_xml_tags("beforemidafter"), "beforeafter"); + assert_eq!(strip_xml_tags("xyz"), "z"); + assert_eq!(strip_xml_tags("no tags here"), "no tags here"); + assert_eq!(strip_xml_tags("a < b > c"), "a < b > c"); + assert_eq!(strip_xml_tags("überok"), "ok"); + assert_eq!(strip_xml_tags("日本語hello"), "hello"); + assert_eq!(strip_xml_tags(""), ""); + assert_eq!(strip_xml_tags("<>stuff"), "<>stuff"); + // attributes + assert_eq!( + strip_xml_tags(r#"reasoninganswer"#), + "answer" + ); + // self-closing tags + assert_eq!(strip_xml_tags("
self closing"), "self closing"); + // orphan closing tags + assert_eq!(strip_xml_tags("orphan tag"), "orphan tag"); + // multiline content + assert_eq!( + strip_xml_tags("\nline1\nline2\nresult"), + "result" + ); + } + + #[test] + fn test_usage_creation() { + let usage = Usage::new(Some(10), Some(20), Some(30)); + assert_eq!(usage.input_tokens, Some(10)); + assert_eq!(usage.output_tokens, Some(20)); + assert_eq!(usage.total_tokens, Some(30)); + } + fn content_from_str(s: String) -> MessageContent { if let Some(img_data) = s.strip_prefix("*img:") { MessageContent::image(format!("http://example.com/{}", img_data), "image/png") @@ -798,11 +839,10 @@ mod tests { #[tokio::test] async fn test_collect_stream_defaults_usage() { - // Should not error when usage is missing let stream = create_test_stream(vec!["Hello".to_string()]); let (msg, usage) = collect_stream(Box::pin(stream)).await.unwrap(); assert_eq!(content_to_strings(&msg), vec!["Hello"]); - assert_eq!(usage.model, "unknown"); // Default usage + assert_eq!(usage.model, "unknown"); } #[test] diff --git a/crates/goose/src/providers/init.rs b/crates/goose/src/providers/init.rs index c1f69e61d6..8300f5a6df 100644 --- a/crates/goose/src/providers/init.rs +++ b/crates/goose/src/providers/init.rs @@ -16,6 +16,7 @@ use super::{ google::GoogleProvider, lead_worker::LeadWorkerProvider, litellm::LiteLLMProvider, + local_inference::LocalInferenceProvider, ollama::OllamaProvider, openai::OpenAiProvider, openrouter::OpenRouterProvider, @@ -47,6 +48,7 @@ async fn init_registry() -> RwLock { registry.register::(true); registry.register::(false); registry.register::(false); + registry.register::(false); registry.register::(true); registry.register::(true); registry.register::(true); diff --git a/crates/goose/src/providers/local_inference.rs b/crates/goose/src/providers/local_inference.rs new file mode 100644 index 0000000000..32503e9b3b --- /dev/null +++ b/crates/goose/src/providers/local_inference.rs @@ -0,0 +1,647 @@ +pub mod hf_models; +mod inference_emulated_tools; +mod inference_engine; +mod inference_native_tools; +pub mod local_model_registry; +mod tool_parsing; + +use inference_emulated_tools::{ + build_emulator_tool_description, generate_with_emulated_tools, load_tiny_model_prompt, +}; +use inference_engine::GenerationContext; +use inference_engine::LoadedModel; +use inference_native_tools::generate_with_native_tools; +use tool_parsing::compact_tools_json; + +use crate::config::ExtensionConfig; +use crate::conversation::message::{Message, MessageContent}; +use crate::model::ModelConfig; +use crate::providers::base::{ + MessageStream, Provider, ProviderDef, ProviderMetadata, ProviderUsage, Usage, +}; +use crate::providers::errors::ProviderError; +use crate::providers::formats::openai::format_tools; +use crate::providers::utils::RequestLog; +use anyhow::Result; +use async_stream::try_stream; +use async_trait::async_trait; +use futures::future::BoxFuture; +use llama_cpp_2::llama_backend::LlamaBackend; +use llama_cpp_2::model::params::LlamaModelParams; +use llama_cpp_2::model::{LlamaChatMessage, LlamaChatTemplate, LlamaModel}; +use llama_cpp_2::{list_llama_ggml_backend_devices, LlamaBackendDeviceType}; +use rmcp::model::{Role, Tool}; +use serde_json::{json, Value}; +use std::collections::HashMap; +use std::path::PathBuf; +use std::sync::{Arc, Mutex as StdMutex, Weak}; +use tokio::sync::Mutex; +use uuid::Uuid; + +const SHELL_TOOL: &str = "developer__shell"; +const CODE_EXECUTION_TOOL: &str = "code_execution__execute"; + +type ModelSlot = Arc>>; + +/// Owns the llama backend and all cached models. Field order matters: +/// `models` is declared before `backend` so Rust drops all loaded models +/// (and their Metal/GPU resources) before the backend calls +/// `llama_backend_free()`, avoiding the ggml-metal assertion on shutdown. +pub struct InferenceRuntime { + models: StdMutex>, + backend: LlamaBackend, +} + +/// Global weak reference used to share a single `InferenceRuntime` across +/// all providers and server routes. Only a `Weak` is stored — strong `Arc`s +/// live in providers and `AppState`. When all strong refs drop (normal +/// shutdown), the runtime is deallocated and the backend freed. The `Weak` +/// left behind is inert during `__cxa_finalize`, so no ggml statics race. +static RUNTIME: StdMutex> = StdMutex::new(Weak::new()); + +impl InferenceRuntime { + pub fn get_or_init() -> Arc { + let mut guard = RUNTIME.lock().expect("runtime lock poisoned"); + if let Some(runtime) = guard.upgrade() { + return runtime; + } + // Safety invariant: the Weak::upgrade() check and LlamaBackend::init() + // both execute inside this same mutex guard, so there is no window where + // another thread could drop the Arc and re-enter concurrently. + // BackendAlreadyInitialized therefore means LlamaBackend::drop() did not + // reset the C library's init flag — a llama-cpp-rs bug, not a race. + let backend = match LlamaBackend::init() { + Ok(b) => b, + Err(llama_cpp_2::LlamaCppError::BackendAlreadyInitialized) => { + unreachable!( + "LlamaBackend already initialized but Weak was dead; \ + the mutex guard prevents concurrent re-init" + ) + } + Err(e) => panic!("Failed to init llama backend: {}", e), + }; + let runtime = Arc::new(Self { + models: StdMutex::new(HashMap::new()), + backend, + }); + *guard = Arc::downgrade(&runtime); + runtime + } + + pub fn backend(&self) -> &LlamaBackend { + &self.backend + } + + fn get_or_create_model_slot(&self, model_id: &str) -> ModelSlot { + let mut map = self.models.lock().expect("model cache lock poisoned"); + map.entry(model_id.to_string()) + .or_insert_with(|| Arc::new(Mutex::new(None))) + .clone() + } + + fn other_model_slots(&self, keep_model_id: &str) -> Vec { + let map = self.models.lock().expect("model cache lock poisoned"); + map.iter() + .filter(|(id, _)| id.as_str() != keep_model_id) + .map(|(_, slot)| slot.clone()) + .collect() + } +} + +const PROVIDER_NAME: &str = "local"; +const DEFAULT_MODEL: &str = "bartowski/Llama-3.2-1B-Instruct-GGUF:Q4_K_M"; + +pub const LOCAL_LLM_MODEL_CONFIG_KEY: &str = "LOCAL_LLM_MODEL"; + +/// Resolve model path, context limit, and settings for a model ID from the registry. +pub fn resolve_model_path( + model_id: &str, +) -> Option<( + PathBuf, + usize, + crate::providers::local_inference::local_model_registry::ModelSettings, +)> { + use crate::providers::local_inference::local_model_registry::get_registry; + + if let Ok(registry) = get_registry().lock() { + if let Some(entry) = registry.get_model(model_id) { + let ctx = entry.settings.context_size.unwrap_or(0) as usize; + return Some((entry.local_path.clone(), ctx, entry.settings.clone())); + } + } + + None +} + +pub fn available_inference_memory_bytes(runtime: &InferenceRuntime) -> u64 { + let _ = &runtime.backend; + let devices = list_llama_ggml_backend_devices(); + + let accel_memory = devices + .iter() + .filter(|d| { + matches!( + d.device_type, + LlamaBackendDeviceType::Gpu + | LlamaBackendDeviceType::IntegratedGpu + | LlamaBackendDeviceType::Accelerator + ) + }) + .map(|d| d.memory_free as u64) + .max() + .unwrap_or(0); + + if accel_memory > 0 { + accel_memory + } else { + devices + .iter() + .filter(|d| d.device_type == LlamaBackendDeviceType::Cpu) + .map(|d| d.memory_free as u64) + .max() + .unwrap_or(0) + } +} + +pub fn recommend_local_model(runtime: &InferenceRuntime) -> String { + use local_model_registry::{get_registry, is_featured_model, FEATURED_MODELS}; + + let available_memory = available_inference_memory_bytes(runtime); + + if let Ok(registry) = get_registry().lock() { + let mut models: Vec<_> = registry + .list_models() + .iter() + .filter(|m| is_featured_model(&m.id) && m.size_bytes > 0) + .collect(); + models.sort_by(|a, b| b.size_bytes.cmp(&a.size_bytes)); + + // Return largest that fits in available memory + for model in &models { + if available_memory >= model.size_bytes { + return model.id.clone(); + } + } + + // If nothing fits, return smallest + if let Some(smallest) = models.last() { + return smallest.id.clone(); + } + } + + // Fallback to first featured model + FEATURED_MODELS[0].to_string() +} + +fn build_openai_messages_json(system: &str, messages: &[Message]) -> String { + use crate::providers::formats::openai::format_messages; + use crate::providers::utils::ImageFormat; + + let mut arr: Vec = vec![json!({"role": "system", "content": system})]; + arr.extend(format_messages(messages, &ImageFormat::OpenAi)); + serde_json::to_string(&arr).unwrap_or_else(|_| "[]".to_string()) +} + +/// Convert a message into plain text for the emulator path's chat history. +/// +/// This is the emulator-path counterpart of [`format_messages`] used by the native +/// path. It reconstructs the text-based tool syntax that the emulator prompt teaches +/// the model: +/// +/// - `ToolRequest` with a `"command"` argument → `$ command` +/// - `ToolRequest` with a `"code"` argument → `` ```execute\n…\n``` `` +/// - `ToolResponse` → `Command output:\n…` +/// +/// Only `developer__shell` and `code_execution__execute` style tool calls are +/// recognized (by argument shape, not tool name). Tool calls from other extensions +/// (e.g. custom MCP tools made by a native-tool-calling model earlier in the +/// conversation) are silently dropped, since the emulator path has no syntax to +/// represent them. +fn extract_text_content(msg: &Message) -> String { + let mut parts = Vec::new(); + + for content in &msg.content { + match content { + MessageContent::Text(text) => { + parts.push(text.text.clone()); + } + MessageContent::ToolRequest(req) => { + if let Ok(call) = &req.tool_call { + if let Some(cmd) = call + .arguments + .as_ref() + .and_then(|a| a.get("command")) + .and_then(|v| v.as_str()) + { + parts.push(format!("$ {}", cmd)); + } else if let Some(code) = call + .arguments + .as_ref() + .and_then(|a| a.get("code")) + .and_then(|v| v.as_str()) + { + parts.push(format!("```execute\n{}\n```", code)); + } + } + } + MessageContent::ToolResponse(response) => match &response.tool_result { + Ok(result) => { + let mut output_parts = Vec::new(); + for content_item in &result.content { + if let Some(text_content) = content_item.as_text() { + output_parts.push(text_content.text.to_string()); + } + } + if !output_parts.is_empty() { + parts.push(format!("Command output:\n{}", output_parts.join("\n"))); + } + } + Err(e) => { + parts.push(format!("Command error: {}", e)); + } + }, + _ => {} + } + } + + parts.join("\n") +} + +/// Build a `ProviderUsage` and write the request log entry. +fn finalize_usage( + log: &mut RequestLog, + model_name: String, + path_label: &str, + prompt_token_count: usize, + output_token_count: i32, + extra_log_fields: Option<(&str, &str)>, +) -> ProviderUsage { + let input_tokens = prompt_token_count as i32; + let total_tokens = input_tokens + output_token_count; + let usage = Usage::new( + Some(input_tokens), + Some(output_token_count), + Some(total_tokens), + ); + let mut log_json = serde_json::json!({ + "path": path_label, + "prompt_tokens": input_tokens, + "output_tokens": output_token_count, + }); + if let Some((key, value)) = extra_log_fields { + log_json[key] = serde_json::json!(value); + } + let _ = log.write(&log_json, Some(&usage)); + ProviderUsage::new(model_name, usage) +} + +type StreamSender = + tokio::sync::mpsc::Sender, Option), ProviderError>>; + +pub struct LocalInferenceProvider { + runtime: Arc, + model: ModelSlot, + model_config: ModelConfig, + name: String, +} + +impl LocalInferenceProvider { + pub async fn from_env(model: ModelConfig, _extensions: Vec) -> Result { + let runtime = InferenceRuntime::get_or_init(); + let model_slot = runtime.get_or_create_model_slot(&model.model_name); + Ok(Self { + runtime, + model: model_slot, + model_config: model, + name: PROVIDER_NAME.to_string(), + }) + } + + fn load_model_sync( + runtime: &InferenceRuntime, + model_id: &str, + settings: &crate::providers::local_inference::local_model_registry::ModelSettings, + ) -> Result { + let (model_path, _context_limit, _) = resolve_model_path(model_id) + .ok_or_else(|| ProviderError::ExecutionError(format!("Unknown model: {}", model_id)))?; + + if !model_path.exists() { + return Err(ProviderError::ExecutionError(format!( + "Model not downloaded: {}. Please download it from Settings > Local Inference.", + model_id + ))); + } + + tracing::info!("Loading {} from: {}", model_id, model_path.display()); + + let backend = runtime.backend(); + + let mut params = LlamaModelParams::default(); + if let Some(n_gpu_layers) = settings.n_gpu_layers { + params = params.with_n_gpu_layers(n_gpu_layers); + } + if settings.use_mlock { + params = params.with_use_mlock(true); + } + let model = LlamaModel::load_from_file(backend, &model_path, ¶ms) + .map_err(|e| ProviderError::ExecutionError(e.to_string()))?; + + let template = match model.chat_template(None) { + Ok(t) => t, + Err(_) => { + tracing::warn!("Model has no embedded chat template, falling back to chatml"); + LlamaChatTemplate::new("chatml").map_err(|e| { + ProviderError::ExecutionError(format!( + "Failed to create fallback chat template: {}", + e + )) + })? + } + }; + + tracing::info!("Model loaded successfully"); + + Ok(LoadedModel { model, template }) + } +} + +impl ProviderDef for LocalInferenceProvider { + type Provider = Self; + + fn metadata() -> ProviderMetadata + where + Self: Sized, + { + use crate::providers::local_inference::local_model_registry::{ + get_registry, FEATURED_MODELS, + }; + + let mut known_models: Vec<&str> = FEATURED_MODELS.to_vec(); + + // Add any registry models not already in the featured list + let mut dynamic_models = Vec::new(); + if let Ok(registry) = get_registry().lock() { + for entry in registry.list_models() { + if !known_models.contains(&entry.id.as_str()) { + dynamic_models.push(entry.id.clone()); + } + } + } + let dynamic_refs: Vec<&str> = dynamic_models.iter().map(|s| s.as_str()).collect(); + known_models.extend(dynamic_refs); + + ProviderMetadata::new( + PROVIDER_NAME, + "Local Inference", + "Local inference using quantized GGUF models (llama.cpp)", + DEFAULT_MODEL, + known_models, + "https://github.com/utilityai/llama-cpp-rs", + vec![], + ) + } + + fn from_env( + model: ModelConfig, + extensions: Vec, + ) -> BoxFuture<'static, Result> + where + Self: Sized, + { + Box::pin(Self::from_env(model, extensions)) + } +} + +#[async_trait] +impl Provider for LocalInferenceProvider { + fn get_name(&self) -> &str { + &self.name + } + + fn get_model_config(&self) -> ModelConfig { + self.model_config.clone() + } + + async fn fetch_supported_models(&self) -> Result, ProviderError> { + use crate::providers::local_inference::local_model_registry::get_registry; + + let mut all_models: Vec = Vec::new(); + + if let Ok(registry) = get_registry().lock() { + for entry in registry.list_models() { + all_models.push(entry.id.clone()); + } + } + + Ok(all_models) + } + + async fn stream( + &self, + model_config: &ModelConfig, + _session_id: &str, + system: &str, + messages: &[Message], + tools: &[Tool], + ) -> Result { + let (_model_path, model_context_limit, model_settings) = + resolve_model_path(&model_config.model_name).ok_or_else(|| { + ProviderError::ExecutionError(format!( + "Model not found: {}", + model_config.model_name + )) + })?; + + // Ensure model is loaded — unload any other models first to free memory. + { + let mut model_lock = self.model.lock().await; + if model_lock.is_none() { + for slot in self.runtime.other_model_slots(&model_config.model_name) { + let mut other = slot.lock().await; + if other.is_some() { + tracing::info!("Unloading previous model to free memory"); + *other = None; + } + } + + let model_id = model_config.model_name.clone(); + let settings_for_load = model_settings.clone(); + let runtime_for_load = self.runtime.clone(); + let loaded = tokio::task::spawn_blocking(move || { + Self::load_model_sync(&runtime_for_load, &model_id, &settings_for_load) + }) + .await + .map_err(|e| ProviderError::ExecutionError(e.to_string()))??; + *model_lock = Some(loaded); + } + } + + // Models that support native OpenAI-compatible tool-call JSON use the + // native path (template-based tool calling with JSON output). All other + // models use the emulator which parses `$ command` and ```execute blocks. + // Only use emulator when there are actually tools to emulate - utility calls + // like compaction and session naming pass empty tools and should preserve + // their system prompts. + let use_emulator = !model_settings.native_tool_calling && !tools.is_empty(); + let system_prompt = if use_emulator { + load_tiny_model_prompt() + } else { + system.to_string() + }; + + // Build chat messages for the template + let mut chat_messages = + vec![ + LlamaChatMessage::new("system".to_string(), system_prompt.clone()).map_err( + |e| { + ProviderError::ExecutionError(format!( + "Failed to create system message: {}", + e + )) + }, + )?, + ]; + + let code_mode_enabled = tools.iter().any(|t| t.name == CODE_EXECUTION_TOOL); + + if use_emulator && !tools.is_empty() { + let tool_desc = build_emulator_tool_description(tools, code_mode_enabled); + chat_messages = vec![LlamaChatMessage::new( + "system".to_string(), + format!("{}{}", system_prompt, tool_desc), + ) + .map_err(|e| { + ProviderError::ExecutionError(format!("Failed to create system message: {}", e)) + })?]; + } + + for msg in messages { + let role = match msg.role { + Role::User => "user", + Role::Assistant => "assistant", + }; + let content = extract_text_content(msg); + if !content.trim().is_empty() { + chat_messages.push(LlamaChatMessage::new(role.to_string(), content).map_err( + |e| ProviderError::ExecutionError(format!("Failed to create message: {}", e)), + )?); + } + } + + let (full_tools_json, compact_tools) = if !use_emulator && !tools.is_empty() { + let full = format_tools(tools) + .ok() + .and_then(|spec| serde_json::to_string(&spec).ok()); + let compact = compact_tools_json(tools); + (full, compact) + } else { + (None, None) + }; + + let oai_messages_json = if model_settings.use_jinja { + Some(build_openai_messages_json(&system_prompt, messages)) + } else { + None + }; + + let model_arc = self.model.clone(); + let runtime = self.runtime.clone(); + let model_name = model_config.model_name.clone(); + let context_limit = model_context_limit; + let settings = model_settings; + + let log_payload = serde_json::json!({ + "system": &system_prompt, + "messages": messages.iter().map(|m| { + serde_json::json!({ + "role": match m.role { Role::User => "user", Role::Assistant => "assistant" }, + "content": extract_text_content(m), + }) + }).collect::>(), + "tools": tools.iter().map(|t| &t.name).collect::>(), + "settings": { + "use_jinja": settings.use_jinja, + "native_tool_calling": settings.native_tool_calling, + "context_size": settings.context_size, + "sampling": settings.sampling, + }, + }); + + let mut log = RequestLog::start(&self.model_config, &log_payload) + .map_err(|e| ProviderError::ExecutionError(e.to_string()))?; + + let (tx, mut rx) = tokio::sync::mpsc::channel::< + Result<(Option, Option), ProviderError>, + >(32); + + tokio::task::spawn_blocking(move || { + // Macro to log errors before sending them through the channel + macro_rules! send_err { + ($err:expr) => {{ + let err = $err; + let msg = match &err { + ProviderError::ExecutionError(s) => s.as_str(), + ProviderError::ContextLengthExceeded(s) => s.as_str(), + _ => "unknown error", + }; + let _ = log.error(msg); + let _ = tx.blocking_send(Err(err)); + return; + }}; + } + + let model_guard = model_arc.blocking_lock(); + let loaded = match model_guard.as_ref() { + Some(l) => l, + None => { + send_err!(ProviderError::ExecutionError( + "Model not loaded".to_string() + )); + } + }; + + let message_id = Uuid::new_v4().to_string(); + + let mut gen_ctx = GenerationContext { + loaded, + runtime: &runtime, + chat_messages: &chat_messages, + settings: &settings, + context_limit, + model_name, + message_id: &message_id, + tx: &tx, + log: &mut log, + }; + + let result = if use_emulator { + generate_with_emulated_tools(&mut gen_ctx, code_mode_enabled) + } else { + generate_with_native_tools( + &mut gen_ctx, + &oai_messages_json, + full_tools_json.as_deref(), + compact_tools.as_deref(), + ) + }; + + if let Err(err) = result { + let msg = match &err { + ProviderError::ExecutionError(s) => s.as_str(), + ProviderError::ContextLengthExceeded(s) => s.as_str(), + _ => "unknown error", + }; + let _ = log.error(msg); + let _ = tx.blocking_send(Err(err)); + } + }); + + Ok(Box::pin(try_stream! { + while let Some(result) = rx.recv().await { + let item = result?; + yield item; + } + + })) + } +} diff --git a/crates/goose/src/providers/local_inference/hf_models.rs b/crates/goose/src/providers/local_inference/hf_models.rs new file mode 100644 index 0000000000..9729fcd832 --- /dev/null +++ b/crates/goose/src/providers/local_inference/hf_models.rs @@ -0,0 +1,486 @@ +use anyhow::{bail, Result}; +use serde::{Deserialize, Serialize}; + +use utoipa::ToSchema; + +const HF_API_BASE: &str = "https://huggingface.co/api/models"; +const HF_DOWNLOAD_BASE: &str = "https://huggingface.co"; + +#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)] +pub struct HfModelInfo { + pub repo_id: String, + pub author: String, + pub model_name: String, + pub downloads: u64, + pub gguf_files: Vec, +} + +/// A single downloadable GGUF file (used internally and for downloads). +#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)] +pub struct HfGgufFile { + pub filename: String, + pub size_bytes: u64, + pub quantization: String, + pub download_url: String, +} + +/// A quantization variant — groups sharded files into one logical entry. +#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)] +pub struct HfQuantVariant { + pub quantization: String, + pub size_bytes: u64, + pub filename: String, + pub download_url: String, + pub description: &'static str, + pub quality_rank: u8, +} + +#[derive(Debug, Deserialize)] +struct HfApiModel { + id: Option, + author: Option, + downloads: Option, + siblings: Option>, +} + +#[derive(Debug, Deserialize)] +struct HfApiSibling { + rfilename: String, + #[serde(default)] + size: Option, +} + +struct QuantInfo { + description: &'static str, + quality_rank: u8, +} + +const QUANT_TABLE: &[(&str, &str, u8)] = &[ + ("IQ1_S", "Extremely small, very low quality", 1), + ("IQ1_M", "Extremely small, very low quality", 2), + ("IQ2_XXS", "Very small, low quality", 3), + ("IQ2_XS", "Very small, low quality", 4), + ("IQ2_S", "Very small, low quality", 5), + ("IQ2_M", "Very small, low quality", 6), + ("Q2_K", "Small, low quality", 7), + ("Q2_K_S", "Small, low quality", 7), + ("IQ3_XXS", "Very small, moderate quality loss", 8), + ("IQ3_XS", "Small, moderate quality loss", 9), + ("IQ3_S", "Small, moderate quality loss", 9), + ("Q3_K_S", "Small, moderate quality loss", 10), + ("IQ3_M", "Small, moderate quality loss", 11), + ("Q3_K_M", "Small, balanced quality/size", 12), + ("Q3_K_L", "Medium-small, decent quality", 13), + ("IQ4_XS", "Medium, good quality", 14), + ("IQ4_NL", "Medium, good quality", 15), + ("Q4_0", "Medium, good quality", 16), + ("Q4_1", "Medium, good quality", 17), + ("Q4_K_S", "Medium, good quality/size balance", 18), + ( + "Q4_K_M", + "Medium, recommended balance of quality and size", + 19, + ), + ("Q5_0", "Medium-large, high quality", 20), + ("Q5_1", "Medium-large, high quality", 21), + ("Q5_K_S", "Medium-large, high quality", 22), + ("Q5_K_M", "Medium-large, very high quality", 23), + ("Q6_K", "Large, near-lossless quality", 24), + ("Q8_0", "Large, near-lossless quality", 25), + ("F16", "Full size, original quality (16-bit)", 26), + ("BF16", "Full size, original quality (bfloat16)", 27), + ("F32", "Full size, original quality (32-bit)", 28), + ( + "MXFP4_MOE", + "Medium, mixed-precision 4-bit for MoE models", + 18, + ), + ("TQ1_0", "Tiny, ternary quantization", 1), + ("Q2_K_XL", "Extended-layer variant", 15), + ("Q3_K_XL", "Extended-layer variant", 15), + ("Q4_K_XL", "Extended-layer variant", 15), + ("Q2_K_L", "Small, low quality (large variant)", 8), + ("Q4_K_L", "Medium, good quality (large variant)", 20), +]; + +fn quant_info(quant: &str) -> QuantInfo { + QUANT_TABLE + .iter() + .find(|(name, _, _)| *name == quant) + .map(|(_, description, quality_rank)| QuantInfo { + description, + quality_rank: *quality_rank, + }) + .unwrap_or(QuantInfo { + description: "", + quality_rank: 15, + }) +} + +pub fn parse_quantization_from_filename(filename: &str) -> String { + parse_quantization(filename) +} + +fn parse_quantization(filename: &str) -> String { + // Strip directory prefix (e.g. "Q5_K_M/Model-Q5_K_M-00001-of-00002.gguf") + let basename = filename.rsplit('/').next().unwrap_or(filename); + let stem = basename.trim_end_matches(".gguf"); + + // Strip shard suffix like "-00001-of-00004" + let stem = if let Some(pos) = stem.rfind("-of-") { + stem.get(..pos) + .and_then(|s| s.rsplit_once('-').map(|(prefix, _)| prefix)) + .unwrap_or(stem) + } else { + stem + }; + + // The quantization tag is typically the last hyphen-separated component + // that looks like a quant identifier (starts with Q, IQ, F, BF, TQ, MXFP, etc.) + // e.g. "Qwen3-Coder-Next-Q4_K_M" -> "Q4_K_M" + // "Model-UD-IQ1_M" -> "IQ1_M" + if let Some((_, candidate)) = stem.rsplit_once('-') { + if looks_like_quant(candidate) { + return candidate.to_string(); + } + } + + // Fallback: try dot separator (e.g. "model.Q4_K_M") + if let Some((_, candidate)) = stem.rsplit_once('.') { + if looks_like_quant(candidate) { + return candidate.to_string(); + } + } + + "unknown".to_string() +} + +fn looks_like_quant(s: &str) -> bool { + let upper = s.to_uppercase(); + upper.starts_with("Q") + || upper.starts_with("IQ") + || upper.starts_with("TQ") + || upper.starts_with("MXFP") + || upper == "F16" + || upper == "F32" + || upper == "BF16" +} + +fn is_shard_file(filename: &str) -> bool { + // Matches patterns like "-00001-of-00003.gguf" + let basename = filename.rsplit('/').next().unwrap_or(filename); + let stem = basename.trim_end_matches(".gguf"); + if let Some(pos) = stem.rfind("-of-") { + stem.get(..pos) + .and_then(|before| before.rsplit('-').next()) + .map(|s| !s.is_empty() && s.chars().all(|c| c.is_ascii_digit())) + .unwrap_or(false) + } else { + false + } +} + +fn build_download_url(repo_id: &str, filename: &str) -> String { + format!("{}/{}/resolve/main/{}", HF_DOWNLOAD_BASE, repo_id, filename) +} + +/// Collect single-file GGUFs into quantization variants (sharded files are excluded). +fn group_into_variants(repo_id: &str, files: Vec) -> Vec { + let mut variants: Vec = files + .into_iter() + .filter(|s| { + s.rfilename.ends_with(".gguf") + && !is_shard_file(&s.rfilename) + && parse_quantization(&s.rfilename) != "unknown" + }) + .map(|s| { + let quant = parse_quantization(&s.rfilename); + let info = quant_info(&quant); + let download_url = build_download_url(repo_id, &s.rfilename); + HfQuantVariant { + quantization: quant, + size_bytes: s.size.unwrap_or(0), + filename: s.rfilename, + download_url, + description: info.description, + quality_rank: info.quality_rank, + } + }) + .collect(); + + variants.sort_by_key(|v| v.quality_rank); + variants +} + +pub async fn search_gguf_models(query: &str, limit: usize) -> Result> { + let client = reqwest::Client::new(); + let url = format!( + "{}?search={}&filter=gguf&sort=downloads&direction=-1&limit={}", + HF_API_BASE, query, limit + ); + + let response = client + .get(&url) + .header("User-Agent", "goose-ai-agent") + .send() + .await?; + + if !response.status().is_success() { + bail!("HuggingFace API returned status {}", response.status()); + } + + let models: Vec = response.json().await?; + + let results = models + .into_iter() + .filter_map(|m| { + let repo_id = m.id?; + let siblings = m.siblings.unwrap_or_default(); + + // The search endpoint may not include `siblings`; parse whatever + // is available. Files are fetched on-demand via `get_repo_gguf_variants`. + let gguf_files: Vec = siblings + .into_iter() + .filter(|s| s.rfilename.ends_with(".gguf")) + .map(|s| { + let quantization = parse_quantization(&s.rfilename); + let download_url = build_download_url(&repo_id, &s.rfilename); + HfGgufFile { + filename: s.rfilename, + size_bytes: s.size.unwrap_or(0), + quantization, + download_url, + } + }) + .collect(); + + let author = m + .author + .unwrap_or_else(|| repo_id.split('/').next().unwrap_or_default().to_string()); + let model_name = repo_id + .split('/') + .next_back() + .unwrap_or(&repo_id) + .to_string(); + + Some(HfModelInfo { + repo_id, + author, + model_name, + downloads: m.downloads.unwrap_or(0), + gguf_files, + }) + }) + .collect(); + + Ok(results) +} + +/// Fetch GGUF files for a repo and return them grouped by quantization. +pub async fn get_repo_gguf_variants(repo_id: &str) -> Result> { + let client = reqwest::Client::new(); + let url = format!("{}/{}?blobs=true", HF_API_BASE, repo_id); + + let response = client + .get(&url) + .header("User-Agent", "goose-ai-agent") + .send() + .await?; + + if !response.status().is_success() { + bail!( + "HuggingFace API returned status {} for repo {}", + response.status(), + repo_id + ); + } + + let model: HfApiModel = response.json().await?; + let siblings = model.siblings.unwrap_or_default(); + + Ok(group_into_variants(repo_id, siblings)) +} + +/// Fetch raw GGUF files (kept for resolve_model_spec). +pub async fn get_repo_gguf_files(repo_id: &str) -> Result> { + let client = reqwest::Client::new(); + let url = format!("{}/{}?blobs=true", HF_API_BASE, repo_id); + + let response = client + .get(&url) + .header("User-Agent", "goose-ai-agent") + .send() + .await?; + + if !response.status().is_success() { + bail!( + "HuggingFace API returned status {} for repo {}", + response.status(), + repo_id + ); + } + + let model: HfApiModel = response.json().await?; + let siblings = model.siblings.unwrap_or_default(); + + let files = siblings + .into_iter() + .filter(|s| s.rfilename.ends_with(".gguf")) + .filter(|s| !is_shard_file(&s.rfilename)) + .map(|s| { + let quantization = parse_quantization(&s.rfilename); + let download_url = build_download_url(repo_id, &s.rfilename); + HfGgufFile { + filename: s.rfilename, + size_bytes: s.size.unwrap_or(0), + quantization, + download_url, + } + }) + .collect(); + + Ok(files) +} + +/// Parse a model spec like "bartowski/Llama-3.2-1B-Instruct-GGUF:Q4_K_M" into (repo_id, quantization). +pub fn parse_model_spec(spec: &str) -> Result<(String, String)> { + let (repo_id, quant) = spec.rsplit_once(':').ok_or_else(|| { + anyhow::anyhow!( + "Invalid model spec '{}': expected format 'user/repo:quantization'", + spec + ) + })?; + + if !repo_id.contains('/') { + bail!("Invalid repo_id '{}': expected format 'user/repo'", repo_id); + } + + Ok((repo_id.to_string(), quant.to_string())) +} + +/// Resolve a model spec to a specific GGUF file from the repo. +pub async fn resolve_model_spec(spec: &str) -> Result<(String, HfGgufFile)> { + let (repo_id, quant) = parse_model_spec(spec)?; + let files = get_repo_gguf_files(&repo_id).await?; + + let file = files + .into_iter() + .find(|f| f.quantization.eq_ignore_ascii_case(&quant)) + .ok_or_else(|| { + anyhow::anyhow!( + "No GGUF file with quantization '{}' found in {}", + quant, + repo_id + ) + })?; + + Ok((repo_id, file)) +} + +/// Recommend which quantization variant to use based on available memory. +pub fn recommend_variant( + variants: &[HfQuantVariant], + available_memory_bytes: u64, +) -> Option { + // We need ~10-20% overhead beyond model size for inference context. + // Pick the highest-quality variant that fits. + let usable = (available_memory_bytes as f64 * 0.85) as u64; + + let mut best: Option = None; + for (i, v) in variants.iter().enumerate() { + if v.size_bytes <= usable { + match best { + Some(bi) if variants[bi].quality_rank < v.quality_rank => best = Some(i), + None => best = Some(i), + _ => {} + } + } + } + best +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_parse_quantization() { + assert_eq!(parse_quantization("Model-Q4_K_M.gguf"), "Q4_K_M"); + assert_eq!(parse_quantization("Model-Q8_0.gguf"), "Q8_0"); + assert_eq!(parse_quantization("Model-IQ4_NL.gguf"), "IQ4_NL"); + assert_eq!(parse_quantization("Model-F16.gguf"), "F16"); + assert_eq!(parse_quantization("random-name.gguf"), "unknown"); + } + + #[test] + fn test_parse_quantization_with_directory() { + assert_eq!( + parse_quantization("Q5_K_M/Model-Q5_K_M-00001-of-00002.gguf"), + "Q5_K_M" + ); + } + + #[test] + fn test_parse_quantization_extended_tags() { + assert_eq!(parse_quantization("Model-MXFP4_MOE.gguf"), "MXFP4_MOE"); + assert_eq!(parse_quantization("Model-UD-TQ1_0.gguf"), "TQ1_0"); + assert_eq!(parse_quantization("Model-Q2_K_L.gguf"), "Q2_K_L"); + assert_eq!(parse_quantization("Model-UD-Q4_K_XL.gguf"), "Q4_K_XL"); + assert_eq!(parse_quantization("Model-UD-IQ1_M.gguf"), "IQ1_M"); + } + + #[test] + fn test_is_shard_file() { + assert!(is_shard_file("Q5_K_M/Model-Q5_K_M-00001-of-00002.gguf")); + assert!(is_shard_file("Model-BF16-00003-of-00004.gguf")); + assert!(!is_shard_file("Model-Q4_K_M.gguf")); + } + + #[test] + fn test_parse_model_spec() { + let (repo, quant) = + parse_model_spec("bartowski/Llama-3.2-1B-Instruct-GGUF:Q4_K_M").unwrap(); + assert_eq!(repo, "bartowski/Llama-3.2-1B-Instruct-GGUF"); + assert_eq!(quant, "Q4_K_M"); + } + + #[test] + fn test_parse_model_spec_invalid() { + assert!(parse_model_spec("no-colon").is_err()); + assert!(parse_model_spec("noslash:Q4_K_M").is_err()); + } + + #[test] + fn test_recommend_variant() { + let variants = vec![ + HfQuantVariant { + quantization: "Q2_K".into(), + size_bytes: 2_000_000_000, + filename: "m-Q2_K.gguf".into(), + download_url: String::new(), + description: "Small", + quality_rank: 7, + }, + HfQuantVariant { + quantization: "Q4_K_M".into(), + size_bytes: 4_000_000_000, + filename: "m-Q4_K_M.gguf".into(), + download_url: String::new(), + description: "Medium", + quality_rank: 19, + }, + HfQuantVariant { + quantization: "Q8_0".into(), + size_bytes: 8_000_000_000, + filename: "m-Q8_0.gguf".into(), + download_url: String::new(), + description: "Large", + quality_rank: 25, + }, + ]; + + assert_eq!(recommend_variant(&variants, 5_000_000_000), Some(1)); + assert_eq!(recommend_variant(&variants, 10_000_000_000), Some(2)); + assert_eq!(recommend_variant(&variants, 1_000_000_000), None); + } +} diff --git a/crates/goose/src/providers/local_inference/inference_emulated_tools.rs b/crates/goose/src/providers/local_inference/inference_emulated_tools.rs new file mode 100644 index 0000000000..4f9fb0f870 --- /dev/null +++ b/crates/goose/src/providers/local_inference/inference_emulated_tools.rs @@ -0,0 +1,685 @@ +//! Tool call emulation for models without native tool-calling support. +//! +//! The model is prompted to emit shell commands as `$ command` on a new line and +//! code blocks as `` ```execute `` fenced blocks. A streaming parser detects these +//! patterns and converts them into tool-call messages. +//! +//! # Known false-positive scenarios +//! +//! Because detection is purely text-based, the parser can misinterpret model output: +//! +//! - **`$` at line start in explanatory text.** If the model writes a line starting +//! with `$` as an example (e.g. "$ is the jQuery selector"), it will be treated as +//! a shell command. Mid-sentence `$` (e.g. "costs $50") is safe — only `\n$` or +//! `$` at the very start of output triggers command detection. +//! +//! - **`` ```execute `` in explanatory code fences.** If the model uses this exact +//! fence tag in prose, the content will be executed. Standard `` ```js `` or +//! `` ```python `` fences are not affected. +//! +//! These are inherent to text-based tool emulation. Models with native tool-calling +//! support should use the `inference_native_tools` path instead. + +use crate::conversation::message::{Message, MessageContent}; +use crate::providers::errors::ProviderError; +use llama_cpp_2::model::AddBos; +use rmcp::model::{CallToolRequestParams, Tool}; +use serde_json::json; +use std::borrow::Cow; +use uuid::Uuid; + +use super::inference_engine::{ + create_and_prefill_context, generation_loop, validate_and_compute_context, GenerationContext, + TokenAction, +}; +use super::{finalize_usage, StreamSender, CODE_EXECUTION_TOOL, SHELL_TOOL}; + +const HOLD_BACK_CODE_MODE: usize = " ```execute\n".len(); +const HOLD_BACK_SHELL_ONLY: usize = "\n$".len(); + +pub(super) fn load_tiny_model_prompt() -> String { + use std::env; + + let os = if cfg!(target_os = "macos") { + "macos" + } else if cfg!(target_os = "linux") { + "linux" + } else if cfg!(target_os = "windows") { + "windows" + } else { + "unknown" + }; + + let working_directory = env::current_dir() + .map(|p| p.display().to_string()) + .unwrap_or_else(|_| "unknown".to_string()); + + let shell = env::var("SHELL").unwrap_or_else(|_| "/bin/sh".to_string()); + + let context = json!({ + "os": os, + "working_directory": working_directory, + "shell": shell, + }); + + crate::prompt_template::render_template("tiny_model_system.md", &context).unwrap_or_else(|e| { + tracing::warn!("Failed to load tiny_model_system.md: {:?}", e); + "You are Goose, an AI assistant. You can execute shell commands by starting lines with $." + .to_string() + }) +} + +pub(super) fn build_emulator_tool_description(tools: &[Tool], code_mode_enabled: bool) -> String { + let mut tool_desc = String::new(); + + if code_mode_enabled { + tool_desc.push_str("\n\n# Running Code\n\n"); + tool_desc.push_str( + "You can call tools by writing code in a ```execute block. \ + The code runs immediately — do not explain it, just run it.\n\n", + ); + tool_desc.push_str("Example — counting files in /tmp:\n\n"); + tool_desc.push_str("```execute\nasync function run() {\n"); + tool_desc.push_str( + " const result = await Developer.shell({ command: \"ls -1 /tmp | wc -l\" });\n", + ); + tool_desc.push_str(" return result;\n}\n```\n\n"); + tool_desc.push_str("Rules:\n"); + tool_desc.push_str("- Code MUST define async function run() and return a result\n"); + tool_desc.push_str("- All function calls are async — use await\n"); + tool_desc.push_str("- Use ```execute for tool calls, $ for simple shell one-liners\n\n"); + tool_desc.push_str("Available functions:\n\n"); + + for tool in tools { + if tool.name.starts_with("code_execution__") { + continue; + } + let parts: Vec<&str> = tool.name.splitn(2, "__").collect(); + if parts.len() == 2 { + let namespace = { + let mut c = parts[0].chars(); + match c.next() { + None => String::new(), + Some(first) => first.to_uppercase().chain(c).collect::(), + } + }; + let camel_name: String = parts[1] + .split('_') + .enumerate() + .map(|(i, part)| { + if i == 0 { + part.to_string() + } else { + let mut c = part.chars(); + match c.next() { + None => String::new(), + Some(first) => first.to_uppercase().chain(c).collect(), + } + } + }) + .collect(); + let desc = tool.description.as_ref().map(|d| d.as_ref()).unwrap_or(""); + tool_desc.push_str(&format!("- {namespace}.{camel_name}(): {desc}\n")); + } + } + } else { + tool_desc.push_str("\n\n# Tools\n\nYou have access to the following tools:\n\n"); + for tool in tools { + let desc = tool + .description + .as_ref() + .map(|d| d.as_ref()) + .unwrap_or("No description"); + tool_desc.push_str(&format!("- {}: {}\n", tool.name, desc)); + } + } + + tool_desc +} + +enum EmulatorAction { + Text(String), + ShellCommand(String), + ExecuteCode(String), +} + +enum ParserState { + Normal, + InCommand, + InExecuteBlock, +} + +struct StreamingEmulatorParser { + buffer: String, + state: ParserState, + code_mode_enabled: bool, +} + +impl StreamingEmulatorParser { + fn new(code_mode_enabled: bool) -> Self { + Self { + buffer: String::new(), + state: ParserState::Normal, + code_mode_enabled, + } + } + + fn process_chunk(&mut self, chunk: &str) -> Vec { + self.buffer.push_str(chunk); + let mut results = Vec::new(); + + loop { + match self.state { + ParserState::InCommand => { + if let Some((command_line, rest)) = self.buffer.split_once('\n') { + if let Some(command) = command_line.strip_prefix('$') { + let command = command.trim(); + if !command.is_empty() { + results.push(EmulatorAction::ShellCommand(command.to_string())); + } + } + self.buffer = rest.to_string(); + self.state = ParserState::Normal; + } else { + break; + } + } + ParserState::InExecuteBlock => { + // Look for closing ``` to end the execute block + if let Some(end_idx) = self.buffer.find("\n```") { + #[allow(clippy::string_slice)] + let code = self.buffer[..end_idx].to_string(); + // Skip past the closing ``` and any trailing newline + #[allow(clippy::string_slice)] + let rest = &self.buffer[end_idx + 4..]; + let rest = rest.strip_prefix('\n').unwrap_or(rest); + self.buffer = rest.to_string(); + self.state = ParserState::Normal; + if !code.trim().is_empty() { + results.push(EmulatorAction::ExecuteCode(code)); + } + } else { + // Still accumulating code — wait for closing fence + break; + } + } + ParserState::Normal => { + // Check for ```execute block (code mode) + if self.code_mode_enabled { + if let Some((before, after)) = self.buffer.split_once("```execute\n") { + if !before.trim().is_empty() { + results.push(EmulatorAction::Text(before.to_string())); + } + self.buffer = after.to_string(); + self.state = ParserState::InExecuteBlock; + continue; + } + // Also handle without newline after tag (accumulating) + if self.buffer.ends_with("```execute") { + let before = self.buffer.trim_end_matches("```execute"); + if !before.trim().is_empty() { + results.push(EmulatorAction::Text(before.to_string())); + } + self.buffer.clear(); + self.state = ParserState::InExecuteBlock; + continue; + } + } + + // Check for $ command + if let Some((before_dollar, from_dollar)) = self.buffer.split_once("\n$") { + let text = format!("{}\n", before_dollar); + if !text.trim().is_empty() { + results.push(EmulatorAction::Text(text)); + } + self.buffer = format!("${}", from_dollar); + self.state = ParserState::InCommand; + } else if self.buffer.starts_with('$') && self.buffer.len() == chunk.len() { + self.state = ParserState::InCommand; + } else { + let hold_back = if self.code_mode_enabled { + HOLD_BACK_CODE_MODE + } else { + HOLD_BACK_SHELL_ONLY + }; + let char_count = self.buffer.chars().count(); + if char_count > hold_back && !self.buffer.ends_with('\n') { + let mut chars = self.buffer.chars(); + let emit_count = char_count - hold_back; + let emit_text: String = chars.by_ref().take(emit_count).collect(); + let keep_text: String = chars.collect(); + if !emit_text.is_empty() { + results.push(EmulatorAction::Text(emit_text)); + } + self.buffer = keep_text; + } + break; + } + } + } + } + + results + } + + fn flush(&mut self) -> Vec { + let mut results = Vec::new(); + + if !self.buffer.is_empty() { + match self.state { + ParserState::InCommand => { + let command_line = self.buffer.trim(); + if let Some(command) = command_line.strip_prefix('$') { + let command = command.trim(); + if !command.is_empty() { + results.push(EmulatorAction::ShellCommand(command.to_string())); + } + } else if !command_line.is_empty() { + results.push(EmulatorAction::Text(self.buffer.clone())); + } + } + ParserState::InExecuteBlock => { + let code = self.buffer.trim(); + if !code.is_empty() { + results.push(EmulatorAction::ExecuteCode(code.to_string())); + } + } + ParserState::Normal => { + results.push(EmulatorAction::Text(self.buffer.clone())); + } + } + self.buffer.clear(); + self.state = ParserState::Normal; + } + + results + } +} + +fn send_emulator_action( + action: &EmulatorAction, + message_id: &str, + tx: &StreamSender, +) -> Result { + match action { + EmulatorAction::Text(text) => { + let mut message = Message::assistant().with_text(text); + message.id = Some(message_id.to_string()); + tx.blocking_send(Ok((Some(message), None))) + .map_err(|_| ())?; + Ok(false) + } + EmulatorAction::ShellCommand(command) => { + let tool_id = Uuid::new_v4().to_string(); + let mut args = serde_json::Map::new(); + args.insert("command".to_string(), json!(command)); + let tool_call = CallToolRequestParams { + meta: None, + task: None, + name: Cow::Borrowed(SHELL_TOOL), + arguments: Some(args), + }; + let mut message = Message::assistant(); + message + .content + .push(MessageContent::tool_request(tool_id, Ok(tool_call))); + message.id = Some(message_id.to_string()); + tx.blocking_send(Ok((Some(message), None))) + .map_err(|_| ())?; + Ok(true) + } + EmulatorAction::ExecuteCode(code) => { + let tool_id = Uuid::new_v4().to_string(); + let wrapped = if code.contains("async function run()") { + code.clone() + } else { + format!("async function run() {{\n{}\n}}", code) + }; + let mut args = serde_json::Map::new(); + args.insert("code".to_string(), json!(wrapped)); + let tool_call = CallToolRequestParams { + meta: None, + task: None, + name: Cow::Borrowed(CODE_EXECUTION_TOOL), + arguments: Some(args), + }; + let mut message = Message::assistant(); + message + .content + .push(MessageContent::tool_request(tool_id, Ok(tool_call))); + message.id = Some(message_id.to_string()); + tx.blocking_send(Ok((Some(message), None))) + .map_err(|_| ())?; + Ok(true) + } + } +} + +pub(super) fn generate_with_emulated_tools( + ctx: &mut GenerationContext<'_>, + code_mode_enabled: bool, +) -> Result<(), ProviderError> { + let prompt = ctx + .loaded + .model + .apply_chat_template(&ctx.loaded.template, ctx.chat_messages, true) + .map_err(|e| { + ProviderError::ExecutionError(format!("Failed to apply chat template: {}", e)) + })?; + + let tokens = ctx + .loaded + .model + .str_to_token(&prompt, AddBos::Never) + .map_err(|e| ProviderError::ExecutionError(e.to_string()))?; + + let (prompt_token_count, effective_ctx) = validate_and_compute_context( + ctx.loaded, + ctx.runtime, + tokens.len(), + ctx.context_limit, + ctx.settings, + )?; + let mut llama_ctx = create_and_prefill_context( + ctx.loaded, + ctx.runtime, + &tokens, + effective_ctx, + ctx.settings, + )?; + + let message_id = ctx.message_id; + let tx = ctx.tx; + let mut emulator_parser = StreamingEmulatorParser::new(code_mode_enabled); + let mut tool_call_emitted = false; + let mut send_failed = false; + + let output_token_count = generation_loop( + &ctx.loaded.model, + &mut llama_ctx, + ctx.settings, + prompt_token_count, + effective_ctx, + |piece| { + let actions = emulator_parser.process_chunk(piece); + for action in actions { + match send_emulator_action(&action, message_id, tx) { + Ok(is_tool) => { + if is_tool { + tool_call_emitted = true; + } + } + Err(_) => { + send_failed = true; + return Ok(TokenAction::Stop); + } + } + } + if tool_call_emitted { + Ok(TokenAction::Stop) + } else { + Ok(TokenAction::Continue) + } + }, + )?; + + if !send_failed { + for action in emulator_parser.flush() { + if send_emulator_action(&action, message_id, tx).is_err() { + break; + } + } + } + + let provider_usage = finalize_usage( + ctx.log, + std::mem::take(&mut ctx.model_name), + "emulator", + prompt_token_count, + output_token_count, + None, + ); + let _ = ctx.tx.blocking_send(Ok((None, Some(provider_usage)))); + Ok(()) +} + +#[cfg(test)] +mod tests { + use super::*; + + /// Collect all actions from feeding chunks through the parser, then flushing. + fn parse_chunks(chunks: &[&str], code_mode: bool) -> Vec { + let mut parser = StreamingEmulatorParser::new(code_mode); + let mut actions = Vec::new(); + for chunk in chunks { + actions.extend(parser.process_chunk(chunk)); + } + actions.extend(parser.flush()); + actions + } + + fn parse_all(input: &str, code_mode: bool) -> Vec { + parse_chunks(&[input], code_mode) + } + + fn assert_text(action: &EmulatorAction, expected: &str) { + match action { + EmulatorAction::Text(t) => assert_eq!(t.trim(), expected.trim(), "text mismatch"), + other => panic!("expected Text, got {:?}", action_label(other)), + } + } + + fn assert_shell(action: &EmulatorAction, expected: &str) { + match action { + EmulatorAction::ShellCommand(cmd) => { + assert_eq!(cmd, expected, "shell command mismatch") + } + other => panic!("expected ShellCommand, got {:?}", action_label(other)), + } + } + + fn assert_execute(action: &EmulatorAction, expected: &str) { + match action { + EmulatorAction::ExecuteCode(code) => { + assert_eq!(code.trim(), expected.trim(), "execute code mismatch") + } + other => panic!("expected ExecuteCode, got {:?}", action_label(other)), + } + } + + fn action_label(a: &EmulatorAction) -> &'static str { + match a { + EmulatorAction::Text(_) => "Text", + EmulatorAction::ShellCommand(_) => "ShellCommand", + EmulatorAction::ExecuteCode(_) => "ExecuteCode", + } + } + + #[test] + fn plain_text_no_tools() { + let actions = parse_all("Hello, world!", false); + // Hold-back may split text across actions; concatenate all text + let all_text: String = actions + .iter() + .map(|a| match a { + EmulatorAction::Text(t) => t.as_str(), + _ => panic!("expected only Text actions"), + }) + .collect(); + assert_eq!(all_text.trim(), "Hello, world!"); + } + + #[test] + fn single_shell_command() { + let actions = parse_all("$ ls -la\n", false); + assert_eq!(actions.len(), 1); + assert_shell(&actions[0], "ls -la"); + } + + #[test] + fn text_then_shell_command() { + let actions = parse_all("Let me check:\n$ ls -la\n", false); + assert!(actions.len() >= 2); + assert_text(&actions[0], "Let me check:"); + assert_shell(&actions[actions.len() - 1], "ls -la"); + } + + #[test] + fn shell_command_at_start_of_output() { + let actions = parse_all("$ whoami\n", false); + assert_eq!(actions.len(), 1); + assert_shell(&actions[0], "whoami"); + } + + #[test] + fn shell_command_without_trailing_newline() { + // Flush should handle unterminated command + let actions = parse_all("$ whoami", false); + assert_eq!(actions.len(), 1); + assert_shell(&actions[0], "whoami"); + } + + #[test] + fn dollar_sign_mid_sentence_is_not_command() { + let actions = parse_all("It costs $50 per month", false); + for action in &actions { + assert!( + matches!(action, EmulatorAction::Text(_)), + "mid-sentence $ should not trigger a shell command" + ); + } + let all_text: String = actions + .iter() + .filter_map(|a| match a { + EmulatorAction::Text(t) => Some(t.as_str()), + _ => None, + }) + .collect(); + assert_eq!(all_text.trim(), "It costs $50 per month"); + } + + #[test] + fn execute_block() { + let input = "Here's the code:\n```execute\nconsole.log('hi');\n```\n"; + let actions = parse_all(input, true); + assert!(actions.len() >= 2); + assert_text(&actions[0], "Here's the code:"); + assert_execute(&actions[actions.len() - 1], "console.log('hi');"); + } + + #[test] + fn execute_block_not_detected_without_code_mode() { + let input = "```execute\nconsole.log('hi');\n```\n"; + let actions = parse_all(input, false); + // Should be treated as plain text + for action in &actions { + assert!(matches!(action, EmulatorAction::Text(_))); + } + } + + #[test] + fn dollar_split_across_chunks() { + // The \n and $ arrive in separate chunks + let actions = parse_chunks(&["Let me check\n", "$ ls -la\n"], false); + let shells: Vec<_> = actions + .iter() + .filter(|a| matches!(a, EmulatorAction::ShellCommand(_))) + .collect(); + assert_eq!(shells.len(), 1); + assert_shell(shells[0], "ls -la"); + } + + #[test] + fn execute_fence_split_across_chunks() { + let actions = parse_chunks(&["Here:\n```ex", "ecute\nlet x = 1;\n", "```\n"], true); + let executes: Vec<_> = actions + .iter() + .filter(|a| matches!(a, EmulatorAction::ExecuteCode(_))) + .collect(); + assert_eq!(executes.len(), 1); + assert_execute(executes[0], "let x = 1;"); + } + + #[test] + fn multiple_commands_on_separate_lines() { + // In practice, generation stops after the first tool call. But the + // parser should detect commands separated by \n$ when fed as chunks. + let actions = parse_chunks(&["Here:\n$ cd /tmp\n", "Done.\n$ ls\n"], false); + let shells: Vec<_> = actions + .iter() + .filter(|a| matches!(a, EmulatorAction::ShellCommand(_))) + .collect(); + assert_eq!(shells.len(), 2); + assert_shell(shells[0], "cd /tmp"); + assert_shell(shells[1], "ls"); + } + + #[test] + fn regular_code_fence_not_treated_as_execute() { + let input = "```python\nprint('hi')\n```\n"; + let actions = parse_all(input, true); + for action in &actions { + assert!( + matches!(action, EmulatorAction::Text(_)), + "regular code fence should be text" + ); + } + } + + #[test] + fn empty_command_ignored() { + let actions = parse_all("$\n", false); + // Empty command after $ should not produce a ShellCommand + let shells: Vec<_> = actions + .iter() + .filter(|a| matches!(a, EmulatorAction::ShellCommand(_))) + .collect(); + assert_eq!(shells.len(), 0); + } + + #[test] + fn token_by_token_streaming() { + // Simulate LLM generating one token at a time + let input = "$ echo hello\n"; + let chars: Vec = input.chars().map(|c| c.to_string()).collect(); + let chunks: Vec<&str> = chars.iter().map(|s| s.as_str()).collect(); + let actions = parse_chunks(&chunks, false); + let shells: Vec<_> = actions + .iter() + .filter(|a| matches!(a, EmulatorAction::ShellCommand(_))) + .collect(); + assert_eq!(shells.len(), 1); + assert_shell(shells[0], "echo hello"); + } + + #[test] + fn execute_block_with_multiline_code() { + let input = "```execute\nasync function run() {\n const r = await Developer.shell({ command: \"ls\" });\n return r;\n}\n```\n"; + let actions = parse_all(input, true); + let executes: Vec<_> = actions + .iter() + .filter(|a| matches!(a, EmulatorAction::ExecuteCode(_))) + .collect(); + assert_eq!(executes.len(), 1); + match executes[0] { + EmulatorAction::ExecuteCode(code) => { + assert!(code.contains("async function run()")); + assert!(code.contains("Developer.shell")); + } + _ => unreachable!(), + } + } + + #[test] + fn unclosed_execute_block_flushed() { + // Model stops generating mid-block + let input = "```execute\nlet x = 1;"; + let actions = parse_all(input, true); + let executes: Vec<_> = actions + .iter() + .filter(|a| matches!(a, EmulatorAction::ExecuteCode(_))) + .collect(); + assert_eq!(executes.len(), 1); + assert_execute(executes[0], "let x = 1;"); + } +} diff --git a/crates/goose/src/providers/local_inference/inference_engine.rs b/crates/goose/src/providers/local_inference/inference_engine.rs new file mode 100644 index 0000000000..06256fca90 --- /dev/null +++ b/crates/goose/src/providers/local_inference/inference_engine.rs @@ -0,0 +1,387 @@ +use crate::providers::errors::ProviderError; +use crate::providers::local_inference::local_model_registry::ModelSettings; +use crate::providers::utils::RequestLog; +use llama_cpp_2::context::params::LlamaContextParams; +use llama_cpp_2::llama_batch::LlamaBatch; +use llama_cpp_2::model::{LlamaChatMessage, LlamaChatTemplate, LlamaModel}; +use llama_cpp_2::sampling::LlamaSampler; +use std::num::NonZeroU32; + +use super::{InferenceRuntime, StreamSender}; + +pub(super) struct GenerationContext<'a> { + pub loaded: &'a LoadedModel, + pub runtime: &'a InferenceRuntime, + pub chat_messages: &'a [LlamaChatMessage], + pub settings: &'a ModelSettings, + pub context_limit: usize, + pub model_name: String, + pub message_id: &'a str, + pub tx: &'a StreamSender, + pub log: &'a mut RequestLog, +} + +pub(super) struct LoadedModel { + pub model: LlamaModel, + pub template: LlamaChatTemplate, +} + +/// Estimate the maximum context length that can fit in available accelerator/CPU +/// memory based on the model's KV cache requirements. +/// +/// Returns `None` if the model architecture values are unavailable. +pub(super) fn estimate_max_context_for_memory( + model: &LlamaModel, + runtime: &InferenceRuntime, +) -> Option { + let available = super::available_inference_memory_bytes(runtime); + if available == 0 { + return None; + } + + // Reserve memory for computation scratch buffers (attention, etc.) and other overhead. + // The compute buffer can be 40-50% of the KV cache size for large models, so we + // conservatively use only half the available memory for the KV cache. + let usable = (available as f64 * 0.5) as u64; + + let n_layer = model.n_layer() as u64; + let n_head_kv = model.n_head_kv() as u64; + let n_head = model.n_head() as u64; + let n_embd = model.n_embd() as u64; + + if n_head == 0 || n_layer == 0 || n_head_kv == 0 || n_embd == 0 { + return None; + } + + // For MLA (Multi-head Latent Attention) models like DeepSeek/GLM, the actual KV cache + // dimensions differ from n_head_kv * head_dim. Read the true dimensions from GGUF metadata. + let arch = model + .meta_val_str("general.architecture") + .unwrap_or_default(); + let head_dim = n_embd / n_head; + let k_per_head = model + .meta_val_str(&format!("{arch}.attention.key_length")) + .ok() + .and_then(|v| v.parse::().ok()) + .unwrap_or(head_dim); + let v_per_head = model + .meta_val_str(&format!("{arch}.attention.value_length")) + .ok() + .and_then(|v| v.parse::().ok()) + .unwrap_or(head_dim); + + // Total KV dimensions across all KV heads, times n_layer, times 2 bytes (f16) per element + let bytes_per_token = (k_per_head + v_per_head) * n_head_kv * n_layer * 2; + + if bytes_per_token == 0 { + return None; + } + + Some((usable / bytes_per_token) as usize) +} + +pub(super) fn context_cap( + settings: &crate::providers::local_inference::local_model_registry::ModelSettings, + context_limit: usize, + n_ctx_train: usize, + memory_max_ctx: Option, +) -> usize { + if let Some(ctx_size) = settings.context_size { + return ctx_size as usize; + } + + let limit = if context_limit > 0 { + context_limit + } else { + n_ctx_train + }; + + match memory_max_ctx { + Some(mem_max) if mem_max < limit => { + tracing::info!( + "Capping context from {} to {} based on available memory", + limit, + mem_max, + ); + mem_max + } + _ => limit, + } +} + +pub(super) fn effective_context_size( + prompt_token_count: usize, + settings: &crate::providers::local_inference::local_model_registry::ModelSettings, + context_limit: usize, + n_ctx_train: usize, + memory_max_ctx: Option, +) -> usize { + let limit = context_cap(settings, context_limit, n_ctx_train, memory_max_ctx); + let min_generation_headroom = 512; + let needed = prompt_token_count + min_generation_headroom; + if needed > limit { + tracing::warn!( + "Prompt ({} tokens) + headroom exceeds context limit ({}), capping to limit", + prompt_token_count, + limit, + ); + } + needed.min(limit) +} + +pub(super) fn build_context_params( + ctx_size: u32, + settings: &crate::providers::local_inference::local_model_registry::ModelSettings, +) -> LlamaContextParams { + let mut params = LlamaContextParams::default().with_n_ctx(NonZeroU32::new(ctx_size)); + + if let Some(n_batch) = settings.n_batch { + params = params.with_n_batch(n_batch); + } + if let Some(n_threads) = settings.n_threads { + params = params.with_n_threads(n_threads); + params = params.with_n_threads_batch(n_threads); + } + if let Some(flash_attn) = settings.flash_attention { + let policy = if flash_attn { 1 } else { 0 }; + params = params.with_flash_attention_policy(policy); + } + + params +} + +pub(super) fn build_sampler( + settings: &crate::providers::local_inference::local_model_registry::ModelSettings, +) -> LlamaSampler { + use crate::providers::local_inference::local_model_registry::SamplingConfig; + + let has_penalties = settings.repeat_penalty != 1.0 + || settings.frequency_penalty != 0.0 + || settings.presence_penalty != 0.0; + + let mut samplers: Vec = Vec::new(); + + if has_penalties { + samplers.push(LlamaSampler::penalties( + settings.repeat_last_n, + settings.repeat_penalty, + settings.frequency_penalty, + settings.presence_penalty, + )); + } + + match &settings.sampling { + SamplingConfig::Greedy => { + samplers.push(LlamaSampler::greedy()); + } + SamplingConfig::Temperature { + temperature, + top_k, + top_p, + min_p, + seed, + } => { + samplers.push(LlamaSampler::top_k(*top_k)); + samplers.push(LlamaSampler::top_p(*top_p, 1)); + samplers.push(LlamaSampler::min_p(*min_p, 1)); + samplers.push(LlamaSampler::temp(*temperature)); + samplers.push(LlamaSampler::dist(seed.unwrap_or(0))); + } + SamplingConfig::MirostatV2 { tau, eta, seed } => { + samplers.push(LlamaSampler::mirostat_v2(seed.unwrap_or(0), *tau, *eta)); + } + } + + if samplers.len() == 1 { + samplers.pop().unwrap() + } else { + LlamaSampler::chain_simple(samplers) + } +} + +/// Validate prompt tokens against memory limits and compute the effective +/// context size. Returns `(prompt_token_count, effective_ctx)`. +pub(super) fn validate_and_compute_context( + loaded: &LoadedModel, + runtime: &InferenceRuntime, + prompt_token_count: usize, + context_limit: usize, + settings: &crate::providers::local_inference::local_model_registry::ModelSettings, +) -> Result<(usize, usize), ProviderError> { + let n_ctx_train = loaded.model.n_ctx_train() as usize; + let memory_max_ctx = estimate_max_context_for_memory(&loaded.model, runtime); + let effective_ctx = effective_context_size( + prompt_token_count, + settings, + context_limit, + n_ctx_train, + memory_max_ctx, + ); + if let Some(mem_max) = memory_max_ctx { + if prompt_token_count > mem_max { + return Err(ProviderError::ContextLengthExceeded(format!( + "Prompt ({} tokens) exceeds estimated memory capacity ({} tokens). \ + Try a smaller model or reduce conversation length.", + prompt_token_count, mem_max, + ))); + } + } + Ok((prompt_token_count, effective_ctx)) +} + +/// Create a llama context and prefill (decode) all prompt tokens. +pub(super) fn create_and_prefill_context<'model>( + loaded: &'model LoadedModel, + runtime: &InferenceRuntime, + tokens: &[llama_cpp_2::token::LlamaToken], + effective_ctx: usize, + settings: &crate::providers::local_inference::local_model_registry::ModelSettings, +) -> Result, ProviderError> { + let ctx_params = build_context_params(effective_ctx as u32, settings); + let mut ctx = loaded + .model + .new_context(runtime.backend(), ctx_params) + .map_err(|e| ProviderError::ExecutionError(format!("Failed to create context: {}", e)))?; + + let n_batch = ctx.n_batch() as usize; + for chunk in tokens.chunks(n_batch) { + let mut batch = LlamaBatch::get_one(chunk) + .map_err(|e| ProviderError::ExecutionError(format!("Failed to create batch: {}", e)))?; + ctx.decode(&mut batch) + .map_err(|e| ProviderError::ExecutionError(format!("Prefill decode failed: {}", e)))?; + } + + Ok(ctx) +} + +/// Action to take after processing a generated token piece. +pub(super) enum TokenAction { + Continue, + Stop, +} + +/// Run the autoregressive generation loop. Calls `on_piece` for each non-empty +/// token piece. The callback returns `TokenAction::Stop` to break early. +/// Returns the total number of generated tokens. +pub(super) fn generation_loop( + model: &LlamaModel, + ctx: &mut llama_cpp_2::context::LlamaContext<'_>, + settings: &crate::providers::local_inference::local_model_registry::ModelSettings, + prompt_token_count: usize, + effective_ctx: usize, + mut on_piece: impl FnMut(&str) -> Result, +) -> Result { + let mut sampler = build_sampler(settings); + let max_output = if let Some(max) = settings.max_output_tokens { + effective_ctx.saturating_sub(prompt_token_count).min(max) + } else { + effective_ctx.saturating_sub(prompt_token_count) + }; + let mut decoder = encoding_rs::UTF_8.new_decoder(); + let mut output_token_count: i32 = 0; + + for _ in 0..max_output { + let token = sampler.sample(ctx, -1); + sampler.accept(token); + + if model.is_eog_token(token) { + break; + } + + output_token_count += 1; + + let piece = model + .token_to_piece(token, &mut decoder, true, None) + .map_err(|e| ProviderError::ExecutionError(format!("Failed to decode token: {}", e)))?; + + if !piece.is_empty() && matches!(on_piece(&piece)?, TokenAction::Stop) { + break; + } + + let next_tokens = [token]; + let mut next_batch = LlamaBatch::get_one(&next_tokens) + .map_err(|e| ProviderError::ExecutionError(format!("Failed to create batch: {}", e)))?; + ctx.decode(&mut next_batch) + .map_err(|e| ProviderError::ExecutionError(format!("Decode failed: {}", e)))?; + } + + Ok(output_token_count) +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::providers::local_inference::local_model_registry::ModelSettings; + + fn default_settings() -> ModelSettings { + ModelSettings::default() + } + + #[test] + fn test_effective_context_size_basic() { + assert_eq!( + effective_context_size(100, &default_settings(), 4096, 4096, None), + 612 + ); + } + + #[test] + fn test_effective_context_size_capped_by_limit() { + assert_eq!( + effective_context_size(100, &default_settings(), 1024, 8192, None), + 612 + ); + } + + #[test] + fn test_effective_context_size_capped_by_memory() { + assert_eq!( + effective_context_size(100, &default_settings(), 4096, 4096, Some(800)), + 612 + ); + } + + #[test] + fn test_effective_context_size_memory_smaller_than_needed() { + assert_eq!( + effective_context_size(600, &default_settings(), 4096, 4096, Some(700)), + 700 + ); + } + + #[test] + fn test_effective_context_size_zero_limit_uses_train() { + assert_eq!( + effective_context_size(100, &default_settings(), 0, 2048, None), + 612 + ); + } + + #[test] + fn test_effective_context_size_prompt_exceeds_all_limits() { + assert_eq!( + effective_context_size(5000, &default_settings(), 4096, 4096, None), + 4096 + ); + } + + #[test] + fn test_context_cap_with_settings_override() { + let mut settings = default_settings(); + settings.context_size = Some(2048); + assert_eq!(context_cap(&settings, 4096, 8192, Some(1024)), 2048); + } + + #[test] + fn test_context_cap_without_override() { + assert_eq!(context_cap(&default_settings(), 4096, 8192, None), 4096); + } + + #[test] + fn test_context_cap_memory_limited() { + assert_eq!( + context_cap(&default_settings(), 4096, 8192, Some(2048)), + 2048 + ); + } +} diff --git a/crates/goose/src/providers/local_inference/inference_native_tools.rs b/crates/goose/src/providers/local_inference/inference_native_tools.rs new file mode 100644 index 0000000000..656a6e08cf --- /dev/null +++ b/crates/goose/src/providers/local_inference/inference_native_tools.rs @@ -0,0 +1,197 @@ +use crate::conversation::message::Message; +use crate::providers::errors::ProviderError; +use llama_cpp_2::model::AddBos; +use llama_cpp_2::openai::OpenAIChatTemplateParams; + +use super::finalize_usage; +use super::inference_engine::{ + context_cap, create_and_prefill_context, estimate_max_context_for_memory, generation_loop, + validate_and_compute_context, GenerationContext, TokenAction, +}; +use super::tool_parsing::{ + extract_tool_call_messages, extract_xml_tool_call_messages, safe_stream_end, + split_content_and_tool_calls, split_content_and_xml_tool_calls, +}; + +pub(super) fn generate_with_native_tools( + ctx: &mut GenerationContext<'_>, + oai_messages_json: &Option, + full_tools_json: Option<&str>, + compact_tools: Option<&str>, +) -> Result<(), ProviderError> { + let min_generation_headroom = 512; + let n_ctx_train = ctx.loaded.model.n_ctx_train() as usize; + let memory_max_ctx = estimate_max_context_for_memory(&ctx.loaded.model, ctx.runtime); + let cap = context_cap(ctx.settings, ctx.context_limit, n_ctx_train, memory_max_ctx); + let token_budget = cap.saturating_sub(min_generation_headroom); + + let apply_template = |tools: Option<&str>| { + if let Some(ref messages_json) = oai_messages_json { + let params = OpenAIChatTemplateParams { + messages_json: messages_json.as_str(), + tools_json: tools, + tool_choice: None, + json_schema: None, + grammar: None, + reasoning_format: None, + chat_template_kwargs: None, + add_generation_prompt: true, + use_jinja: true, + parallel_tool_calls: false, + enable_thinking: false, + add_bos: false, + add_eos: false, + parse_tool_calls: true, + }; + ctx.loaded + .model + .apply_chat_template_oaicompat(&ctx.loaded.template, ¶ms) + } else { + ctx.loaded.model.apply_chat_template_with_tools_oaicompat( + &ctx.loaded.template, + ctx.chat_messages, + tools, + None, + true, + ) + } + }; + + let template_result = match apply_template(full_tools_json) { + Ok(r) => { + let token_count = ctx + .loaded + .model + .str_to_token(&r.prompt, AddBos::Never) + .map(|t| t.len()) + .unwrap_or(0); + if token_count > token_budget { + apply_template(compact_tools).unwrap_or(r) + } else { + r + } + } + Err(_) => apply_template(compact_tools).map_err(|e| { + ProviderError::ExecutionError(format!("Failed to apply chat template: {}", e)) + })?, + }; + + let _ = ctx.log.write( + &serde_json::json!({"applied_prompt": &template_result.prompt}), + None, + ); + + let tokens = ctx + .loaded + .model + .str_to_token(&template_result.prompt, AddBos::Never) + .map_err(|e| ProviderError::ExecutionError(e.to_string()))?; + + let (prompt_token_count, effective_ctx) = validate_and_compute_context( + ctx.loaded, + ctx.runtime, + tokens.len(), + ctx.context_limit, + ctx.settings, + )?; + let mut llama_ctx = create_and_prefill_context( + ctx.loaded, + ctx.runtime, + &tokens, + effective_ctx, + ctx.settings, + )?; + + let message_id = ctx.message_id; + let tx = ctx.tx; + let mut generated_text = String::new(); + let mut streamed_len: usize = 0; + + let output_token_count = generation_loop( + &ctx.loaded.model, + &mut llama_ctx, + ctx.settings, + prompt_token_count, + effective_ctx, + |piece| { + generated_text.push_str(piece); + + let has_xml_tc = split_content_and_xml_tool_calls(&generated_text).is_some(); + let (content, tc) = split_content_and_tool_calls(&generated_text); + let stream_up_to = if tc.is_some() { + content.len() + } else if has_xml_tc { + split_content_and_xml_tool_calls(&generated_text) + .map(|(c, _)| c.len()) + .unwrap_or(0) + } else { + safe_stream_end(&generated_text) + }; + if stream_up_to > streamed_len { + #[allow(clippy::string_slice)] + let new_text = &generated_text[streamed_len..stream_up_to]; + if !new_text.is_empty() { + let mut msg = Message::assistant().with_text(new_text); + msg.id = Some(message_id.to_string()); + if tx.blocking_send(Ok((Some(msg), None))).is_err() { + return Ok(TokenAction::Stop); + } + } + streamed_len = stream_up_to; + } + + let should_stop = template_result + .additional_stops + .iter() + .any(|stop| generated_text.ends_with(stop)); + if should_stop { + Ok(TokenAction::Stop) + } else { + Ok(TokenAction::Continue) + } + }, + )?; + + let (content, tool_call_msgs) = + if let Some((xml_content, xml_calls)) = split_content_and_xml_tool_calls(&generated_text) { + let msgs = extract_xml_tool_call_messages(xml_calls, message_id); + (xml_content, msgs) + } else { + let (json_content, tool_calls_json) = split_content_and_tool_calls(&generated_text); + let msgs = tool_calls_json + .map(|tc| extract_tool_call_messages(&tc, message_id)) + .unwrap_or_default(); + (json_content, msgs) + }; + + if content.len() > streamed_len { + #[allow(clippy::string_slice)] + let remaining = &content[streamed_len..]; + if !remaining.is_empty() { + let mut msg = Message::assistant().with_text(remaining); + msg.id = Some(message_id.to_string()); + let _ = tx.blocking_send(Ok((Some(msg), None))); + } + } + + if !tool_call_msgs.is_empty() { + for msg in tool_call_msgs { + let _ = tx.blocking_send(Ok((Some(msg), None))); + } + } else if content.is_empty() && !generated_text.is_empty() { + let mut msg = Message::assistant().with_text(&generated_text); + msg.id = Some(message_id.to_string()); + let _ = tx.blocking_send(Ok((Some(msg), None))); + } + + let provider_usage = finalize_usage( + ctx.log, + std::mem::take(&mut ctx.model_name), + "native", + prompt_token_count, + output_token_count, + Some(("generated_text", &generated_text)), + ); + let _ = ctx.tx.blocking_send(Ok((None, Some(provider_usage)))); + Ok(()) +} diff --git a/crates/goose/src/providers/local_inference/local_model_registry.rs b/crates/goose/src/providers/local_inference/local_model_registry.rs new file mode 100644 index 0000000000..898a138912 --- /dev/null +++ b/crates/goose/src/providers/local_inference/local_model_registry.rs @@ -0,0 +1,319 @@ +use crate::config::paths::Paths; +use crate::download_manager::{get_download_manager, DownloadStatus}; +use anyhow::Result; +use serde::{Deserialize, Serialize}; +use std::path::PathBuf; +use std::sync::{Mutex, OnceLock}; +use utoipa::ToSchema; + +#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)] +#[serde(tag = "type")] +pub enum SamplingConfig { + Greedy, + Temperature { + temperature: f32, + top_k: i32, + top_p: f32, + min_p: f32, + seed: Option, + }, + MirostatV2 { + tau: f32, + eta: f32, + seed: Option, + }, +} + +impl Default for SamplingConfig { + fn default() -> Self { + SamplingConfig::Temperature { + temperature: 0.8, + top_k: 40, + top_p: 0.95, + min_p: 0.05, + seed: None, + } + } +} + +#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)] +pub struct ModelSettings { + pub context_size: Option, + pub max_output_tokens: Option, + #[serde(default)] + pub sampling: SamplingConfig, + #[serde(default = "default_repeat_penalty")] + pub repeat_penalty: f32, + #[serde(default = "default_repeat_last_n")] + pub repeat_last_n: i32, + #[serde(default)] + pub frequency_penalty: f32, + #[serde(default)] + pub presence_penalty: f32, + pub n_batch: Option, + pub n_gpu_layers: Option, + #[serde(default)] + pub use_mlock: bool, + pub flash_attention: Option, + pub n_threads: Option, + #[serde(default)] + pub native_tool_calling: bool, + #[serde(default)] + pub use_jinja: bool, +} + +fn default_repeat_penalty() -> f32 { + 1.0 +} + +fn default_repeat_last_n() -> i32 { + 64 +} + +impl Default for ModelSettings { + fn default() -> Self { + Self { + context_size: None, + max_output_tokens: None, + sampling: SamplingConfig::default(), + repeat_penalty: 1.0, + repeat_last_n: 64, + frequency_penalty: 0.0, + presence_penalty: 0.0, + n_batch: None, + n_gpu_layers: None, + use_mlock: false, + flash_attention: None, + n_threads: None, + native_tool_calling: false, + use_jinja: false, + } + } +} + +/// Featured models — HuggingFace specs in "author/repo-GGUF:quantization" format. +pub const FEATURED_MODELS: &[&str] = &[ + "bartowski/Llama-3.2-1B-Instruct-GGUF:Q4_K_M", + "bartowski/Llama-3.2-3B-Instruct-GGUF:Q4_K_M", + "bartowski/Hermes-2-Pro-Mistral-7B-GGUF:Q4_K_M", + "bartowski/Mistral-Small-24B-Instruct-2501-GGUF:Q4_K_M", +]; + +/// Check if a model ID corresponds to a featured model. +pub fn is_featured_model(model_id: &str) -> bool { + use super::hf_models::parse_model_spec; + FEATURED_MODELS.iter().any(|spec| { + if let Ok((repo_id, quant)) = parse_model_spec(spec) { + model_id_from_repo(&repo_id, &quant) == model_id + } else { + false + } + }) +} + +static REGISTRY: OnceLock> = OnceLock::new(); + +pub fn get_registry() -> &'static Mutex { + REGISTRY.get_or_init(|| { + let registry = LocalModelRegistry::load().unwrap_or_default(); + Mutex::new(registry) + }) +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct LocalModelEntry { + pub id: String, + pub display_name: String, + pub repo_id: String, + pub filename: String, + pub quantization: String, + pub local_path: PathBuf, + pub source_url: String, + #[serde(default)] + pub settings: ModelSettings, + #[serde(default)] + pub size_bytes: u64, +} + +impl LocalModelEntry { + pub fn is_downloaded(&self) -> bool { + self.local_path.exists() + } + + pub fn is_downloading(&self) -> bool { + let download_id = format!("{}-model", self.id); + let manager = get_download_manager(); + manager.get_progress(&download_id).is_some() + } + + pub fn download_status(&self) -> ModelDownloadStatus { + if self.local_path.exists() { + return ModelDownloadStatus::Downloaded; + } + + let download_id = format!("{}-model", self.id); + let manager = get_download_manager(); + if let Some(progress) = manager.get_progress(&download_id) { + return match progress.status { + DownloadStatus::Downloading => ModelDownloadStatus::Downloading { + progress_percent: progress.progress_percent, + bytes_downloaded: progress.bytes_downloaded, + total_bytes: progress.total_bytes, + speed_bps: progress.speed_bps.unwrap_or(0), + }, + DownloadStatus::Completed => ModelDownloadStatus::Downloaded, + DownloadStatus::Failed | DownloadStatus::Cancelled => { + ModelDownloadStatus::NotDownloaded + } + }; + } + + ModelDownloadStatus::NotDownloaded + } + + pub fn file_size(&self) -> u64 { + if self.size_bytes > 0 { + return self.size_bytes; + } + std::fs::metadata(&self.local_path) + .map(|m| m.len()) + .unwrap_or(0) + } +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub enum ModelDownloadStatus { + NotDownloaded, + Downloading { + progress_percent: f32, + bytes_downloaded: u64, + total_bytes: u64, + speed_bps: u64, + }, + Downloaded, +} + +#[derive(Debug, Clone, Serialize, Deserialize, Default)] +pub struct LocalModelRegistry { + pub models: Vec, +} + +impl LocalModelRegistry { + fn registry_path() -> PathBuf { + Paths::in_data_dir("models/registry.json") + } + + pub fn load() -> Result { + let path = Self::registry_path(); + if path.exists() { + let lock_path = path.with_extension("json.lock"); + let lock_file = std::fs::File::create(&lock_path)?; + fs2::FileExt::lock_shared(&lock_file)?; + let contents = std::fs::read_to_string(&path)?; + fs2::FileExt::unlock(&lock_file)?; + let registry: LocalModelRegistry = serde_json::from_str(&contents)?; + Ok(registry) + } else { + Ok(Self::default()) + } + } + + pub fn save(&self) -> Result<()> { + let path = Self::registry_path(); + if let Some(parent) = path.parent() { + std::fs::create_dir_all(parent)?; + } + + let lock_path = path.with_extension("json.lock"); + let lock_file = std::fs::File::create(&lock_path)?; + fs2::FileExt::lock_exclusive(&lock_file)?; + + let mut tmp = tempfile::NamedTempFile::new_in(path.parent().unwrap())?; + let contents = serde_json::to_string_pretty(self)?; + std::io::Write::write_all(&mut tmp, contents.as_bytes())?; + tmp.persist(&path)?; + + fs2::FileExt::unlock(&lock_file)?; + Ok(()) + } + + /// Sync registry with featured models: + /// add any featured models that are missing, remove non-downloaded non-featured models. + pub fn sync_with_featured(&mut self, featured_entries: Vec) { + let mut changed = false; + + for entry in featured_entries { + if !self.models.iter().any(|m| m.id == entry.id) { + self.models.push(entry); + changed = true; + } + } + + let before_len = self.models.len(); + self.models + .retain(|m| m.is_downloaded() || m.is_downloading() || is_featured_model(&m.id)); + if self.models.len() != before_len { + changed = true; + } + + if changed { + let _ = self.save(); + } + } + + pub fn add_model(&mut self, entry: LocalModelEntry) -> Result<()> { + if let Some(existing) = self.models.iter_mut().find(|m| m.id == entry.id) { + *existing = entry; + } else { + self.models.push(entry); + } + self.save() + } + + pub fn remove_model(&mut self, id: &str) -> Result<()> { + self.models.retain(|m| m.id != id); + self.save() + } + + pub fn get_model(&self, id: &str) -> Option<&LocalModelEntry> { + self.models.iter().find(|m| m.id == id) + } + + pub fn has_model(&self, id: &str) -> bool { + self.models.iter().any(|m| m.id == id) + } + + pub fn get_model_settings(&self, id: &str) -> Option<&ModelSettings> { + self.models.iter().find(|m| m.id == id).map(|m| &m.settings) + } + + pub fn update_model_settings(&mut self, id: &str, settings: ModelSettings) -> Result<()> { + let entry = self + .models + .iter_mut() + .find(|m| m.id == id) + .ok_or_else(|| anyhow::anyhow!("Model not found: {}", id))?; + entry.settings = settings; + self.save() + } + + pub fn list_models(&self) -> &[LocalModelEntry] { + &self.models + } +} + +/// Generate a unique ID for a model from its repo_id and quantization. +pub fn model_id_from_repo(repo_id: &str, quantization: &str) -> String { + format!("{}:{}", repo_id, quantization) +} + +/// Generate a display name from repo_id and quantization. +pub fn display_name_from_repo(repo_id: &str, quantization: &str) -> String { + let model_name = repo_id + .split('/') + .next_back() + .unwrap_or(repo_id) + .trim_end_matches("-GGUF") + .trim_end_matches("-gguf"); + format!("{} ({})", model_name, quantization) +} diff --git a/crates/goose/src/providers/local_inference/tool_parsing.rs b/crates/goose/src/providers/local_inference/tool_parsing.rs new file mode 100644 index 0000000000..cf6124a6e1 --- /dev/null +++ b/crates/goose/src/providers/local_inference/tool_parsing.rs @@ -0,0 +1,601 @@ +use crate::conversation::message::{Message, MessageContent}; +use rmcp::model::{CallToolRequestParams, Tool}; +use serde_json::{json, Value}; +use std::borrow::Cow; +use uuid::Uuid; + +pub(super) fn compact_tools_json(tools: &[Tool]) -> Option { + let compact: Vec = tools + .iter() + .map(|t| { + json!({ + "type": "function", + "function": { + "name": t.name, + "description": t.description.as_ref().map(|d| d.as_ref()).unwrap_or(""), + } + }) + }) + .collect(); + serde_json::to_string(&compact).ok() +} + +/// Split generated text into (content, tool_calls_json). +/// Looks for the last top-level JSON object containing `"tool_calls"`. +/// Returns the text before it as content, and the JSON string if found. +#[allow(clippy::string_slice)] +pub(super) fn split_content_and_tool_calls(text: &str) -> (String, Option) { + let trimmed = text.trim_end(); + if !trimmed.ends_with('}') { + return (text.to_string(), None); + } + + // Scan backwards for the matching '{' of the final '}'. + // We only match on ASCII braces so `start` is always a char boundary. + let bytes = trimmed.as_bytes(); + let mut depth = 0i32; + let mut json_start = None; + for i in (0..bytes.len()).rev() { + match bytes[i] { + b'}' => depth += 1, + b'{' => { + depth -= 1; + if depth == 0 { + json_start = Some(i); + break; + } + } + _ => {} + } + } + + let Some(start) = json_start else { + return (text.to_string(), None); + }; + + let json_str = &trimmed[start..]; + let parsed: Value = match serde_json::from_str(json_str) { + Ok(v) => v, + Err(_) => return (text.to_string(), None), + }; + + if parsed + .get("tool_calls") + .and_then(|v| v.as_array()) + .is_none() + { + return (text.to_string(), None); + } + + let content = trimmed[..start].trim_end().to_string(); + (content, Some(json_str.to_string())) +} + +/// Return the byte length of text that is safe to stream. +/// Everything before the last unmatched top-level `{` is safe — the `{` could +/// be the start of a tool-call JSON block still being generated. +/// If all braces are balanced the entire text is safe. +pub(super) fn safe_stream_end(text: &str) -> usize { + // Hold back from the start of any incomplete tag. + // If we find an unmatched opening, nothing from that point should be streamed. + let xml_hold = text.find("").unwrap_or(text.len()); + + let bytes = text.as_bytes(); + let mut safe_end = bytes.len(); + let mut depth = 0i32; + for (i, &b) in bytes.iter().enumerate() { + match b { + b'{' => { + if depth == 0 { + safe_end = i; + } + depth += 1; + } + b'}' => { + depth -= 1; + if depth == 0 { + safe_end = i + 1; + } + } + _ => { + if depth == 0 { + safe_end = i + 1; + } + } + } + } + + // Also hold back a partial ``, hold them. + let tag = b""; + let tail_hold = { + let mut hold = safe_end; + let check_len = tag.len().min(bytes.len()); + for start in (safe_end.saturating_sub(check_len))..safe_end { + let tail = &bytes[start..safe_end]; + if tag.starts_with(tail) { + hold = start; + break; + } + } + hold + }; + + safe_end.min(xml_hold).min(tail_hold) +} + +/// Extract tool call messages from a JSON object containing "tool_calls". +/// Handles both the model's native format (name/arguments at top level) +/// and the OpenAI format (function.name/function.arguments). +pub(super) fn extract_tool_call_messages(tool_calls_json: &str, message_id: &str) -> Vec { + let parsed: Value = match serde_json::from_str(tool_calls_json) { + Ok(v) => v, + Err(_) => return vec![], + }; + + let Some(tool_calls) = parsed.get("tool_calls").and_then(|v| v.as_array()) else { + return vec![]; + }; + + let mut messages = Vec::new(); + for tc in tool_calls { + // Try OpenAI format first: {"function": {"name": ..., "arguments": ...}, "id": ...} + // Then model's native format: {"name": ..., "arguments": {...}, "id": ...} + let (name, arguments) = if let Some(func) = tc.get("function") { + let n = func.get("name").and_then(|v| v.as_str()).unwrap_or(""); + let args_str = func + .get("arguments") + .and_then(|v| v.as_str()) + .unwrap_or("{}"); + let args: Option> = serde_json::from_str(args_str).ok(); + (n.to_string(), args) + } else { + let n = tc.get("name").and_then(|v| v.as_str()).unwrap_or(""); + // Arguments may be an object directly (model format) or a string (OAI format) + let args = if let Some(obj) = tc.get("arguments").and_then(|v| v.as_object()) { + Some(obj.clone()) + } else if let Some(s) = tc.get("arguments").and_then(|v| v.as_str()) { + serde_json::from_str(s).ok() + } else { + None + }; + (n.to_string(), args) + }; + + if name.is_empty() { + continue; + } + + let id = tc + .get("id") + .and_then(|v| v.as_str()) + .map(|s| s.to_string()) + .unwrap_or_else(|| Uuid::new_v4().to_string()); + + let tool_call = CallToolRequestParams { + meta: None, + task: None, + name: Cow::Owned(name), + arguments, + }; + + let mut msg = Message::assistant(); + msg.content + .push(MessageContent::tool_request(id, Ok(tool_call))); + msg.id = Some(message_id.to_string()); + messages.push(msg); + } + + messages +} + +/// Parse XML-style tool calls used by models like qwen3-coder. +/// Format: +/// ```text +/// +/// +/// value1 +/// value2 +/// +/// +/// ``` +/// Returns (content_before_tool_calls, vec_of_tool_calls) or None if no XML tool calls found. +#[allow(clippy::type_complexity)] +pub(super) fn split_content_and_xml_tool_calls( + text: &str, +) -> Option<(String, Vec<(String, serde_json::Map)>)> { + let (content, first_block_and_rest) = text.split_once("")?; + let content = content.trim_end().to_string(); + let mut tool_calls = Vec::new(); + + // Process the first block, then keep splitting on subsequent tags + let mut remaining = first_block_and_rest; + loop { + // Split off the block up to (or take the rest if unclosed) + let (block, after_close) = remaining + .split_once("") + .unwrap_or((remaining, "")); + + if let Some(tool_call) = parse_single_xml_tool_call(block) { + tool_calls.push(tool_call); + } + + // Try to find the next in what remains + match after_close.split_once("") { + Some((_between, next_remaining)) => remaining = next_remaining, + None => break, + } + } + + if tool_calls.is_empty() { + None + } else { + Some((content, tool_calls)) + } +} + +fn parse_single_xml_tool_call(block: &str) -> Option<(String, serde_json::Map)> { + // Try V... format first + if let Some(result) = parse_xml_function_format(block) { + return Some(result); + } + // Try GLM-style: TOOL_NAMEKV... + parse_xml_arg_key_value_format(block) +} + +fn parse_xml_function_format(block: &str) -> Option<(String, serde_json::Map)> { + let (_, after_func_eq) = block.split_once("')?; + let func_name = func_name.trim().to_string(); + + let mut args = serde_json::Map::new(); + let mut rest = func_body; + + while let Some((_, after_param_eq)) = rest.split_once("') else { + break; + }; + let param_name = param_name.trim().to_string(); + + let (value, after_value) = after_name_close + .split_once("") + .unwrap_or((after_name_close, "")); + let value = value.trim(); + + let json_value = + serde_json::from_str(value).unwrap_or_else(|_| Value::String(value.to_string())); + args.insert(param_name, json_value); + + rest = after_value; + } + + Some((func_name, args)) +} + +/// Parse GLM-style tool calls: `NAMEKV...` +/// Also handles zero-argument calls like just `NAME`. +fn parse_xml_arg_key_value_format(block: &str) -> Option<(String, serde_json::Map)> { + let func_name_end = block.find("").unwrap_or(block.len()); + // Safe: find returns a byte offset at the start of an ASCII '<' character, + // and block.len() is always a valid boundary. + #[allow(clippy::string_slice)] + let func_name = block[..func_name_end].trim().to_string(); + if func_name.is_empty() { + return None; + } + + let mut args = serde_json::Map::new(); + #[allow(clippy::string_slice)] + let mut rest = &block[func_name_end..]; + + while let Some((_, after_key_open)) = rest.split_once("") { + let Some((key, after_key_close)) = after_key_open.split_once("") else { + break; + }; + let key = key.trim().to_string(); + + let Some((_, after_val_open)) = after_key_close.split_once("") else { + break; + }; + let (value, after_val_close) = after_val_open + .split_once("") + .unwrap_or((after_val_open, "")); + let value = value.trim(); + + let json_value = + serde_json::from_str(value).unwrap_or_else(|_| Value::String(value.to_string())); + args.insert(key, json_value); + + rest = after_val_close; + } + + Some((func_name, args)) +} + +pub(super) fn extract_xml_tool_call_messages( + tool_calls: Vec<(String, serde_json::Map)>, + message_id: &str, +) -> Vec { + tool_calls + .into_iter() + .map(|(name, args)| { + let tool_call = CallToolRequestParams { + meta: None, + task: None, + name: Cow::Owned(name), + arguments: if args.is_empty() { None } else { Some(args) }, + }; + let mut msg = Message::assistant(); + msg.content.push(MessageContent::tool_request( + Uuid::new_v4().to_string(), + Ok(tool_call), + )); + msg.id = Some(message_id.to_string()); + msg + }) + .collect() +} + +#[cfg(test)] +mod tests { + use super::*; + use serde_json::json; + + const SHELL_TOOL: &str = "developer__shell"; + + #[test] + fn test_parse_xml_tool_call_single() { + let text = "I'll search for that.\n\n\n\nlocal.*inference\n\n"; + let result = split_content_and_xml_tool_calls(text); + assert!(result.is_some()); + let (content, calls) = result.unwrap(); + assert_eq!(content, "I'll search for that."); + assert_eq!(calls.len(), 1); + assert_eq!(calls[0].0, "search__files"); + assert_eq!(calls[0].1.get("pattern").unwrap(), "local.*inference"); + } + + #[test] + fn test_parse_xml_tool_call_multiple_params() { + let text = "\n\nls -la\n30\n\n"; + let result = split_content_and_xml_tool_calls(text); + assert!(result.is_some()); + let (content, calls) = result.unwrap(); + assert!(content.is_empty()); + assert_eq!(calls.len(), 1); + assert_eq!(calls[0].0, SHELL_TOOL); + assert_eq!(calls[0].1.get("command").unwrap(), "ls -la"); + // 30 should be parsed as a number + assert_eq!(calls[0].1.get("timeout").unwrap(), &json!(30)); + } + + #[test] + fn test_parse_xml_tool_call_no_tool_call() { + let text = "Just some regular text with no tool calls."; + assert!(split_content_and_xml_tool_calls(text).is_none()); + } + + #[test] + fn test_parse_xml_tool_call_multiple_calls() { + let text = "Doing two things:\n\n\n1\n\n\n\n\nhello\n\n"; + let result = split_content_and_xml_tool_calls(text); + assert!(result.is_some()); + let (content, calls) = result.unwrap(); + assert_eq!(content, "Doing two things:"); + assert_eq!(calls.len(), 2); + assert_eq!(calls[0].0, "foo__bar"); + assert_eq!(calls[1].0, "baz__qux"); + } + + #[test] + fn test_parse_xml_tool_call_multiline_value() { + let text = "\n\ntest.py\ndef hello():\n print(\"world\")\n\n"; + let result = split_content_and_xml_tool_calls(text); + assert!(result.is_some()); + let (_content, calls) = result.unwrap(); + assert_eq!(calls[0].0, "developer__write_file"); + assert_eq!( + calls[0].1.get("content").unwrap(), + "def hello():\n print(\"world\")" + ); + } + + #[test] + fn test_safe_stream_end_holds_back_tool_call_tag() { + let text = "Some text before \n"; + let safe = safe_stream_end(text); + assert!(safe <= text.find("").unwrap()); + } + + #[test] + fn test_safe_stream_end_holds_back_partial_tag() { + let text = "Some text "; + let result = split_content_and_xml_tool_calls(text); + assert!(result.is_some()); + let (content, calls) = result.unwrap(); + assert_eq!(content, "Let me check."); + assert_eq!(calls.len(), 1); + assert_eq!(calls[0].0, "execute"); + assert_eq!( + calls[0].1.get("code").unwrap(), + "async function run() { return 1; }" + ); + // tool_graph should be parsed as JSON array + assert!(calls[0].1.get("tool_graph").unwrap().is_array()); + } + + #[test] + fn test_extract_xml_tool_call_messages() { + let calls = vec![( + SHELL_TOOL.to_string(), + serde_json::Map::from_iter(vec![("command".to_string(), json!("ls"))]), + )]; + let msgs = extract_xml_tool_call_messages(calls, "test-id"); + assert_eq!(msgs.len(), 1); + assert_eq!(msgs[0].id, Some("test-id".to_string())); + match &msgs[0].content[0] { + MessageContent::ToolRequest(req) => { + let call = req.tool_call.as_ref().unwrap(); + assert_eq!(&*call.name, SHELL_TOOL); + assert_eq!( + call.arguments.as_ref().unwrap().get("command").unwrap(), + "ls" + ); + } + _ => panic!("Expected ToolRequest"), + } + } + + #[test] + fn test_split_content_and_tool_calls_with_tool() { + let text = "Here is the result.\n{\"tool_calls\": [{\"function\": {\"name\": \"shell\", \"arguments\": \"{}\"}, \"id\": \"abc\"}]}"; + let (content, tc) = split_content_and_tool_calls(text); + assert_eq!(content, "Here is the result."); + assert!(tc.is_some()); + let parsed: serde_json::Value = serde_json::from_str(&tc.unwrap()).unwrap(); + assert_eq!(parsed["tool_calls"].as_array().unwrap().len(), 1); + } + + #[test] + fn test_split_content_and_tool_calls_no_tool() { + let text = "Just regular text, no JSON."; + let (content, tc) = split_content_and_tool_calls(text); + assert_eq!(content, text); + assert!(tc.is_none()); + } + + #[test] + fn test_split_content_and_tool_calls_json_without_tool_calls_key() { + let text = "{\"key\": \"value\"}"; + let (content, tc) = split_content_and_tool_calls(text); + assert_eq!(content, text); + assert!(tc.is_none()); + } + + #[test] + fn test_extract_tool_call_messages_openai_format() { + let json_str = r#"{"tool_calls": [{"function": {"name": "developer__shell", "arguments": "{\"command\": \"ls\"}"}, "id": "call-1"}]}"#; + let msgs = extract_tool_call_messages(json_str, "msg-1"); + assert_eq!(msgs.len(), 1); + match &msgs[0].content[0] { + MessageContent::ToolRequest(req) => { + let call = req.tool_call.as_ref().unwrap(); + assert_eq!(&*call.name, SHELL_TOOL); + assert_eq!( + call.arguments.as_ref().unwrap().get("command").unwrap(), + "ls" + ); + } + _ => panic!("Expected ToolRequest"), + } + } + + #[test] + fn test_extract_tool_call_messages_native_format() { + let json_str = r#"{"tool_calls": [{"name": "developer__shell", "arguments": {"command": "ls"}, "id": "call-2"}]}"#; + let msgs = extract_tool_call_messages(json_str, "msg-2"); + assert_eq!(msgs.len(), 1); + match &msgs[0].content[0] { + MessageContent::ToolRequest(req) => { + let call = req.tool_call.as_ref().unwrap(); + assert_eq!(&*call.name, SHELL_TOOL); + } + _ => panic!("Expected ToolRequest"), + } + } + + #[test] + fn test_extract_tool_call_messages_invalid_json() { + assert!(extract_tool_call_messages("not json", "msg-3").is_empty()); + } + + #[test] + fn test_extract_tool_call_messages_empty_name_skipped() { + let json_str = r#"{"tool_calls": [{"name": "", "arguments": {}, "id": "x"}]}"#; + assert!(extract_tool_call_messages(json_str, "msg-4").is_empty()); + } + + #[test] + fn test_compact_tools_json_produces_minimal_output() { + use rmcp::model::Tool; + use rmcp::object; + + let tools = vec![Tool::new( + "developer__shell".to_string(), + "Run shell commands".to_string(), + object!({"type": "object", "properties": {"command": {"type": "string"}}}), + )]; + let result = compact_tools_json(&tools); + assert!(result.is_some()); + let parsed: Vec = serde_json::from_str(&result.unwrap()).unwrap(); + assert_eq!(parsed.len(), 1); + let func = &parsed[0]["function"]; + assert_eq!(func["name"], "developer__shell"); + assert_eq!(func["description"], "Run shell commands"); + // Should not contain full parameter schemas + assert!(func.get("parameters").is_none()); + } + + #[test] + fn test_compact_tools_json_empty() { + let result = compact_tools_json(&[]); + assert!(result.is_some()); + let parsed: Vec = serde_json::from_str(&result.unwrap()).unwrap(); + assert!(parsed.is_empty()); + } + + #[test] + fn test_safe_stream_end_balanced_braces() { + let text = "Result: {\"key\": \"value\"} done"; + assert_eq!(safe_stream_end(text), text.len()); + } + + #[test] + fn test_safe_stream_end_unbalanced_open_brace() { + let text = "Some text {\"tool_calls\": ["; + assert_eq!(safe_stream_end(text), "Some text ".len()); + } + + #[test] + fn test_safe_stream_end_empty() { + assert_eq!(safe_stream_end(""), 0); + } + + #[test] + fn test_safe_stream_end_no_braces() { + let text = "plain text here"; + assert_eq!(safe_stream_end(text), text.len()); + } +} diff --git a/crates/goose/src/providers/mod.rs b/crates/goose/src/providers/mod.rs index 6e4862f0df..581fc2747e 100644 --- a/crates/goose/src/providers/mod.rs +++ b/crates/goose/src/providers/mod.rs @@ -23,6 +23,7 @@ pub mod google; mod init; pub mod lead_worker; pub mod litellm; +pub mod local_inference; pub mod oauth; pub mod ollama; pub mod openai; diff --git a/crates/goose/src/providers/ollama.rs b/crates/goose/src/providers/ollama.rs index 30a53b5c54..7b6104d658 100644 --- a/crates/goose/src/providers/ollama.rs +++ b/crates/goose/src/providers/ollama.rs @@ -7,16 +7,13 @@ use super::utils::{ImageFormat, RequestLog}; use crate::config::declarative_providers::DeclarativeProviderConfig; use crate::config::GooseMode; use crate::conversation::message::Message; -use crate::conversation::Conversation; use crate::model::ModelConfig; use crate::providers::formats::ollama::{create_request, response_to_streaming_message_ollama}; -use crate::utils::safe_truncate; use anyhow::{Error, Result}; use async_stream::try_stream; use async_trait::async_trait; use futures::future::BoxFuture; use futures::TryStreamExt; -use regex::Regex; use reqwest::Response; use rmcp::model::Tool; use serde_json::{json, Value}; @@ -215,30 +212,6 @@ impl Provider for OllamaProvider { self.model.clone() } - async fn generate_session_name( - &self, - session_id: &str, - messages: &Conversation, - ) -> Result { - let context = self.get_initial_user_messages(messages); - let message = Message::user().with_text(self.create_session_name_prompt(&context)); - let model_config = self.get_model_config(); - let result = self - .complete( - &model_config, - session_id, - "You are a title generator. Output only the requested title of 4 words or less, with no additional text, reasoning, or explanations.", - &[message], - &[], - ) - .await?; - - let mut description = result.0.as_concat_text(); - description = Self::filter_reasoning_tokens(&description); - - Ok(safe_truncate(&description, 100)) - } - async fn stream( &self, model_config: &ModelConfig, @@ -318,46 +291,6 @@ impl Provider for OllamaProvider { } } -impl OllamaProvider { - fn filter_reasoning_tokens(text: &str) -> String { - let mut filtered = text.to_string(); - - let reasoning_patterns = [ - r".*?", - r".*?", - r"Let me think.*?\n", - r"I need to.*?\n", - r"First, I.*?\n", - r"Okay, .*?\n", - r"So, .*?\n", - r"Well, .*?\n", - r"Hmm, .*?\n", - r"Actually, .*?\n", - r"Based on.*?I think", - r"Looking at.*?I would say", - ]; - - for pattern in reasoning_patterns { - if let Ok(re) = Regex::new(pattern) { - filtered = re.replace_all(&filtered, "").to_string(); - } - } - filtered = filtered - .replace("", "") - .replace("", "") - .replace("", "") - .replace("", ""); - filtered = filtered - .lines() - .map(|line| line.trim()) - .filter(|line| !line.is_empty()) - .collect::>() - .join(" "); - - filtered - } -} - /// Ollama-specific streaming handler with XML tool call fallback. /// Uses the Ollama format module which buffers text when XML tool calls are detected, /// preventing duplicate content from being emitted to the UI. diff --git a/crates/goose/tests/local_inference_integration.rs b/crates/goose/tests/local_inference_integration.rs new file mode 100644 index 0000000000..35002904a5 --- /dev/null +++ b/crates/goose/tests/local_inference_integration.rs @@ -0,0 +1,128 @@ +//! Integration tests for LocalInferenceProvider. +//! +//! These tests require a downloaded GGUF model and are ignored by default. +//! Run with: cargo test -p goose --test local_inference_integration -- --ignored + +use futures::StreamExt; +use goose::conversation::message::Message; +use goose::model::ModelConfig; +use goose::providers::create; +use std::time::Instant; + +const TEST_MODEL: &str = "llama-3.2-1b"; + +#[tokio::test] +#[ignore] +async fn test_local_inference_stream_produces_output() { + let model_config = ModelConfig::new(TEST_MODEL).expect("valid model config"); + let provider = create("local", model_config.clone(), Vec::new()) + .await + .expect("provider creation should succeed"); + + let system = "You are a helpful assistant. Be brief."; + let messages = vec![Message::user().with_text("Say hello.")]; + + let mut stream = provider + .stream(&model_config, "test-session", system, &messages, &[]) + .await + .expect("stream should start"); + + let mut got_text = false; + let mut got_usage = false; + + while let Some(result) = stream.next().await { + let (msg, usage) = result.expect("stream item should be Ok"); + if msg.is_some() { + got_text = true; + } + if let Some(u) = usage { + got_usage = true; + let usage_inner = u.usage; + assert!( + usage_inner.input_tokens.unwrap_or(0) > 0, + "should have input tokens" + ); + assert!( + usage_inner.output_tokens.unwrap_or(0) > 0, + "should have output tokens" + ); + } + } + + assert!(got_text, "stream should produce at least one text message"); + assert!(got_usage, "stream should produce usage info"); +} + +#[tokio::test] +#[ignore] +async fn test_local_inference_cold_and_warm_performance() { + let model_config = ModelConfig::new(TEST_MODEL).expect("valid model config"); + let provider = create("local", model_config.clone(), Vec::new()) + .await + .expect("provider creation should succeed"); + + // Cold start (includes model loading) + let messages = vec![Message::user().with_text("what is the capital of Moldova?")]; + let start = Instant::now(); + let (response, _usage) = provider + .complete(&model_config, "test-session", "", &messages, &[]) + .await + .expect("cold completion should succeed"); + let cold_elapsed = start.elapsed(); + + let text = response.as_concat_text(); + assert!(!text.is_empty(), "cold start should produce a response"); + println!( + "Cold start: {cold_elapsed:.2?}, response length: {}", + text.len() + ); + + // Warm run (model already loaded) + let messages2 = vec![Message::user().with_text("what is the capital of France?")]; + let start2 = Instant::now(); + let (response2, _usage2) = provider + .complete(&model_config, "test-session", "", &messages2, &[]) + .await + .expect("warm completion should succeed"); + let warm_elapsed = start2.elapsed(); + + let text2 = response2.as_concat_text(); + assert!(!text2.is_empty(), "warm run should produce a response"); + println!( + "Warm run: {warm_elapsed:.2?}, response length: {}", + text2.len() + ); + assert!( + warm_elapsed < cold_elapsed, + "warm run ({warm_elapsed:.2?}) should be faster than cold start ({cold_elapsed:.2?})" + ); +} + +#[tokio::test] +#[ignore] +async fn test_local_inference_large_prompt() { + let model_config = ModelConfig::new(TEST_MODEL).expect("valid model config"); + let provider = create("local", model_config.clone(), Vec::new()) + .await + .expect("provider creation should succeed"); + + // Build a large prompt (~3500 tokens) to exercise prefill performance + let padding = "You are Goose, a highly capable AI assistant.\n".repeat(80); + let prompt = format!("{padding}\nNow answer this: what is the capital of Moldova?"); + let messages = vec![Message::user().with_text(&prompt)]; + + let start = Instant::now(); + let (response, _usage) = provider + .complete(&model_config, "test-session", "", &messages, &[]) + .await + .expect("large prompt completion should succeed"); + let elapsed = start.elapsed(); + + let text = response.as_concat_text(); + assert!(!text.is_empty(), "large prompt should produce a response"); + println!( + "Large prompt: {elapsed:.2?}, prompt ~{} chars, response length: {}", + prompt.len(), + text.len() + ); +} diff --git a/ui/desktop/openapi.json b/ui/desktop/openapi.json index fb9712d723..2fee277007 100644 --- a/ui/desktop/openapi.json +++ b/ui/desktop/openapi.json @@ -1827,6 +1827,308 @@ } } }, + "/local-inference/download": { + "post": { + "tags": [ + "super::routes::local_inference" + ], + "operationId": "download_hf_model", + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/DownloadModelRequest" + } + } + }, + "required": true + }, + "responses": { + "202": { + "description": "Download started", + "content": { + "text/plain": { + "schema": { + "type": "string" + } + } + } + }, + "400": { + "description": "Invalid request" + } + } + } + }, + "/local-inference/models": { + "get": { + "tags": [ + "super::routes::local_inference" + ], + "operationId": "list_local_models", + "responses": { + "200": { + "description": "List of available local LLM models", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "$ref": "#/components/schemas/LocalModelResponse" + } + } + } + } + } + } + } + }, + "/local-inference/models/{model_id}": { + "delete": { + "tags": [ + "super::routes::local_inference" + ], + "operationId": "delete_local_model", + "parameters": [ + { + "name": "model_id", + "in": "path", + "required": true, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "Model deleted" + }, + "404": { + "description": "Model not found" + } + } + } + }, + "/local-inference/models/{model_id}/download": { + "get": { + "tags": [ + "super::routes::local_inference" + ], + "operationId": "get_local_model_download_progress", + "parameters": [ + { + "name": "model_id", + "in": "path", + "required": true, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "Download progress", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/DownloadProgress" + } + } + } + }, + "404": { + "description": "No active download" + } + } + }, + "delete": { + "tags": [ + "super::routes::local_inference" + ], + "operationId": "cancel_local_model_download", + "parameters": [ + { + "name": "model_id", + "in": "path", + "required": true, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "Download cancelled" + }, + "404": { + "description": "No active download" + } + } + } + }, + "/local-inference/models/{model_id}/settings": { + "get": { + "tags": [ + "super::routes::local_inference" + ], + "operationId": "get_model_settings", + "parameters": [ + { + "name": "model_id", + "in": "path", + "required": true, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "Model settings", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ModelSettings" + } + } + } + }, + "404": { + "description": "Model not found" + } + } + }, + "put": { + "tags": [ + "super::routes::local_inference" + ], + "operationId": "update_model_settings", + "parameters": [ + { + "name": "model_id", + "in": "path", + "required": true, + "schema": { + "type": "string" + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ModelSettings" + } + } + }, + "required": true + }, + "responses": { + "200": { + "description": "Settings updated", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ModelSettings" + } + } + } + }, + "404": { + "description": "Model not found" + }, + "500": { + "description": "Failed to save settings" + } + } + } + }, + "/local-inference/repo/{author}/{repo}/files": { + "get": { + "tags": [ + "super::routes::local_inference" + ], + "operationId": "get_repo_files", + "parameters": [ + { + "name": "author", + "in": "path", + "required": true, + "schema": { + "type": "string" + } + }, + { + "name": "repo", + "in": "path", + "required": true, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "GGUF files in the repo", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/RepoVariantsResponse" + } + } + } + } + } + } + }, + "/local-inference/search": { + "get": { + "tags": [ + "super::routes::local_inference" + ], + "operationId": "search_hf_models", + "parameters": [ + { + "name": "q", + "in": "query", + "description": "Search query", + "required": true, + "schema": { + "type": "string" + } + }, + { + "name": "limit", + "in": "query", + "description": "Max results", + "required": false, + "schema": { + "type": "integer", + "nullable": true, + "minimum": 0 + } + } + ], + "responses": { + "200": { + "description": "Search results", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "$ref": "#/components/schemas/HfModelInfo" + } + } + } + } + }, + "500": { + "description": "Search failed" + } + } + } + }, "/mcp-ui-proxy": { "get": { "tags": [ @@ -3954,6 +4256,18 @@ } } }, + "DownloadModelRequest": { + "type": "object", + "required": [ + "spec" + ], + "properties": { + "spec": { + "type": "string", + "description": "Model spec like \"bartowski/Llama-3.2-3B-Instruct-GGUF:Q4_K_M\"" + } + } + }, "DownloadProgress": { "type": "object", "required": [ @@ -4588,6 +4902,100 @@ } ] }, + "HfGgufFile": { + "type": "object", + "description": "A single downloadable GGUF file (used internally and for downloads).", + "required": [ + "filename", + "size_bytes", + "quantization", + "download_url" + ], + "properties": { + "download_url": { + "type": "string" + }, + "filename": { + "type": "string" + }, + "quantization": { + "type": "string" + }, + "size_bytes": { + "type": "integer", + "format": "int64", + "minimum": 0 + } + } + }, + "HfModelInfo": { + "type": "object", + "required": [ + "repo_id", + "author", + "model_name", + "downloads", + "gguf_files" + ], + "properties": { + "author": { + "type": "string" + }, + "downloads": { + "type": "integer", + "format": "int64", + "minimum": 0 + }, + "gguf_files": { + "type": "array", + "items": { + "$ref": "#/components/schemas/HfGgufFile" + } + }, + "model_name": { + "type": "string" + }, + "repo_id": { + "type": "string" + } + } + }, + "HfQuantVariant": { + "type": "object", + "description": "A quantization variant — groups sharded files into one logical entry.", + "required": [ + "quantization", + "size_bytes", + "filename", + "download_url", + "description", + "quality_rank" + ], + "properties": { + "description": { + "type": "string" + }, + "download_url": { + "type": "string" + }, + "filename": { + "type": "string" + }, + "quality_rank": { + "type": "integer", + "format": "int32", + "minimum": 0 + }, + "quantization": { + "type": "string" + }, + "size_bytes": { + "type": "integer", + "format": "int64", + "minimum": 0 + } + } + }, "Icon": { "type": "object", "required": [ @@ -4773,6 +5181,51 @@ } } }, + "LocalModelResponse": { + "type": "object", + "required": [ + "id", + "display_name", + "repo_id", + "filename", + "quantization", + "size_bytes", + "status", + "recommended", + "settings" + ], + "properties": { + "display_name": { + "type": "string" + }, + "filename": { + "type": "string" + }, + "id": { + "type": "string" + }, + "quantization": { + "type": "string" + }, + "recommended": { + "type": "boolean" + }, + "repo_id": { + "type": "string" + }, + "settings": { + "$ref": "#/components/schemas/ModelSettings" + }, + "size_bytes": { + "type": "integer", + "format": "int64", + "minimum": 0 + }, + "status": { + "$ref": "#/components/schemas/ModelDownloadStatus" + } + } + }, "McpAppResource": { "type": "object", "description": "MCP App Resource\nRepresents a UI resource that can be rendered in an MCP App", @@ -5293,6 +5746,78 @@ } } }, + "ModelDownloadStatus": { + "oneOf": [ + { + "type": "object", + "required": [ + "state" + ], + "properties": { + "state": { + "type": "string", + "enum": [ + "NotDownloaded" + ] + } + } + }, + { + "type": "object", + "required": [ + "progress_percent", + "bytes_downloaded", + "total_bytes", + "state" + ], + "properties": { + "bytes_downloaded": { + "type": "integer", + "format": "int64", + "minimum": 0 + }, + "progress_percent": { + "type": "number", + "format": "float" + }, + "speed_bps": { + "type": "integer", + "format": "int64", + "nullable": true, + "minimum": 0 + }, + "state": { + "type": "string", + "enum": [ + "Downloading" + ] + }, + "total_bytes": { + "type": "integer", + "format": "int64", + "minimum": 0 + } + } + }, + { + "type": "object", + "required": [ + "state" + ], + "properties": { + "state": { + "type": "string", + "enum": [ + "Downloaded" + ] + } + } + } + ], + "discriminator": { + "propertyName": "state" + } + }, "ModelInfo": { "type": "object", "description": "Information about a model's capabilities", @@ -5417,6 +5942,71 @@ } } }, + "ModelSettings": { + "type": "object", + "properties": { + "context_size": { + "type": "integer", + "format": "int32", + "nullable": true, + "minimum": 0 + }, + "flash_attention": { + "type": "boolean", + "nullable": true + }, + "frequency_penalty": { + "type": "number", + "format": "float" + }, + "max_output_tokens": { + "type": "integer", + "nullable": true, + "minimum": 0 + }, + "n_batch": { + "type": "integer", + "format": "int32", + "nullable": true, + "minimum": 0 + }, + "n_gpu_layers": { + "type": "integer", + "format": "int32", + "nullable": true, + "minimum": 0 + }, + "n_threads": { + "type": "integer", + "format": "int32", + "nullable": true + }, + "native_tool_calling": { + "type": "boolean" + }, + "presence_penalty": { + "type": "number", + "format": "float" + }, + "repeat_last_n": { + "type": "integer", + "format": "int32" + }, + "repeat_penalty": { + "type": "number", + "format": "float" + }, + "sampling": { + "$ref": "#/components/schemas/SamplingConfig" + }, + "use_jinja": { + "type": "boolean" + }, + "use_mlock": { + "type": "boolean" + } + } + }, "ParseRecipeRequest": { "type": "object", "required": [ @@ -6005,6 +6595,25 @@ } } }, + "RepoVariantsResponse": { + "type": "object", + "required": [ + "variants" + ], + "properties": { + "recommended_index": { + "type": "integer", + "nullable": true, + "minimum": 0 + }, + "variants": { + "type": "array", + "items": { + "$ref": "#/components/schemas/HfQuantVariant" + } + } + } + }, "ResourceContents": { "anyOf": [ { @@ -6196,6 +6805,97 @@ } } }, + "SamplingConfig": { + "oneOf": [ + { + "type": "object", + "required": [ + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "Greedy" + ] + } + } + }, + { + "type": "object", + "required": [ + "temperature", + "top_k", + "top_p", + "min_p", + "type" + ], + "properties": { + "min_p": { + "type": "number", + "format": "float" + }, + "seed": { + "type": "integer", + "format": "int32", + "nullable": true, + "minimum": 0 + }, + "temperature": { + "type": "number", + "format": "float" + }, + "top_k": { + "type": "integer", + "format": "int32" + }, + "top_p": { + "type": "number", + "format": "float" + }, + "type": { + "type": "string", + "enum": [ + "Temperature" + ] + } + } + }, + { + "type": "object", + "required": [ + "tau", + "eta", + "type" + ], + "properties": { + "eta": { + "type": "number", + "format": "float" + }, + "seed": { + "type": "integer", + "format": "int32", + "nullable": true, + "minimum": 0 + }, + "tau": { + "type": "number", + "format": "float" + }, + "type": { + "type": "string", + "enum": [ + "MirostatV2" + ] + } + } + } + ], + "discriminator": { + "propertyName": "type" + } + }, "SavePromptRequest": { "type": "object", "required": [ diff --git a/ui/desktop/src/api/index.ts b/ui/desktop/src/api/index.ts index 9a24bb7ac0..2e65e54472 100644 --- a/ui/desktop/src/api/index.ts +++ b/ui/desktop/src/api/index.ts @@ -1,4 +1,4 @@ // This file is auto-generated by @hey-api/openapi-ts -export { addExtension, agentAddExtension, agentRemoveExtension, backupConfig, callTool, cancelDownload, checkProvider, configureProviderOauth, confirmToolAction, createCustomProvider, createRecipe, createSchedule, decodeRecipe, deleteModel, deleteRecipe, deleteSchedule, deleteSession, detectProvider, diagnostics, downloadModel, encodeRecipe, exportApp, exportSession, forkSession, getCanonicalModelInfo, getCustomProvider, getDictationConfig, getDownloadProgress, getExtensions, getPrompt, getPrompts, getProviderModels, getSession, getSessionExtensions, getSessionInsights, getSlashCommands, getTools, getTunnelStatus, importApp, importSession, initConfig, inspectRunningJob, killRunningJob, listApps, listModels, listRecipes, listSchedules, listSessions, mcpUiProxy, type Options, parseRecipe, pauseSchedule, providers, readAllConfig, readConfig, readResource, recipeToYaml, recoverConfig, removeConfig, removeCustomProvider, removeExtension, reply, resetPrompt, restartAgent, resumeAgent, runNowHandler, savePrompt, saveRecipe, scanRecipe, scheduleRecipe, searchSessions, sendTelemetryEvent, sessionsHandler, setConfigProvider, setRecipeSlashCommand, startAgent, startOpenrouterSetup, startTetrateSetup, startTunnel, status, stopAgent, stopTunnel, systemInfo, transcribeDictation, unpauseSchedule, updateAgentProvider, updateCustomProvider, updateFromSession, updateSchedule, updateSessionName, updateSessionUserRecipeValues, updateWorkingDir, upsertConfig, upsertPermissions, validateConfig } from './sdk.gen'; -export type { ActionRequired, ActionRequiredData, AddExtensionData, AddExtensionErrors, AddExtensionRequest, AddExtensionResponse, AddExtensionResponses, AgentAddExtensionData, AgentAddExtensionErrors, AgentAddExtensionResponse, AgentAddExtensionResponses, AgentRemoveExtensionData, AgentRemoveExtensionErrors, AgentRemoveExtensionResponse, AgentRemoveExtensionResponses, Annotations, Author, AuthorRequest, BackupConfigData, BackupConfigErrors, BackupConfigResponse, BackupConfigResponses, CallToolData, CallToolErrors, CallToolRequest, CallToolResponse, CallToolResponse2, CallToolResponses, CancelDownloadData, CancelDownloadErrors, CancelDownloadResponses, ChatRequest, CheckProviderData, CheckProviderRequest, ClientOptions, CommandType, ConfigKey, ConfigKeyQuery, ConfigResponse, ConfigureProviderOauthData, ConfigureProviderOauthErrors, ConfigureProviderOauthResponses, ConfirmToolActionData, ConfirmToolActionErrors, ConfirmToolActionRequest, ConfirmToolActionResponses, Content, Conversation, CreateCustomProviderData, CreateCustomProviderErrors, CreateCustomProviderResponse, CreateCustomProviderResponses, CreateRecipeData, CreateRecipeErrors, CreateRecipeRequest, CreateRecipeResponse, CreateRecipeResponse2, CreateRecipeResponses, CreateScheduleData, CreateScheduleErrors, CreateScheduleRequest, CreateScheduleResponse, CreateScheduleResponses, CspMetadata, DeclarativeProviderConfig, DecodeRecipeData, DecodeRecipeErrors, DecodeRecipeRequest, DecodeRecipeResponse, DecodeRecipeResponse2, DecodeRecipeResponses, DeleteModelData, DeleteModelErrors, DeleteModelResponses, DeleteRecipeData, DeleteRecipeErrors, DeleteRecipeRequest, DeleteRecipeResponse, DeleteRecipeResponses, DeleteScheduleData, DeleteScheduleErrors, DeleteScheduleResponse, DeleteScheduleResponses, DeleteSessionData, DeleteSessionErrors, DeleteSessionResponses, DetectProviderData, DetectProviderErrors, DetectProviderRequest, DetectProviderResponse, DetectProviderResponse2, DetectProviderResponses, DiagnosticsData, DiagnosticsErrors, DiagnosticsResponse, DiagnosticsResponses, DictationProvider, DictationProviderStatus, DownloadModelData, DownloadModelErrors, DownloadModelResponses, DownloadProgress, DownloadStatus, EmbeddedResource, EncodeRecipeData, EncodeRecipeErrors, EncodeRecipeRequest, EncodeRecipeResponse, EncodeRecipeResponse2, EncodeRecipeResponses, Envs, ErrorResponse, ExportAppData, ExportAppError, ExportAppErrors, ExportAppResponse, ExportAppResponses, ExportSessionData, ExportSessionErrors, ExportSessionResponse, ExportSessionResponses, ExtensionConfig, ExtensionData, ExtensionEntry, ExtensionLoadResult, ExtensionQuery, ExtensionResponse, ForkRequest, ForkResponse, ForkSessionData, ForkSessionErrors, ForkSessionResponse, ForkSessionResponses, FrontendToolRequest, GetCanonicalModelInfoData, GetCanonicalModelInfoResponse, GetCanonicalModelInfoResponses, GetCustomProviderData, GetCustomProviderErrors, GetCustomProviderResponse, GetCustomProviderResponses, GetDictationConfigData, GetDictationConfigResponse, GetDictationConfigResponses, GetDownloadProgressData, GetDownloadProgressErrors, GetDownloadProgressResponse, GetDownloadProgressResponses, GetExtensionsData, GetExtensionsErrors, GetExtensionsResponse, GetExtensionsResponses, GetPromptData, GetPromptErrors, GetPromptResponse, GetPromptResponses, GetPromptsData, GetPromptsResponse, GetPromptsResponses, GetProviderModelsData, GetProviderModelsErrors, GetProviderModelsResponse, GetProviderModelsResponses, GetSessionData, GetSessionErrors, GetSessionExtensionsData, GetSessionExtensionsErrors, GetSessionExtensionsResponse, GetSessionExtensionsResponses, GetSessionInsightsData, GetSessionInsightsErrors, GetSessionInsightsResponse, GetSessionInsightsResponses, GetSessionResponse, GetSessionResponses, GetSlashCommandsData, GetSlashCommandsResponse, GetSlashCommandsResponses, GetToolsData, GetToolsErrors, GetToolsQuery, GetToolsResponse, GetToolsResponses, GetTunnelStatusData, GetTunnelStatusResponse, GetTunnelStatusResponses, GooseApp, Icon, ImageContent, ImportAppData, ImportAppError, ImportAppErrors, ImportAppRequest, ImportAppResponse, ImportAppResponse2, ImportAppResponses, ImportSessionData, ImportSessionErrors, ImportSessionRequest, ImportSessionResponse, ImportSessionResponses, InitConfigData, InitConfigErrors, InitConfigResponse, InitConfigResponses, InspectJobResponse, InspectRunningJobData, InspectRunningJobErrors, InspectRunningJobResponse, InspectRunningJobResponses, JsonObject, KillJobResponse, KillRunningJobData, KillRunningJobResponses, ListAppsData, ListAppsError, ListAppsErrors, ListAppsRequest, ListAppsResponse, ListAppsResponse2, ListAppsResponses, ListModelsData, ListModelsResponse, ListModelsResponses, ListRecipeResponse, ListRecipesData, ListRecipesErrors, ListRecipesResponse, ListRecipesResponses, ListSchedulesData, ListSchedulesErrors, ListSchedulesResponse, ListSchedulesResponse2, ListSchedulesResponses, ListSessionsData, ListSessionsErrors, ListSessionsResponse, ListSessionsResponses, LoadedProvider, McpAppResource, McpUiProxyData, McpUiProxyErrors, McpUiProxyResponses, Message, MessageContent, MessageEvent, MessageMetadata, ModelConfig, ModelInfo, ModelInfoData, ModelInfoQuery, ModelInfoResponse, ParseRecipeData, ParseRecipeError, ParseRecipeErrors, ParseRecipeRequest, ParseRecipeResponse, ParseRecipeResponse2, ParseRecipeResponses, PauseScheduleData, PauseScheduleErrors, PauseScheduleResponse, PauseScheduleResponses, Permission, PermissionLevel, PermissionsMetadata, PrincipalType, PromptContentResponse, PromptsListResponse, ProviderDetails, ProviderEngine, ProviderMetadata, ProvidersData, ProvidersResponse, ProvidersResponse2, ProvidersResponses, ProviderType, RawAudioContent, RawEmbeddedResource, RawImageContent, RawResource, RawTextContent, ReadAllConfigData, ReadAllConfigResponse, ReadAllConfigResponses, ReadConfigData, ReadConfigErrors, ReadConfigResponses, ReadResourceData, ReadResourceErrors, ReadResourceRequest, ReadResourceResponse, ReadResourceResponse2, ReadResourceResponses, ReasoningContent, Recipe, RecipeManifest, RecipeParameter, RecipeParameterInputType, RecipeParameterRequirement, RecipeToYamlData, RecipeToYamlError, RecipeToYamlErrors, RecipeToYamlRequest, RecipeToYamlResponse, RecipeToYamlResponse2, RecipeToYamlResponses, RecoverConfigData, RecoverConfigErrors, RecoverConfigResponse, RecoverConfigResponses, RedactedThinkingContent, RemoveConfigData, RemoveConfigErrors, RemoveConfigResponse, RemoveConfigResponses, RemoveCustomProviderData, RemoveCustomProviderErrors, RemoveCustomProviderResponse, RemoveCustomProviderResponses, RemoveExtensionData, RemoveExtensionErrors, RemoveExtensionRequest, RemoveExtensionResponse, RemoveExtensionResponses, ReplyData, ReplyErrors, ReplyResponse, ReplyResponses, ResetPromptData, ResetPromptErrors, ResetPromptResponse, ResetPromptResponses, ResourceContents, ResourceMetadata, Response, RestartAgentData, RestartAgentErrors, RestartAgentRequest, RestartAgentResponse, RestartAgentResponse2, RestartAgentResponses, ResumeAgentData, ResumeAgentErrors, ResumeAgentRequest, ResumeAgentResponse, ResumeAgentResponse2, ResumeAgentResponses, RetryConfig, Role, RunNowHandlerData, RunNowHandlerErrors, RunNowHandlerResponse, RunNowHandlerResponses, RunNowResponse, SavePromptData, SavePromptErrors, SavePromptRequest, SavePromptResponse, SavePromptResponses, SaveRecipeData, SaveRecipeError, SaveRecipeErrors, SaveRecipeRequest, SaveRecipeResponse, SaveRecipeResponse2, SaveRecipeResponses, ScanRecipeData, ScanRecipeRequest, ScanRecipeResponse, ScanRecipeResponse2, ScanRecipeResponses, ScheduledJob, ScheduleRecipeData, ScheduleRecipeErrors, ScheduleRecipeRequest, ScheduleRecipeResponses, SearchSessionsData, SearchSessionsErrors, SearchSessionsResponse, SearchSessionsResponses, SendTelemetryEventData, SendTelemetryEventResponses, Session, SessionDisplayInfo, SessionExtensionsResponse, SessionInsights, SessionListResponse, SessionsHandlerData, SessionsHandlerErrors, SessionsHandlerResponse, SessionsHandlerResponses, SessionsQuery, SessionType, SetConfigProviderData, SetProviderRequest, SetRecipeSlashCommandData, SetRecipeSlashCommandErrors, SetRecipeSlashCommandResponses, SetSlashCommandRequest, Settings, SetupResponse, SlashCommand, SlashCommandsResponse, StartAgentData, StartAgentError, StartAgentErrors, StartAgentRequest, StartAgentResponse, StartAgentResponses, StartOpenrouterSetupData, StartOpenrouterSetupResponse, StartOpenrouterSetupResponses, StartTetrateSetupData, StartTetrateSetupResponse, StartTetrateSetupResponses, StartTunnelData, StartTunnelError, StartTunnelErrors, StartTunnelResponse, StartTunnelResponses, StatusData, StatusResponse, StatusResponses, StopAgentData, StopAgentErrors, StopAgentRequest, StopAgentResponse, StopAgentResponses, StopTunnelData, StopTunnelError, StopTunnelErrors, StopTunnelResponses, SubRecipe, SuccessCheck, SystemInfo, SystemInfoData, SystemInfoResponse, SystemInfoResponses, SystemNotificationContent, SystemNotificationType, TaskSupport, TelemetryEventRequest, Template, TextContent, ThinkingContent, TokenState, Tool, ToolAnnotations, ToolConfirmationRequest, ToolExecution, ToolInfo, ToolPermission, ToolRequest, ToolResponse, TranscribeDictationData, TranscribeDictationErrors, TranscribeDictationResponse, TranscribeDictationResponses, TranscribeRequest, TranscribeResponse, TunnelInfo, TunnelState, UiMetadata, UnpauseScheduleData, UnpauseScheduleErrors, UnpauseScheduleResponse, UnpauseScheduleResponses, UpdateAgentProviderData, UpdateAgentProviderErrors, UpdateAgentProviderResponses, UpdateCustomProviderData, UpdateCustomProviderErrors, UpdateCustomProviderRequest, UpdateCustomProviderResponse, UpdateCustomProviderResponses, UpdateFromSessionData, UpdateFromSessionErrors, UpdateFromSessionRequest, UpdateFromSessionResponses, UpdateProviderRequest, UpdateScheduleData, UpdateScheduleErrors, UpdateScheduleRequest, UpdateScheduleResponse, UpdateScheduleResponses, UpdateSessionNameData, UpdateSessionNameErrors, UpdateSessionNameRequest, UpdateSessionNameResponses, UpdateSessionUserRecipeValuesData, UpdateSessionUserRecipeValuesError, UpdateSessionUserRecipeValuesErrors, UpdateSessionUserRecipeValuesRequest, UpdateSessionUserRecipeValuesResponse, UpdateSessionUserRecipeValuesResponse2, UpdateSessionUserRecipeValuesResponses, UpdateWorkingDirData, UpdateWorkingDirErrors, UpdateWorkingDirRequest, UpdateWorkingDirResponses, UpsertConfigData, UpsertConfigErrors, UpsertConfigQuery, UpsertConfigResponse, UpsertConfigResponses, UpsertPermissionsData, UpsertPermissionsErrors, UpsertPermissionsQuery, UpsertPermissionsResponse, UpsertPermissionsResponses, ValidateConfigData, ValidateConfigErrors, ValidateConfigResponse, ValidateConfigResponses, WhisperModelResponse, WindowProps } from './types.gen'; +export { addExtension, agentAddExtension, agentRemoveExtension, backupConfig, callTool, cancelDownload, cancelLocalModelDownload, checkProvider, configureProviderOauth, confirmToolAction, createCustomProvider, createRecipe, createSchedule, decodeRecipe, deleteLocalModel, deleteModel, deleteRecipe, deleteSchedule, deleteSession, detectProvider, diagnostics, downloadHfModel, downloadModel, encodeRecipe, exportApp, exportSession, forkSession, getCanonicalModelInfo, getCustomProvider, getDictationConfig, getDownloadProgress, getExtensions, getLocalModelDownloadProgress, getModelSettings, getPrompt, getPrompts, getProviderModels, getRepoFiles, getSession, getSessionExtensions, getSessionInsights, getSlashCommands, getTools, getTunnelStatus, importApp, importSession, initConfig, inspectRunningJob, killRunningJob, listApps, listLocalModels, listModels, listRecipes, listSchedules, listSessions, mcpUiProxy, type Options, parseRecipe, pauseSchedule, providers, readAllConfig, readConfig, readResource, recipeToYaml, recoverConfig, removeConfig, removeCustomProvider, removeExtension, reply, resetPrompt, restartAgent, resumeAgent, runNowHandler, savePrompt, saveRecipe, scanRecipe, scheduleRecipe, searchHfModels, searchSessions, sendTelemetryEvent, sessionsHandler, setConfigProvider, setRecipeSlashCommand, startAgent, startOpenrouterSetup, startTetrateSetup, startTunnel, status, stopAgent, stopTunnel, systemInfo, transcribeDictation, unpauseSchedule, updateAgentProvider, updateCustomProvider, updateFromSession, updateModelSettings, updateSchedule, updateSessionName, updateSessionUserRecipeValues, updateWorkingDir, upsertConfig, upsertPermissions, validateConfig } from './sdk.gen'; +export type { ActionRequired, ActionRequiredData, AddExtensionData, AddExtensionErrors, AddExtensionRequest, AddExtensionResponse, AddExtensionResponses, AgentAddExtensionData, AgentAddExtensionErrors, AgentAddExtensionResponse, AgentAddExtensionResponses, AgentRemoveExtensionData, AgentRemoveExtensionErrors, AgentRemoveExtensionResponse, AgentRemoveExtensionResponses, Annotations, Author, AuthorRequest, BackupConfigData, BackupConfigErrors, BackupConfigResponse, BackupConfigResponses, CallToolData, CallToolErrors, CallToolRequest, CallToolResponse, CallToolResponse2, CallToolResponses, CancelDownloadData, CancelDownloadErrors, CancelDownloadResponses, CancelLocalModelDownloadData, CancelLocalModelDownloadErrors, CancelLocalModelDownloadResponses, ChatRequest, CheckProviderData, CheckProviderRequest, ClientOptions, CommandType, ConfigKey, ConfigKeyQuery, ConfigResponse, ConfigureProviderOauthData, ConfigureProviderOauthErrors, ConfigureProviderOauthResponses, ConfirmToolActionData, ConfirmToolActionErrors, ConfirmToolActionRequest, ConfirmToolActionResponses, Content, Conversation, CreateCustomProviderData, CreateCustomProviderErrors, CreateCustomProviderResponse, CreateCustomProviderResponses, CreateRecipeData, CreateRecipeErrors, CreateRecipeRequest, CreateRecipeResponse, CreateRecipeResponse2, CreateRecipeResponses, CreateScheduleData, CreateScheduleErrors, CreateScheduleRequest, CreateScheduleResponse, CreateScheduleResponses, CspMetadata, DeclarativeProviderConfig, DecodeRecipeData, DecodeRecipeErrors, DecodeRecipeRequest, DecodeRecipeResponse, DecodeRecipeResponse2, DecodeRecipeResponses, DeleteLocalModelData, DeleteLocalModelErrors, DeleteLocalModelResponses, DeleteModelData, DeleteModelErrors, DeleteModelResponses, DeleteRecipeData, DeleteRecipeErrors, DeleteRecipeRequest, DeleteRecipeResponse, DeleteRecipeResponses, DeleteScheduleData, DeleteScheduleErrors, DeleteScheduleResponse, DeleteScheduleResponses, DeleteSessionData, DeleteSessionErrors, DeleteSessionResponses, DetectProviderData, DetectProviderErrors, DetectProviderRequest, DetectProviderResponse, DetectProviderResponse2, DetectProviderResponses, DiagnosticsData, DiagnosticsErrors, DiagnosticsResponse, DiagnosticsResponses, DictationProvider, DictationProviderStatus, DownloadHfModelData, DownloadHfModelErrors, DownloadHfModelResponse, DownloadHfModelResponses, DownloadModelData, DownloadModelErrors, DownloadModelRequest, DownloadModelResponses, DownloadProgress, DownloadStatus, EmbeddedResource, EncodeRecipeData, EncodeRecipeErrors, EncodeRecipeRequest, EncodeRecipeResponse, EncodeRecipeResponse2, EncodeRecipeResponses, Envs, ErrorResponse, ExportAppData, ExportAppError, ExportAppErrors, ExportAppResponse, ExportAppResponses, ExportSessionData, ExportSessionErrors, ExportSessionResponse, ExportSessionResponses, ExtensionConfig, ExtensionData, ExtensionEntry, ExtensionLoadResult, ExtensionQuery, ExtensionResponse, ForkRequest, ForkResponse, ForkSessionData, ForkSessionErrors, ForkSessionResponse, ForkSessionResponses, FrontendToolRequest, GetCanonicalModelInfoData, GetCanonicalModelInfoResponse, GetCanonicalModelInfoResponses, GetCustomProviderData, GetCustomProviderErrors, GetCustomProviderResponse, GetCustomProviderResponses, GetDictationConfigData, GetDictationConfigResponse, GetDictationConfigResponses, GetDownloadProgressData, GetDownloadProgressErrors, GetDownloadProgressResponse, GetDownloadProgressResponses, GetExtensionsData, GetExtensionsErrors, GetExtensionsResponse, GetExtensionsResponses, GetLocalModelDownloadProgressData, GetLocalModelDownloadProgressErrors, GetLocalModelDownloadProgressResponse, GetLocalModelDownloadProgressResponses, GetModelSettingsData, GetModelSettingsErrors, GetModelSettingsResponse, GetModelSettingsResponses, GetPromptData, GetPromptErrors, GetPromptResponse, GetPromptResponses, GetPromptsData, GetPromptsResponse, GetPromptsResponses, GetProviderModelsData, GetProviderModelsErrors, GetProviderModelsResponse, GetProviderModelsResponses, GetRepoFilesData, GetRepoFilesResponse, GetRepoFilesResponses, GetSessionData, GetSessionErrors, GetSessionExtensionsData, GetSessionExtensionsErrors, GetSessionExtensionsResponse, GetSessionExtensionsResponses, GetSessionInsightsData, GetSessionInsightsErrors, GetSessionInsightsResponse, GetSessionInsightsResponses, GetSessionResponse, GetSessionResponses, GetSlashCommandsData, GetSlashCommandsResponse, GetSlashCommandsResponses, GetToolsData, GetToolsErrors, GetToolsQuery, GetToolsResponse, GetToolsResponses, GetTunnelStatusData, GetTunnelStatusResponse, GetTunnelStatusResponses, GooseApp, HfGgufFile, HfModelInfo, HfQuantVariant, Icon, ImageContent, ImportAppData, ImportAppError, ImportAppErrors, ImportAppRequest, ImportAppResponse, ImportAppResponse2, ImportAppResponses, ImportSessionData, ImportSessionErrors, ImportSessionRequest, ImportSessionResponse, ImportSessionResponses, InitConfigData, InitConfigErrors, InitConfigResponse, InitConfigResponses, InspectJobResponse, InspectRunningJobData, InspectRunningJobErrors, InspectRunningJobResponse, InspectRunningJobResponses, JsonObject, KillJobResponse, KillRunningJobData, KillRunningJobResponses, ListAppsData, ListAppsError, ListAppsErrors, ListAppsRequest, ListAppsResponse, ListAppsResponse2, ListAppsResponses, ListLocalModelsData, ListLocalModelsResponse, ListLocalModelsResponses, ListModelsData, ListModelsResponse, ListModelsResponses, ListRecipeResponse, ListRecipesData, ListRecipesErrors, ListRecipesResponse, ListRecipesResponses, ListSchedulesData, ListSchedulesErrors, ListSchedulesResponse, ListSchedulesResponse2, ListSchedulesResponses, ListSessionsData, ListSessionsErrors, ListSessionsResponse, ListSessionsResponses, LoadedProvider, LocalModelResponse, McpAppResource, McpUiProxyData, McpUiProxyErrors, McpUiProxyResponses, Message, MessageContent, MessageEvent, MessageMetadata, ModelConfig, ModelDownloadStatus, ModelInfo, ModelInfoData, ModelInfoQuery, ModelInfoResponse, ModelSettings, ParseRecipeData, ParseRecipeError, ParseRecipeErrors, ParseRecipeRequest, ParseRecipeResponse, ParseRecipeResponse2, ParseRecipeResponses, PauseScheduleData, PauseScheduleErrors, PauseScheduleResponse, PauseScheduleResponses, Permission, PermissionLevel, PermissionsMetadata, PrincipalType, PromptContentResponse, PromptsListResponse, ProviderDetails, ProviderEngine, ProviderMetadata, ProvidersData, ProvidersResponse, ProvidersResponse2, ProvidersResponses, ProviderType, RawAudioContent, RawEmbeddedResource, RawImageContent, RawResource, RawTextContent, ReadAllConfigData, ReadAllConfigResponse, ReadAllConfigResponses, ReadConfigData, ReadConfigErrors, ReadConfigResponses, ReadResourceData, ReadResourceErrors, ReadResourceRequest, ReadResourceResponse, ReadResourceResponse2, ReadResourceResponses, ReasoningContent, Recipe, RecipeManifest, RecipeParameter, RecipeParameterInputType, RecipeParameterRequirement, RecipeToYamlData, RecipeToYamlError, RecipeToYamlErrors, RecipeToYamlRequest, RecipeToYamlResponse, RecipeToYamlResponse2, RecipeToYamlResponses, RecoverConfigData, RecoverConfigErrors, RecoverConfigResponse, RecoverConfigResponses, RedactedThinkingContent, RemoveConfigData, RemoveConfigErrors, RemoveConfigResponse, RemoveConfigResponses, RemoveCustomProviderData, RemoveCustomProviderErrors, RemoveCustomProviderResponse, RemoveCustomProviderResponses, RemoveExtensionData, RemoveExtensionErrors, RemoveExtensionRequest, RemoveExtensionResponse, RemoveExtensionResponses, ReplyData, ReplyErrors, ReplyResponse, ReplyResponses, RepoVariantsResponse, ResetPromptData, ResetPromptErrors, ResetPromptResponse, ResetPromptResponses, ResourceContents, ResourceMetadata, Response, RestartAgentData, RestartAgentErrors, RestartAgentRequest, RestartAgentResponse, RestartAgentResponse2, RestartAgentResponses, ResumeAgentData, ResumeAgentErrors, ResumeAgentRequest, ResumeAgentResponse, ResumeAgentResponse2, ResumeAgentResponses, RetryConfig, Role, RunNowHandlerData, RunNowHandlerErrors, RunNowHandlerResponse, RunNowHandlerResponses, RunNowResponse, SamplingConfig, SavePromptData, SavePromptErrors, SavePromptRequest, SavePromptResponse, SavePromptResponses, SaveRecipeData, SaveRecipeError, SaveRecipeErrors, SaveRecipeRequest, SaveRecipeResponse, SaveRecipeResponse2, SaveRecipeResponses, ScanRecipeData, ScanRecipeRequest, ScanRecipeResponse, ScanRecipeResponse2, ScanRecipeResponses, ScheduledJob, ScheduleRecipeData, ScheduleRecipeErrors, ScheduleRecipeRequest, ScheduleRecipeResponses, SearchHfModelsData, SearchHfModelsErrors, SearchHfModelsResponse, SearchHfModelsResponses, SearchSessionsData, SearchSessionsErrors, SearchSessionsResponse, SearchSessionsResponses, SendTelemetryEventData, SendTelemetryEventResponses, Session, SessionDisplayInfo, SessionExtensionsResponse, SessionInsights, SessionListResponse, SessionsHandlerData, SessionsHandlerErrors, SessionsHandlerResponse, SessionsHandlerResponses, SessionsQuery, SessionType, SetConfigProviderData, SetProviderRequest, SetRecipeSlashCommandData, SetRecipeSlashCommandErrors, SetRecipeSlashCommandResponses, SetSlashCommandRequest, Settings, SetupResponse, SlashCommand, SlashCommandsResponse, StartAgentData, StartAgentError, StartAgentErrors, StartAgentRequest, StartAgentResponse, StartAgentResponses, StartOpenrouterSetupData, StartOpenrouterSetupResponse, StartOpenrouterSetupResponses, StartTetrateSetupData, StartTetrateSetupResponse, StartTetrateSetupResponses, StartTunnelData, StartTunnelError, StartTunnelErrors, StartTunnelResponse, StartTunnelResponses, StatusData, StatusResponse, StatusResponses, StopAgentData, StopAgentErrors, StopAgentRequest, StopAgentResponse, StopAgentResponses, StopTunnelData, StopTunnelError, StopTunnelErrors, StopTunnelResponses, SubRecipe, SuccessCheck, SystemInfo, SystemInfoData, SystemInfoResponse, SystemInfoResponses, SystemNotificationContent, SystemNotificationType, TaskSupport, TelemetryEventRequest, Template, TextContent, ThinkingContent, TokenState, Tool, ToolAnnotations, ToolConfirmationRequest, ToolExecution, ToolInfo, ToolPermission, ToolRequest, ToolResponse, TranscribeDictationData, TranscribeDictationErrors, TranscribeDictationResponse, TranscribeDictationResponses, TranscribeRequest, TranscribeResponse, TunnelInfo, TunnelState, UiMetadata, UnpauseScheduleData, UnpauseScheduleErrors, UnpauseScheduleResponse, UnpauseScheduleResponses, UpdateAgentProviderData, UpdateAgentProviderErrors, UpdateAgentProviderResponses, UpdateCustomProviderData, UpdateCustomProviderErrors, UpdateCustomProviderRequest, UpdateCustomProviderResponse, UpdateCustomProviderResponses, UpdateFromSessionData, UpdateFromSessionErrors, UpdateFromSessionRequest, UpdateFromSessionResponses, UpdateModelSettingsData, UpdateModelSettingsErrors, UpdateModelSettingsResponse, UpdateModelSettingsResponses, UpdateProviderRequest, UpdateScheduleData, UpdateScheduleErrors, UpdateScheduleRequest, UpdateScheduleResponse, UpdateScheduleResponses, UpdateSessionNameData, UpdateSessionNameErrors, UpdateSessionNameRequest, UpdateSessionNameResponses, UpdateSessionUserRecipeValuesData, UpdateSessionUserRecipeValuesError, UpdateSessionUserRecipeValuesErrors, UpdateSessionUserRecipeValuesRequest, UpdateSessionUserRecipeValuesResponse, UpdateSessionUserRecipeValuesResponse2, UpdateSessionUserRecipeValuesResponses, UpdateWorkingDirData, UpdateWorkingDirErrors, UpdateWorkingDirRequest, UpdateWorkingDirResponses, UpsertConfigData, UpsertConfigErrors, UpsertConfigQuery, UpsertConfigResponse, UpsertConfigResponses, UpsertPermissionsData, UpsertPermissionsErrors, UpsertPermissionsQuery, UpsertPermissionsResponse, UpsertPermissionsResponses, ValidateConfigData, ValidateConfigErrors, ValidateConfigResponse, ValidateConfigResponses, WhisperModelResponse, WindowProps } from './types.gen'; diff --git a/ui/desktop/src/api/sdk.gen.ts b/ui/desktop/src/api/sdk.gen.ts index 012124b3b4..da2dc61d4b 100644 --- a/ui/desktop/src/api/sdk.gen.ts +++ b/ui/desktop/src/api/sdk.gen.ts @@ -2,7 +2,7 @@ import type { Client, Options as Options2, TDataShape } from './client'; import { client } from './client.gen'; -import type { AddExtensionData, AddExtensionErrors, AddExtensionResponses, AgentAddExtensionData, AgentAddExtensionErrors, AgentAddExtensionResponses, AgentRemoveExtensionData, AgentRemoveExtensionErrors, AgentRemoveExtensionResponses, BackupConfigData, BackupConfigErrors, BackupConfigResponses, CallToolData, CallToolErrors, CallToolResponses, CancelDownloadData, CancelDownloadErrors, CancelDownloadResponses, CheckProviderData, ConfigureProviderOauthData, ConfigureProviderOauthErrors, ConfigureProviderOauthResponses, ConfirmToolActionData, ConfirmToolActionErrors, ConfirmToolActionResponses, CreateCustomProviderData, CreateCustomProviderErrors, CreateCustomProviderResponses, CreateRecipeData, CreateRecipeErrors, CreateRecipeResponses, CreateScheduleData, CreateScheduleErrors, CreateScheduleResponses, DecodeRecipeData, DecodeRecipeErrors, DecodeRecipeResponses, DeleteModelData, DeleteModelErrors, DeleteModelResponses, DeleteRecipeData, DeleteRecipeErrors, DeleteRecipeResponses, DeleteScheduleData, DeleteScheduleErrors, DeleteScheduleResponses, DeleteSessionData, DeleteSessionErrors, DeleteSessionResponses, DetectProviderData, DetectProviderErrors, DetectProviderResponses, DiagnosticsData, DiagnosticsErrors, DiagnosticsResponses, DownloadModelData, DownloadModelErrors, DownloadModelResponses, EncodeRecipeData, EncodeRecipeErrors, EncodeRecipeResponses, ExportAppData, ExportAppErrors, ExportAppResponses, ExportSessionData, ExportSessionErrors, ExportSessionResponses, ForkSessionData, ForkSessionErrors, ForkSessionResponses, GetCanonicalModelInfoData, GetCanonicalModelInfoResponses, GetCustomProviderData, GetCustomProviderErrors, GetCustomProviderResponses, GetDictationConfigData, GetDictationConfigResponses, GetDownloadProgressData, GetDownloadProgressErrors, GetDownloadProgressResponses, GetExtensionsData, GetExtensionsErrors, GetExtensionsResponses, GetPromptData, GetPromptErrors, GetPromptResponses, GetPromptsData, GetPromptsResponses, GetProviderModelsData, GetProviderModelsErrors, GetProviderModelsResponses, GetSessionData, GetSessionErrors, GetSessionExtensionsData, GetSessionExtensionsErrors, GetSessionExtensionsResponses, GetSessionInsightsData, GetSessionInsightsErrors, GetSessionInsightsResponses, GetSessionResponses, GetSlashCommandsData, GetSlashCommandsResponses, GetToolsData, GetToolsErrors, GetToolsResponses, GetTunnelStatusData, GetTunnelStatusResponses, ImportAppData, ImportAppErrors, ImportAppResponses, ImportSessionData, ImportSessionErrors, ImportSessionResponses, InitConfigData, InitConfigErrors, InitConfigResponses, InspectRunningJobData, InspectRunningJobErrors, InspectRunningJobResponses, KillRunningJobData, KillRunningJobResponses, ListAppsData, ListAppsErrors, ListAppsResponses, ListModelsData, ListModelsResponses, ListRecipesData, ListRecipesErrors, ListRecipesResponses, ListSchedulesData, ListSchedulesErrors, ListSchedulesResponses, ListSessionsData, ListSessionsErrors, ListSessionsResponses, McpUiProxyData, McpUiProxyErrors, McpUiProxyResponses, ParseRecipeData, ParseRecipeErrors, ParseRecipeResponses, PauseScheduleData, PauseScheduleErrors, PauseScheduleResponses, ProvidersData, ProvidersResponses, ReadAllConfigData, ReadAllConfigResponses, ReadConfigData, ReadConfigErrors, ReadConfigResponses, ReadResourceData, ReadResourceErrors, ReadResourceResponses, RecipeToYamlData, RecipeToYamlErrors, RecipeToYamlResponses, RecoverConfigData, RecoverConfigErrors, RecoverConfigResponses, RemoveConfigData, RemoveConfigErrors, RemoveConfigResponses, RemoveCustomProviderData, RemoveCustomProviderErrors, RemoveCustomProviderResponses, RemoveExtensionData, RemoveExtensionErrors, RemoveExtensionResponses, ReplyData, ReplyErrors, ReplyResponses, ResetPromptData, ResetPromptErrors, ResetPromptResponses, RestartAgentData, RestartAgentErrors, RestartAgentResponses, ResumeAgentData, ResumeAgentErrors, ResumeAgentResponses, RunNowHandlerData, RunNowHandlerErrors, RunNowHandlerResponses, SavePromptData, SavePromptErrors, SavePromptResponses, SaveRecipeData, SaveRecipeErrors, SaveRecipeResponses, ScanRecipeData, ScanRecipeResponses, ScheduleRecipeData, ScheduleRecipeErrors, ScheduleRecipeResponses, SearchSessionsData, SearchSessionsErrors, SearchSessionsResponses, SendTelemetryEventData, SendTelemetryEventResponses, SessionsHandlerData, SessionsHandlerErrors, SessionsHandlerResponses, SetConfigProviderData, SetRecipeSlashCommandData, SetRecipeSlashCommandErrors, SetRecipeSlashCommandResponses, StartAgentData, StartAgentErrors, StartAgentResponses, StartOpenrouterSetupData, StartOpenrouterSetupResponses, StartTetrateSetupData, StartTetrateSetupResponses, StartTunnelData, StartTunnelErrors, StartTunnelResponses, StatusData, StatusResponses, StopAgentData, StopAgentErrors, StopAgentResponses, StopTunnelData, StopTunnelErrors, StopTunnelResponses, SystemInfoData, SystemInfoResponses, TranscribeDictationData, TranscribeDictationErrors, TranscribeDictationResponses, UnpauseScheduleData, UnpauseScheduleErrors, UnpauseScheduleResponses, UpdateAgentProviderData, UpdateAgentProviderErrors, UpdateAgentProviderResponses, UpdateCustomProviderData, UpdateCustomProviderErrors, UpdateCustomProviderResponses, UpdateFromSessionData, UpdateFromSessionErrors, UpdateFromSessionResponses, UpdateScheduleData, UpdateScheduleErrors, UpdateScheduleResponses, UpdateSessionNameData, UpdateSessionNameErrors, UpdateSessionNameResponses, UpdateSessionUserRecipeValuesData, UpdateSessionUserRecipeValuesErrors, UpdateSessionUserRecipeValuesResponses, UpdateWorkingDirData, UpdateWorkingDirErrors, UpdateWorkingDirResponses, UpsertConfigData, UpsertConfigErrors, UpsertConfigResponses, UpsertPermissionsData, UpsertPermissionsErrors, UpsertPermissionsResponses, ValidateConfigData, ValidateConfigErrors, ValidateConfigResponses } from './types.gen'; +import type { AddExtensionData, AddExtensionErrors, AddExtensionResponses, AgentAddExtensionData, AgentAddExtensionErrors, AgentAddExtensionResponses, AgentRemoveExtensionData, AgentRemoveExtensionErrors, AgentRemoveExtensionResponses, BackupConfigData, BackupConfigErrors, BackupConfigResponses, CallToolData, CallToolErrors, CallToolResponses, CancelDownloadData, CancelDownloadErrors, CancelDownloadResponses, CancelLocalModelDownloadData, CancelLocalModelDownloadErrors, CancelLocalModelDownloadResponses, CheckProviderData, ConfigureProviderOauthData, ConfigureProviderOauthErrors, ConfigureProviderOauthResponses, ConfirmToolActionData, ConfirmToolActionErrors, ConfirmToolActionResponses, CreateCustomProviderData, CreateCustomProviderErrors, CreateCustomProviderResponses, CreateRecipeData, CreateRecipeErrors, CreateRecipeResponses, CreateScheduleData, CreateScheduleErrors, CreateScheduleResponses, DecodeRecipeData, DecodeRecipeErrors, DecodeRecipeResponses, DeleteLocalModelData, DeleteLocalModelErrors, DeleteLocalModelResponses, DeleteModelData, DeleteModelErrors, DeleteModelResponses, DeleteRecipeData, DeleteRecipeErrors, DeleteRecipeResponses, DeleteScheduleData, DeleteScheduleErrors, DeleteScheduleResponses, DeleteSessionData, DeleteSessionErrors, DeleteSessionResponses, DetectProviderData, DetectProviderErrors, DetectProviderResponses, DiagnosticsData, DiagnosticsErrors, DiagnosticsResponses, DownloadHfModelData, DownloadHfModelErrors, DownloadHfModelResponses, DownloadModelData, DownloadModelErrors, DownloadModelResponses, EncodeRecipeData, EncodeRecipeErrors, EncodeRecipeResponses, ExportAppData, ExportAppErrors, ExportAppResponses, ExportSessionData, ExportSessionErrors, ExportSessionResponses, ForkSessionData, ForkSessionErrors, ForkSessionResponses, GetCanonicalModelInfoData, GetCanonicalModelInfoResponses, GetCustomProviderData, GetCustomProviderErrors, GetCustomProviderResponses, GetDictationConfigData, GetDictationConfigResponses, GetDownloadProgressData, GetDownloadProgressErrors, GetDownloadProgressResponses, GetExtensionsData, GetExtensionsErrors, GetExtensionsResponses, GetLocalModelDownloadProgressData, GetLocalModelDownloadProgressErrors, GetLocalModelDownloadProgressResponses, GetModelSettingsData, GetModelSettingsErrors, GetModelSettingsResponses, GetPromptData, GetPromptErrors, GetPromptResponses, GetPromptsData, GetPromptsResponses, GetProviderModelsData, GetProviderModelsErrors, GetProviderModelsResponses, GetRepoFilesData, GetRepoFilesResponses, GetSessionData, GetSessionErrors, GetSessionExtensionsData, GetSessionExtensionsErrors, GetSessionExtensionsResponses, GetSessionInsightsData, GetSessionInsightsErrors, GetSessionInsightsResponses, GetSessionResponses, GetSlashCommandsData, GetSlashCommandsResponses, GetToolsData, GetToolsErrors, GetToolsResponses, GetTunnelStatusData, GetTunnelStatusResponses, ImportAppData, ImportAppErrors, ImportAppResponses, ImportSessionData, ImportSessionErrors, ImportSessionResponses, InitConfigData, InitConfigErrors, InitConfigResponses, InspectRunningJobData, InspectRunningJobErrors, InspectRunningJobResponses, KillRunningJobData, KillRunningJobResponses, ListAppsData, ListAppsErrors, ListAppsResponses, ListLocalModelsData, ListLocalModelsResponses, ListModelsData, ListModelsResponses, ListRecipesData, ListRecipesErrors, ListRecipesResponses, ListSchedulesData, ListSchedulesErrors, ListSchedulesResponses, ListSessionsData, ListSessionsErrors, ListSessionsResponses, McpUiProxyData, McpUiProxyErrors, McpUiProxyResponses, ParseRecipeData, ParseRecipeErrors, ParseRecipeResponses, PauseScheduleData, PauseScheduleErrors, PauseScheduleResponses, ProvidersData, ProvidersResponses, ReadAllConfigData, ReadAllConfigResponses, ReadConfigData, ReadConfigErrors, ReadConfigResponses, ReadResourceData, ReadResourceErrors, ReadResourceResponses, RecipeToYamlData, RecipeToYamlErrors, RecipeToYamlResponses, RecoverConfigData, RecoverConfigErrors, RecoverConfigResponses, RemoveConfigData, RemoveConfigErrors, RemoveConfigResponses, RemoveCustomProviderData, RemoveCustomProviderErrors, RemoveCustomProviderResponses, RemoveExtensionData, RemoveExtensionErrors, RemoveExtensionResponses, ReplyData, ReplyErrors, ReplyResponses, ResetPromptData, ResetPromptErrors, ResetPromptResponses, RestartAgentData, RestartAgentErrors, RestartAgentResponses, ResumeAgentData, ResumeAgentErrors, ResumeAgentResponses, RunNowHandlerData, RunNowHandlerErrors, RunNowHandlerResponses, SavePromptData, SavePromptErrors, SavePromptResponses, SaveRecipeData, SaveRecipeErrors, SaveRecipeResponses, ScanRecipeData, ScanRecipeResponses, ScheduleRecipeData, ScheduleRecipeErrors, ScheduleRecipeResponses, SearchHfModelsData, SearchHfModelsErrors, SearchHfModelsResponses, SearchSessionsData, SearchSessionsErrors, SearchSessionsResponses, SendTelemetryEventData, SendTelemetryEventResponses, SessionsHandlerData, SessionsHandlerErrors, SessionsHandlerResponses, SetConfigProviderData, SetRecipeSlashCommandData, SetRecipeSlashCommandErrors, SetRecipeSlashCommandResponses, StartAgentData, StartAgentErrors, StartAgentResponses, StartOpenrouterSetupData, StartOpenrouterSetupResponses, StartTetrateSetupData, StartTetrateSetupResponses, StartTunnelData, StartTunnelErrors, StartTunnelResponses, StatusData, StatusResponses, StopAgentData, StopAgentErrors, StopAgentResponses, StopTunnelData, StopTunnelErrors, StopTunnelResponses, SystemInfoData, SystemInfoResponses, TranscribeDictationData, TranscribeDictationErrors, TranscribeDictationResponses, UnpauseScheduleData, UnpauseScheduleErrors, UnpauseScheduleResponses, UpdateAgentProviderData, UpdateAgentProviderErrors, UpdateAgentProviderResponses, UpdateCustomProviderData, UpdateCustomProviderErrors, UpdateCustomProviderResponses, UpdateFromSessionData, UpdateFromSessionErrors, UpdateFromSessionResponses, UpdateModelSettingsData, UpdateModelSettingsErrors, UpdateModelSettingsResponses, UpdateScheduleData, UpdateScheduleErrors, UpdateScheduleResponses, UpdateSessionNameData, UpdateSessionNameErrors, UpdateSessionNameResponses, UpdateSessionUserRecipeValuesData, UpdateSessionUserRecipeValuesErrors, UpdateSessionUserRecipeValuesResponses, UpdateWorkingDirData, UpdateWorkingDirErrors, UpdateWorkingDirResponses, UpsertConfigData, UpsertConfigErrors, UpsertConfigResponses, UpsertPermissionsData, UpsertPermissionsErrors, UpsertPermissionsResponses, ValidateConfigData, ValidateConfigErrors, ValidateConfigResponses } from './types.gen'; export type Options = Options2 & { /** @@ -308,6 +308,38 @@ export const startOpenrouterSetup = (optio export const startTetrateSetup = (options?: Options) => (options?.client ?? client).post({ url: '/handle_tetrate', ...options }); +export const downloadHfModel = (options: Options) => (options.client ?? client).post({ + url: '/local-inference/download', + ...options, + headers: { + 'Content-Type': 'application/json', + ...options.headers + } +}); + +export const listLocalModels = (options?: Options) => (options?.client ?? client).get({ url: '/local-inference/models', ...options }); + +export const deleteLocalModel = (options: Options) => (options.client ?? client).delete({ url: '/local-inference/models/{model_id}', ...options }); + +export const cancelLocalModelDownload = (options: Options) => (options.client ?? client).delete({ url: '/local-inference/models/{model_id}/download', ...options }); + +export const getLocalModelDownloadProgress = (options: Options) => (options.client ?? client).get({ url: '/local-inference/models/{model_id}/download', ...options }); + +export const getModelSettings = (options: Options) => (options.client ?? client).get({ url: '/local-inference/models/{model_id}/settings', ...options }); + +export const updateModelSettings = (options: Options) => (options.client ?? client).put({ + url: '/local-inference/models/{model_id}/settings', + ...options, + headers: { + 'Content-Type': 'application/json', + ...options.headers + } +}); + +export const getRepoFiles = (options: Options) => (options.client ?? client).get({ url: '/local-inference/repo/{author}/{repo}/files', ...options }); + +export const searchHfModels = (options: Options) => (options.client ?? client).get({ url: '/local-inference/search', ...options }); + export const mcpUiProxy = (options: Options) => (options.client ?? client).get({ url: '/mcp-ui-proxy', ...options }); export const createRecipe = (options: Options) => (options.client ?? client).post({ diff --git a/ui/desktop/src/api/types.gen.ts b/ui/desktop/src/api/types.gen.ts index 22524f9403..a4bc570102 100644 --- a/ui/desktop/src/api/types.gen.ts +++ b/ui/desktop/src/api/types.gen.ts @@ -232,6 +232,13 @@ export type DictationProviderStatus = { uses_provider_config: boolean; }; +export type DownloadModelRequest = { + /** + * Model spec like "bartowski/Llama-3.2-3B-Instruct-GGUF:Q4_K_M" + */ + spec: string; +}; + export type DownloadProgress = { /** * Bytes downloaded so far @@ -446,6 +453,36 @@ export type GooseApp = McpAppResource & (WindowProps | null) & { prd?: string | null; }; +/** + * A single downloadable GGUF file (used internally and for downloads). + */ +export type HfGgufFile = { + download_url: string; + filename: string; + quantization: string; + size_bytes: number; +}; + +export type HfModelInfo = { + author: string; + downloads: number; + gguf_files: Array; + model_name: string; + repo_id: string; +}; + +/** + * A quantization variant — groups sharded files into one logical entry. + */ +export type HfQuantVariant = { + description: string; + download_url: string; + filename: string; + quality_rank: number; + quantization: string; + size_bytes: number; +}; + export type Icon = { mimeType?: string; sizes?: Array; @@ -511,6 +548,18 @@ export type LoadedProvider = { is_editable: boolean; }; +export type LocalModelResponse = { + display_name: string; + filename: string; + id: string; + quantization: string; + recommended: boolean; + repo_id: string; + settings: ModelSettings; + size_bytes: number; + status: ModelDownloadStatus; +}; + /** * MCP App Resource * Represents a UI resource that can be rendered in an MCP App @@ -638,6 +687,18 @@ export type ModelConfig = { toolshim_model?: string | null; }; +export type ModelDownloadStatus = { + state: 'NotDownloaded'; +} | { + bytes_downloaded: number; + progress_percent: number; + speed_bps?: number | null; + state: 'Downloading'; + total_bytes: number; +} | { + state: 'Downloaded'; +}; + /** * Information about a model's capabilities */ @@ -690,6 +751,23 @@ export type ModelInfoResponse = { source: string; }; +export type ModelSettings = { + context_size?: number | null; + flash_attention?: boolean | null; + frequency_penalty?: number; + max_output_tokens?: number | null; + n_batch?: number | null; + n_gpu_layers?: number | null; + n_threads?: number | null; + native_tool_calling?: boolean; + presence_penalty?: number; + repeat_last_n?: number; + repeat_penalty?: number; + sampling?: SamplingConfig; + use_jinja?: boolean; + use_mlock?: boolean; +}; + export type ParseRecipeRequest = { content: string; }; @@ -909,6 +987,11 @@ export type RemoveExtensionRequest = { session_id: string; }; +export type RepoVariantsResponse = { + recommended_index?: number | null; + variants: Array; +}; + export type ResourceContents = { _meta?: { [key: string]: unknown; @@ -986,6 +1069,22 @@ export type RunNowResponse = { session_id: string; }; +export type SamplingConfig = { + type: 'Greedy'; +} | { + min_p: number; + seed?: number | null; + temperature: number; + top_k: number; + top_p: number; + type: 'Temperature'; +} | { + eta: number; + seed?: number | null; + tau: number; + type: 'MirostatV2'; +}; + export type SavePromptRequest = { content: string; }; @@ -2836,6 +2935,221 @@ export type StartTetrateSetupResponses = { export type StartTetrateSetupResponse = StartTetrateSetupResponses[keyof StartTetrateSetupResponses]; +export type DownloadHfModelData = { + body: DownloadModelRequest; + path?: never; + query?: never; + url: '/local-inference/download'; +}; + +export type DownloadHfModelErrors = { + /** + * Invalid request + */ + 400: unknown; +}; + +export type DownloadHfModelResponses = { + /** + * Download started + */ + 202: string; +}; + +export type DownloadHfModelResponse = DownloadHfModelResponses[keyof DownloadHfModelResponses]; + +export type ListLocalModelsData = { + body?: never; + path?: never; + query?: never; + url: '/local-inference/models'; +}; + +export type ListLocalModelsResponses = { + /** + * List of available local LLM models + */ + 200: Array; +}; + +export type ListLocalModelsResponse = ListLocalModelsResponses[keyof ListLocalModelsResponses]; + +export type DeleteLocalModelData = { + body?: never; + path: { + model_id: string; + }; + query?: never; + url: '/local-inference/models/{model_id}'; +}; + +export type DeleteLocalModelErrors = { + /** + * Model not found + */ + 404: unknown; +}; + +export type DeleteLocalModelResponses = { + /** + * Model deleted + */ + 200: unknown; +}; + +export type CancelLocalModelDownloadData = { + body?: never; + path: { + model_id: string; + }; + query?: never; + url: '/local-inference/models/{model_id}/download'; +}; + +export type CancelLocalModelDownloadErrors = { + /** + * No active download + */ + 404: unknown; +}; + +export type CancelLocalModelDownloadResponses = { + /** + * Download cancelled + */ + 200: unknown; +}; + +export type GetLocalModelDownloadProgressData = { + body?: never; + path: { + model_id: string; + }; + query?: never; + url: '/local-inference/models/{model_id}/download'; +}; + +export type GetLocalModelDownloadProgressErrors = { + /** + * No active download + */ + 404: unknown; +}; + +export type GetLocalModelDownloadProgressResponses = { + /** + * Download progress + */ + 200: DownloadProgress; +}; + +export type GetLocalModelDownloadProgressResponse = GetLocalModelDownloadProgressResponses[keyof GetLocalModelDownloadProgressResponses]; + +export type GetModelSettingsData = { + body?: never; + path: { + model_id: string; + }; + query?: never; + url: '/local-inference/models/{model_id}/settings'; +}; + +export type GetModelSettingsErrors = { + /** + * Model not found + */ + 404: unknown; +}; + +export type GetModelSettingsResponses = { + /** + * Model settings + */ + 200: ModelSettings; +}; + +export type GetModelSettingsResponse = GetModelSettingsResponses[keyof GetModelSettingsResponses]; + +export type UpdateModelSettingsData = { + body: ModelSettings; + path: { + model_id: string; + }; + query?: never; + url: '/local-inference/models/{model_id}/settings'; +}; + +export type UpdateModelSettingsErrors = { + /** + * Model not found + */ + 404: unknown; + /** + * Failed to save settings + */ + 500: unknown; +}; + +export type UpdateModelSettingsResponses = { + /** + * Settings updated + */ + 200: ModelSettings; +}; + +export type UpdateModelSettingsResponse = UpdateModelSettingsResponses[keyof UpdateModelSettingsResponses]; + +export type GetRepoFilesData = { + body?: never; + path: { + author: string; + repo: string; + }; + query?: never; + url: '/local-inference/repo/{author}/{repo}/files'; +}; + +export type GetRepoFilesResponses = { + /** + * GGUF files in the repo + */ + 200: RepoVariantsResponse; +}; + +export type GetRepoFilesResponse = GetRepoFilesResponses[keyof GetRepoFilesResponses]; + +export type SearchHfModelsData = { + body?: never; + path?: never; + query: { + /** + * Search query + */ + q: string; + /** + * Max results + */ + limit?: number | null; + }; + url: '/local-inference/search'; +}; + +export type SearchHfModelsErrors = { + /** + * Search failed + */ + 500: unknown; +}; + +export type SearchHfModelsResponses = { + /** + * Search results + */ + 200: Array; +}; + +export type SearchHfModelsResponse = SearchHfModelsResponses[keyof SearchHfModelsResponses]; + export type McpUiProxyData = { body?: never; path?: never; diff --git a/ui/desktop/src/components/LocalModelSetup.tsx b/ui/desktop/src/components/LocalModelSetup.tsx new file mode 100644 index 0000000000..4fe469d3a8 --- /dev/null +++ b/ui/desktop/src/components/LocalModelSetup.tsx @@ -0,0 +1,397 @@ +import { useState, useEffect, useCallback, useRef } from 'react'; +import { useConfig } from './ConfigContext'; +import { + listLocalModels, + downloadHfModel, + getLocalModelDownloadProgress, + cancelLocalModelDownload, + type DownloadProgress, + type LocalModelResponse, +} from '../api'; +import { toastService } from '../toasts'; +import { trackOnboardingSetupFailed } from '../utils/analytics'; +import { Goose } from './icons'; + +interface LocalModelSetupProps { + onSuccess: () => void; + onCancel: () => void; +} + +const formatBytes = (bytes: number): string => { + if (bytes < 1024) return `${bytes}B`; + if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(0)}KB`; + if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(0)}MB`; + return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)}GB`; +}; + +const formatSize = (bytes: number): string => { + const mb = bytes / (1024 * 1024); + return mb >= 1024 ? `${(mb / 1024).toFixed(1)}GB` : `${mb.toFixed(0)}MB`; +}; + +type SetupPhase = 'loading' | 'select' | 'downloading' | 'error'; + +export function LocalModelSetup({ onSuccess, onCancel }: LocalModelSetupProps) { + const { upsert } = useConfig(); + const [phase, setPhase] = useState('loading'); + const [models, setModels] = useState([]); + const [selectedModelId, setSelectedModelId] = useState(null); + const [downloadProgress, setDownloadProgress] = useState(null); + const [errorMessage, setErrorMessage] = useState(null); + const [showAllModels, setShowAllModels] = useState(false); + const pollRef = useRef | null>(null); + + const cleanup = useCallback(() => { + if (pollRef.current) { + clearInterval(pollRef.current); + pollRef.current = null; + } + }, []); + + useEffect(() => cleanup, [cleanup]); + + useEffect(() => { + const load = async () => { + try { + const response = await listLocalModels(); + if (response.data) { + setModels(response.data); + + const alreadyDownloaded = response.data.find((m) => m.status.state === 'Downloaded'); + if (alreadyDownloaded) { + setSelectedModelId(alreadyDownloaded.id); + } else { + const recommended = response.data.find((m: LocalModelResponse) => m.recommended); + if (recommended) setSelectedModelId(recommended.id); + } + } + } catch (error) { + console.error('Failed to load local models:', error); + setErrorMessage('Failed to load available models. Please try again.'); + setPhase('error'); + return; + } + setPhase('select'); + }; + load(); + }, []); + + const finishSetup = async (modelId: string) => { + await upsert('GOOSE_PROVIDER', 'local', false); + await upsert('GOOSE_MODEL', modelId, false); + toastService.success({ + title: 'Local Model Ready', + msg: `Running entirely on your machine with ${modelId}.`, + }); + onSuccess(); + }; + + const startDownload = async (modelId: string) => { + setPhase('downloading'); + setDownloadProgress(null); + setErrorMessage(null); + + const model = models.find((m) => m.id === modelId); + if (!model) { + setErrorMessage('Model not found'); + setPhase('error'); + return; + } + + try { + await downloadHfModel({ body: { spec: model.id } }); + } catch (error) { + console.error('Failed to start download:', error); + setErrorMessage('Failed to start download. Please try again.'); + trackOnboardingSetupFailed('local', 'download_start_failed'); + setPhase('error'); + return; + } + + pollRef.current = setInterval(async () => { + try { + const response = await getLocalModelDownloadProgress({ path: { model_id: modelId } }); + if (response.data) { + setDownloadProgress(response.data); + if (response.data.status === 'completed') { + cleanup(); + await finishSetup(modelId); + } else if (response.data.status === 'failed') { + cleanup(); + setErrorMessage(response.data.error || 'Download failed.'); + trackOnboardingSetupFailed('local', response.data.error || 'download_failed'); + setPhase('error'); + } else if (response.data.status === 'cancelled') { + cleanup(); + setPhase('select'); + } + } + } catch { + cleanup(); + setErrorMessage('Lost connection to download. Please try again.'); + trackOnboardingSetupFailed('local', 'progress_poll_failed'); + setPhase('error'); + } + }, 500); + }; + + const handleCancel = async () => { + if (phase === 'downloading' && selectedModelId) { + cleanup(); + try { + await cancelLocalModelDownload({ path: { model_id: selectedModelId } }); + } catch { + // best-effort + } + setDownloadProgress(null); + setPhase('select'); + } else { + onCancel(); + } + }; + + const handlePrimaryAction = async () => { + if (!selectedModelId) return; + const model = models.find((m) => m.id === selectedModelId); + if (!model) return; + if (model.status.state === 'Downloaded') { + await finishSetup(model.id); + } else { + await startDownload(model.id); + } + }; + + const recommended = models.find((m) => m.recommended); + const otherModels = models.filter((m) => m.id !== recommended?.id); + const selectedModel = models.find((m) => m.id === selectedModelId); + + if (phase === 'loading') { + return ( +
+
+

Checking available models...

+
+ ); + } + + return ( +
+ {/* Header */} +
+
+ +
+

Run Locally

+

+ Download a model to run Goose entirely on your machine — no API keys, no accounts, completely free and private. +

+
+ + {/* Error state */} + {phase === 'error' && ( +
+
+

{errorMessage}

+
+ + +
+ )} + + {/* Model selection */} + {phase === 'select' && ( +
+ {/* Recommended model card */} + {recommended && ( +
setSelectedModelId(recommended.id)} + className={`relative w-full p-4 sm:p-6 border rounded-xl cursor-pointer transition-all duration-200 group ${ + selectedModelId === recommended.id + ? 'border-blue-500 bg-blue-500/5' + : 'border-border-subtle hover:border-border-default' + }`} + > +
+ + Best for your machine + +
+
+ setSelectedModelId(recommended.id)} + className="cursor-pointer flex-shrink-0 mt-1" + /> +
+
+ + {recommended.display_name} + + {recommended.status.state === 'Downloaded' && ( + + Ready + + )} +
+

+ {formatSize(recommended.size_bytes)} +

+
+
+
+ )} + + {/* Expandable other models */} + {otherModels.length > 0 && ( +
+ + + {showAllModels && ( +
+ {otherModels.map((model) => ( +
setSelectedModelId(model.id)} + className={`w-full p-4 border rounded-xl cursor-pointer transition-all duration-200 ${ + selectedModelId === model.id + ? 'border-blue-500 bg-blue-500/5' + : 'border-border-subtle hover:border-border-default' + }`} + > +
+ setSelectedModelId(model.id)} + className="cursor-pointer flex-shrink-0 mt-0.5" + /> +
+
+ {model.display_name} + {formatSize(model.size_bytes)} + {model.status.state === 'Downloaded' && ( + + Ready + + )} +
+
+
+
+ ))} +
+ )} +
+ )} + + {/* Primary action */} + + + +
+ )} + + {/* Downloading state */} + {phase === 'downloading' && selectedModel && ( +
+
+

+ Downloading {selectedModel.display_name} +

+ + {downloadProgress ? ( +
+ {/* Progress bar */} +
+
+
+ + {/* Stats row */} +
+ + {formatBytes(downloadProgress.bytes_downloaded)} of{' '} + {formatBytes(downloadProgress.total_bytes)} + + {downloadProgress.progress_percent.toFixed(0)}% +
+ +
+ {downloadProgress.speed_bps ? ( + {formatBytes(downloadProgress.speed_bps)}/s + ) : ( + + )} + {downloadProgress.eta_seconds != null && downloadProgress.eta_seconds > 0 && ( + + ~{downloadProgress.eta_seconds < 60 + ? `${Math.round(downloadProgress.eta_seconds)}s` + : `${Math.round(downloadProgress.eta_seconds / 60)}m`}{' '} + remaining + + )} +
+
+ ) : ( +
+
+ Starting download... +
+ )} +
+ + +
+ )} +
+ ); +} diff --git a/ui/desktop/src/components/McpApps/McpAppRenderer.tsx b/ui/desktop/src/components/McpApps/McpAppRenderer.tsx index cd1646fcbb..4733727359 100644 --- a/ui/desktop/src/components/McpApps/McpAppRenderer.tsx +++ b/ui/desktop/src/components/McpApps/McpAppRenderer.tsx @@ -15,7 +15,7 @@ * - "standalone" — Goose-specific mode for dedicated Electron windows */ -import { AppRenderer, type RequestHandlerExtra } from '@mcp-ui/client'; +import { AppRenderer } from '@mcp-ui/client'; import type { McpUiDisplayMode, McpUiHostContext, @@ -23,7 +23,7 @@ import type { McpUiResourcePermissions, McpUiSizeChangedNotification, } from '@modelcontextprotocol/ext-apps/app-bridge'; -import type { CallToolResult, JSONRPCRequest } from '@modelcontextprotocol/sdk/types.js'; +import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js'; import { useCallback, useEffect, useMemo, useReducer, useRef, useState } from 'react'; import { callTool, readResource } from '../../api'; import { AppEvents } from '../../constants/events'; @@ -40,8 +40,6 @@ import { McpAppToolInputPartial, McpAppToolResult, DimensionLayout, - SamplingCreateMessageParams, - SamplingCreateMessageResponse, } from './types'; const DEFAULT_IFRAME_HEIGHT = 200; @@ -267,13 +265,7 @@ export default function McpAppRenderer({ const containerRef = useRef(null); const [containerWidth, setContainerWidth] = useState(0); const [containerHeight, setContainerHeight] = useState(0); - const [apiHost, setApiHost] = useState(null); - const [secretKey, setSecretKey] = useState(null); - useEffect(() => { - window.electron.getGoosedHostPort().then(setApiHost); - window.electron.getSecretKey().then(setSecretKey); - }, []); // Fetch the resource from the extension to get HTML and metadata (CSP, permissions, etc.). // If cachedHtml is provided we show it immediately; the fetch updates metadata and @@ -535,42 +527,6 @@ export default function McpAppRenderer({ return () => observer.disconnect(); }, []); - const handleFallbackRequest = useCallback( - async (request: JSONRPCRequest, _extra: RequestHandlerExtra) => { - if (request.method === 'sampling/createMessage') { - if (!sessionId || !apiHost || !secretKey) { - throw new Error('Session not initialized for sampling request'); - } - const { messages, systemPrompt, maxTokens } = - request.params as unknown as SamplingCreateMessageParams; - const response = await fetch(`${apiHost}/sessions/${sessionId}/sampling/message`, { - method: 'POST', - headers: { - 'Content-Type': 'application/json', - 'X-Secret-Key': secretKey, - }, - body: JSON.stringify({ - messages: messages.map((m) => ({ - role: m.role, - content: m.content, - })), - systemPrompt, - maxTokens, - }), - }); - if (!response.ok) { - throw new Error(`Sampling request failed: ${response.statusText}`); - } - return (await response.json()) as SamplingCreateMessageResponse; - } - return { - status: 'error' as const, - message: `Unhandled JSON-RPC method: ${request.method ?? ''}`, - }; - }, - [sessionId, apiHost, secretKey] - ); - const handleError = useCallback((err: Error) => { console.error('[MCP App Error]:', err); dispatch({ type: 'ERROR', message: errorMessage(err) }); @@ -687,7 +643,6 @@ export default function McpAppRenderer({ onReadResource={handleReadResource} onLoggingMessage={handleLoggingMessage} onSizeChanged={handleSizeChanged} - onFallbackRequest={handleFallbackRequest} onError={handleError} /> ); diff --git a/ui/desktop/src/components/ProviderGuard.tsx b/ui/desktop/src/components/ProviderGuard.tsx index e1f6dd8421..21094510df 100644 --- a/ui/desktop/src/components/ProviderGuard.tsx +++ b/ui/desktop/src/components/ProviderGuard.tsx @@ -8,6 +8,7 @@ import { startChatGptCodexSetup } from '../utils/chatgptCodexSetup'; import WelcomeGooseLogo from './WelcomeGooseLogo'; import { toastService } from '../toasts'; import { OllamaSetup } from './OllamaSetup'; +import { LocalModelSetup } from './LocalModelSetup'; import ApiKeyTester from './ApiKeyTester'; import { SwitchModelModal } from './settings/models/subcomponents/SwitchModelModal'; import { createNavigationHandler } from '../utils/navigationUtils'; @@ -34,6 +35,7 @@ export default function ProviderGuard({ didSelectProvider, children }: ProviderG const [hasProvider, setHasProvider] = useState(false); const [showFirstTimeSetup, setShowFirstTimeSetup] = useState(false); const [showOllamaSetup, setShowOllamaSetup] = useState(false); + const [showLocalModelSetup, setShowLocalModelSetup] = useState(false); const [userInActiveSetup, setUserInActiveSetup] = useState(false); const [showSwitchModelModal, setShowSwitchModelModal] = useState(false); const [switchModelProvider, setSwitchModelProvider] = useState(null); @@ -200,6 +202,19 @@ export default function ProviderGuard({ didSelectProvider, children }: ProviderG setShowOllamaSetup(false); }; + const handleLocalModelComplete = () => { + trackOnboardingCompleted('local'); + setShowLocalModelSetup(false); + setShowFirstTimeSetup(false); + setHasProvider(true); + navigate('/', { replace: true }); + }; + + const handleLocalModelCancel = () => { + trackOnboardingAbandoned('local_model_setup'); + setShowLocalModelSetup(false); + }; + const handleRetrySetup = (setupType: 'openrouter' | 'tetrate' | 'chatgpt_codex') => { if (setupType === 'openrouter') { setOpenRouterSetupState(null); @@ -285,6 +300,23 @@ export default function ProviderGuard({ didSelectProvider, children }: ProviderG return ; } + if (showLocalModelSetup) { + return ( +
+
+
+
+ +
+
+
+
+ ); + } + if (!hasProvider && showFirstTimeSetup) { return (
@@ -316,6 +348,48 @@ export default function ProviderGuard({ didSelectProvider, children }: ProviderG }} /> + {/* Run Locally Card */} +
+
+ + Free & Private + +
+
{ + trackOnboardingProviderSelected('local'); + setShowLocalModelSetup(true); + }} + className="w-full p-4 sm:p-6 bg-transparent border rounded-xl transition-all duration-200 cursor-pointer group" + > +
+
+ + Run Locally + +
+
+ + + +
+
+

+ Download a model and run entirely on your machine. No API keys, no accounts. +

+
+
+ {/* ChatGPT Subscription Card - Full Width */}
diff --git a/ui/desktop/src/components/settings/SettingsView.tsx b/ui/desktop/src/components/settings/SettingsView.tsx index 2e04ab651f..05a17d9ccb 100644 --- a/ui/desktop/src/components/settings/SettingsView.tsx +++ b/ui/desktop/src/components/settings/SettingsView.tsx @@ -9,10 +9,11 @@ import ConfigSettings from './config/ConfigSettings'; import PromptsSettingsSection from './PromptsSettingsSection'; import { ExtensionConfig } from '../../api'; import { MainPanelLayout } from '../Layout/MainPanelLayout'; -import { Bot, Share2, Monitor, MessageSquare, FileText, Keyboard } from 'lucide-react'; +import { Bot, Share2, Monitor, MessageSquare, FileText, Keyboard, HardDrive } from 'lucide-react'; import { useState, useEffect, useRef } from 'react'; import ChatSettingsSection from './chat/ChatSettingsSection'; import KeyboardShortcutsSection from './keyboard/KeyboardShortcutsSection'; +import LocalInferenceSection from './localInference/LocalInferenceSection'; import { CONFIGURATION_ENABLED } from '../../updates'; import { trackSettingsTabViewed } from '../../utils/analytics'; @@ -54,6 +55,7 @@ export default function SettingsView({ chat: 'chat', prompts: 'prompts', keyboard: 'keyboard', + 'local-inference': 'local-inference', }; const targetTab = sectionToTab[viewOptions.section]; @@ -112,6 +114,14 @@ export default function SettingsView({ Models + + + Local Inference + Chat @@ -155,6 +165,13 @@ export default function SettingsView({ + + + + { // eslint-disable-next-line react-hooks/exhaustive-deps }, []); - // Determine if we should show all models by default (if non-recommended models are downloaded) - useEffect(() => { - if (models.length === 0) return; - - const hasDownloadedNonRecommended = models.some( - (model) => model.downloaded && !model.recommended - ); - - if (hasDownloadedNonRecommended && !showAllModels) { - setShowAllModels(true); - } - }, [models, showAllModels]); - const loadSelectedModel = async () => { try { const value = await read(LOCAL_WHISPER_MODEL_CONFIG_KEY, false); @@ -145,8 +132,14 @@ export const LocalModelManager = () => { } }; - const displayedModels = showAllModels ? models : models.filter((m) => m.recommended); + const hasDownloadedNonRecommended = models.some( + (model) => model.downloaded && !model.recommended + ); + const displayedModels = showAllModels || hasDownloadedNonRecommended + ? models + : models.filter((m) => m.recommended); const hasNonRecommendedModels = models.some((m) => !m.recommended); + const showToggleButton = hasNonRecommendedModels && !hasDownloadedNonRecommended; return (
@@ -267,7 +260,7 @@ export const LocalModelManager = () => { })}
- {hasNonRecommendedModels && ( + {showToggleButton && ( diff --git a/ui/desktop/src/components/settings/localInference/HuggingFaceModelSearch.tsx b/ui/desktop/src/components/settings/localInference/HuggingFaceModelSearch.tsx new file mode 100644 index 0000000000..241921555d --- /dev/null +++ b/ui/desktop/src/components/settings/localInference/HuggingFaceModelSearch.tsx @@ -0,0 +1,358 @@ +import { useState, useCallback, useRef } from 'react'; +import { Search, Download, ChevronDown, ChevronUp, Loader2, Star } from 'lucide-react'; +import { Button } from '../../ui/button'; +import { + searchHfModels, + getRepoFiles, + downloadHfModel, + type HfModelInfo, + type HfQuantVariant, +} from '../../../api'; + +const formatBytes = (bytes: number): string => { + if (bytes === 0) return 'unknown'; + if (bytes < 1024) return `${bytes}B`; + if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(0)}KB`; + if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(0)}MB`; + return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)}GB`; +}; + +const formatDownloads = (n: number): string => { + if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`; + if (n >= 1_000) return `${(n / 1_000).toFixed(1)}K`; + return `${n}`; +}; + +interface RepoData { + variants: HfQuantVariant[]; + recommendedIndex: number | null; +} + +interface Props { + onDownloadStarted: (modelId: string) => void; +} + +export const HuggingFaceModelSearch = ({ onDownloadStarted }: Props) => { + const [query, setQuery] = useState(''); + const [results, setResults] = useState([]); + const [expandedRepo, setExpandedRepo] = useState(null); + const [repoData, setRepoData] = useState>({}); + const [searching, setSearching] = useState(false); + const [downloading, setDownloading] = useState>(new Set()); + const [loadingFiles, setLoadingFiles] = useState>(new Set()); + const [directSpec, setDirectSpec] = useState(''); + const [error, setError] = useState(null); + const debounceRef = useRef | null>(null); + + const doSearch = useCallback(async (q: string) => { + if (!q.trim()) { + setResults([]); + setError(null); + return; + } + setSearching(true); + setError(null); + try { + const response = await searchHfModels({ + query: { q, limit: 20 }, + }); + if (response.data) { + // Pre-fetch variants for all results and filter out repos with no suitable quantizations + const modelsWithVariants = await Promise.all( + response.data.map(async (model) => { + try { + const [author, repo] = model.repo_id.split('/'); + const filesResponse = await getRepoFiles({ path: { author, repo } }); + if (filesResponse.data && filesResponse.data.variants.length > 0) { + return { model, data: filesResponse.data }; + } + } catch { + // Skip repos we can't fetch + } + return null; + }) + ); + + const validResults = modelsWithVariants.filter(Boolean) as { + model: HfModelInfo; + data: { variants: HfQuantVariant[]; recommended_index?: number | null }; + }[]; + + setResults(validResults.map((r) => r.model)); + setRepoData((prev) => { + const next = { ...prev }; + for (const r of validResults) { + next[r.model.repo_id] = { + variants: r.data.variants, + recommendedIndex: r.data.recommended_index ?? null, + }; + } + return next; + }); + + if (validResults.length === 0) { + setError('No GGUF models found for this query.'); + } + } else { + console.error('Search response:', response); + const errMsg = response.error + ? `Search error: ${JSON.stringify(response.error)}` + : 'Search returned no data.'; + setError(errMsg); + } + } catch (e) { + console.error('Search failed:', e); + setError('Search failed. Please try again.'); + } finally { + setSearching(false); + } + }, []); + + const handleQueryChange = (value: string) => { + setQuery(value); + if (debounceRef.current) clearTimeout(debounceRef.current); + debounceRef.current = setTimeout(() => doSearch(value), 300); + }; + + const toggleRepo = async (repoId: string) => { + if (expandedRepo === repoId) { + setExpandedRepo(null); + return; + } + setExpandedRepo(repoId); + + if (!repoData[repoId]?.variants.length) { + setLoadingFiles((prev) => new Set(prev).add(repoId)); + try { + const [author, repo] = repoId.split('/'); + const response = await getRepoFiles({ + path: { author, repo }, + }); + if (response.data) { + const variants = response.data.variants; + setRepoData((prev) => ({ + ...prev, + [repoId]: { + variants, + recommendedIndex: response.data!.recommended_index ?? null, + }, + })); + } + } catch (e) { + console.error('Failed to fetch repo files:', e); + } finally { + setLoadingFiles((prev) => { + const next = new Set(prev); + next.delete(repoId); + return next; + }); + } + } + }; + + const startDownload = async (repoId: string, quantization: string) => { + const spec = `${repoId}:${quantization}`; + setDownloading((prev) => new Set(prev).add(spec)); + try { + const response = await downloadHfModel({ + body: { spec }, + }); + if (response.data) { + onDownloadStarted(response.data); + } + } catch (e) { + console.error('Download failed:', e); + } finally { + setDownloading((prev) => { + const next = new Set(prev); + next.delete(spec); + return next; + }); + } + }; + + const startDirectDownload = async () => { + const spec = directSpec.trim(); + if (!spec) return; + const key = `direct:${spec}`; + setDownloading((prev) => new Set(prev).add(key)); + try { + const response = await downloadHfModel({ + body: { spec }, + }); + if (response.data) { + onDownloadStarted(response.data); + setDirectSpec(''); + } + } catch (e) { + console.error('Direct download failed:', e); + } finally { + setDownloading((prev) => { + const next = new Set(prev); + next.delete(key); + return next; + }); + } + }; + + return ( +
+
+

Search HuggingFace

+
+ + handleQueryChange(e.target.value)} + placeholder="Search for GGUF models..." + className="w-full pl-9 pr-4 py-2 text-sm border border-border-subtle rounded-lg bg-background-default text-text-default placeholder:text-text-muted focus:outline-none focus:border-accent-primary" + /> + {searching && ( + + )} +
+
+ + {error && !searching && ( +

{error}

+ )} + + {results.length > 0 && ( +
+ {results.map((model) => { + const isExpanded = expandedRepo === model.repo_id; + const data = repoData[model.repo_id]; + const variants = data?.variants || []; + const recommendedIndex = data?.recommendedIndex ?? null; + + return ( +
+ + + {isExpanded && ( +
+ {loadingFiles.has(model.repo_id) && ( +
+ + Loading variants... +
+ )} + {variants.map((variant, idx) => { + const dlKey = `${model.repo_id}:${variant.quantization}`; + const isStarting = downloading.has(dlKey); + const isRecommended = idx === recommendedIndex; + + return ( +
+
+
+ + {variant.quantization} + + + {formatBytes(variant.size_bytes)} + + {isRecommended && ( + + + Recommended + + )} +
+ {variant.description && ( + + {variant.description} + + )} +
+ +
+ ); + })} +
+ )} +
+ ); + })} +
+ )} + +
+

Direct Download

+

+ Specify a model directly: user/repo:quantization +

+
+ setDirectSpec(e.target.value)} + placeholder="bartowski/Llama-3.2-1B-Instruct-GGUF:Q4_K_M" + className="flex-1 px-3 py-2 text-sm border border-border-subtle rounded-lg bg-background-default text-text-default placeholder:text-text-muted focus:outline-none focus:border-accent-primary" + onKeyDown={(e) => { + if (e.key === 'Enter') startDirectDownload(); + }} + /> + +
+
+
+ ); +}; diff --git a/ui/desktop/src/components/settings/localInference/LocalInferenceSection.tsx b/ui/desktop/src/components/settings/localInference/LocalInferenceSection.tsx new file mode 100644 index 0000000000..3a68c21171 --- /dev/null +++ b/ui/desktop/src/components/settings/localInference/LocalInferenceSection.tsx @@ -0,0 +1,9 @@ +import { LocalInferenceSettings } from './LocalInferenceSettings'; + +export default function LocalInferenceSection() { + return ( +
+ +
+ ); +} diff --git a/ui/desktop/src/components/settings/localInference/LocalInferenceSettings.tsx b/ui/desktop/src/components/settings/localInference/LocalInferenceSettings.tsx new file mode 100644 index 0000000000..dc97643585 --- /dev/null +++ b/ui/desktop/src/components/settings/localInference/LocalInferenceSettings.tsx @@ -0,0 +1,410 @@ +import { useState, useEffect, useCallback, useRef } from 'react'; +import { Download, Trash2, X, ChevronDown, ChevronUp, Settings2 } from 'lucide-react'; +import { Button } from '../../ui/button'; +import { useModelAndProvider } from '../../ModelAndProviderContext'; +import { + listLocalModels, + downloadHfModel, + getLocalModelDownloadProgress, + cancelLocalModelDownload, + deleteLocalModel, + setConfigProvider, + type DownloadProgress, + type LocalModelResponse, +} from '../../../api'; +import { HuggingFaceModelSearch } from './HuggingFaceModelSearch'; +import { ModelSettingsPanel } from './ModelSettingsPanel'; +import { + Dialog, + DialogContent, + DialogHeader, + DialogTitle, +} from '../../ui/dialog'; + +const formatBytes = (bytes: number): string => { + if (bytes < 1024) return `${bytes}B`; + if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(0)}KB`; + if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(0)}MB`; + return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)}GB`; +}; + +export const LocalInferenceSettings = () => { + const [models, setModels] = useState([]); + const [downloads, setDownloads] = useState>(new Map()); + const [showAllFeatured, setShowAllFeatured] = useState(false); + const [settingsOpenFor, setSettingsOpenFor] = useState(null); + const { currentModel, currentProvider, setProviderAndModel } = useModelAndProvider(); + const downloadSectionRef = useRef(null); + const selectedModelId = currentProvider === 'local' ? currentModel : null; + + const getDisplayName = useCallback( + (modelId: string): string => { + const model = models.find((m) => m.id === modelId); + return model?.display_name || modelId; + }, + [models] + ); + + const loadModels = useCallback(async () => { + try { + const response = await listLocalModels(); + if (response.data) { + setModels(response.data); + } + } catch (error) { + console.error('Failed to load models:', error); + } + }, []); + + // Check for any in-progress downloads when models list changes + const detectActiveDownloads = useCallback(async () => { + for (const model of models) { + if (downloads.has(model.id)) continue; + // Check models that the API reports as downloading + if (model.status.state === 'Downloading') { + pollDownloadProgress(model.id); + } + } + // eslint-disable-next-line react-hooks/exhaustive-deps + }, [models, downloads]); + + useEffect(() => { + loadModels(); + }, [loadModels]); + + useEffect(() => { + if (models.length > 0) { + detectActiveDownloads(); + } + // eslint-disable-next-line react-hooks/exhaustive-deps + }, [models]); + + const selectModel = async (modelId: string) => { + setProviderAndModel('local', modelId); + try { + await setConfigProvider({ + body: { provider: 'local', model: modelId }, + throwOnError: true, + }); + } catch (error) { + console.error('Failed to select model:', error); + } + }; + + const startFeaturedDownload = async (modelId: string) => { + const model = models.find((m) => m.id === modelId); + if (!model) return; + try { + await downloadHfModel({ body: { spec: model.id } }); + pollDownloadProgress(modelId); + scrollToDownloads(); + } catch (error) { + console.error('Failed to start download:', error); + } + }; + + const scrollToDownloads = useCallback(() => { + requestAnimationFrame(() => { + downloadSectionRef.current?.scrollIntoView({ behavior: 'smooth', block: 'nearest' }); + }); + }, []); + + const pollDownloadProgress = (modelId: string) => { + const interval = setInterval(async () => { + try { + const response = await getLocalModelDownloadProgress({ path: { model_id: modelId } }); + if (response.data) { + const progress = response.data; + setDownloads((prev) => new Map(prev).set(modelId, progress)); + + if (progress.status === 'completed') { + clearInterval(interval); + setDownloads((prev) => { + const next = new Map(prev); + next.delete(modelId); + return next; + }); + await loadModels(); + await selectModel(modelId); + } else if (progress.status === 'failed') { + clearInterval(interval); + await loadModels(); + } + } else { + clearInterval(interval); + } + } catch { + clearInterval(interval); + } + }, 1000); + }; + + const cancelDownload = async (modelId: string) => { + try { + await cancelLocalModelDownload({ path: { model_id: modelId } }); + setDownloads((prev) => { + const next = new Map(prev); + next.delete(modelId); + return next; + }); + } catch (error) { + console.error('Failed to cancel download:', error); + } + }; + + const handleDeleteModel = async (modelId: string) => { + if (!window.confirm('Delete this model? You can re-download it later.')) return; + try { + await deleteLocalModel({ path: { model_id: modelId } }); + await loadModels(); + } catch (error) { + console.error('Failed to delete model:', error); + } + }; + + const handleHfDownloadStarted = (modelId: string) => { + pollDownloadProgress(modelId); + loadModels(); + scrollToDownloads(); + }; + + const isDownloaded = (model: LocalModelResponse) => model.status.state === 'Downloaded'; + const isNotDownloaded = (model: LocalModelResponse) => + model.status.state === 'NotDownloaded' && !downloads.has(model.id); + + const downloadedModels = models.filter(isDownloaded); + const notDownloadedModels = models.filter(isNotDownloaded); + const recommendedModels = notDownloadedModels.filter((m) => m.recommended); + const displayedFeatured = showAllFeatured ? notDownloadedModels : recommendedModels; + const showFeaturedToggle = notDownloadedModels.length > recommendedModels.length; + + return ( +
+
+

Local Inference Models

+

+ Download and manage local LLM models for inference without API keys. Search HuggingFace + for any GGUF model or use the featured picks below. +

+
+ + {/* Active Downloads */} + {downloads.size > 0 && ( +
+

Downloading

+
+ {Array.from(downloads.entries()).map(([modelId, progress]) => { + if (progress.status === 'completed') return null; + const displayName = getDisplayName(modelId); + return ( +
+
+ + {displayName} + + {progress.status === 'downloading' && ( + + )} +
+ {progress.status === 'downloading' && ( +
+
+
+
+
+ + {formatBytes(progress.bytes_downloaded)} /{' '} + {formatBytes(progress.total_bytes)} ( + {progress.progress_percent.toFixed(0)}%) + + + {progress.eta_seconds != null && progress.eta_seconds > 0 && ( + + {progress.eta_seconds < 60 + ? `${Math.round(progress.eta_seconds)}s` + : `${Math.round(progress.eta_seconds / 60)}m`}{' '} + remaining + + )} + {progress.speed_bps != null && progress.speed_bps > 0 && ( + {formatBytes(progress.speed_bps)}/s + )} + +
+
+ )} + {progress.status === 'failed' && ( +

+ {progress.error || 'Download failed'} +

+ )} +
+ ); + })} +
+
+ )} + + {/* Downloaded Models */} + {downloadedModels.length > 0 && ( +
+

Downloaded Models

+
+ {downloadedModels.map((model) => { + const isSelected = selectedModelId === model.id; + return ( +
+
+
+ selectModel(model.id)} + className="cursor-pointer" + /> + + {model.display_name} + + + {formatBytes(model.size_bytes)} + + {model.recommended && ( + + Recommended + + )} +
+
+ + +
+
+
+ ); + })} +
+
+ )} + + {/* Featured Models (not yet downloaded) */} + {displayedFeatured.length > 0 && ( +
+

Featured Models

+
+ {displayedFeatured.map((model) => ( +
+
+
+
+

+ {model.display_name} +

+ + {formatBytes(model.size_bytes)} + + {model.recommended && ( + + Recommended + + )} +
+
+ +
+
+ ))} +
+ + {showFeaturedToggle && ( + + )} +
+ )} + + {/* HuggingFace Search */} +
+ +
+ + {models.length === 0 && ( +
No models available
+ )} + + { + if (!open) setSettingsOpenFor(null); + }} + > + + + Model Settings +

{getDisplayName(settingsOpenFor || '')}

+ + {settingsOpenFor && } + + +
+ ); +}; diff --git a/ui/desktop/src/components/settings/localInference/ModelSettingsPanel.tsx b/ui/desktop/src/components/settings/localInference/ModelSettingsPanel.tsx new file mode 100644 index 0000000000..6ab726cc3e --- /dev/null +++ b/ui/desktop/src/components/settings/localInference/ModelSettingsPanel.tsx @@ -0,0 +1,415 @@ +import { useState, useEffect, useCallback } from 'react'; +import { RotateCcw } from 'lucide-react'; +import { Button } from '../../ui/button'; +import { Switch } from '../../ui/switch'; +import { + getModelSettings, + updateModelSettings, + type ModelSettings, + type SamplingConfig, +} from '../../../api'; + +const DEFAULT_SETTINGS: ModelSettings = { + context_size: null, + max_output_tokens: null, + sampling: { type: 'Temperature', temperature: 0.8, top_k: 40, top_p: 0.95, min_p: 0.05, seed: null }, + repeat_penalty: 1.0, + repeat_last_n: 64, + frequency_penalty: 0.0, + presence_penalty: 0.0, + n_batch: null, + n_gpu_layers: null, + use_mlock: false, + flash_attention: null, + n_threads: null, + native_tool_calling: false, +}; + +type SamplingType = SamplingConfig['type']; + +function NumberField({ + label, + description, + value, + onChange, + placeholder, + min, + max, + step, + allowNull, +}: { + label: string; + description?: string; + value: number | null | undefined; + onChange: (v: number | null) => void; + placeholder?: string; + min?: number; + max?: number; + step?: number; + allowNull?: boolean; +}) { + return ( +
+ + {description && {description}} + { + const raw = e.target.value; + if (raw === '' && allowNull) { + onChange(null); + } else { + const n = step && step < 1 ? parseFloat(raw) : parseInt(raw, 10); + if (!isNaN(n)) onChange(n); + } + }} + placeholder={placeholder ?? 'Auto'} + min={min} + max={max} + step={step} + /> +
+ ); +} + +function ToggleField({ + label, + description, + value, + onChange, +}: { + label: string; + description?: string; + value: boolean; + onChange: (v: boolean) => void; +}) { + return ( +
+
+
{label}
+ {description && {description}} +
+ +
+ ); +} + +function SelectField({ + label, + description, + value, + options, + onChange, +}: { + label: string; + description?: string; + value: T; + options: { value: T; label: string }[]; + onChange: (v: T) => void; +}) { + return ( +
+
+
{label}
+ {description && {description}} +
+ +
+ ); +} + +export const ModelSettingsPanel = ({ modelId }: { modelId: string }) => { + const [settings, setSettings] = useState(DEFAULT_SETTINGS); + const [loading, setLoading] = useState(true); + const [saving, setSaving] = useState(false); + + const load = useCallback(async () => { + try { + const res = await getModelSettings({ path: { model_id: modelId } }); + if (res.data) setSettings(res.data); + } catch { + // use defaults + } finally { + setLoading(false); + } + }, [modelId]); + + useEffect(() => { + load(); + }, [load]); + + const save = async (updated: ModelSettings) => { + setSettings(updated); + setSaving(true); + try { + await updateModelSettings({ path: { model_id: modelId }, body: updated }); + } catch (e) { + console.error('Failed to save settings:', e); + } finally { + setSaving(false); + } + }; + + const resetDefaults = () => save(DEFAULT_SETTINGS); + + const updateField = (key: K, value: ModelSettings[K]) => { + save({ ...settings, [key]: value }); + }; + + const samplingType: SamplingType = settings.sampling?.type ?? 'Temperature'; + + const setSamplingType = (type: SamplingType) => { + let sampling: SamplingConfig; + if (type === 'Greedy') { + sampling = { type: 'Greedy' }; + } else if (type === 'MirostatV2') { + sampling = { type: 'MirostatV2', tau: 5.0, eta: 0.1, seed: null }; + } else { + sampling = { type: 'Temperature', temperature: 0.8, top_k: 40, top_p: 0.95, min_p: 0.05, seed: null }; + } + save({ ...settings, sampling }); + }; + + const updateSampling = (partial: Partial) => { + save({ ...settings, sampling: { ...settings.sampling!, ...partial } as SamplingConfig }); + }; + + if (loading) { + return
Loading settings...
; + } + + return ( +
+
+ {saving && Saving...} + +
+ + {/* Context & Generation */} +
+
Context & Generation
+
+ updateField('context_size', v)} + placeholder="Auto" + min={0} + allowNull + /> + updateField('max_output_tokens', v)} + placeholder="No limit" + min={1} + allowNull + /> +
+
+ + {/* Sampling */} +
+ setSamplingType(v)} + /> + + {samplingType === 'Temperature' && settings.sampling?.type === 'Temperature' && ( +
+ updateSampling({ temperature: v ?? 0.8 })} + min={0} + max={2} + step={0.05} + /> + updateSampling({ top_k: v ?? 40 })} + min={0} + /> + updateSampling({ top_p: v ?? 0.95 })} + min={0} + max={1} + step={0.01} + /> + updateSampling({ min_p: v ?? 0.05 })} + min={0} + max={1} + step={0.01} + /> + updateSampling({ seed: v })} + placeholder="Random" + min={0} + allowNull + /> +
+ )} + + {samplingType === 'MirostatV2' && settings.sampling?.type === 'MirostatV2' && ( +
+ updateSampling({ tau: v ?? 5.0 })} + min={0} + step={0.1} + /> + updateSampling({ eta: v ?? 0.1 })} + min={0} + max={1} + step={0.01} + /> + updateSampling({ seed: v })} + placeholder="Random" + min={0} + allowNull + /> +
+ )} +
+ + {/* Repetition Penalty */} +
+
Repetition Penalty
+
+ updateField('repeat_penalty', v ?? 1.0)} + min={0} + step={0.05} + /> + updateField('repeat_last_n', v ?? 64)} + min={0} + /> + updateField('frequency_penalty', v ?? 0.0)} + min={0} + max={2} + step={0.05} + /> + updateField('presence_penalty', v ?? 0.0)} + min={0} + max={2} + step={0.05} + /> +
+
+ + {/* Performance */} +
+
Performance
+
+ updateField('n_batch', v)} + placeholder="Auto" + min={1} + allowNull + /> + updateField('n_gpu_layers', v)} + placeholder="All" + min={0} + allowNull + /> + updateField('n_threads', v)} + placeholder="Auto" + min={1} + allowNull + /> +
+ updateField('use_mlock', v)} + /> + updateField('flash_attention', v === 'auto' ? null : v === 'on')} + /> +
+ {/* Tool Calling */} +
+
Tool Calling
+ updateField('native_tool_calling', v)} + /> +
+
+ ); +}; diff --git a/ui/desktop/src/components/settings/models/modelInterface.ts b/ui/desktop/src/components/settings/models/modelInterface.ts index f5fb73758a..0be12e2244 100644 --- a/ui/desktop/src/components/settings/models/modelInterface.ts +++ b/ui/desktop/src/components/settings/models/modelInterface.ts @@ -1,4 +1,4 @@ -import { ProviderDetails, getProviderModels } from '../../../api'; +import { ProviderDetails, getProviderModels, listLocalModels } from '../../../api'; import { errorMessage as getErrorMessage } from '../../../utils/conversionUtils'; export default interface Model { @@ -54,6 +54,16 @@ export async function fetchModelsForProviders( ): Promise { const modelPromises = activeProviders.map(async (p) => { try { + // For local provider, use listLocalModels and filter to only downloaded models + if (p.name === 'local') { + const response = await listLocalModels(); + const allModels = response.data || []; + const downloadedModels = allModels + .filter((m) => m.status.state === 'Downloaded') + .map((m) => m.id); + return { provider: p, models: downloadedModels, error: null }; + } + const response = await getProviderModels({ path: { name: p.name }, throwOnError: true, diff --git a/ui/desktop/src/components/settings/models/subcomponents/SwitchModelModal.tsx b/ui/desktop/src/components/settings/models/subcomponents/SwitchModelModal.tsx index 6d294a18b9..4783e77c75 100644 --- a/ui/desktop/src/components/settings/models/subcomponents/SwitchModelModal.tsx +++ b/ui/desktop/src/components/settings/models/subcomponents/SwitchModelModal.tsx @@ -486,7 +486,36 @@ export const SwitchModelModal = ({ {provider && ( <> - {providerErrors[provider] ? ( + {provider === 'local' && + !loadingModels && + filteredModelOptions.flatMap((g) => g.options).filter((o) => o.value !== 'custom') + .length === 0 ? ( + /* Show special UI for local provider when no models are downloaded */ +
+
+
+

+ Local models need to be downloaded first +

+
+ To use local inference, you need to download a model to your computer + first. Go to Settings → Models to manage local models. +
+
+ +
+
+ ) : providerErrors[provider] ? ( /* Show error message when provider failed to connect */
diff --git a/ui/desktop/src/utils/analytics.ts b/ui/desktop/src/utils/analytics.ts index 73ee208f4c..6bf157e499 100644 --- a/ui/desktop/src/utils/analytics.ts +++ b/ui/desktop/src/utils/analytics.ts @@ -70,7 +70,7 @@ export type AnalyticsEvent = | { name: 'onboarding_provider_selected'; properties: { - method: 'api_key' | 'openrouter' | 'tetrate' | 'chatgpt_codex' | 'ollama' | 'other'; + method: 'api_key' | 'openrouter' | 'tetrate' | 'chatgpt_codex' | 'ollama' | 'local' | 'other'; }; } | { @@ -80,7 +80,7 @@ export type AnalyticsEvent = | { name: 'onboarding_abandoned'; properties: { step: string; duration_seconds?: number } } | { name: 'onboarding_setup_failed'; - properties: { provider: 'openrouter' | 'tetrate' | 'chatgpt_codex'; error_message?: string }; + properties: { provider: 'openrouter' | 'tetrate' | 'chatgpt_codex' | 'local'; error_message?: string }; } | { name: 'error_occurred'; @@ -284,7 +284,7 @@ export function trackOnboardingStarted(): void { } export function trackOnboardingProviderSelected( - method: 'api_key' | 'openrouter' | 'tetrate' | 'chatgpt_codex' | 'ollama' | 'other' + method: 'api_key' | 'openrouter' | 'tetrate' | 'chatgpt_codex' | 'ollama' | 'local' | 'other' ): void { trackEvent({ name: 'onboarding_provider_selected', @@ -317,7 +317,7 @@ export function trackOnboardingAbandoned(step: string): void { } export function trackOnboardingSetupFailed( - provider: 'openrouter' | 'tetrate' | 'chatgpt_codex', + provider: 'openrouter' | 'tetrate' | 'chatgpt_codex' | 'local', errorMessage?: string ): void { trackEvent({ From 6e9be0749117ba83bff1d67fa9ee88878316bcce Mon Sep 17 00:00:00 2001 From: dianed-square <73617011+dianed-square@users.noreply.github.com> Date: Thu, 19 Feb 2026 12:11:55 -0800 Subject: [PATCH 02/21] docs: update sandbox topic (#7336) --- .../docs/guides/environment-variables.md | 8 + documentation/docs/guides/sandbox.md | 190 +++++++++++------- documentation/docs/guides/security/index.mdx | 5 + 3 files changed, 128 insertions(+), 75 deletions(-) diff --git a/documentation/docs/guides/environment-variables.md b/documentation/docs/guides/environment-variables.md index 43b4d80155..b522fe80e4 100644 --- a/documentation/docs/guides/environment-variables.md +++ b/documentation/docs/guides/environment-variables.md @@ -460,6 +460,14 @@ When the keyring is disabled (or cannot be accessed and goose [falls back to fil * Windows: `%APPDATA%\Block\goose\config\secrets.yaml` ::: +### macOS Sandbox for goose Desktop + +Optional [macOS sandbox](/docs/guides/sandbox) for goose Desktop that restricts file access, network connections, and process execution using Apple's `sandbox-exec` technology. + +| Variable | Purpose | Values | Default | +|----------|---------|--------|---------| +| `GOOSE_SANDBOX` | Enable the sandbox with [customizable security controls](/docs/guides/sandbox#configuration) | `true` or `1` to enable | `false` | + ## Network Configuration These variables configure network proxy settings for goose. diff --git a/documentation/docs/guides/sandbox.md b/documentation/docs/guides/sandbox.md index 71b1d77fb8..8d185f9fd9 100644 --- a/documentation/docs/guides/sandbox.md +++ b/documentation/docs/guides/sandbox.md @@ -1,83 +1,116 @@ -# macOS Sandbox for goosed +--- +title: macOS Sandbox for goose Desktop +sidebar_label: Sandbox for goose Desktop +description: Optional sandboxing for goose Desktop to control file access, filter network traffic, and enforce security policies on macOS +--- -goose includes an optional macOS sandbox that restricts the goosed process using Apple's seatbelt (`sandbox-exec`) and routes all network traffic through a local egress proxy. This limits what the agent can do on your system — blocking sensitive file writes, raw sockets, tunneling tools, and unapproved network destinations. +goose Desktop includes an optional macOS sandbox that you can enable when you need stricter control and visibility over what goose can access on your system. Use it to: -> **Requirements:** macOS only. The sandbox relies on `/usr/bin/sandbox-exec` which is only available on macOS. +- **Restrict file system access** — Block writes to SSH keys, shell configs, and goose configuration files +- **Control network connections** — Force all traffic through a filtering proxy that blocks unapproved domains +- **Prevent security bypasses** — Block tunneling tools, raw sockets, and other techniques that could circumvent restrictions +- **Audit and enforce policies** — Log all network activity and enforce compliance requirements + +goose runs with full tool access, but the sandbox uses two layers of protection: +- **File access control** - Apple's `sandbox-exec` restricts file and network access at the system level +- **Outbound connections** - A local egress proxy filters and logs outgoing connections + +:::info macOS Requirement +The sandbox relies on `/usr/bin/sandbox-exec`, which is only available on macOS and is also known as Apple's seatbelt technology. +::: ## Quick Start -Set the environment variable before launching the goose desktop app: +To enable the sandbox, launch goose Desktop from the terminal with the environment variable set. For example: ```bash -GOOSE_SANDBOX=true +export GOOSE_SANDBOX=true +open -a Goose ``` -Then start the desktop app as normal. goose will: +When the app starts with sandboxing enabled, it will: 1. Generate a seatbelt sandbox profile 2. Start a local HTTP CONNECT proxy on localhost -3. Launch goosed inside `sandbox-exec`, forcing all traffic through the proxy +3. Launch the `goosed` backend for goose Desktop inside `sandbox-exec`, forcing all traffic through the proxy -If `sandbox-exec` is not available (e.g. you're on Linux), goose will fail fast with a clear error rather than running unsandboxed. - -## What Gets Restricted - -### File System (seatbelt) - -By default, the sandbox blocks writes to: - -| Path | Purpose | -|------|---------| -| `~/.ssh/` | Prevent SSH key tampering | -| `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`, `~/.zprofile` | Prevent shell config injection | -| `~/.config/goose/sandbox/` | Protect sandbox config from the sandboxed process | -| `~/.config/goose/config.yaml` | Protect goose config | - -### Network (seatbelt) - -All direct network access is denied. The only allowed paths are: - -- **Localhost** — so the process can reach the egress proxy and its own server port -- **Unix sockets** — for local IPC -- **mDNSResponder** — for DNS resolution - -Everything else must go through the proxy. - -### Process Restrictions (seatbelt) - -- **Tunneling tools blocked:** `nc`, `ncat`, `netcat`, `socat`, `telnet` — prevents the agent from bypassing the proxy -- **Raw sockets blocked:** `SOCK_RAW` on `AF_INET`/`AF_INET6` — prevents raw packet crafting -- **Kernel extensions blocked:** `system-kext-load` denied - -### Network (proxy) - -The egress proxy checks connections in this order: - -1. **Loopback detection** — prevents using the proxy as a relay back to localhost -2. **Raw IP blocking** — connections to bare IP addresses (no domain) are blocked -3. **Domain blocklist** — domains listed in `blocked.txt` are denied (including all subdomains) -4. **SSH/Git host restrictions** — SSH ports (22, 2222, 7999) are restricted to known git hosts -5. **LaunchDarkly allowlist** (optional) — dynamic egress control via feature flag +The sandbox remains active until you quit goose Desktop. To disable it, quit the app and relaunch normally (or set `GOOSE_SANDBOX=false` when opening from the terminal). ## Configuration -All configuration is via environment variables. Defaults are designed to be secure out of the box. +All configuration is via environment variables. Defaults are designed to be secure out of the box, but you can adjust them to match your security requirements. ### Core | Variable | Default | Description | |----------|---------|-------------| -| `GOOSE_SANDBOX` | `false` | Set to `true` or `1` to enable the sandbox | +| `GOOSE_SANDBOX` | `false` | Set to `true` or `1` to enable the sandbox. See [Quick Start](#quick-start) for launch instructions. | -### Seatbelt Profile +---- + +### File System + +The [seatbelt sandbox profile](https://github.com/block/goose/blob/main/ui/desktop/src/sandbox/index.ts) blocks write operations to these sensitive files: + +- `~/.ssh/` - Prevent SSH key tampering +- `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`, `~/.zprofile` - Prevent shell config injection +- `~/.config/goose/sandbox/` - Protect sandbox config from the sandboxed process +- `~/.config/goose/config.yaml` - Protect goose config + + +#### Environment Variables + +| Variable | Default | Description | +|----------|---------|-------------| +| `GOOSE_SANDBOX_PROTECT_FILES` | `true` | Write-protect sensitive files listed above. Set to `false` to disable | + +---- + +### Direct Network Access + +The seatbelt sandbox denies all direct network access, forcing traffic through the proxy. The only allowed connections are: + +- **Localhost** — Allows the `goosed` process to reach the egress proxy and its own server port +- **Unix sockets** — For local inter-process communication (IPC) +- **mDNSResponder** — For DNS resolution + +:::info Not Configurable +These restrictions are always active when the sandbox is enabled. +::: + +---- + +### Process Restrictions + +The seatbelt sandbox blocks tools and system calls that could bypass security controls: + +- **Tunneling tools** — `nc`, `ncat`, `netcat`, `socat`, `telnet` are blocked to prevent bypassing the proxy +- **Raw sockets** — `SOCK_RAW` on `AF_INET`/`AF_INET6` is blocked to prevent raw packet crafting +- **Kernel extensions** — `system-kext-load` is denied + +#### Environment Variables | Variable | Default | Description | |----------|---------|-------------| -| `GOOSE_SANDBOX_PROTECT_FILES` | `true` | Write-protect `~/.ssh` and shell configs. Set to `false` to disable | | `GOOSE_SANDBOX_BLOCK_RAW_SOCKETS` | `true` | Block `SOCK_RAW`. Set to `false` to disable | | `GOOSE_SANDBOX_BLOCK_TUNNELING` | `true` | Block `nc`/`netcat`/`socat`/`telnet`. Set to `false` to disable | -### Proxy +---- + +### Network Filtering + +The egress proxy inspects and filters all outgoing connections. You can customize filtering rules through the blocklist file and configuration variables. + +The egress proxy checks connections in this order: + +1. **Loopback detection** — Prevents using the proxy as a relay back to localhost +2. **Raw IP blocking** — Connections to bare IP addresses (no domain) are blocked +3. **Domain blocklist** — Domains listed in `blocked.txt` are denied (including all subdomains) +4. **SSH/Git host restrictions** — SSH ports (22, 2222, 7999) are restricted to known git hosts + +For optional LaunchDarkly-based egress control, see [LaunchDarkly](#launchdarkly-optional). + +#### Environment Variables | Variable | Default | Description | |----------|---------|-------------| @@ -87,16 +120,7 @@ All configuration is via environment variables. Defaults are designed to be secu | `GOOSE_SANDBOX_GIT_HOSTS` | built-in list | Comma-separated list of allowed SSH git hosts (e.g. `github.com,gitlab.com`) | | `GOOSE_SANDBOX_SSH_ALL_HOSTS` | `false` | Set to `true` to allow SSH to any host (not just git hosts) | -### LaunchDarkly (optional — not required) - -LaunchDarkly is **not required**. The sandbox works fully without it using the local `blocked.txt` blocklist. These settings only apply if your organization uses LaunchDarkly for dynamic egress control. - -| Variable | Default | Description | -|----------|---------|-------------| -| `LAUNCHDARKLY_CLIENT_ID` | — | LD client SDK key to enable dynamic egress control | -| `GOOSE_SANDBOX_LD_FAILOVER` | — | Failover mode if LD is unreachable: `allow`, `deny`, or `blocklist` | - -## Domain Blocklist +#### Managing the Domain Blocklist The file `~/.config/goose/sandbox/blocked.txt` controls which domains are blocked by the proxy. It's created automatically on first run from a bundled template. @@ -109,13 +133,15 @@ transfer.sh webhook.site ``` -**Live reload:** Changes to `blocked.txt` take effect immediately — the proxy watches the file with `fs.watch` and reloads it automatically. No restart needed. +:::tip Live Reload +Changes to `blocked.txt` take effect immediately — the proxy watches the file with `fs.watch` and reloads it automatically. No restart needed. +::: -## SSH and Git +#### Using Git Over SSH -SSH git operations (`git clone git@github.com:...`) work through the sandbox via a bundled `connect-proxy.pl` script that acts as an SSH `ProxyCommand`. This routes SSH connections through the egress proxy, which then applies the same allowlist rules. +SSH git operations (e.g. `git clone git@github.com:...`) work through the sandbox via a bundled `connect-proxy.pl` script that acts as an SSH `ProxyCommand`. This routes SSH connections through the egress proxy, which then applies the same allowlist rules. -By default, SSH is only allowed to well-known git hosting domains (GitHub, GitLab, Bitbucket, etc.). To customise: +By default, SSH is only allowed to well-known git hosting domains (e.g. GitHub, GitLab, Bitbucket). To customize: ```bash # Add custom git hosts @@ -125,6 +151,19 @@ export GOOSE_SANDBOX_GIT_HOSTS="github.com,gitlab.com,your-gitea.internal.com" export GOOSE_SANDBOX_SSH_ALL_HOSTS=true ``` +---- + +### LaunchDarkly (Optional) + +For enterprise environments, LaunchDarkly provides optional dynamic egress control. If not configured, the sandbox uses the local `blocked.txt` blocklist. + +#### Environment Variables + +| Variable | Default | Description | +|----------|---------|-------------| +| `LAUNCHDARKLY_CLIENT_ID` | — | LD client SDK key to enable dynamic egress control | +| `GOOSE_SANDBOX_LD_FAILOVER` | — | Failover mode if LD is unreachable: `allow`, `deny`, or `blocklist` | + ## Example Configurations ### Maximum security @@ -148,7 +187,7 @@ export GOOSE_SANDBOX=true export GOOSE_SANDBOX_ALLOW_SSH=false ``` -### Relaxed mode (sandbox on, fewer restrictions) +### Relaxed mode (fewer restrictions) ```bash export GOOSE_SANDBOX=true @@ -169,14 +208,15 @@ export GOOSE_SANDBOX_LD_FAILOVER=blocklist # fall back to local blocklist if LD ## Troubleshooting -**"GOOSE_SANDBOX=true but sandbox-exec is not available (macOS only)"** -You're not on macOS, or `/usr/bin/sandbox-exec` is missing. The sandbox only works on macOS. +- **Error: "GOOSE_SANDBOX=true but sandbox-exec is not available (macOS only)"** + You're not on macOS, or `/usr/bin/sandbox-exec` is missing. The sandbox only works on macOS. -**Extensions or tools can't reach the network** -Check if the destination domain is in `~/.config/goose/sandbox/blocked.txt`, or if you need to enable `GOOSE_SANDBOX_ALLOW_IP=true` for IP-based endpoints. +- **Extensions or tools can't reach the network** + Check if the destination domain is in `~/.config/goose/sandbox/blocked.txt`, or if you need to enable `GOOSE_SANDBOX_ALLOW_IP=true` for IP-based endpoints. -**Git clone over SSH fails** -The target host may not be in the default git hosts allowlist. Add it with `GOOSE_SANDBOX_GIT_HOSTS=your-host.com` or set `GOOSE_SANDBOX_SSH_ALL_HOSTS=true`. +- **git clone over SSH fails** + The target host may not be in the default Git hosts allowlist. Add it with `GOOSE_SANDBOX_GIT_HOSTS=your-host.com` or set `GOOSE_SANDBOX_SSH_ALL_HOSTS=true`. + +- **Want to inspect what the proxy is blocking?** + Check the [Desktop application logs](/docs/guides/logs#desktop-application-log). Blocked connections are logged with the prefix `[sandbox-proxy]` and include the reason for blocking. -**Want to inspect what the proxy is blocking?** -Check the Electron/goosed logs — blocked connections are logged with the reason. diff --git a/documentation/docs/guides/security/index.mdx b/documentation/docs/guides/security/index.mdx index 1905516d36..13e83a0da1 100644 --- a/documentation/docs/guides/security/index.mdx +++ b/documentation/docs/guides/security/index.mdx @@ -25,6 +25,11 @@ import styles from '@site/src/components/Card/styles.module.css'; description="API specification for self-hosting ML-based prompt injection detection endpoints." link="/docs/guides/security/classification-api-spec" /> +
From 608d7e1b12ceff1942937980c63a6acb006ea563 Mon Sep 17 00:00:00 2001 From: dianed-square <73617011+dianed-square@users.noreply.github.com> Date: Thu, 19 Feb 2026 12:12:09 -0800 Subject: [PATCH 03/21] docs: pass env vars to shell (#7361) --- .../docs/guides/environment-variables.md | 6 ++++++ documentation/docs/mcp/developer-mcp.md | 19 ++++++++++++++++++- 2 files changed, 24 insertions(+), 1 deletion(-) diff --git a/documentation/docs/guides/environment-variables.md b/documentation/docs/guides/environment-variables.md index b522fe80e4..7ace4f8f33 100644 --- a/documentation/docs/guides/environment-variables.md +++ b/documentation/docs/guides/environment-variables.md @@ -671,6 +671,12 @@ echo "Results from step 1" > ~/Desktop/${AGENT_SESSION_ID}/handoff/output.txt cat ~/Desktop/${AGENT_SESSION_ID}/handoff/output.txt ``` +## Environment Variable Passthrough + +The Developer extension's `shell` tool inherits environment variables from your session. This enables workflows that depend on environment configuration, such as authenticated CLI operations and build processes. + +See [Environment Variables in Shell Commands](/docs/mcp/developer-mcp#environment-variables-in-shell-commands) for details. + ## Enterprise Environments When deploying goose in enterprise environments, administrators might need to control behavior and infrastructure, or enforce consistent settings across teams. The following environment variables are commonly used: diff --git a/documentation/docs/mcp/developer-mcp.md b/documentation/docs/mcp/developer-mcp.md index a200c30e52..c7bed24457 100644 --- a/documentation/docs/mcp/developer-mcp.md +++ b/documentation/docs/mcp/developer-mcp.md @@ -172,6 +172,23 @@ The Developer extension provides these tools: | `screen_capture` | Take screenshots | Debugging UI issues, documenting state | ✅ Low
Visual information only | | `image_processor` | Process and resize images | Optimizing assets, format conversion | ✅ Low
Image manipulation only | +### Environment Variables in Shell Commands + +Shell commands executed by the `shell` tool inherit the environment of the running goose process. This typically includes: +- System variables like `PATH`, `HOME`, and `USER` +- Environment variables present in the process that launched goose (for example, your terminal's environment when you start goose from a shell) +- Session-specific variables injected by goose, such as `AGENT_SESSION_ID` for [session-isolated workflows](/docs/guides/environment-variables#using-session-ids-in-workflows) + +This enables workflows that depend on environment configuration, such as authenticated CLI operations and build processes. + +:::info +goose Desktop or launcher-based starts may use a different environment and may not load your shell startup files. +::: + +:::warning Sensitive Information +Environment variables may contain sensitive values like API keys and tokens (e.g., `GITHUB_TOKEN`, `AWS_ACCESS_KEY_ID`). +::: + ### Access Control Features You can layer multiple controls to match your risk tolerance and workflow: @@ -222,4 +239,4 @@ As you become more comfortable with goose's behavior, you can adjust these setti :::info Also see the [Security Guide](/docs/guides/security/) for information about using goose safely. -::: \ No newline at end of file +::: From 398bf8be8c4a17207b603e3f72f0fe66615ee7f9 Mon Sep 17 00:00:00 2001 From: dianed-square <73617011+dianed-square@users.noreply.github.com> Date: Thu, 19 Feb 2026 12:12:16 -0800 Subject: [PATCH 04/21] docs: agent variable (#7365) --- .../docs/guides/environment-variables.md | 28 +++++++++++++++++-- 1 file changed, 26 insertions(+), 2 deletions(-) diff --git a/documentation/docs/guides/environment-variables.md b/documentation/docs/guides/environment-variables.md index 7ace4f8f33..7c84b397cf 100644 --- a/documentation/docs/guides/environment-variables.md +++ b/documentation/docs/guides/environment-variables.md @@ -619,14 +619,27 @@ These variables are automatically set by goose during command execution. | Variable | Purpose | Values | Default | |----------|---------|---------|---------| | `GOOSE_TERMINAL` | Indicates that a command is being executed by goose, enables [customizing shell behavior](#customizing-shell-behavior) | "1" when set | Unset | +| `AGENT` | Generic agent identifier for cross-tool compatibility, enables tools and scripts to detect when they're being run by goose | "goose" when set | Unset | | `AGENT_SESSION_ID` | The current session ID for [session-isolated workflows](#using-session-ids-in-workflows), automatically available to STDIO extensions and the Developer extension shell commands | Session ID string (e.g., `20260217_5`) | Unset (only set in extension/shell contexts) | ### Customizing Shell Behavior -Sometimes you want goose to use different commands or have different shell behavior than your normal terminal usage. For example, you might want goose to use a different tool, prevent goose from running `git commit`, or block long-running development servers that could hang the AI agent. This is most useful when using goose CLI, where shell commands are executed directly in your terminal environment. +Sometimes you want goose to use different commands or have different shell behavior than your normal terminal usage. Common use cases include: +- Skipping expensive shell initialization (e.g. syntax highlighting, custom prompts) +- Blocking interactive commands that would hang the agent (e.g., `git commit`) +- Redirecting to agent-friendly tools (e.g., `rg` instead of `find`) +- Building cross-agent tools and scripts that detect AI agent execution +- Integrating with MCP servers and LLM gateways + +This is most useful when using goose CLI, where shell commands are executed directly in your terminal environment. **How it works:** -1. When goose runs commands, `GOOSE_TERMINAL` is automatically set to "1" + +goose provides the `GOOSE_TERMINAL` and `AGENT` variables you can use to detect whether goose is the executing agent. + +1. When goose runs commands: + - `GOOSE_TERMINAL` is automatically set to "1" + - `AGENT` is automatically set to "goose" 2. Your shell configuration can detect this and change behavior while keeping your normal terminal usage unchanged **Examples:** @@ -653,6 +666,17 @@ if [[ -n "$GOOSE_TERMINAL" ]]; then fi ``` +```bash +# Detect AI agent execution using standard naming convention +if [[ -n "$AGENT" ]]; then + echo "Running under AI agent: $AGENT" + # Apply agent-specific behavior if needed + if [[ "$AGENT" == "goose" ]]; then + echo "Detected goose - applying goose-specific settings" + fi +fi +``` + ### Using Session IDs in Workflows STDIO extensions (local extensions that communicate via standard input/output) and the Developer extension's shell commands automatically receive the `AGENT_SESSION_ID` environment variable. This enables you to create session-isolated workflows and make it easier to: From d4dfa5d3119ee3efe315a7ca3ae4ca17d82c0fc7 Mon Sep 17 00:00:00 2001 From: Alex Hancock Date: Thu, 19 Feb 2026 15:54:07 -0500 Subject: [PATCH 05/21] feat: TUI client of goose-acp (#7362) --- crates/goose-acp/src/bin/server.rs | 3 + ui/acp/generate-schema.ts | 22 +- ui/acp/src/generated/client.gen.ts | 30 +- ui/acp/src/generated/index.ts | 35 - ui/acp/src/goose-client.ts | 118 +++ ui/acp/src/index.ts | 10 +- ui/text/.gitignore | 1 + ui/text/.npmrc | 1 + ui/text/README.md | 16 + ui/text/package-lock.json | 1244 ++++++++++++++++++++++++++++ ui/text/package.json | 25 + ui/text/src/app.tsx | 764 +++++++++++++++++ ui/text/src/cli.tsx | 25 + ui/text/src/transport.ts | 120 +++ ui/text/tsconfig.json | 16 + 15 files changed, 2343 insertions(+), 87 deletions(-) create mode 100644 ui/acp/src/goose-client.ts create mode 100644 ui/text/.gitignore create mode 100644 ui/text/.npmrc create mode 100644 ui/text/README.md create mode 100644 ui/text/package-lock.json create mode 100644 ui/text/package.json create mode 100644 ui/text/src/app.tsx create mode 100644 ui/text/src/cli.tsx create mode 100644 ui/text/src/transport.ts create mode 100644 ui/text/tsconfig.json diff --git a/crates/goose-acp/src/bin/server.rs b/crates/goose-acp/src/bin/server.rs index c3c6a9aed5..f59f634a2a 100644 --- a/crates/goose-acp/src/bin/server.rs +++ b/crates/goose-acp/src/bin/server.rs @@ -1,5 +1,6 @@ use anyhow::Result; use clap::Parser; +use goose::builtin_extension::register_builtin_extensions; use goose::config::paths::Paths; use goose_acp::server_factory::{AcpServer, AcpServerFactoryConfig}; use std::net::SocketAddr; @@ -29,6 +30,8 @@ async fn main() -> Result<()> { .with(tracing_subscriber::fmt::layer().with_target(true)) .init(); + register_builtin_extensions(goose_mcp::BUILTIN_EXTENSIONS.clone()); + let cli = Cli::parse(); let builtins = if cli.builtins.is_empty() { diff --git a/ui/acp/generate-schema.ts b/ui/acp/generate-schema.ts index ee63176c2d..909542f842 100644 --- a/ui/acp/generate-schema.ts +++ b/ui/acp/generate-schema.ts @@ -28,7 +28,6 @@ main().catch((err) => { async function main() { const schemaSrc = await fs.readFile(SCHEMA_PATH, "utf8"); const jsonSchema = JSON.parse( - // Convert JSON Schema $defs refs to OpenAPI component refs schemaSrc.replaceAll("#/$defs/", "#/components/schemas/"), ); @@ -63,7 +62,6 @@ async function main() { async function postProcessTypes() { const tsPath = resolve(OUTPUT_DIR, "types.gen.ts"); let src = await fs.readFile(tsPath, "utf8"); - // Remove the ClientOptions type block injected by @hey-api (not part of our schema) src = src.replace(/\nexport type ClientOptions =[\s\S]*?^};\n/m, "\n"); await fs.writeFile(tsPath, src); } @@ -72,17 +70,14 @@ async function postProcessIndex(meta: { methods: unknown[] }) { const indexPath = resolve(OUTPUT_DIR, "index.ts"); let src = await fs.readFile(indexPath, "utf8"); - // Strip ClientOptions from re-exports src = src.replace(/,?\s*ClientOptions\s*,?/g, (match) => { if (match.startsWith(",") && match.endsWith(",")) return ","; if (match.startsWith(",")) return ""; return ""; }); - // Fix bare relative imports to use .js extensions (required by nodenext consumers) src = fixRelativeImports(src); - // Append method constants const methodConstants = await prettier.format( ` export const GOOSE_EXT_METHODS = ${JSON.stringify(meta.methods, null, 2)} as const; @@ -94,7 +89,6 @@ export type GooseExtMethod = (typeof GOOSE_EXT_METHODS)[number]; await fs.writeFile(indexPath, `${src}\n${methodConstants}`); - // Also fix imports in zod.gen.ts (it may import from types.gen) for (const file of ["zod.gen.ts", "types.gen.ts"]) { const filePath = resolve(OUTPUT_DIR, file); try { @@ -127,9 +121,6 @@ interface MethodMeta { responseType: string | null; } -/** - * Convert a method path like "session/list" or "working_dir/update" to camelCase "sessionList", "workingDirUpdate". - */ function methodToCamelCase(method: string): string { return method .split(/[/_]/) @@ -139,10 +130,6 @@ function methodToCamelCase(method: string): string { .join(""); } -/** - * Generate a typed GooseClient class that wraps ClientSideConnection.extMethod() - * with proper TypeScript types and Zod runtime validation. - */ async function generateClient(meta: { methods: MethodMeta[] }) { const typeImports = new Set(); const zodImports = new Set(); @@ -153,7 +140,6 @@ async function generateClient(meta: { methods: MethodMeta[] }) { const fnName = methodToCamelCase(m.method); const fullMethod = `_goose/${m.method}`; - // Build param type and arg let paramType = ""; let paramArg = ""; let callParams = "{}"; @@ -164,7 +150,6 @@ async function generateClient(meta: { methods: MethodMeta[] }) { callParams = "params"; } - // Build return type and validation let returnType: string; let bodyLines: string[]; @@ -183,7 +168,6 @@ async function generateClient(meta: { methods: MethodMeta[] }) { `await this.conn.extMethod("${fullMethod}", ${callParams});`, ]; } else { - // Both request and response are untyped (serde_json::Value) returnType = "Record"; bodyLines = [ `return await this.conn.extMethod("${fullMethod}", ${callParams ? callParams : "{}"});`, @@ -212,11 +196,7 @@ export interface ExtMethodProvider { ${typeImportLine} ${zodImportLine} -/** - * Typed client for Goose custom extension methods. - * Wraps an ExtMethodProvider (e.g. ClientSideConnection) with proper types and Zod validation. - */ -export class GooseClient { +export class GooseExtClient { constructor(private conn: ExtMethodProvider) {} ${methodDefs.join("\n")} } diff --git a/ui/acp/src/generated/client.gen.ts b/ui/acp/src/generated/client.gen.ts index db0ae5eb21..8de00f5a1e 100644 --- a/ui/acp/src/generated/client.gen.ts +++ b/ui/acp/src/generated/client.gen.ts @@ -39,7 +39,7 @@ import { * Typed client for Goose custom extension methods. * Wraps an ExtMethodProvider (e.g. ClientSideConnection) with proper types and Zod validation. */ -export class GooseClient { +export class GooseExtClient { constructor(private conn: ExtMethodProvider) {} async extensionsAdd(params: AddExtensionRequest): Promise { @@ -98,32 +98,4 @@ export class GooseClient { const raw = await this.conn.extMethod("_goose/config/extensions", {}); return zGetExtensionsResponse.parse(raw) as GetExtensionsResponse; } - - async toolCall(): Promise> { - return await this.conn.extMethod("_goose/tool/call", {}); - } - - async providerUpdate(): Promise> { - return await this.conn.extMethod("_goose/provider/update", {}); - } - - async containerSet(): Promise> { - return await this.conn.extMethod("_goose/container/set", {}); - } - - async appsList(): Promise> { - return await this.conn.extMethod("_goose/apps/list", {}); - } - - async appsExport(): Promise> { - return await this.conn.extMethod("_goose/apps/export", {}); - } - - async appsImport(): Promise> { - return await this.conn.extMethod("_goose/apps/import", {}); - } - - async configProviders(): Promise> { - return await this.conn.extMethod("_goose/config/providers", {}); - } } diff --git a/ui/acp/src/generated/index.ts b/ui/acp/src/generated/index.ts index b44b568427..2f6a85b441 100644 --- a/ui/acp/src/generated/index.ts +++ b/ui/acp/src/generated/index.ts @@ -58,41 +58,6 @@ export const GOOSE_EXT_METHODS = [ requestType: null, responseType: "GetExtensionsResponse", }, - { - method: "tool/call", - requestType: null, - responseType: null, - }, - { - method: "provider/update", - requestType: null, - responseType: null, - }, - { - method: "container/set", - requestType: null, - responseType: null, - }, - { - method: "apps/list", - requestType: null, - responseType: null, - }, - { - method: "apps/export", - requestType: null, - responseType: null, - }, - { - method: "apps/import", - requestType: null, - responseType: null, - }, - { - method: "config/providers", - requestType: null, - responseType: null, - }, ] as const; export type GooseExtMethod = (typeof GOOSE_EXT_METHODS)[number]; diff --git a/ui/acp/src/goose-client.ts b/ui/acp/src/goose-client.ts new file mode 100644 index 0000000000..f64a190329 --- /dev/null +++ b/ui/acp/src/goose-client.ts @@ -0,0 +1,118 @@ +import { + ClientSideConnection, + type Client, + type Stream, + type InitializeRequest, + type InitializeResponse, + type NewSessionRequest, + type NewSessionResponse, + type LoadSessionRequest, + type LoadSessionResponse, + type PromptRequest, + type PromptResponse, + type CancelNotification, + type AuthenticateRequest, + type AuthenticateResponse, + type SetSessionModeRequest, + type SetSessionModeResponse, + type SetSessionConfigOptionRequest, + type SetSessionConfigOptionResponse, + type ForkSessionRequest, + type ForkSessionResponse, + type ListSessionsRequest, + type ListSessionsResponse, + type ResumeSessionRequest, + type ResumeSessionResponse, + type SetSessionModelRequest, + type SetSessionModelResponse, +} from "@agentclientprotocol/sdk"; +import { GooseExtClient } from "./generated/client.gen.js"; + +export class GooseClient { + private conn: ClientSideConnection; + private ext: GooseExtClient; + + constructor(toClient: () => Client, stream: Stream) { + this.conn = new ClientSideConnection(toClient, stream); + this.ext = new GooseExtClient(this.conn); + } + + get signal(): AbortSignal { + return this.conn.signal; + } + + get closed(): Promise { + return this.conn.closed; + } + + initialize(params: InitializeRequest): Promise { + return this.conn.initialize(params); + } + + newSession(params: NewSessionRequest): Promise { + return this.conn.newSession(params); + } + + loadSession(params: LoadSessionRequest): Promise { + return this.conn.loadSession(params); + } + + prompt(params: PromptRequest): Promise { + return this.conn.prompt(params); + } + + cancel(params: CancelNotification): Promise { + return this.conn.cancel(params); + } + + authenticate(params: AuthenticateRequest): Promise { + return this.conn.authenticate(params); + } + + setSessionMode( + params: SetSessionModeRequest, + ): Promise { + return this.conn.setSessionMode(params); + } + + setSessionConfigOption( + params: SetSessionConfigOptionRequest, + ): Promise { + return this.conn.setSessionConfigOption(params); + } + + unstable_forkSession( + params: ForkSessionRequest, + ): Promise { + return this.conn.unstable_forkSession(params); + } + + unstable_listSessions( + params: ListSessionsRequest, + ): Promise { + return this.conn.unstable_listSessions(params); + } + + unstable_resumeSession( + params: ResumeSessionRequest, + ): Promise { + return this.conn.unstable_resumeSession(params); + } + + unstable_setSessionModel( + params: SetSessionModelRequest, + ): Promise { + return this.conn.unstable_setSessionModel(params); + } + + extMethod( + method: string, + params: Record, + ): Promise> { + return this.conn.extMethod(method, params); + } + + get goose(): GooseExtClient { + return this.ext; + } +} diff --git a/ui/acp/src/index.ts b/ui/acp/src/index.ts index 04ae78458e..eb8a86ec5a 100644 --- a/ui/acp/src/index.ts +++ b/ui/acp/src/index.ts @@ -1,3 +1,9 @@ -export * from "./generated/index.js"; +export * from "./generated/types.gen.js"; export * from "./generated/zod.gen.js"; -export { GooseClient } from "./generated/client.gen.js"; +export { GooseClient } from "./goose-client.js"; + +export { + ClientSideConnection, + type Client, + type Stream, +} from "@agentclientprotocol/sdk"; diff --git a/ui/text/.gitignore b/ui/text/.gitignore new file mode 100644 index 0000000000..1521c8b765 --- /dev/null +++ b/ui/text/.gitignore @@ -0,0 +1 @@ +dist diff --git a/ui/text/.npmrc b/ui/text/.npmrc new file mode 100644 index 0000000000..214c29d139 --- /dev/null +++ b/ui/text/.npmrc @@ -0,0 +1 @@ +registry=https://registry.npmjs.org/ diff --git a/ui/text/README.md b/ui/text/README.md new file mode 100644 index 0000000000..09555d5ac2 --- /dev/null +++ b/ui/text/README.md @@ -0,0 +1,16 @@ +# goose ACP TUI + +Early stage and part of goose's broader move to ACP + +https://github.com/block/goose/issues/6642 +https://github.com/block/goose/discussions/7309 + +## Running + +1. Run the server `cargo run -p goose-acp --bin goose-acp-server` +2. Run the tui + ``` + cd ui/text + npm i + npm run start + ``` diff --git a/ui/text/package-lock.json b/ui/text/package-lock.json new file mode 100644 index 0000000000..bf6499854a --- /dev/null +++ b/ui/text/package-lock.json @@ -0,0 +1,1244 @@ +{ + "name": "goose-text", + "version": "0.1.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "goose-text", + "version": "0.1.0", + "dependencies": { + "@agentclientprotocol/sdk": "^0.14.1", + "@goose/acp": "file:../acp", + "ink": "^5.1.0", + "ink-text-input": "^6.0.0", + "meow": "^13.2.0", + "react": "^18.3.1" + }, + "devDependencies": { + "@types/node": "^25.2.3", + "@types/react": "^18.3.0", + "tsx": "^4.19.0", + "typescript": "^5.7.0" + } + }, + "../acp": { + "name": "goose-acp-types", + "version": "0.1.0", + "dependencies": { + "zod": "^3.25.76" + }, + "devDependencies": { + "@agentclientprotocol/sdk": "^0.14.1", + "@hey-api/openapi-ts": "^0.92.3", + "prettier": "^3.8.1", + "tsx": "^4.21.0", + "typescript": "~5.9.3" + }, + "peerDependencies": { + "@agentclientprotocol/sdk": "*" + } + }, + "node_modules/@agentclientprotocol/sdk": { + "version": "0.14.1", + "resolved": "https://registry.npmjs.org/@agentclientprotocol/sdk/-/sdk-0.14.1.tgz", + "integrity": "sha512-b6r3PS3Nly+Wyw9U+0nOr47bV8tfS476EgyEMhoKvJCZLbgqoDFN7DJwkxL88RR0aiOqOYV1ZnESHqb+RmdH8w==", + "license": "Apache-2.0", + "peerDependencies": { + "zod": "^3.25.0 || ^4.0.0" + } + }, + "node_modules/@alcalzone/ansi-tokenize": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/@alcalzone/ansi-tokenize/-/ansi-tokenize-0.1.3.tgz", + "integrity": "sha512-3yWxPTq3UQ/FY9p1ErPxIyfT64elWaMvM9lIHnaqpyft63tkxodF5aUElYHrdisWve5cETkh1+KBw1yJuW0aRw==", + "license": "MIT", + "dependencies": { + "ansi-styles": "^6.2.1", + "is-fullwidth-code-point": "^4.0.0" + }, + "engines": { + "node": ">=14.13.1" + } + }, + "node_modules/@esbuild/aix-ppc64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.27.3.tgz", + "integrity": "sha512-9fJMTNFTWZMh5qwrBItuziu834eOCUcEqymSH7pY+zoMVEZg3gcPuBNxH1EvfVYe9h0x/Ptw8KBzv7qxb7l8dg==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "aix" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.27.3.tgz", + "integrity": "sha512-i5D1hPY7GIQmXlXhs2w8AWHhenb00+GxjxRncS2ZM7YNVGNfaMxgzSGuO8o8SJzRc/oZwU2bcScvVERk03QhzA==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.27.3.tgz", + "integrity": "sha512-YdghPYUmj/FX2SYKJ0OZxf+iaKgMsKHVPF1MAq/P8WirnSpCStzKJFjOjzsW0QQ7oIAiccHdcqjbHmJxRb/dmg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-x64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.27.3.tgz", + "integrity": "sha512-IN/0BNTkHtk8lkOM8JWAYFg4ORxBkZQf9zXiEOfERX/CzxW3Vg1ewAhU7QSWQpVIzTW+b8Xy+lGzdYXV6UZObQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-arm64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.27.3.tgz", + "integrity": "sha512-Re491k7ByTVRy0t3EKWajdLIr0gz2kKKfzafkth4Q8A5n1xTHrkqZgLLjFEHVD+AXdUGgQMq+Godfq45mGpCKg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-x64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.27.3.tgz", + "integrity": "sha512-vHk/hA7/1AckjGzRqi6wbo+jaShzRowYip6rt6q7VYEDX4LEy1pZfDpdxCBnGtl+A5zq8iXDcyuxwtv3hNtHFg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-arm64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.27.3.tgz", + "integrity": "sha512-ipTYM2fjt3kQAYOvo6vcxJx3nBYAzPjgTCk7QEgZG8AUO3ydUhvelmhrbOheMnGOlaSFUoHXB6un+A7q4ygY9w==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-x64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.27.3.tgz", + "integrity": "sha512-dDk0X87T7mI6U3K9VjWtHOXqwAMJBNN2r7bejDsc+j03SEjtD9HrOl8gVFByeM0aJksoUuUVU9TBaZa2rgj0oA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.27.3.tgz", + "integrity": "sha512-s6nPv2QkSupJwLYyfS+gwdirm0ukyTFNl3KTgZEAiJDd+iHZcbTPPcWCcRYH+WlNbwChgH2QkE9NSlNrMT8Gfw==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.27.3.tgz", + "integrity": "sha512-sZOuFz/xWnZ4KH3YfFrKCf1WyPZHakVzTiqji3WDc0BCl2kBwiJLCXpzLzUBLgmp4veFZdvN5ChW4Eq/8Fc2Fg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ia32": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.27.3.tgz", + "integrity": "sha512-yGlQYjdxtLdh0a3jHjuwOrxQjOZYD/C9PfdbgJJF3TIZWnm/tMd/RcNiLngiu4iwcBAOezdnSLAwQDPqTmtTYg==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-loong64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.27.3.tgz", + "integrity": "sha512-WO60Sn8ly3gtzhyjATDgieJNet/KqsDlX5nRC5Y3oTFcS1l0KWba+SEa9Ja1GfDqSF1z6hif/SkpQJbL63cgOA==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-mips64el": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.27.3.tgz", + "integrity": "sha512-APsymYA6sGcZ4pD6k+UxbDjOFSvPWyZhjaiPyl/f79xKxwTnrn5QUnXR5prvetuaSMsb4jgeHewIDCIWljrSxw==", + "cpu": [ + "mips64el" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ppc64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.27.3.tgz", + "integrity": "sha512-eizBnTeBefojtDb9nSh4vvVQ3V9Qf9Df01PfawPcRzJH4gFSgrObw+LveUyDoKU3kxi5+9RJTCWlj4FjYXVPEA==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-riscv64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.27.3.tgz", + "integrity": "sha512-3Emwh0r5wmfm3ssTWRQSyVhbOHvqegUDRd0WhmXKX2mkHJe1SFCMJhagUleMq+Uci34wLSipf8Lagt4LlpRFWQ==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-s390x": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.27.3.tgz", + "integrity": "sha512-pBHUx9LzXWBc7MFIEEL0yD/ZVtNgLytvx60gES28GcWMqil8ElCYR4kvbV2BDqsHOvVDRrOxGySBM9Fcv744hw==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-x64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.27.3.tgz", + "integrity": "sha512-Czi8yzXUWIQYAtL/2y6vogER8pvcsOsk5cpwL4Gk5nJqH5UZiVByIY8Eorm5R13gq+DQKYg0+JyQoytLQas4dA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-arm64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.27.3.tgz", + "integrity": "sha512-sDpk0RgmTCR/5HguIZa9n9u+HVKf40fbEUt+iTzSnCaGvY9kFP0YKBWZtJaraonFnqef5SlJ8/TiPAxzyS+UoA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-x64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.27.3.tgz", + "integrity": "sha512-P14lFKJl/DdaE00LItAukUdZO5iqNH7+PjoBm+fLQjtxfcfFE20Xf5CrLsmZdq5LFFZzb5JMZ9grUwvtVYzjiA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-arm64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.27.3.tgz", + "integrity": "sha512-AIcMP77AvirGbRl/UZFTq5hjXK+2wC7qFRGoHSDrZ5v5b8DK/GYpXW3CPRL53NkvDqb9D+alBiC/dV0Fb7eJcw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-x64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.27.3.tgz", + "integrity": "sha512-DnW2sRrBzA+YnE70LKqnM3P+z8vehfJWHXECbwBmH/CU51z6FiqTQTHFenPlHmo3a8UgpLyH3PT+87OViOh1AQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openharmony-arm64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.27.3.tgz", + "integrity": "sha512-NinAEgr/etERPTsZJ7aEZQvvg/A6IsZG/LgZy+81wON2huV7SrK3e63dU0XhyZP4RKGyTm7aOgmQk0bGp0fy2g==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/sunos-x64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.27.3.tgz", + "integrity": "sha512-PanZ+nEz+eWoBJ8/f8HKxTTD172SKwdXebZ0ndd953gt1HRBbhMsaNqjTyYLGLPdoWHy4zLU7bDVJztF5f3BHA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "sunos" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-arm64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.27.3.tgz", + "integrity": "sha512-B2t59lWWYrbRDw/tjiWOuzSsFh1Y/E95ofKz7rIVYSQkUYBjfSgf6oeYPNWHToFRr2zx52JKApIcAS/D5TUBnA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-ia32": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.27.3.tgz", + "integrity": "sha512-QLKSFeXNS8+tHW7tZpMtjlNb7HKau0QDpwm49u0vUp9y1WOF+PEzkU84y9GqYaAVW8aH8f3GcBck26jh54cX4Q==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-x64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.27.3.tgz", + "integrity": "sha512-4uJGhsxuptu3OcpVAzli+/gWusVGwZZHTlS63hh++ehExkVT8SgiEf7/uC/PclrPPkLhZqGgCTjd0VWLo6xMqA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@goose/acp": { + "resolved": "../acp", + "link": true + }, + "node_modules/@types/node": { + "version": "25.2.3", + "resolved": "https://registry.npmjs.org/@types/node/-/node-25.2.3.tgz", + "integrity": "sha512-m0jEgYlYz+mDJZ2+F4v8D1AyQb+QzsNqRuI7xg1VQX/KlKS0qT9r1Mo16yo5F/MtifXFgaofIFsdFMox2SxIbQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "undici-types": "~7.16.0" + } + }, + "node_modules/@types/prop-types": { + "version": "15.7.15", + "resolved": "https://registry.npmjs.org/@types/prop-types/-/prop-types-15.7.15.tgz", + "integrity": "sha512-F6bEyamV9jKGAFBEmlQnesRPGOQqS2+Uwi0Em15xenOxHaf2hv6L8YCVn3rPdPJOiJfPiCnLIRyvwVaqMY3MIw==", + "devOptional": true, + "license": "MIT" + }, + "node_modules/@types/react": { + "version": "18.3.28", + "resolved": "https://registry.npmjs.org/@types/react/-/react-18.3.28.tgz", + "integrity": "sha512-z9VXpC7MWrhfWipitjNdgCauoMLRdIILQsAEV+ZesIzBq/oUlxk0m3ApZuMFCXdnS4U7KrI+l3WRUEGQ8K1QKw==", + "devOptional": true, + "license": "MIT", + "peer": true, + "dependencies": { + "@types/prop-types": "*", + "csstype": "^3.2.2" + } + }, + "node_modules/ansi-escapes": { + "version": "7.3.0", + "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-7.3.0.tgz", + "integrity": "sha512-BvU8nYgGQBxcmMuEeUEmNTvrMVjJNSH7RgW24vXexN4Ven6qCvy4TntnvlnwnMLTVlcRQQdbRY8NKnaIoeWDNg==", + "license": "MIT", + "dependencies": { + "environment": "^1.0.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/ansi-regex": { + "version": "6.2.2", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.2.2.tgz", + "integrity": "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==", + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/ansi-regex?sponsor=1" + } + }, + "node_modules/ansi-styles": { + "version": "6.2.3", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.3.tgz", + "integrity": "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==", + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/auto-bind": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/auto-bind/-/auto-bind-5.0.1.tgz", + "integrity": "sha512-ooviqdwwgfIfNmDwo94wlshcdzfO64XV0Cg6oDsDYBJfITDz1EngD2z7DkbvCWn+XIMsIqW27sEVF6qcpJrRcg==", + "license": "MIT", + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/chalk": { + "version": "5.6.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.6.2.tgz", + "integrity": "sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA==", + "license": "MIT", + "engines": { + "node": "^12.17.0 || ^14.13 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/cli-boxes": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/cli-boxes/-/cli-boxes-3.0.0.tgz", + "integrity": "sha512-/lzGpEWL/8PfI0BmBOPRwp0c/wFNX1RdUML3jK/RcSBA9T8mZDdQpqYBKtCFTOfQbwPqWEOpjqW+Fnayc0969g==", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/cli-cursor": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-4.0.0.tgz", + "integrity": "sha512-VGtlMu3x/4DOtIUwEkRezxUZ2lBacNJCHash0N0WeZDBS+7Ux1dm3XWAgWYxLJFMMdOeXMHXorshEFhbMSGelg==", + "license": "MIT", + "dependencies": { + "restore-cursor": "^4.0.0" + }, + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/cli-truncate": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/cli-truncate/-/cli-truncate-4.0.0.tgz", + "integrity": "sha512-nPdaFdQ0h/GEigbPClz11D0v/ZJEwxmeVZGeMo3Z5StPtUTkA9o1lD6QwoirYiSDzbcwn2XcjwmCp68W1IS4TA==", + "license": "MIT", + "dependencies": { + "slice-ansi": "^5.0.0", + "string-width": "^7.0.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/cli-truncate/node_modules/slice-ansi": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-5.0.0.tgz", + "integrity": "sha512-FC+lgizVPfie0kkhqUScwRu1O/lF6NOgJmlCgK+/LYxDCTk8sGelYaHDhFcDN+Sn3Cv+3VSa4Byeo+IMCzpMgQ==", + "license": "MIT", + "dependencies": { + "ansi-styles": "^6.0.0", + "is-fullwidth-code-point": "^4.0.0" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/slice-ansi?sponsor=1" + } + }, + "node_modules/code-excerpt": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/code-excerpt/-/code-excerpt-4.0.0.tgz", + "integrity": "sha512-xxodCmBen3iy2i0WtAK8FlFNrRzjUqjRsMfho58xT/wvZU1YTM3fCnRjcy1gJPMepaRlgm/0e6w8SpWHpn3/cA==", + "license": "MIT", + "dependencies": { + "convert-to-spaces": "^2.0.1" + }, + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + } + }, + "node_modules/convert-to-spaces": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/convert-to-spaces/-/convert-to-spaces-2.0.1.tgz", + "integrity": "sha512-rcQ1bsQO9799wq24uE5AM2tAILy4gXGIK/njFWcVQkGNZ96edlpY+A7bjwvzjYvLDyzmG1MmMLZhpcsb+klNMQ==", + "license": "MIT", + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + } + }, + "node_modules/csstype": { + "version": "3.2.3", + "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz", + "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==", + "devOptional": true, + "license": "MIT" + }, + "node_modules/emoji-regex": { + "version": "10.6.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-10.6.0.tgz", + "integrity": "sha512-toUI84YS5YmxW219erniWD0CIVOo46xGKColeNQRgOzDorgBi1v4D71/OFzgD9GO2UGKIv1C3Sp8DAn0+j5w7A==", + "license": "MIT" + }, + "node_modules/environment": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/environment/-/environment-1.1.0.tgz", + "integrity": "sha512-xUtoPkMggbz0MPyPiIWr1Kp4aeWJjDZ6SMvURhimjdZgsRuDplF5/s9hcgGhyXMhs+6vpnuoiZ2kFiu3FMnS8Q==", + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/es-toolkit": { + "version": "1.44.0", + "resolved": "https://registry.npmjs.org/es-toolkit/-/es-toolkit-1.44.0.tgz", + "integrity": "sha512-6penXeZalaV88MM3cGkFZZfOoLGWshWWfdy0tWw/RlVVyhvMaWSBTOvXNeiW3e5FwdS5ePW0LGEu17zT139ktg==", + "license": "MIT", + "workspaces": [ + "docs", + "benchmarks" + ] + }, + "node_modules/esbuild": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.27.3.tgz", + "integrity": "sha512-8VwMnyGCONIs6cWue2IdpHxHnAjzxnw2Zr7MkVxB2vjmQ2ivqGFb4LEG3SMnv0Gb2F/G/2yA8zUaiL1gywDCCg==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=18" + }, + "optionalDependencies": { + "@esbuild/aix-ppc64": "0.27.3", + "@esbuild/android-arm": "0.27.3", + "@esbuild/android-arm64": "0.27.3", + "@esbuild/android-x64": "0.27.3", + "@esbuild/darwin-arm64": "0.27.3", + "@esbuild/darwin-x64": "0.27.3", + "@esbuild/freebsd-arm64": "0.27.3", + "@esbuild/freebsd-x64": "0.27.3", + "@esbuild/linux-arm": "0.27.3", + "@esbuild/linux-arm64": "0.27.3", + "@esbuild/linux-ia32": "0.27.3", + "@esbuild/linux-loong64": "0.27.3", + "@esbuild/linux-mips64el": "0.27.3", + "@esbuild/linux-ppc64": "0.27.3", + "@esbuild/linux-riscv64": "0.27.3", + "@esbuild/linux-s390x": "0.27.3", + "@esbuild/linux-x64": "0.27.3", + "@esbuild/netbsd-arm64": "0.27.3", + "@esbuild/netbsd-x64": "0.27.3", + "@esbuild/openbsd-arm64": "0.27.3", + "@esbuild/openbsd-x64": "0.27.3", + "@esbuild/openharmony-arm64": "0.27.3", + "@esbuild/sunos-x64": "0.27.3", + "@esbuild/win32-arm64": "0.27.3", + "@esbuild/win32-ia32": "0.27.3", + "@esbuild/win32-x64": "0.27.3" + } + }, + "node_modules/escape-string-regexp": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-2.0.0.tgz", + "integrity": "sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/fsevents": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", + "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/get-east-asian-width": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/get-east-asian-width/-/get-east-asian-width-1.5.0.tgz", + "integrity": "sha512-CQ+bEO+Tva/qlmw24dCejulK5pMzVnUOFOijVogd3KQs07HnRIgp8TGipvCCRT06xeYEbpbgwaCxglFyiuIcmA==", + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/get-tsconfig": { + "version": "4.13.6", + "resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.13.6.tgz", + "integrity": "sha512-shZT/QMiSHc/YBLxxOkMtgSid5HFoauqCE3/exfsEcwg1WkeqjG+V40yBbBrsD+jW2HDXcs28xOfcbm2jI8Ddw==", + "dev": true, + "license": "MIT", + "dependencies": { + "resolve-pkg-maps": "^1.0.0" + }, + "funding": { + "url": "https://github.com/privatenumber/get-tsconfig?sponsor=1" + } + }, + "node_modules/indent-string": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-5.0.0.tgz", + "integrity": "sha512-m6FAo/spmsW2Ab2fU35JTYwtOKa2yAwXSwgjSv1TJzh4Mh7mC3lzAOVLBprb72XsTrgkEIsl7YrFNAiDiRhIGg==", + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/ink": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/ink/-/ink-5.2.1.tgz", + "integrity": "sha512-BqcUyWrG9zq5HIwW6JcfFHsIYebJkWWb4fczNah1goUO0vv5vneIlfwuS85twyJ5hYR/y18FlAYUxrO9ChIWVg==", + "license": "MIT", + "peer": true, + "dependencies": { + "@alcalzone/ansi-tokenize": "^0.1.3", + "ansi-escapes": "^7.0.0", + "ansi-styles": "^6.2.1", + "auto-bind": "^5.0.1", + "chalk": "^5.3.0", + "cli-boxes": "^3.0.0", + "cli-cursor": "^4.0.0", + "cli-truncate": "^4.0.0", + "code-excerpt": "^4.0.0", + "es-toolkit": "^1.22.0", + "indent-string": "^5.0.0", + "is-in-ci": "^1.0.0", + "patch-console": "^2.0.0", + "react-reconciler": "^0.29.0", + "scheduler": "^0.23.0", + "signal-exit": "^3.0.7", + "slice-ansi": "^7.1.0", + "stack-utils": "^2.0.6", + "string-width": "^7.2.0", + "type-fest": "^4.27.0", + "widest-line": "^5.0.0", + "wrap-ansi": "^9.0.0", + "ws": "^8.18.0", + "yoga-layout": "~3.2.1" + }, + "engines": { + "node": ">=18" + }, + "peerDependencies": { + "@types/react": ">=18.0.0", + "react": ">=18.0.0", + "react-devtools-core": "^4.19.1" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "react-devtools-core": { + "optional": true + } + } + }, + "node_modules/ink-text-input": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/ink-text-input/-/ink-text-input-6.0.0.tgz", + "integrity": "sha512-Fw64n7Yha5deb1rHY137zHTAbSTNelUKuB5Kkk2HACXEtwIHBCf9OH2tP/LQ9fRYTl1F0dZgbW0zPnZk6FA9Lw==", + "license": "MIT", + "dependencies": { + "chalk": "^5.3.0", + "type-fest": "^4.18.2" + }, + "engines": { + "node": ">=18" + }, + "peerDependencies": { + "ink": ">=5", + "react": ">=18" + } + }, + "node_modules/is-fullwidth-code-point": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-4.0.0.tgz", + "integrity": "sha512-O4L094N2/dZ7xqVdrXhh9r1KODPJpFms8B5sGdJLPy664AgvXsreZUyCQQNItZRDlYug4xStLjNp/sz3HvBowQ==", + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/is-in-ci": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-in-ci/-/is-in-ci-1.0.0.tgz", + "integrity": "sha512-eUuAjybVTHMYWm/U+vBO1sY/JOCgoPCXRxzdju0K+K0BiGW0SChEL1MLC0PoCIR1OlPo5YAp8HuQoUlsWEICwg==", + "license": "MIT", + "bin": { + "is-in-ci": "cli.js" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/js-tokens": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz", + "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==", + "license": "MIT" + }, + "node_modules/loose-envify": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz", + "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==", + "license": "MIT", + "dependencies": { + "js-tokens": "^3.0.0 || ^4.0.0" + }, + "bin": { + "loose-envify": "cli.js" + } + }, + "node_modules/meow": { + "version": "13.2.0", + "resolved": "https://registry.npmjs.org/meow/-/meow-13.2.0.tgz", + "integrity": "sha512-pxQJQzB6djGPXh08dacEloMFopsOqGVRKFPYvPOt9XDZ1HasbgDZA74CJGreSU4G3Ak7EFJGoiH2auq+yXISgA==", + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/mimic-fn": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz", + "integrity": "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/onetime": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/onetime/-/onetime-5.1.2.tgz", + "integrity": "sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==", + "license": "MIT", + "dependencies": { + "mimic-fn": "^2.1.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/patch-console": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/patch-console/-/patch-console-2.0.0.tgz", + "integrity": "sha512-0YNdUceMdaQwoKce1gatDScmMo5pu/tfABfnzEqeG0gtTmd7mh/WcwgUjtAeOU7N8nFFlbQBnFK2gXW5fGvmMA==", + "license": "MIT", + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + } + }, + "node_modules/react": { + "version": "18.3.1", + "resolved": "https://registry.npmjs.org/react/-/react-18.3.1.tgz", + "integrity": "sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==", + "license": "MIT", + "peer": true, + "dependencies": { + "loose-envify": "^1.1.0" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/react-reconciler": { + "version": "0.29.2", + "resolved": "https://registry.npmjs.org/react-reconciler/-/react-reconciler-0.29.2.tgz", + "integrity": "sha512-zZQqIiYgDCTP/f1N/mAR10nJGrPD2ZR+jDSEsKWJHYC7Cm2wodlwbR3upZRdC3cjIjSlTLNVyO7Iu0Yy7t2AYg==", + "license": "MIT", + "dependencies": { + "loose-envify": "^1.1.0", + "scheduler": "^0.23.2" + }, + "engines": { + "node": ">=0.10.0" + }, + "peerDependencies": { + "react": "^18.3.1" + } + }, + "node_modules/resolve-pkg-maps": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/resolve-pkg-maps/-/resolve-pkg-maps-1.0.0.tgz", + "integrity": "sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/privatenumber/resolve-pkg-maps?sponsor=1" + } + }, + "node_modules/restore-cursor": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-4.0.0.tgz", + "integrity": "sha512-I9fPXU9geO9bHOt9pHHOhOkYerIMsmVaWB0rA2AI9ERh/+x/i7MV5HKBNrg+ljO5eoPVgCcnFuRjJ9uH6I/3eg==", + "license": "MIT", + "dependencies": { + "onetime": "^5.1.0", + "signal-exit": "^3.0.2" + }, + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/scheduler": { + "version": "0.23.2", + "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.23.2.tgz", + "integrity": "sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==", + "license": "MIT", + "dependencies": { + "loose-envify": "^1.1.0" + } + }, + "node_modules/signal-exit": { + "version": "3.0.7", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz", + "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==", + "license": "ISC" + }, + "node_modules/slice-ansi": { + "version": "7.1.2", + "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-7.1.2.tgz", + "integrity": "sha512-iOBWFgUX7caIZiuutICxVgX1SdxwAVFFKwt1EvMYYec/NWO5meOJ6K5uQxhrYBdQJne4KxiqZc+KptFOWFSI9w==", + "license": "MIT", + "dependencies": { + "ansi-styles": "^6.2.1", + "is-fullwidth-code-point": "^5.0.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/chalk/slice-ansi?sponsor=1" + } + }, + "node_modules/slice-ansi/node_modules/is-fullwidth-code-point": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-5.1.0.tgz", + "integrity": "sha512-5XHYaSyiqADb4RnZ1Bdad6cPp8Toise4TzEjcOYDHZkTCbKgiUl7WTUCpNWHuxmDt91wnsZBc9xinNzopv3JMQ==", + "license": "MIT", + "dependencies": { + "get-east-asian-width": "^1.3.1" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/stack-utils": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/stack-utils/-/stack-utils-2.0.6.tgz", + "integrity": "sha512-XlkWvfIm6RmsWtNJx+uqtKLS8eqFbxUg0ZzLXqY0caEy9l7hruX8IpiDnjsLavoBgqCCR71TqWO8MaXYheJ3RQ==", + "license": "MIT", + "dependencies": { + "escape-string-regexp": "^2.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/string-width": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-7.2.0.tgz", + "integrity": "sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ==", + "license": "MIT", + "dependencies": { + "emoji-regex": "^10.3.0", + "get-east-asian-width": "^1.0.0", + "strip-ansi": "^7.1.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/strip-ansi": { + "version": "7.1.2", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.2.tgz", + "integrity": "sha512-gmBGslpoQJtgnMAvOVqGZpEz9dyoKTCzy2nfz/n8aIFhN/jCE/rCmcxabB6jOOHV+0WNnylOxaxBQPSvcWklhA==", + "license": "MIT", + "dependencies": { + "ansi-regex": "^6.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/strip-ansi?sponsor=1" + } + }, + "node_modules/tsx": { + "version": "4.21.0", + "resolved": "https://registry.npmjs.org/tsx/-/tsx-4.21.0.tgz", + "integrity": "sha512-5C1sg4USs1lfG0GFb2RLXsdpXqBSEhAaA/0kPL01wxzpMqLILNxIxIOKiILz+cdg/pLnOUxFYOR5yhHU666wbw==", + "dev": true, + "license": "MIT", + "dependencies": { + "esbuild": "~0.27.0", + "get-tsconfig": "^4.7.5" + }, + "bin": { + "tsx": "dist/cli.mjs" + }, + "engines": { + "node": ">=18.0.0" + }, + "optionalDependencies": { + "fsevents": "~2.3.3" + } + }, + "node_modules/type-fest": { + "version": "4.41.0", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-4.41.0.tgz", + "integrity": "sha512-TeTSQ6H5YHvpqVwBRcnLDCBnDOHWYu7IvGbHT6N8AOymcr9PJGjc1GTtiWZTYg0NCgYwvnYWEkVChQAr9bjfwA==", + "license": "(MIT OR CC0-1.0)", + "engines": { + "node": ">=16" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/typescript": { + "version": "5.9.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz", + "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=14.17" + } + }, + "node_modules/undici-types": { + "version": "7.16.0", + "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.16.0.tgz", + "integrity": "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw==", + "dev": true, + "license": "MIT" + }, + "node_modules/widest-line": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/widest-line/-/widest-line-5.0.0.tgz", + "integrity": "sha512-c9bZp7b5YtRj2wOe6dlj32MK+Bx/M/d+9VB2SHM1OtsUHR0aV0tdP6DWh/iMt0kWi1t5g1Iudu6hQRNd1A4PVA==", + "license": "MIT", + "dependencies": { + "string-width": "^7.0.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/wrap-ansi": { + "version": "9.0.2", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-9.0.2.tgz", + "integrity": "sha512-42AtmgqjV+X1VpdOfyTGOYRi0/zsoLqtXQckTmqTeybT+BDIbM/Guxo7x3pE2vtpr1ok6xRqM9OpBe+Jyoqyww==", + "license": "MIT", + "dependencies": { + "ansi-styles": "^6.2.1", + "string-width": "^7.0.0", + "strip-ansi": "^7.1.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/chalk/wrap-ansi?sponsor=1" + } + }, + "node_modules/ws": { + "version": "8.19.0", + "resolved": "https://registry.npmjs.org/ws/-/ws-8.19.0.tgz", + "integrity": "sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg==", + "license": "MIT", + "engines": { + "node": ">=10.0.0" + }, + "peerDependencies": { + "bufferutil": "^4.0.1", + "utf-8-validate": ">=5.0.2" + }, + "peerDependenciesMeta": { + "bufferutil": { + "optional": true + }, + "utf-8-validate": { + "optional": true + } + } + }, + "node_modules/yoga-layout": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/yoga-layout/-/yoga-layout-3.2.1.tgz", + "integrity": "sha512-0LPOt3AxKqMdFBZA3HBAt/t/8vIKq7VaQYbuA8WxCgung+p9TVyKRYdpvCb80HcdTN2NkbIKbhNwKUfm3tQywQ==", + "license": "MIT" + }, + "node_modules/zod": { + "version": "4.3.6", + "resolved": "https://registry.npmjs.org/zod/-/zod-4.3.6.tgz", + "integrity": "sha512-rftlrkhHZOcjDwkGlnUtZZkvaPHCsDATp4pGpuOOMDaTdDDXF91wuVDJoWoPsKX/3YPQ5fHuF3STjcYyKr+Qhg==", + "license": "MIT", + "peer": true, + "funding": { + "url": "https://github.com/sponsors/colinhacks" + } + } + } +} diff --git a/ui/text/package.json b/ui/text/package.json new file mode 100644 index 0000000000..ded27fb2af --- /dev/null +++ b/ui/text/package.json @@ -0,0 +1,25 @@ +{ + "name": "goose-text", + "version": "0.1.0", + "private": true, + "type": "module", + "scripts": { + "build": "tsc", + "start": "tsx src/cli.tsx", + "lint": "tsc --noEmit" + }, + "dependencies": { + "@agentclientprotocol/sdk": "^0.14.1", + "@goose/acp": "file:../acp", + "ink": "^5.1.0", + "ink-text-input": "^6.0.0", + "meow": "^13.2.0", + "react": "^18.3.1" + }, + "devDependencies": { + "@types/node": "^25.2.3", + "@types/react": "^18.3.0", + "tsx": "^4.19.0", + "typescript": "^5.7.0" + } +} diff --git a/ui/text/src/app.tsx b/ui/text/src/app.tsx new file mode 100644 index 0000000000..135ccae9c5 --- /dev/null +++ b/ui/text/src/app.tsx @@ -0,0 +1,764 @@ +import React, { useState, useEffect, useCallback, useRef } from "react"; +import { Box, Text, useApp, useInput, useStdout } from "ink"; +import TextInput from "ink-text-input"; +import type { + SessionNotification, + RequestPermissionRequest, + RequestPermissionResponse, +} from "@agentclientprotocol/sdk"; +import { GooseClient } from "@goose/acp"; +import { createHttpStream } from "./transport.js"; + +interface PendingPermission { + toolTitle: string; + options: Array<{ optionId: string; name: string; kind: string }>; + resolve: (response: RequestPermissionResponse) => void; +} + +const CRANBERRY_BRIGHT = "#C0354A"; +const HARBOR_NAVY = "#1B2A4A"; +const DEEP_SLATE = "#3A4F6F"; +const SLATE = "#6B7F99"; +const LIGHT_SLATE = "#8FA4BD"; +const AUTUMN_GOLD = "#C4883A"; +const OCEAN_TEAL = "#3A7D7B"; +const CEDAR_BROWN = "#6B5344"; +const FOG_WHITE = "#E8E4DF"; +const PARCHMENT = "#D4CFC8"; + +const GOOSE_FRAMES = [ + [ + " ,_", + " (o >", + " //\\", + " \\\\ \\", + " \\\\_/", + " | |", + " ^ ^", + ], + [ + " ,_", + " (o >", + " //\\", + " \\\\ \\", + " \\\\_/", + " / |", + " ^ ^", + ], + [ + " ,_", + " (o >", + " //\\", + " \\\\ \\", + " \\\\_/", + " | |", + " ^ ^", + ], + [ + " ,_", + " (o >", + " //\\", + " \\\\ \\", + " \\\\_/", + " | \\", + " ^ ^", + ], +]; + +const TITLE_TEXT = "goose"; + +const GREETING_MESSAGES = [ + "What would you like to work on?", + "Ready to build something amazing?", + "What would you like to explore?", + "What's on your mind?", + "What shall we create today?", + "What project needs attention?", + "What would you like to tackle?", + "What needs to be done?", + "What's the plan for today?", + "Ready to create something great?", + "What can be built today?", + "What's the next challenge?", + "What progress can be made?", + "What would you like to accomplish?", + "What task awaits?", + "What's the mission today?", + "What can be achieved?", + "What project is ready to begin?", +]; + +const INITIAL_GREETING = + GREETING_MESSAGES[Math.floor(Math.random() * GREETING_MESSAGES.length)]!; + +const SPINNER_FRAMES = ["◐", "◓", "◑", "◒"]; + +const PERMISSION_LABELS: Record = { + allow_once: "Allow once", + allow_always: "Always allow", + reject_once: "Reject once", + reject_always: "Always reject", +}; + +const PERMISSION_KEYS: Record = { + allow_once: "y", + allow_always: "a", + reject_once: "n", + reject_always: "N", +}; + +interface TextMessage { + kind: "text"; + role: "user" | "agent"; + text: string; +} + +interface ToolCallMessage { + kind: "tool_call"; + title: string; +} + +type Message = TextMessage | ToolCallMessage; + +function HRule({ width, color }: { width: number; color?: string }) { + return ( + + + {"─".repeat(Math.max(width, 1))} + + + ); +} + +function HeaderBar({ + width, + status, + loading, + spinIdx, + hasPendingPermission, +}: { + width: number; + status: string; + loading: boolean; + spinIdx: number; + hasPendingPermission: boolean; +}) { + const statusColor = + status === "ready" + ? OCEAN_TEAL + : status.startsWith("error") || status.startsWith("failed") + ? CRANBERRY_BRIGHT + : SLATE; + + const leftContent = ` ${TITLE_TEXT} `; + const spinner = + loading && !hasPendingPermission + ? ` ${SPINNER_FRAMES[spinIdx % SPINNER_FRAMES.length]} ` + : ""; + + return ( + + + + + {leftContent} + + │ + {status} + {spinner && {spinner}} + + + + ctrl+c to exit{" "} + + + + + + ); +} + +function ToolCallBlock({ title, width }: { title: string; width: number }) { + return ( + + ⚙ + + {title} + + + ); +} + +function UserMessage({ text, width }: { text: string; width: number }) { + return ( + + + + {"❯ "} + + + {text} + + + + ); +} + +function AgentMessage({ text, width }: { text: string; width: number }) { + return ( + + {text} + + ); +} + +function PermissionPrompt({ + toolTitle, + options, + selectedIdx, + width, +}: { + toolTitle: string; + options: Array<{ optionId: string; name: string; kind: string }>; + selectedIdx: number; + width: number; +}) { + return ( + + + 🔒 Permission required + + {toolTitle} + + {options.map((opt, i) => { + const key = PERMISSION_KEYS[opt.kind] ?? String(i + 1); + const label = PERMISSION_LABELS[opt.kind] ?? opt.name; + const selected = i === selectedIdx; + return ( + + + {selected ? " ▸ " : " "} + + + [{key}] {label} + + + ); + })} + + + + ↑↓ select · enter confirm · esc cancel + + + + ); +} + +function SplashScreen({ + animFrame, + width, + height, + status, + loading, + spinIdx, + showInput, + input, + onInputChange, + onInputSubmit, +}: { + animFrame: number; + width: number; + height: number; + status: string; + loading: boolean; + spinIdx: number; + showInput: boolean; + input: string; + onInputChange: (v: string) => void; + onInputSubmit: (v: string) => void; +}) { + const frame = GOOSE_FRAMES[animFrame % GOOSE_FRAMES.length]!; + const statusColor = + status === "ready" + ? OCEAN_TEAL + : status.startsWith("error") || status.startsWith("failed") + ? CRANBERRY_BRIGHT + : SLATE; + + const inputWidth = Math.min(60, width - 8); + + return ( + + + {frame.map((line, i) => ( + + {line} + + ))} + + + + {TITLE_TEXT} + + + + your on-machine AI agent + + + {showInput ? ( + <> + + + + + + {"❯ "} + + + + + + + + ) : ( + <> + + + + + {loading && ( + + {SPINNER_FRAMES[spinIdx % SPINNER_FRAMES.length]}{" "} + + )} + {status} + + + )} + + ); +} + +function InputBar({ + width, + input, + onChange, + onSubmit, +}: { + width: number; + input: string; + onChange: (v: string) => void; + onSubmit: (v: string) => void; +}) { + return ( + + + + + {"❯ "} + + + + + ); +} + +function LoadingIndicator({ + status, + spinIdx, +}: { + status: string; + spinIdx: number; +}) { + return ( + + + {SPINNER_FRAMES[spinIdx % SPINNER_FRAMES.length]}{" "} + + + {status} + + + ); +} + +export default function App({ + serverUrl, + initialPrompt, +}: { + serverUrl: string; + initialPrompt?: string; +}) { + const { exit } = useApp(); + const { stdout } = useStdout(); + const termWidth = stdout?.columns ?? 80; + const termHeight = stdout?.rows ?? 24; + + const [messages, setMessages] = useState([]); + const [input, setInput] = useState(""); + const [loading, setLoading] = useState(true); + const [status, setStatus] = useState("connecting..."); + const [spinIdx, setSpinIdx] = useState(0); + const [gooseFrame, setGooseFrame] = useState(0); + const [bannerVisible, setBannerVisible] = useState(true); + const [pendingPermission, setPendingPermission] = + useState(null); + const [permissionIdx, setPermissionIdx] = useState(0); + const clientRef = useRef(null); + const sessionIdRef = useRef(null); + const streamBuf = useRef(""); + const sentInitialPrompt = useRef(false); + + useEffect(() => { + const t = setInterval(() => { + setSpinIdx((i) => (i + 1) % SPINNER_FRAMES.length); + setGooseFrame((f) => f + 1); + }, 300); + return () => clearInterval(t); + }, []); + + useEffect(() => { + if (messages.length > 0) { + setBannerVisible(false); + } + }, [messages]); + + const appendAgent = useCallback((text: string) => { + setMessages((prev) => { + const last = prev[prev.length - 1]; + if (last && last.kind === "text" && last.role === "agent") { + return [ + ...prev.slice(0, -1), + { + kind: "text" as const, + role: "agent" as const, + text: last.text + text, + }, + ]; + } + return [...prev, { kind: "text" as const, role: "agent" as const, text }]; + }); + }, []); + + const appendToolCall = useCallback((title: string) => { + setMessages((prev) => [...prev, { kind: "tool_call" as const, title }]); + }, []); + + const resolvePermission = useCallback( + (option: { optionId: string } | "cancelled") => { + if (!pendingPermission) return; + const { resolve } = pendingPermission; + if (option === "cancelled") { + resolve({ outcome: { outcome: "cancelled" } }); + } else { + resolve({ + outcome: { outcome: "selected", optionId: option.optionId }, + }); + } + setPendingPermission(null); + setPermissionIdx(0); + }, + [pendingPermission], + ); + + const sendPrompt = useCallback( + async (text: string) => { + const client = clientRef.current; + const sid = sessionIdRef.current; + if (!client || !sid) return; + + setMessages((prev) => [ + ...prev, + { kind: "text" as const, role: "user" as const, text }, + ]); + setLoading(true); + setStatus("thinking..."); + streamBuf.current = ""; + + try { + const result = await client.prompt({ + sessionId: sid, + prompt: [{ type: "text", text }], + }); + + if (streamBuf.current) { + appendAgent(""); + } + + setStatus( + result.stopReason === "end_turn" + ? "ready" + : `stopped: ${result.stopReason}`, + ); + } catch (e: unknown) { + const errMsg = e instanceof Error ? e.message : String(e); + setStatus(`error: ${errMsg}`); + } finally { + setLoading(false); + } + }, + [appendAgent], + ); + + useEffect(() => { + let cancelled = false; + + (async () => { + try { + setStatus("initializing..."); + const stream = createHttpStream(serverUrl); + + const client = new GooseClient( + () => ({ + sessionUpdate: async (params: SessionNotification) => { + const update = params.update; + + if (update.sessionUpdate === "agent_message_chunk") { + if (update.content.type === "text") { + streamBuf.current += update.content.text; + appendAgent(update.content.text); + } + } else if (update.sessionUpdate === "tool_call") { + appendToolCall(update.title || "tool"); + } + }, + requestPermission: async ( + params: RequestPermissionRequest, + ): Promise => { + return new Promise((resolve) => { + const toolTitle = params.toolCall.title ?? "unknown tool"; + const options = params.options.map((opt) => ({ + optionId: opt.optionId, + name: opt.name, + kind: opt.kind, + })); + setPendingPermission({ toolTitle, options, resolve }); + setPermissionIdx(0); + }); + }, + }), + stream, + ); + + if (cancelled) return; + clientRef.current = client; + + setStatus("handshaking..."); + await client.initialize({ + protocolVersion: 0, + clientInfo: { name: "goose-text", version: "0.1.0" }, + clientCapabilities: {}, + }); + + if (cancelled) return; + + setStatus("creating session..."); + const session = await client.newSession({ + cwd: process.cwd(), + mcpServers: [], + }); + + if (cancelled) return; + sessionIdRef.current = session.sessionId; + setLoading(false); + setStatus("ready"); + + if (initialPrompt && !sentInitialPrompt.current) { + sentInitialPrompt.current = true; + await sendPrompt(initialPrompt); + if (initialPrompt) { + setTimeout(() => exit(), 100); + } + } + } catch (e: unknown) { + if (cancelled) return; + const errMsg = e instanceof Error ? e.message : String(e); + setStatus(`failed: ${errMsg}`); + setLoading(false); + } + })(); + + return () => { + cancelled = true; + }; + }, [serverUrl, initialPrompt, sendPrompt, appendAgent, appendToolCall, exit]); + + const handleSubmit = useCallback( + (value: string) => { + const trimmed = value.trim(); + if (!trimmed || loading) return; + setInput(""); + sendPrompt(trimmed); + }, + [loading, sendPrompt], + ); + + useInput((ch, key) => { + if (key.escape || (ch === "c" && key.ctrl)) { + if (pendingPermission) { + resolvePermission("cancelled"); + return; + } + exit(); + } + + if (pendingPermission) { + const opts = pendingPermission.options; + + if (key.upArrow) { + setPermissionIdx((i) => (i - 1 + opts.length) % opts.length); + return; + } + if (key.downArrow) { + setPermissionIdx((i) => (i + 1) % opts.length); + return; + } + if (key.return) { + const selected = opts[permissionIdx]; + if (selected) { + resolvePermission({ optionId: selected.optionId }); + } + return; + } + + const keyMap: Record = { + y: "allow_once", + a: "allow_always", + n: "reject_once", + N: "reject_always", + }; + const targetKind = keyMap[ch]; + if (targetKind) { + const match = opts.find((o) => o.kind === targetKind); + if (match) { + resolvePermission({ optionId: match.optionId }); + return; + } + } + } + }); + + const PAD_X = 2; + const PAD_BOTTOM = 1; + const innerWidth = Math.max(termWidth - PAD_X * 2, 20); + const headerHeight = 2; + const inputBarHeight = initialPrompt ? 0 : 2; + const bodyHeight = Math.max(termHeight - headerHeight - inputBarHeight - PAD_BOTTOM, 3); + + if (bannerVisible) { + return ( + + + + ); + } + + return ( + + + + + {messages.map((msg, i) => { + if (msg.kind === "tool_call") { + return ; + } + if (msg.role === "user") { + return ( + + {i > 0 && } + + + + ); + } + return ; + })} + + {pendingPermission && ( + + )} + + {loading && !pendingPermission && messages.length > 0 && ( + + )} + + + {!loading && !pendingPermission && !initialPrompt && ( + + )} + + ); +} diff --git a/ui/text/src/cli.tsx b/ui/text/src/cli.tsx new file mode 100644 index 0000000000..568890a1b9 --- /dev/null +++ b/ui/text/src/cli.tsx @@ -0,0 +1,25 @@ +#!/usr/bin/env node +import React from "react"; +import { render } from "ink"; +import meow from "meow"; +import App from "./app.js"; + +const cli = meow( + ` + Usage + $ goose-text + + Options + --server, -s Server URL (default: http://127.0.0.1:3284) + --text, -t Send a single prompt and exit +`, + { + importMeta: import.meta, + flags: { + server: { type: "string", shortFlag: "s", default: "http://127.0.0.1:3284" }, + text: { type: "string", shortFlag: "t" }, + }, + } +); + +render(); diff --git a/ui/text/src/transport.ts b/ui/text/src/transport.ts new file mode 100644 index 0000000000..193b5a1375 --- /dev/null +++ b/ui/text/src/transport.ts @@ -0,0 +1,120 @@ +import type { AnyMessage, Stream } from "@agentclientprotocol/sdk"; + +const ACP_SESSION_HEADER = "Acp-Session-Id"; + +export function createHttpStream(serverUrl: string): Stream { + let sessionId: string | null = null; + const incoming: AnyMessage[] = []; + const waiters: Array<() => void> = []; + const sseAbort = new AbortController(); + + function pushMessage(msg: AnyMessage) { + incoming.push(msg); + const w = waiters.shift(); + if (w) w(); + } + + function waitForMessage(): Promise { + if (incoming.length > 0) return Promise.resolve(); + return new Promise((r) => waiters.push(r)); + } + + async function consumeSSE(response: Response) { + if (!response.body) return; + const reader = response.body.getReader(); + const decoder = new TextDecoder(); + let buffer = ""; + + try { + while (true) { + const { done, value } = await reader.read(); + if (done) break; + buffer += decoder.decode(value, { stream: true }); + + const parts = buffer.split("\n\n"); + buffer = parts.pop() || ""; + + for (const part of parts) { + for (const line of part.split("\n")) { + if (line.startsWith("data: ")) { + try { + const msg = JSON.parse(line.slice(6)) as AnyMessage; + pushMessage(msg); + } catch { + } + } + } + } + } + } catch (e: unknown) { + if (e instanceof DOMException && e.name === "AbortError") return; + } + } + + // POST initialize (no session header) opens a long-lived SSE stream that receives + // ALL subsequent responses and notifications. Later POSTs with the session header + // are fire-and-forget for requests (responses arrive on the first stream) or + // return 202 immediately for notifications/responses. + let isFirstRequest = true; + + const readable = new ReadableStream({ + async pull(controller) { + await waitForMessage(); + while (incoming.length > 0) { + controller.enqueue(incoming.shift()!); + } + }, + }); + + const writable = new WritableStream({ + async write(msg) { + const isRequest = + "method" in msg && "id" in msg && msg.id !== undefined && msg.id !== null; + + const headers: Record = { + "Content-Type": "application/json", + Accept: "application/json, text/event-stream", + }; + if (sessionId) { + headers[ACP_SESSION_HEADER] = sessionId; + } + + if (isFirstRequest && isRequest) { + isFirstRequest = false; + + const response = await fetch(`${serverUrl}/acp`, { + method: "POST", + headers, + body: JSON.stringify(msg), + signal: sseAbort.signal, + }); + + const sid = response.headers.get(ACP_SESSION_HEADER); + if (sid) sessionId = sid; + + consumeSSE(response); + } else if (isRequest) { + const abort = new AbortController(); + fetch(`${serverUrl}/acp`, { + method: "POST", + headers, + body: JSON.stringify(msg), + signal: abort.signal, + }).catch(() => {}); + setTimeout(() => abort.abort(), 200); + } else { + await fetch(`${serverUrl}/acp`, { + method: "POST", + headers, + body: JSON.stringify(msg), + }); + } + }, + + close() { + sseAbort.abort(); + }, + }); + + return { readable, writable }; +} diff --git a/ui/text/tsconfig.json b/ui/text/tsconfig.json new file mode 100644 index 0000000000..c3ee214ac3 --- /dev/null +++ b/ui/text/tsconfig.json @@ -0,0 +1,16 @@ +{ + "compilerOptions": { + "target": "ES2022", + "module": "NodeNext", + "moduleResolution": "NodeNext", + "jsx": "react-jsx", + "strict": true, + "esModuleInterop": true, + "skipLibCheck": true, + "outDir": "dist", + "rootDir": "src", + "declaration": true, + "resolveJsonModule": true + }, + "include": ["src"] +} From f6f0c6e023d3b50c7ee05a7db260472302eebe67 Mon Sep 17 00:00:00 2001 From: Andrew Harvard Date: Thu, 19 Feb 2026 15:57:53 -0500 Subject: [PATCH 06/21] fix(apps): restore MCP app sampling support reverted by #6933 (#7366) --- .../src/components/McpApps/McpAppRenderer.tsx | 49 ++++++++++++++++++- 1 file changed, 47 insertions(+), 2 deletions(-) diff --git a/ui/desktop/src/components/McpApps/McpAppRenderer.tsx b/ui/desktop/src/components/McpApps/McpAppRenderer.tsx index 4733727359..cd1646fcbb 100644 --- a/ui/desktop/src/components/McpApps/McpAppRenderer.tsx +++ b/ui/desktop/src/components/McpApps/McpAppRenderer.tsx @@ -15,7 +15,7 @@ * - "standalone" — Goose-specific mode for dedicated Electron windows */ -import { AppRenderer } from '@mcp-ui/client'; +import { AppRenderer, type RequestHandlerExtra } from '@mcp-ui/client'; import type { McpUiDisplayMode, McpUiHostContext, @@ -23,7 +23,7 @@ import type { McpUiResourcePermissions, McpUiSizeChangedNotification, } from '@modelcontextprotocol/ext-apps/app-bridge'; -import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js'; +import type { CallToolResult, JSONRPCRequest } from '@modelcontextprotocol/sdk/types.js'; import { useCallback, useEffect, useMemo, useReducer, useRef, useState } from 'react'; import { callTool, readResource } from '../../api'; import { AppEvents } from '../../constants/events'; @@ -40,6 +40,8 @@ import { McpAppToolInputPartial, McpAppToolResult, DimensionLayout, + SamplingCreateMessageParams, + SamplingCreateMessageResponse, } from './types'; const DEFAULT_IFRAME_HEIGHT = 200; @@ -265,7 +267,13 @@ export default function McpAppRenderer({ const containerRef = useRef(null); const [containerWidth, setContainerWidth] = useState(0); const [containerHeight, setContainerHeight] = useState(0); + const [apiHost, setApiHost] = useState(null); + const [secretKey, setSecretKey] = useState(null); + useEffect(() => { + window.electron.getGoosedHostPort().then(setApiHost); + window.electron.getSecretKey().then(setSecretKey); + }, []); // Fetch the resource from the extension to get HTML and metadata (CSP, permissions, etc.). // If cachedHtml is provided we show it immediately; the fetch updates metadata and @@ -527,6 +535,42 @@ export default function McpAppRenderer({ return () => observer.disconnect(); }, []); + const handleFallbackRequest = useCallback( + async (request: JSONRPCRequest, _extra: RequestHandlerExtra) => { + if (request.method === 'sampling/createMessage') { + if (!sessionId || !apiHost || !secretKey) { + throw new Error('Session not initialized for sampling request'); + } + const { messages, systemPrompt, maxTokens } = + request.params as unknown as SamplingCreateMessageParams; + const response = await fetch(`${apiHost}/sessions/${sessionId}/sampling/message`, { + method: 'POST', + headers: { + 'Content-Type': 'application/json', + 'X-Secret-Key': secretKey, + }, + body: JSON.stringify({ + messages: messages.map((m) => ({ + role: m.role, + content: m.content, + })), + systemPrompt, + maxTokens, + }), + }); + if (!response.ok) { + throw new Error(`Sampling request failed: ${response.statusText}`); + } + return (await response.json()) as SamplingCreateMessageResponse; + } + return { + status: 'error' as const, + message: `Unhandled JSON-RPC method: ${request.method ?? ''}`, + }; + }, + [sessionId, apiHost, secretKey] + ); + const handleError = useCallback((err: Error) => { console.error('[MCP App Error]:', err); dispatch({ type: 'ERROR', message: errorMessage(err) }); @@ -643,6 +687,7 @@ export default function McpAppRenderer({ onReadResource={handleReadResource} onLoggingMessage={handleLoggingMessage} onSizeChanged={handleSizeChanged} + onFallbackRequest={handleFallbackRequest} onError={handleError} /> ); From 9f8fa368ab974e64fe637b57d21fff6a40c36f41 Mon Sep 17 00:00:00 2001 From: Debbie O'Brien Date: Thu, 19 Feb 2026 22:10:06 +0100 Subject: [PATCH 07/21] docs: update skills detail page to reference Goose Summon extension (#7350) Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> --- documentation/src/pages/skills/detail.tsx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/documentation/src/pages/skills/detail.tsx b/documentation/src/pages/skills/detail.tsx index bf46ca1004..fcde0c8bd8 100644 --- a/documentation/src/pages/skills/detail.tsx +++ b/documentation/src/pages/skills/detail.tsx @@ -227,7 +227,7 @@ export default function SkillDetailPage(): JSX.Element {

- Requires Goose Skills extension enabled + Requires Summon extension enabled

From 91fad4edcc694850d3f64e67c19feccaa3190d9b Mon Sep 17 00:00:00 2001 From: Emma Youndtsmith <90283317+emma-squared@users.noreply.github.com> Date: Thu, 19 Feb 2026 15:18:26 -0600 Subject: [PATCH 08/21] docs for reasoning env var (#7367) --- .../docs/getting-started/providers.md | 39 +++++++++++++++++++ .../docs/guides/environment-variables.md | 8 ++++ 2 files changed, 47 insertions(+) diff --git a/documentation/docs/getting-started/providers.md b/documentation/docs/getting-started/providers.md index 1298fa9757..6af9286822 100644 --- a/documentation/docs/getting-started/providers.md +++ b/documentation/docs/getting-started/providers.md @@ -1156,6 +1156,10 @@ Gemini 3 models support configurable thinking levels to balance response latency - **Low** (default) - Faster responses, lighter reasoning - **High** - Deeper reasoning, higher latency +:::tip +When thinking is enabled, you can view the model's reasoning process. See [Viewing Model Reasoning](#viewing-model-reasoning) for details. +::: + When selecting a Gemini 3 model, a "Thinking Level" dropdown appears automatically. Select your preference and the setting persists across sessions. @@ -1181,6 +1185,41 @@ The thinking level is determined in this order (highest to lowest priority): 3. Default value: `low` ::: +## Viewing Model Reasoning + +Some models expose their internal reasoning or "chain of thought" as part of their response. goose automatically captures this reasoning output and makes it available to you. The following models and providers support reasoning output: + +| Provider / Model | How It Works | +|---|---| +| **DeepSeek-R1** (via OpenAI, Ollama, OpenRouter, OVHcloud, etc.) | Reasoning captured from the `reasoning_content` field in the API response | +| **Kimi** (via Groq or other OpenAI-compatible endpoints) | Reasoning captured from the `reasoning_content` field in the API response | +| **Gemini CLI** (Google Gemini models with thinking enabled) | Thinking blocks captured from the streaming response | +| **Claude** (Anthropic, with [extended thinking](/docs/guides/environment-variables#claude-extended-thinking) enabled) | Thinking blocks captured from the API response | + + + + Reasoning output appears automatically in a collapsible **"Show reasoning"** toggle above the model's response. Click it to expand and view the model's thought process. + + + + Reasoning output is **hidden by default** in the CLI. To display it, set the `GOOSE_CLI_SHOW_THINKING` environment variable: + + ```bash + export GOOSE_CLI_SHOW_THINKING=1 + ``` + + When enabled, reasoning appears under a "Thinking:" header in dimmed text before the model's main response. + + :::note + This requires stdout to be a terminal (reasoning output won't appear when piping output to a file or another command). + ::: + + + +:::tip +Reasoning output can be useful for understanding how the model arrived at its answer, debugging unexpected behavior, or learning from the model's problem-solving approach. However, it can also be verbose — toggle it on only when you need it. +::: + --- If you have any questions or need help with a specific provider, feel free to reach out to us on [Discord](https://discord.gg/goose-oss) or on the [goose repo](https://github.com/block/goose). diff --git a/documentation/docs/guides/environment-variables.md b/documentation/docs/guides/environment-variables.md index 7c84b397cf..64a1e9f325 100644 --- a/documentation/docs/guides/environment-variables.md +++ b/documentation/docs/guides/environment-variables.md @@ -188,6 +188,10 @@ export CLAUDE_THINKING_ENABLED=1 export CLAUDE_THINKING_BUDGET=8000 ``` +:::tip Viewing Thinking Output +To see Claude's thinking output in the **CLI**, you also need to set `GOOSE_CLI_SHOW_THINKING=1`. In **goose Desktop**, thinking output is shown automatically in a collapsible "Show reasoning" toggle. +::: + ### Planning Mode Configuration These variables control goose's [planning functionality](/docs/guides/creating-plans). @@ -262,6 +266,7 @@ These variables control how goose manages conversation sessions and context. | `GOOSE_CLI_LIGHT_THEME` | Custom [bat theme](https://github.com/sharkdp/bat#adding-new-themes) for syntax highlighting when using light mode | bat theme name (e.g., "Solarized (light)", "OneHalfLight") | "GitHub" | | `GOOSE_CLI_DARK_THEME` | Custom [bat theme](https://github.com/sharkdp/bat#adding-new-themes) for syntax highlighting when using dark mode | bat theme name (e.g., "Dracula", "Nord") | "zenburn" | | `GOOSE_CLI_NEWLINE_KEY` | Customize the keyboard shortcut for [inserting newlines in CLI input](/docs/guides/goose-cli-commands#keyboard-shortcuts) | Single character (e.g., "n", "m") | "j" (Ctrl+J) | +| `GOOSE_CLI_SHOW_THINKING` | Shows model reasoning/thinking output in CLI responses. Some models (e.g., DeepSeek-R1, Kimi, Gemini) expose their internal reasoning process — this variable makes it visible in the CLI. | Set to any value to enable | Disabled | | `GOOSE_RANDOM_THINKING_MESSAGES` | Controls whether to show amusing random messages during processing | "true", "false" | "true" | | `GOOSE_CLI_SHOW_COST` | Toggles display of model cost estimates in CLI output | "1", "true" (case-insensitive) to enable | false | | `GOOSE_AUTO_COMPACT_THRESHOLD` | Set the percentage threshold at which goose [automatically summarizes your session](/docs/guides/sessions/smart-context-management#automatic-compaction). | Float between 0.0 and 1.0 (disabled at 0.0) | 0.8 | @@ -313,6 +318,9 @@ export GOOSE_CLI_NEWLINE_KEY=n # Disable random thinking messages for less distraction export GOOSE_RANDOM_THINKING_MESSAGES=false +# Show reasoning/thinking output from models that support it (e.g., DeepSeek-R1, Kimi, Gemini) +export GOOSE_CLI_SHOW_THINKING=1 + # Enable model cost display in CLI export GOOSE_CLI_SHOW_COST=true From 37f419dfb308177f7b88b6d73a0a65a3c1cbea17 Mon Sep 17 00:00:00 2001 From: Rodolfo Olivieri Date: Thu, 19 Feb 2026 18:45:19 -0300 Subject: [PATCH 09/21] Include 3rd-party license copy for JavaScript/CSS minified files (#7352) Signed-off-by: Rodolfo Olivieri --- crates/goose-mcp/Cargo.toml | 10 + crates/goose-mcp/licenses/chart-js.license | 9 + crates/goose-mcp/licenses/d3-js.license | 13 + crates/goose-mcp/licenses/d3-sankey.license | 27 + .../licenses/leaflet-markercluster.license | 20 + crates/goose-mcp/licenses/leaflet.license | 26 + crates/goose-mcp/licenses/mermaid.license | 21 + .../templates/assets/leaflet.min.css | 1322 ++++++++--------- 8 files changed, 787 insertions(+), 661 deletions(-) create mode 100644 crates/goose-mcp/licenses/chart-js.license create mode 100644 crates/goose-mcp/licenses/d3-js.license create mode 100644 crates/goose-mcp/licenses/d3-sankey.license create mode 100644 crates/goose-mcp/licenses/leaflet-markercluster.license create mode 100644 crates/goose-mcp/licenses/leaflet.license create mode 100644 crates/goose-mcp/licenses/mermaid.license diff --git a/crates/goose-mcp/Cargo.toml b/crates/goose-mcp/Cargo.toml index a3472453ff..a54c337e72 100644 --- a/crates/goose-mcp/Cargo.toml +++ b/crates/goose-mcp/Cargo.toml @@ -7,6 +7,16 @@ license.workspace = true repository.workspace = true description.workspace = true +# Include 3rd-party licenses for JavaScript/CSS minified files +include = [ + "licenses/chart-js.license", + "licenses/d3-js.license", + "licenses/d3-sankey.license", + "licenses/leaflet.license", + "licenses/leaflet-markercluster.license", + "licenses/mermaid.license" +] + [lints] workspace = true diff --git a/crates/goose-mcp/licenses/chart-js.license b/crates/goose-mcp/licenses/chart-js.license new file mode 100644 index 0000000000..f216610fd7 --- /dev/null +++ b/crates/goose-mcp/licenses/chart-js.license @@ -0,0 +1,9 @@ +The MIT License (MIT) + +Copyright (c) 2014-2024 Chart.js Contributors + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/crates/goose-mcp/licenses/d3-js.license b/crates/goose-mcp/licenses/d3-js.license new file mode 100644 index 0000000000..3594fffaf6 --- /dev/null +++ b/crates/goose-mcp/licenses/d3-js.license @@ -0,0 +1,13 @@ +Copyright 2010-2023 Mike Bostock + +Permission to use, copy, modify, and/or distribute this software for any purpose +with or without fee is hereby granted, provided that the above copyright notice +and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS +OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER +TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF +THIS SOFTWARE. diff --git a/crates/goose-mcp/licenses/d3-sankey.license b/crates/goose-mcp/licenses/d3-sankey.license new file mode 100644 index 0000000000..77d73f7ca8 --- /dev/null +++ b/crates/goose-mcp/licenses/d3-sankey.license @@ -0,0 +1,27 @@ +Copyright 2015, Mike Bostock +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +* Neither the name of the author nor the names of contributors may be used to + endorse or promote products derived from this software without specific prior + written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/crates/goose-mcp/licenses/leaflet-markercluster.license b/crates/goose-mcp/licenses/leaflet-markercluster.license new file mode 100644 index 0000000000..19af06829c --- /dev/null +++ b/crates/goose-mcp/licenses/leaflet-markercluster.license @@ -0,0 +1,20 @@ +Copyright 2012 David Leaver + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/crates/goose-mcp/licenses/leaflet.license b/crates/goose-mcp/licenses/leaflet.license new file mode 100644 index 0000000000..7b41f200ab --- /dev/null +++ b/crates/goose-mcp/licenses/leaflet.license @@ -0,0 +1,26 @@ +BSD 2-Clause License + +Copyright (c) 2010-2023, Volodymyr Agafonkin +Copyright (c) 2010-2011, CloudMade +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/crates/goose-mcp/licenses/mermaid.license b/crates/goose-mcp/licenses/mermaid.license new file mode 100644 index 0000000000..2e5daebd2a --- /dev/null +++ b/crates/goose-mcp/licenses/mermaid.license @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2014 - 2022 Knut Sveidqvist + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/crates/goose-mcp/src/autovisualiser/templates/assets/leaflet.min.css b/crates/goose-mcp/src/autovisualiser/templates/assets/leaflet.min.css index 2961b7618a..9ade8dc49b 100644 --- a/crates/goose-mcp/src/autovisualiser/templates/assets/leaflet.min.css +++ b/crates/goose-mcp/src/autovisualiser/templates/assets/leaflet.min.css @@ -1,661 +1,661 @@ -/* required styles */ - -.leaflet-pane, -.leaflet-tile, -.leaflet-marker-icon, -.leaflet-marker-shadow, -.leaflet-tile-container, -.leaflet-pane > svg, -.leaflet-pane > canvas, -.leaflet-zoom-box, -.leaflet-image-layer, -.leaflet-layer { - position: absolute; - left: 0; - top: 0; - } -.leaflet-container { - overflow: hidden; - } -.leaflet-tile, -.leaflet-marker-icon, -.leaflet-marker-shadow { - -webkit-user-select: none; - -moz-user-select: none; - user-select: none; - -webkit-user-drag: none; - } -/* Prevents IE11 from highlighting tiles in blue */ -.leaflet-tile::selection { - background: transparent; -} -/* Safari renders non-retina tile on retina better with this, but Chrome is worse */ -.leaflet-safari .leaflet-tile { - image-rendering: -webkit-optimize-contrast; - } -/* hack that prevents hw layers "stretching" when loading new tiles */ -.leaflet-safari .leaflet-tile-container { - width: 1600px; - height: 1600px; - -webkit-transform-origin: 0 0; - } -.leaflet-marker-icon, -.leaflet-marker-shadow { - display: block; - } -/* .leaflet-container svg: reset svg max-width decleration shipped in Joomla! (joomla.org) 3.x */ -/* .leaflet-container img: map is broken in FF if you have max-width: 100% on tiles */ -.leaflet-container .leaflet-overlay-pane svg { - max-width: none !important; - max-height: none !important; - } -.leaflet-container .leaflet-marker-pane img, -.leaflet-container .leaflet-shadow-pane img, -.leaflet-container .leaflet-tile-pane img, -.leaflet-container img.leaflet-image-layer, -.leaflet-container .leaflet-tile { - max-width: none !important; - max-height: none !important; - width: auto; - padding: 0; - } - -.leaflet-container img.leaflet-tile { - /* See: https://bugs.chromium.org/p/chromium/issues/detail?id=600120 */ - mix-blend-mode: plus-lighter; -} - -.leaflet-container.leaflet-touch-zoom { - -ms-touch-action: pan-x pan-y; - touch-action: pan-x pan-y; - } -.leaflet-container.leaflet-touch-drag { - -ms-touch-action: pinch-zoom; - /* Fallback for FF which doesn't support pinch-zoom */ - touch-action: none; - touch-action: pinch-zoom; -} -.leaflet-container.leaflet-touch-drag.leaflet-touch-zoom { - -ms-touch-action: none; - touch-action: none; -} -.leaflet-container { - -webkit-tap-highlight-color: transparent; -} -.leaflet-container a { - -webkit-tap-highlight-color: rgba(51, 181, 229, 0.4); -} -.leaflet-tile { - filter: inherit; - visibility: hidden; - } -.leaflet-tile-loaded { - visibility: inherit; - } -.leaflet-zoom-box { - width: 0; - height: 0; - -moz-box-sizing: border-box; - box-sizing: border-box; - z-index: 800; - } -/* workaround for https://bugzilla.mozilla.org/show_bug.cgi?id=888319 */ -.leaflet-overlay-pane svg { - -moz-user-select: none; - } - -.leaflet-pane { z-index: 400; } - -.leaflet-tile-pane { z-index: 200; } -.leaflet-overlay-pane { z-index: 400; } -.leaflet-shadow-pane { z-index: 500; } -.leaflet-marker-pane { z-index: 600; } -.leaflet-tooltip-pane { z-index: 650; } -.leaflet-popup-pane { z-index: 700; } - -.leaflet-map-pane canvas { z-index: 100; } -.leaflet-map-pane svg { z-index: 200; } - -.leaflet-vml-shape { - width: 1px; - height: 1px; - } -.lvml { - behavior: url(#default#VML); - display: inline-block; - position: absolute; - } - - -/* control positioning */ - -.leaflet-control { - position: relative; - z-index: 800; - pointer-events: visiblePainted; /* IE 9-10 doesn't have auto */ - pointer-events: auto; - } -.leaflet-top, -.leaflet-bottom { - position: absolute; - z-index: 1000; - pointer-events: none; - } -.leaflet-top { - top: 0; - } -.leaflet-right { - right: 0; - } -.leaflet-bottom { - bottom: 0; - } -.leaflet-left { - left: 0; - } -.leaflet-control { - float: left; - clear: both; - } -.leaflet-right .leaflet-control { - float: right; - } -.leaflet-top .leaflet-control { - margin-top: 10px; - } -.leaflet-bottom .leaflet-control { - margin-bottom: 10px; - } -.leaflet-left .leaflet-control { - margin-left: 10px; - } -.leaflet-right .leaflet-control { - margin-right: 10px; - } - - -/* zoom and fade animations */ - -.leaflet-fade-anim .leaflet-popup { - opacity: 0; - -webkit-transition: opacity 0.2s linear; - -moz-transition: opacity 0.2s linear; - transition: opacity 0.2s linear; - } -.leaflet-fade-anim .leaflet-map-pane .leaflet-popup { - opacity: 1; - } -.leaflet-zoom-animated { - -webkit-transform-origin: 0 0; - -ms-transform-origin: 0 0; - transform-origin: 0 0; - } -svg.leaflet-zoom-animated { - will-change: transform; -} - -.leaflet-zoom-anim .leaflet-zoom-animated { - -webkit-transition: -webkit-transform 0.25s cubic-bezier(0,0,0.25,1); - -moz-transition: -moz-transform 0.25s cubic-bezier(0,0,0.25,1); - transition: transform 0.25s cubic-bezier(0,0,0.25,1); - } -.leaflet-zoom-anim .leaflet-tile, -.leaflet-pan-anim .leaflet-tile { - -webkit-transition: none; - -moz-transition: none; - transition: none; - } - -.leaflet-zoom-anim .leaflet-zoom-hide { - visibility: hidden; - } - - -/* cursors */ - -.leaflet-interactive { - cursor: pointer; - } -.leaflet-grab { - cursor: -webkit-grab; - cursor: -moz-grab; - cursor: grab; - } -.leaflet-crosshair, -.leaflet-crosshair .leaflet-interactive { - cursor: crosshair; - } -.leaflet-popup-pane, -.leaflet-control { - cursor: auto; - } -.leaflet-dragging .leaflet-grab, -.leaflet-dragging .leaflet-grab .leaflet-interactive, -.leaflet-dragging .leaflet-marker-draggable { - cursor: move; - cursor: -webkit-grabbing; - cursor: -moz-grabbing; - cursor: grabbing; - } - -/* marker & overlays interactivity */ -.leaflet-marker-icon, -.leaflet-marker-shadow, -.leaflet-image-layer, -.leaflet-pane > svg path, -.leaflet-tile-container { - pointer-events: none; - } - -.leaflet-marker-icon.leaflet-interactive, -.leaflet-image-layer.leaflet-interactive, -.leaflet-pane > svg path.leaflet-interactive, -svg.leaflet-image-layer.leaflet-interactive path { - pointer-events: visiblePainted; /* IE 9-10 doesn't have auto */ - pointer-events: auto; - } - -/* visual tweaks */ - -.leaflet-container { - background: #ddd; - outline-offset: 1px; - } -.leaflet-container a { - color: #0078A8; - } -.leaflet-zoom-box { - border: 2px dotted #38f; - background: rgba(255,255,255,0.5); - } - - -/* general typography */ -.leaflet-container { - font-family: "Helvetica Neue", Arial, Helvetica, sans-serif; - font-size: 12px; - font-size: 0.75rem; - line-height: 1.5; - } - - -/* general toolbar styles */ - -.leaflet-bar { - box-shadow: 0 1px 5px rgba(0,0,0,0.65); - border-radius: 4px; - } -.leaflet-bar a { - background-color: #fff; - border-bottom: 1px solid #ccc; - width: 26px; - height: 26px; - line-height: 26px; - display: block; - text-align: center; - text-decoration: none; - color: black; - } -.leaflet-bar a, -.leaflet-control-layers-toggle { - background-position: 50% 50%; - background-repeat: no-repeat; - display: block; - } -.leaflet-bar a:hover, -.leaflet-bar a:focus { - background-color: #f4f4f4; - } -.leaflet-bar a:first-child { - border-top-left-radius: 4px; - border-top-right-radius: 4px; - } -.leaflet-bar a:last-child { - border-bottom-left-radius: 4px; - border-bottom-right-radius: 4px; - border-bottom: none; - } -.leaflet-bar a.leaflet-disabled { - cursor: default; - background-color: #f4f4f4; - color: #bbb; - } - -.leaflet-touch .leaflet-bar a { - width: 30px; - height: 30px; - line-height: 30px; - } -.leaflet-touch .leaflet-bar a:first-child { - border-top-left-radius: 2px; - border-top-right-radius: 2px; - } -.leaflet-touch .leaflet-bar a:last-child { - border-bottom-left-radius: 2px; - border-bottom-right-radius: 2px; - } - -/* zoom control */ - -.leaflet-control-zoom-in, -.leaflet-control-zoom-out { - font: bold 18px 'Lucida Console', Monaco, monospace; - text-indent: 1px; - } - -.leaflet-touch .leaflet-control-zoom-in, .leaflet-touch .leaflet-control-zoom-out { - font-size: 22px; - } - - -/* layers control */ - -.leaflet-control-layers { - box-shadow: 0 1px 5px rgba(0,0,0,0.4); - background: #fff; - border-radius: 5px; - } -.leaflet-control-layers-toggle { - background-image: url(images/layers.png); - width: 36px; - height: 36px; - } -.leaflet-retina .leaflet-control-layers-toggle { - background-image: url(images/layers-2x.png); - background-size: 26px 26px; - } -.leaflet-touch .leaflet-control-layers-toggle { - width: 44px; - height: 44px; - } -.leaflet-control-layers .leaflet-control-layers-list, -.leaflet-control-layers-expanded .leaflet-control-layers-toggle { - display: none; - } -.leaflet-control-layers-expanded .leaflet-control-layers-list { - display: block; - position: relative; - } -.leaflet-control-layers-expanded { - padding: 6px 10px 6px 6px; - color: #333; - background: #fff; - } -.leaflet-control-layers-scrollbar { - overflow-y: scroll; - overflow-x: hidden; - padding-right: 5px; - } -.leaflet-control-layers-selector { - margin-top: 2px; - position: relative; - top: 1px; - } -.leaflet-control-layers label { - display: block; - font-size: 13px; - font-size: 1.08333em; - } -.leaflet-control-layers-separator { - height: 0; - border-top: 1px solid #ddd; - margin: 5px -10px 5px -6px; - } - -/* Default icon URLs */ -.leaflet-default-icon-path { /* used only in path-guessing heuristic, see L.Icon.Default */ - background-image: url(images/marker-icon.png); - } - - -/* attribution and scale controls */ - -.leaflet-container .leaflet-control-attribution { - background: #fff; - background: rgba(255, 255, 255, 0.8); - margin: 0; - } -.leaflet-control-attribution, -.leaflet-control-scale-line { - padding: 0 5px; - color: #333; - line-height: 1.4; - } -.leaflet-control-attribution a { - text-decoration: none; - } -.leaflet-control-attribution a:hover, -.leaflet-control-attribution a:focus { - text-decoration: underline; - } -.leaflet-attribution-flag { - display: inline !important; - vertical-align: baseline !important; - width: 1em; - height: 0.6669em; - } -.leaflet-left .leaflet-control-scale { - margin-left: 5px; - } -.leaflet-bottom .leaflet-control-scale { - margin-bottom: 5px; - } -.leaflet-control-scale-line { - border: 2px solid #777; - border-top: none; - line-height: 1.1; - padding: 2px 5px 1px; - white-space: nowrap; - -moz-box-sizing: border-box; - box-sizing: border-box; - background: rgba(255, 255, 255, 0.8); - text-shadow: 1px 1px #fff; - } -.leaflet-control-scale-line:not(:first-child) { - border-top: 2px solid #777; - border-bottom: none; - margin-top: -2px; - } -.leaflet-control-scale-line:not(:first-child):not(:last-child) { - border-bottom: 2px solid #777; - } - -.leaflet-touch .leaflet-control-attribution, -.leaflet-touch .leaflet-control-layers, -.leaflet-touch .leaflet-bar { - box-shadow: none; - } -.leaflet-touch .leaflet-control-layers, -.leaflet-touch .leaflet-bar { - border: 2px solid rgba(0,0,0,0.2); - background-clip: padding-box; - } - - -/* popup */ - -.leaflet-popup { - position: absolute; - text-align: center; - margin-bottom: 20px; - } -.leaflet-popup-content-wrapper { - padding: 1px; - text-align: left; - border-radius: 12px; - } -.leaflet-popup-content { - margin: 13px 24px 13px 20px; - line-height: 1.3; - font-size: 13px; - font-size: 1.08333em; - min-height: 1px; - } -.leaflet-popup-content p { - margin: 17px 0; - margin: 1.3em 0; - } -.leaflet-popup-tip-container { - width: 40px; - height: 20px; - position: absolute; - left: 50%; - margin-top: -1px; - margin-left: -20px; - overflow: hidden; - pointer-events: none; - } -.leaflet-popup-tip { - width: 17px; - height: 17px; - padding: 1px; - - margin: -10px auto 0; - pointer-events: auto; - - -webkit-transform: rotate(45deg); - -moz-transform: rotate(45deg); - -ms-transform: rotate(45deg); - transform: rotate(45deg); - } -.leaflet-popup-content-wrapper, -.leaflet-popup-tip { - background: white; - color: #333; - box-shadow: 0 3px 14px rgba(0,0,0,0.4); - } -.leaflet-container a.leaflet-popup-close-button { - position: absolute; - top: 0; - right: 0; - border: none; - text-align: center; - width: 24px; - height: 24px; - font: 16px/24px Tahoma, Verdana, sans-serif; - color: #757575; - text-decoration: none; - background: transparent; - } -.leaflet-container a.leaflet-popup-close-button:hover, -.leaflet-container a.leaflet-popup-close-button:focus { - color: #585858; - } -.leaflet-popup-scrolled { - overflow: auto; - } - -.leaflet-oldie .leaflet-popup-content-wrapper { - -ms-zoom: 1; - } -.leaflet-oldie .leaflet-popup-tip { - width: 24px; - margin: 0 auto; - - -ms-filter: "progid:DXImageTransform.Microsoft.Matrix(M11=0.70710678, M12=0.70710678, M21=-0.70710678, M22=0.70710678)"; - filter: progid:DXImageTransform.Microsoft.Matrix(M11=0.70710678, M12=0.70710678, M21=-0.70710678, M22=0.70710678); - } - -.leaflet-oldie .leaflet-control-zoom, -.leaflet-oldie .leaflet-control-layers, -.leaflet-oldie .leaflet-popup-content-wrapper, -.leaflet-oldie .leaflet-popup-tip { - border: 1px solid #999; - } - - -/* div icon */ - -.leaflet-div-icon { - background: #fff; - border: 1px solid #666; - } - - -/* Tooltip */ -/* Base styles for the element that has a tooltip */ -.leaflet-tooltip { - position: absolute; - padding: 6px; - background-color: #fff; - border: 1px solid #fff; - border-radius: 3px; - color: #222; - white-space: nowrap; - -webkit-user-select: none; - -moz-user-select: none; - -ms-user-select: none; - user-select: none; - pointer-events: none; - box-shadow: 0 1px 3px rgba(0,0,0,0.4); - } -.leaflet-tooltip.leaflet-interactive { - cursor: pointer; - pointer-events: auto; - } -.leaflet-tooltip-top:before, -.leaflet-tooltip-bottom:before, -.leaflet-tooltip-left:before, -.leaflet-tooltip-right:before { - position: absolute; - pointer-events: none; - border: 6px solid transparent; - background: transparent; - content: ""; - } - -/* Directions */ - -.leaflet-tooltip-bottom { - margin-top: 6px; -} -.leaflet-tooltip-top { - margin-top: -6px; -} -.leaflet-tooltip-bottom:before, -.leaflet-tooltip-top:before { - left: 50%; - margin-left: -6px; - } -.leaflet-tooltip-top:before { - bottom: 0; - margin-bottom: -12px; - border-top-color: #fff; - } -.leaflet-tooltip-bottom:before { - top: 0; - margin-top: -12px; - margin-left: -6px; - border-bottom-color: #fff; - } -.leaflet-tooltip-left { - margin-left: -6px; -} -.leaflet-tooltip-right { - margin-left: 6px; -} -.leaflet-tooltip-left:before, -.leaflet-tooltip-right:before { - top: 50%; - margin-top: -6px; - } -.leaflet-tooltip-left:before { - right: 0; - margin-right: -12px; - border-left-color: #fff; - } -.leaflet-tooltip-right:before { - left: 0; - margin-left: -12px; - border-right-color: #fff; - } - -/* Printing */ - -@media print { - /* Prevent printers from removing background-images of controls. */ - .leaflet-control { - -webkit-print-color-adjust: exact; - print-color-adjust: exact; - } - } +/* required styles */ + +.leaflet-pane, +.leaflet-tile, +.leaflet-marker-icon, +.leaflet-marker-shadow, +.leaflet-tile-container, +.leaflet-pane > svg, +.leaflet-pane > canvas, +.leaflet-zoom-box, +.leaflet-image-layer, +.leaflet-layer { + position: absolute; + left: 0; + top: 0; + } +.leaflet-container { + overflow: hidden; + } +.leaflet-tile, +.leaflet-marker-icon, +.leaflet-marker-shadow { + -webkit-user-select: none; + -moz-user-select: none; + user-select: none; + -webkit-user-drag: none; + } +/* Prevents IE11 from highlighting tiles in blue */ +.leaflet-tile::selection { + background: transparent; +} +/* Safari renders non-retina tile on retina better with this, but Chrome is worse */ +.leaflet-safari .leaflet-tile { + image-rendering: -webkit-optimize-contrast; + } +/* hack that prevents hw layers "stretching" when loading new tiles */ +.leaflet-safari .leaflet-tile-container { + width: 1600px; + height: 1600px; + -webkit-transform-origin: 0 0; + } +.leaflet-marker-icon, +.leaflet-marker-shadow { + display: block; + } +/* .leaflet-container svg: reset svg max-width decleration shipped in Joomla! (joomla.org) 3.x */ +/* .leaflet-container img: map is broken in FF if you have max-width: 100% on tiles */ +.leaflet-container .leaflet-overlay-pane svg { + max-width: none !important; + max-height: none !important; + } +.leaflet-container .leaflet-marker-pane img, +.leaflet-container .leaflet-shadow-pane img, +.leaflet-container .leaflet-tile-pane img, +.leaflet-container img.leaflet-image-layer, +.leaflet-container .leaflet-tile { + max-width: none !important; + max-height: none !important; + width: auto; + padding: 0; + } + +.leaflet-container img.leaflet-tile { + /* See: https://bugs.chromium.org/p/chromium/issues/detail?id=600120 */ + mix-blend-mode: plus-lighter; +} + +.leaflet-container.leaflet-touch-zoom { + -ms-touch-action: pan-x pan-y; + touch-action: pan-x pan-y; + } +.leaflet-container.leaflet-touch-drag { + -ms-touch-action: pinch-zoom; + /* Fallback for FF which doesn't support pinch-zoom */ + touch-action: none; + touch-action: pinch-zoom; +} +.leaflet-container.leaflet-touch-drag.leaflet-touch-zoom { + -ms-touch-action: none; + touch-action: none; +} +.leaflet-container { + -webkit-tap-highlight-color: transparent; +} +.leaflet-container a { + -webkit-tap-highlight-color: rgba(51, 181, 229, 0.4); +} +.leaflet-tile { + filter: inherit; + visibility: hidden; + } +.leaflet-tile-loaded { + visibility: inherit; + } +.leaflet-zoom-box { + width: 0; + height: 0; + -moz-box-sizing: border-box; + box-sizing: border-box; + z-index: 800; + } +/* workaround for https://bugzilla.mozilla.org/show_bug.cgi?id=888319 */ +.leaflet-overlay-pane svg { + -moz-user-select: none; + } + +.leaflet-pane { z-index: 400; } + +.leaflet-tile-pane { z-index: 200; } +.leaflet-overlay-pane { z-index: 400; } +.leaflet-shadow-pane { z-index: 500; } +.leaflet-marker-pane { z-index: 600; } +.leaflet-tooltip-pane { z-index: 650; } +.leaflet-popup-pane { z-index: 700; } + +.leaflet-map-pane canvas { z-index: 100; } +.leaflet-map-pane svg { z-index: 200; } + +.leaflet-vml-shape { + width: 1px; + height: 1px; + } +.lvml { + behavior: url(#default#VML); + display: inline-block; + position: absolute; + } + + +/* control positioning */ + +.leaflet-control { + position: relative; + z-index: 800; + pointer-events: visiblePainted; /* IE 9-10 doesn't have auto */ + pointer-events: auto; + } +.leaflet-top, +.leaflet-bottom { + position: absolute; + z-index: 1000; + pointer-events: none; + } +.leaflet-top { + top: 0; + } +.leaflet-right { + right: 0; + } +.leaflet-bottom { + bottom: 0; + } +.leaflet-left { + left: 0; + } +.leaflet-control { + float: left; + clear: both; + } +.leaflet-right .leaflet-control { + float: right; + } +.leaflet-top .leaflet-control { + margin-top: 10px; + } +.leaflet-bottom .leaflet-control { + margin-bottom: 10px; + } +.leaflet-left .leaflet-control { + margin-left: 10px; + } +.leaflet-right .leaflet-control { + margin-right: 10px; + } + + +/* zoom and fade animations */ + +.leaflet-fade-anim .leaflet-popup { + opacity: 0; + -webkit-transition: opacity 0.2s linear; + -moz-transition: opacity 0.2s linear; + transition: opacity 0.2s linear; + } +.leaflet-fade-anim .leaflet-map-pane .leaflet-popup { + opacity: 1; + } +.leaflet-zoom-animated { + -webkit-transform-origin: 0 0; + -ms-transform-origin: 0 0; + transform-origin: 0 0; + } +svg.leaflet-zoom-animated { + will-change: transform; +} + +.leaflet-zoom-anim .leaflet-zoom-animated { + -webkit-transition: -webkit-transform 0.25s cubic-bezier(0,0,0.25,1); + -moz-transition: -moz-transform 0.25s cubic-bezier(0,0,0.25,1); + transition: transform 0.25s cubic-bezier(0,0,0.25,1); + } +.leaflet-zoom-anim .leaflet-tile, +.leaflet-pan-anim .leaflet-tile { + -webkit-transition: none; + -moz-transition: none; + transition: none; + } + +.leaflet-zoom-anim .leaflet-zoom-hide { + visibility: hidden; + } + + +/* cursors */ + +.leaflet-interactive { + cursor: pointer; + } +.leaflet-grab { + cursor: -webkit-grab; + cursor: -moz-grab; + cursor: grab; + } +.leaflet-crosshair, +.leaflet-crosshair .leaflet-interactive { + cursor: crosshair; + } +.leaflet-popup-pane, +.leaflet-control { + cursor: auto; + } +.leaflet-dragging .leaflet-grab, +.leaflet-dragging .leaflet-grab .leaflet-interactive, +.leaflet-dragging .leaflet-marker-draggable { + cursor: move; + cursor: -webkit-grabbing; + cursor: -moz-grabbing; + cursor: grabbing; + } + +/* marker & overlays interactivity */ +.leaflet-marker-icon, +.leaflet-marker-shadow, +.leaflet-image-layer, +.leaflet-pane > svg path, +.leaflet-tile-container { + pointer-events: none; + } + +.leaflet-marker-icon.leaflet-interactive, +.leaflet-image-layer.leaflet-interactive, +.leaflet-pane > svg path.leaflet-interactive, +svg.leaflet-image-layer.leaflet-interactive path { + pointer-events: visiblePainted; /* IE 9-10 doesn't have auto */ + pointer-events: auto; + } + +/* visual tweaks */ + +.leaflet-container { + background: #ddd; + outline-offset: 1px; + } +.leaflet-container a { + color: #0078A8; + } +.leaflet-zoom-box { + border: 2px dotted #38f; + background: rgba(255,255,255,0.5); + } + + +/* general typography */ +.leaflet-container { + font-family: "Helvetica Neue", Arial, Helvetica, sans-serif; + font-size: 12px; + font-size: 0.75rem; + line-height: 1.5; + } + + +/* general toolbar styles */ + +.leaflet-bar { + box-shadow: 0 1px 5px rgba(0,0,0,0.65); + border-radius: 4px; + } +.leaflet-bar a { + background-color: #fff; + border-bottom: 1px solid #ccc; + width: 26px; + height: 26px; + line-height: 26px; + display: block; + text-align: center; + text-decoration: none; + color: black; + } +.leaflet-bar a, +.leaflet-control-layers-toggle { + background-position: 50% 50%; + background-repeat: no-repeat; + display: block; + } +.leaflet-bar a:hover, +.leaflet-bar a:focus { + background-color: #f4f4f4; + } +.leaflet-bar a:first-child { + border-top-left-radius: 4px; + border-top-right-radius: 4px; + } +.leaflet-bar a:last-child { + border-bottom-left-radius: 4px; + border-bottom-right-radius: 4px; + border-bottom: none; + } +.leaflet-bar a.leaflet-disabled { + cursor: default; + background-color: #f4f4f4; + color: #bbb; + } + +.leaflet-touch .leaflet-bar a { + width: 30px; + height: 30px; + line-height: 30px; + } +.leaflet-touch .leaflet-bar a:first-child { + border-top-left-radius: 2px; + border-top-right-radius: 2px; + } +.leaflet-touch .leaflet-bar a:last-child { + border-bottom-left-radius: 2px; + border-bottom-right-radius: 2px; + } + +/* zoom control */ + +.leaflet-control-zoom-in, +.leaflet-control-zoom-out { + font: bold 18px 'Lucida Console', Monaco, monospace; + text-indent: 1px; + } + +.leaflet-touch .leaflet-control-zoom-in, .leaflet-touch .leaflet-control-zoom-out { + font-size: 22px; + } + + +/* layers control */ + +.leaflet-control-layers { + box-shadow: 0 1px 5px rgba(0,0,0,0.4); + background: #fff; + border-radius: 5px; + } +.leaflet-control-layers-toggle { + background-image: url(images/layers.png); + width: 36px; + height: 36px; + } +.leaflet-retina .leaflet-control-layers-toggle { + background-image: url(images/layers-2x.png); + background-size: 26px 26px; + } +.leaflet-touch .leaflet-control-layers-toggle { + width: 44px; + height: 44px; + } +.leaflet-control-layers .leaflet-control-layers-list, +.leaflet-control-layers-expanded .leaflet-control-layers-toggle { + display: none; + } +.leaflet-control-layers-expanded .leaflet-control-layers-list { + display: block; + position: relative; + } +.leaflet-control-layers-expanded { + padding: 6px 10px 6px 6px; + color: #333; + background: #fff; + } +.leaflet-control-layers-scrollbar { + overflow-y: scroll; + overflow-x: hidden; + padding-right: 5px; + } +.leaflet-control-layers-selector { + margin-top: 2px; + position: relative; + top: 1px; + } +.leaflet-control-layers label { + display: block; + font-size: 13px; + font-size: 1.08333em; + } +.leaflet-control-layers-separator { + height: 0; + border-top: 1px solid #ddd; + margin: 5px -10px 5px -6px; + } + +/* Default icon URLs */ +.leaflet-default-icon-path { /* used only in path-guessing heuristic, see L.Icon.Default */ + background-image: url(images/marker-icon.png); + } + + +/* attribution and scale controls */ + +.leaflet-container .leaflet-control-attribution { + background: #fff; + background: rgba(255, 255, 255, 0.8); + margin: 0; + } +.leaflet-control-attribution, +.leaflet-control-scale-line { + padding: 0 5px; + color: #333; + line-height: 1.4; + } +.leaflet-control-attribution a { + text-decoration: none; + } +.leaflet-control-attribution a:hover, +.leaflet-control-attribution a:focus { + text-decoration: underline; + } +.leaflet-attribution-flag { + display: inline !important; + vertical-align: baseline !important; + width: 1em; + height: 0.6669em; + } +.leaflet-left .leaflet-control-scale { + margin-left: 5px; + } +.leaflet-bottom .leaflet-control-scale { + margin-bottom: 5px; + } +.leaflet-control-scale-line { + border: 2px solid #777; + border-top: none; + line-height: 1.1; + padding: 2px 5px 1px; + white-space: nowrap; + -moz-box-sizing: border-box; + box-sizing: border-box; + background: rgba(255, 255, 255, 0.8); + text-shadow: 1px 1px #fff; + } +.leaflet-control-scale-line:not(:first-child) { + border-top: 2px solid #777; + border-bottom: none; + margin-top: -2px; + } +.leaflet-control-scale-line:not(:first-child):not(:last-child) { + border-bottom: 2px solid #777; + } + +.leaflet-touch .leaflet-control-attribution, +.leaflet-touch .leaflet-control-layers, +.leaflet-touch .leaflet-bar { + box-shadow: none; + } +.leaflet-touch .leaflet-control-layers, +.leaflet-touch .leaflet-bar { + border: 2px solid rgba(0,0,0,0.2); + background-clip: padding-box; + } + + +/* popup */ + +.leaflet-popup { + position: absolute; + text-align: center; + margin-bottom: 20px; + } +.leaflet-popup-content-wrapper { + padding: 1px; + text-align: left; + border-radius: 12px; + } +.leaflet-popup-content { + margin: 13px 24px 13px 20px; + line-height: 1.3; + font-size: 13px; + font-size: 1.08333em; + min-height: 1px; + } +.leaflet-popup-content p { + margin: 17px 0; + margin: 1.3em 0; + } +.leaflet-popup-tip-container { + width: 40px; + height: 20px; + position: absolute; + left: 50%; + margin-top: -1px; + margin-left: -20px; + overflow: hidden; + pointer-events: none; + } +.leaflet-popup-tip { + width: 17px; + height: 17px; + padding: 1px; + + margin: -10px auto 0; + pointer-events: auto; + + -webkit-transform: rotate(45deg); + -moz-transform: rotate(45deg); + -ms-transform: rotate(45deg); + transform: rotate(45deg); + } +.leaflet-popup-content-wrapper, +.leaflet-popup-tip { + background: white; + color: #333; + box-shadow: 0 3px 14px rgba(0,0,0,0.4); + } +.leaflet-container a.leaflet-popup-close-button { + position: absolute; + top: 0; + right: 0; + border: none; + text-align: center; + width: 24px; + height: 24px; + font: 16px/24px Tahoma, Verdana, sans-serif; + color: #757575; + text-decoration: none; + background: transparent; + } +.leaflet-container a.leaflet-popup-close-button:hover, +.leaflet-container a.leaflet-popup-close-button:focus { + color: #585858; + } +.leaflet-popup-scrolled { + overflow: auto; + } + +.leaflet-oldie .leaflet-popup-content-wrapper { + -ms-zoom: 1; + } +.leaflet-oldie .leaflet-popup-tip { + width: 24px; + margin: 0 auto; + + -ms-filter: "progid:DXImageTransform.Microsoft.Matrix(M11=0.70710678, M12=0.70710678, M21=-0.70710678, M22=0.70710678)"; + filter: progid:DXImageTransform.Microsoft.Matrix(M11=0.70710678, M12=0.70710678, M21=-0.70710678, M22=0.70710678); + } + +.leaflet-oldie .leaflet-control-zoom, +.leaflet-oldie .leaflet-control-layers, +.leaflet-oldie .leaflet-popup-content-wrapper, +.leaflet-oldie .leaflet-popup-tip { + border: 1px solid #999; + } + + +/* div icon */ + +.leaflet-div-icon { + background: #fff; + border: 1px solid #666; + } + + +/* Tooltip */ +/* Base styles for the element that has a tooltip */ +.leaflet-tooltip { + position: absolute; + padding: 6px; + background-color: #fff; + border: 1px solid #fff; + border-radius: 3px; + color: #222; + white-space: nowrap; + -webkit-user-select: none; + -moz-user-select: none; + -ms-user-select: none; + user-select: none; + pointer-events: none; + box-shadow: 0 1px 3px rgba(0,0,0,0.4); + } +.leaflet-tooltip.leaflet-interactive { + cursor: pointer; + pointer-events: auto; + } +.leaflet-tooltip-top:before, +.leaflet-tooltip-bottom:before, +.leaflet-tooltip-left:before, +.leaflet-tooltip-right:before { + position: absolute; + pointer-events: none; + border: 6px solid transparent; + background: transparent; + content: ""; + } + +/* Directions */ + +.leaflet-tooltip-bottom { + margin-top: 6px; +} +.leaflet-tooltip-top { + margin-top: -6px; +} +.leaflet-tooltip-bottom:before, +.leaflet-tooltip-top:before { + left: 50%; + margin-left: -6px; + } +.leaflet-tooltip-top:before { + bottom: 0; + margin-bottom: -12px; + border-top-color: #fff; + } +.leaflet-tooltip-bottom:before { + top: 0; + margin-top: -12px; + margin-left: -6px; + border-bottom-color: #fff; + } +.leaflet-tooltip-left { + margin-left: -6px; +} +.leaflet-tooltip-right { + margin-left: 6px; +} +.leaflet-tooltip-left:before, +.leaflet-tooltip-right:before { + top: 50%; + margin-top: -6px; + } +.leaflet-tooltip-left:before { + right: 0; + margin-right: -12px; + border-left-color: #fff; + } +.leaflet-tooltip-right:before { + left: 0; + margin-left: -12px; + border-right-color: #fff; + } + +/* Printing */ + +@media print { + /* Prevent printers from removing background-images of controls. */ + .leaflet-control { + -webkit-print-color-adjust: exact; + print-color-adjust: exact; + } + } From 0ed4fed6c5671c709077bae19aa09ff18d2c07c1 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Thu, 19 Feb 2026 14:02:01 -0800 Subject: [PATCH 10/21] chore(deps): bump hono from 4.11.9 to 4.12.0 in /ui/desktop (#7369) Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- ui/desktop/package-lock.json | 52 +++++++++++++++++++++++++++--------- 1 file changed, 39 insertions(+), 13 deletions(-) diff --git a/ui/desktop/package-lock.json b/ui/desktop/package-lock.json index 3b46f36a53..60c21f1f9c 100644 --- a/ui/desktop/package-lock.json +++ b/ui/desktop/package-lock.json @@ -128,10 +128,14 @@ "zod": "^3.25.76" }, "devDependencies": { + "@agentclientprotocol/sdk": "^0.14.1", "@hey-api/openapi-ts": "^0.92.3", "prettier": "^3.8.1", "tsx": "^4.21.0", "typescript": "~5.9.3" + }, + "peerDependencies": { + "@agentclientprotocol/sdk": "*" } }, "node_modules/@acemir/cssom": { @@ -233,6 +237,7 @@ "integrity": "sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "@babel/code-frame": "^7.29.0", "@babel/generator": "^7.29.0", @@ -602,6 +607,7 @@ } ], "license": "MIT", + "peer": true, "engines": { "node": ">=20.19.0" }, @@ -642,6 +648,7 @@ } ], "license": "MIT", + "peer": true, "engines": { "node": ">=20.19.0" } @@ -1099,6 +1106,7 @@ "integrity": "sha512-zx0EIq78WlY/lBb1uXlziZmDZI4ubcCXIMJ4uGjXzZW0nS19TjSPeXPAjzzTmKQlJUZm0SbmZhPKP7tuQ1SsEw==", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "chalk": "^4.1.1", "fs-extra": "^9.0.1", @@ -2732,6 +2740,7 @@ "integrity": "sha512-yl43JD/86CIj3Mz5mvvLJqAOfIup7ncxfJ0Btnl0/v5TouVUyeEdcpknfgc+yMevS/48oH9WAkkw93m7otLb/A==", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "@inquirer/checkbox": "^3.0.1", "@inquirer/confirm": "^4.0.1", @@ -3207,6 +3216,7 @@ "resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-1.26.0.tgz", "integrity": "sha512-Y5RmPncpiDtTXDbLKswIJzTqu2hyBKxTNsgKqKclDbhIgg1wgtf1fRuvxgTnRfcnxtvvgbIEcqUOzZrJ6iSReg==", "license": "MIT", + "peer": true, "dependencies": { "@hono/node-server": "^1.19.9", "ajv": "^8.17.1", @@ -6531,8 +6541,7 @@ "resolved": "https://registry.npmjs.org/@types/aria-query/-/aria-query-5.0.4.tgz", "integrity": "sha512-rfT93uj5s0PRL7EzccGMs3brplhcrghnDoV26NqKhCAS1hVo+WdNsPvE/yb6ilfr5hi2MEk6d5EWJTKdxg8jVw==", "dev": true, - "license": "MIT", - "peer": true + "license": "MIT" }, "node_modules/@types/babel__core": { "version": "7.20.5", @@ -6820,6 +6829,7 @@ "integrity": "sha512-m0jEgYlYz+mDJZ2+F4v8D1AyQb+QzsNqRuI7xg1VQX/KlKS0qT9r1Mo16yo5F/MtifXFgaofIFsdFMox2SxIbQ==", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "undici-types": "~7.16.0" } @@ -6861,6 +6871,7 @@ "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.14.tgz", "integrity": "sha512-ilcTH/UniCkMdtexkoCN0bI7pMcJDvmQFPvuPvmEaYA/NSfFTAgdUSLAoVjaRJm7+6PvcM+q1zYOwS4wTYMF9w==", "license": "MIT", + "peer": true, "dependencies": { "csstype": "^3.2.2" } @@ -6871,6 +6882,7 @@ "integrity": "sha512-jp2L/eY6fn+KgVVQAOqYItbF0VY/YApe5Mz2F0aykSO8gx31bYCZyvSeYxCHKvzHG5eZjc+zyaS5BrBWya2+kQ==", "devOptional": true, "license": "MIT", + "peer": true, "peerDependencies": { "@types/react": "^19.2.0" } @@ -7011,6 +7023,7 @@ "integrity": "sha512-4z2nCSBfVIMnbuu8uinj+f0o4qOeggYJLbjpPHka3KH1om7e+H9yLKTYgksTaHcGco+NClhhY2vyO3HsMH1RGw==", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "@typescript-eslint/scope-manager": "8.55.0", "@typescript-eslint/types": "8.55.0", @@ -7396,6 +7409,7 @@ "integrity": "sha512-CGJ25bc8fRi8Lod/3GHSvXRKi7nBo3kxh0ApW4yCjmrWmRmlT53B5E08XRSZRliygG0aVNxLrBEqPYdz/KcCtQ==", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "@vitest/utils": "4.0.18", "fflate": "^0.8.2", @@ -7644,6 +7658,7 @@ "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==", "dev": true, "license": "MIT", + "peer": true, "bin": { "acorn": "bin/acorn" }, @@ -7716,6 +7731,7 @@ "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz", "integrity": "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==", "license": "MIT", + "peer": true, "dependencies": { "fast-deep-equal": "^3.1.3", "fast-uri": "^3.0.1", @@ -8256,6 +8272,7 @@ } ], "license": "MIT", + "peer": true, "dependencies": { "baseline-browser-mapping": "^2.9.0", "caniuse-lite": "^1.0.30001759", @@ -9558,8 +9575,7 @@ "resolved": "https://registry.npmjs.org/dom-accessibility-api/-/dom-accessibility-api-0.5.16.tgz", "integrity": "sha512-X7BJ2yElsnOJ30pZF4uIIDfBEVgF4XEBxL9Bxhy6dnrm5hkzqmsWHGTiHqRiITNhMyFLyAiWndIJP7Z1NTteDg==", "dev": true, - "license": "MIT", - "peer": true + "license": "MIT" }, "node_modules/dom-helpers": { "version": "5.2.1", @@ -9617,6 +9633,7 @@ "dev": true, "hasInstallScript": true, "license": "MIT", + "peer": true, "dependencies": { "@electron/get": "^2.0.0", "@types/node": "^24.9.0", @@ -10624,6 +10641,7 @@ "integrity": "sha512-LEyamqS7W5HB3ujJyvi0HQK/dtVINZvd5mAAp9eT5S/ujByGjiZLCzPcHVzuXbpJDJF/cxwHlfceVUDZ2lnSTw==", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "@eslint-community/eslint-utils": "^4.8.0", "@eslint-community/regexpp": "^4.12.1", @@ -11107,6 +11125,7 @@ "resolved": "https://registry.npmjs.org/express/-/express-5.2.1.tgz", "integrity": "sha512-hIS4idWWai69NezIdRt2xFVofaF4j+6INOpJlVOLDO8zXGpUVEVzIYk12UUi2JzjEzWL3IOAxcTubgz9Po0yXw==", "license": "MIT", + "peer": true, "dependencies": { "accepts": "^2.0.0", "body-parser": "^2.2.1", @@ -12336,10 +12355,11 @@ "license": "MIT" }, "node_modules/hono": { - "version": "4.11.9", - "resolved": "https://registry.npmjs.org/hono/-/hono-4.11.9.tgz", - "integrity": "sha512-Eaw2YTGM6WOxA6CXbckaEvslr2Ne4NFsKrvc0v97JD5awbmeBLO5w9Ho9L9kmKonrwF9RJlW6BxT1PVv/agBHQ==", + "version": "4.12.0", + "resolved": "https://registry.npmjs.org/hono/-/hono-4.12.0.tgz", + "integrity": "sha512-NekXntS5M94pUfiVZ8oXXK/kkri+5WpX2/Ik+LVsl+uvw+soj4roXIsPqO+XsWrAw20mOzaXOZf3Q7PfB9A/IA==", "license": "MIT", + "peer": true, "engines": { "node": ">=16.9.0" } @@ -13396,6 +13416,7 @@ "integrity": "sha512-KDYJgZ6T2TKdU8yBfYueq5EPG/EylMsBvCaenWMJb2OXmjgczzwveRCoJ+Hgj1lXPDyasvrgneSn4GBuR1hYyA==", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "@acemir/cssom": "^0.9.31", "@asamuzakjp/dom-selector": "^6.7.6", @@ -14638,7 +14659,6 @@ "integrity": "sha512-h5bgJWpxJNswbU7qCrV0tIKQCaS3blPDrqKWx+QxzuzL1zGUzij9XCWLrSLsJPu5t+eWA/ycetzYAO5IOMcWAQ==", "dev": true, "license": "MIT", - "peer": true, "bin": { "lz-string": "bin/bin.js" } @@ -14659,6 +14679,7 @@ "integrity": "sha512-E3ZJh4J3S9KfwdjZhe2afj6R9lGIN5Pher1pF39UGrXRqq/VDaGVIGN13BjHd2u8B61hArAGOnso7nBOouW3TQ==", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "@babel/parser": "^7.29.0", "@babel/types": "^7.29.0", @@ -17034,6 +17055,7 @@ } ], "license": "MIT", + "peer": true, "dependencies": { "nanoid": "^3.3.11", "picocolors": "^1.1.1", @@ -17135,7 +17157,6 @@ "integrity": "sha512-Qb1gy5OrP5+zDf2Bvnzdl3jsTf1qXVMazbvCoKhtKqVs4/YK4ozX4gKQJJVyNe+cajNPn0KoC0MC3FUmaHWEmQ==", "dev": true, "license": "MIT", - "peer": true, "dependencies": { "ansi-regex": "^5.0.1", "ansi-styles": "^5.0.0", @@ -17151,7 +17172,6 @@ "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==", "dev": true, "license": "MIT", - "peer": true, "engines": { "node": ">=10" }, @@ -17507,6 +17527,7 @@ "resolved": "https://registry.npmjs.org/react/-/react-19.2.4.tgz", "integrity": "sha512-9nfp2hYpCwOjAN+8TZFGhtWEwgvWHXqESH8qT89AT/lWklpLON22Lc8pEtnpsZz7VmawabSU0gCjnj8aC0euHQ==", "license": "MIT", + "peer": true, "engines": { "node": ">=0.10.0" } @@ -17516,6 +17537,7 @@ "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.2.4.tgz", "integrity": "sha512-AXJdLo8kgMbimY95O2aKQqsz2iWi9jMgKJhRBAxECE4IFxfcazB2LmzloIoibJI3C12IlY20+KFaLv+71bUJeQ==", "license": "MIT", + "peer": true, "dependencies": { "scheduler": "^0.27.0" }, @@ -17537,8 +17559,7 @@ "resolved": "https://registry.npmjs.org/react-is/-/react-is-17.0.2.tgz", "integrity": "sha512-w2GsyukL62IJnlaff/nRegPQR94C/XXamvMWmSHRJ4y7Ts/4ocGRmTHvOs8PSE6pB3dWOrD/nueuU5sduBsQ4w==", "dev": true, - "license": "MIT", - "peer": true + "license": "MIT" }, "node_modules/react-markdown": { "version": "10.1.0", @@ -19455,7 +19476,8 @@ "version": "4.1.18", "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-4.1.18.tgz", "integrity": "sha512-4+Z+0yiYyEtUVCScyfHCxOYP06L5Ne+JiHhY2IjR2KWMIWhJOYZKLSGZaP5HkZ8+bY0cxfzwDE5uOmzFXyIwxw==", - "license": "MIT" + "license": "MIT", + "peer": true }, "node_modules/tailwindcss-animate": { "version": "1.0.7", @@ -19986,6 +20008,7 @@ "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==", "dev": true, "license": "Apache-2.0", + "peer": true, "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" @@ -20410,6 +20433,7 @@ "integrity": "sha512-w+N7Hifpc3gRjZ63vYBXA56dvvRlNWRczTdmCBBa+CotUzAPf5b7YMdMR/8CQoeYE5LX3W4wj6RYTgonm1b9DA==", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "esbuild": "^0.27.0", "fdir": "^6.5.0", @@ -20500,6 +20524,7 @@ "integrity": "sha512-hOQuK7h0FGKgBAas7v0mSAsnvrIgAvWmRFjmzpJ7SwFHH3g1k2u37JtYwOwmEKhK6ZO3v9ggDBBm0La1LCK4uQ==", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "@vitest/expect": "4.0.18", "@vitest/mocker": "4.0.18", @@ -21148,6 +21173,7 @@ "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz", "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==", "license": "MIT", + "peer": true, "funding": { "url": "https://github.com/sponsors/colinhacks" } From 38684edb707101acb13f29f9bd2d343a0d6117bd Mon Sep 17 00:00:00 2001 From: Michael Neale Date: Fri, 20 Feb 2026 10:31:52 +1100 Subject: [PATCH 11/21] fix: stderr noise (#7346) --- crates/goose-cli/src/session/output.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/crates/goose-cli/src/session/output.rs b/crates/goose-cli/src/session/output.rs index 28ccd1677e..8a73bf4d93 100644 --- a/crates/goose-cli/src/session/output.rs +++ b/crates/goose-cli/src/session/output.rs @@ -261,7 +261,7 @@ pub fn render_message(message: &Message, debug: bool) { } } _ => { - println!("WARNING: Message content type could not be rendered"); + eprintln!("WARNING: Message content type could not be rendered"); } } } @@ -349,7 +349,7 @@ pub fn render_message_streaming( } _ => { flush_markdown_buffer(buffer, theme); - println!("WARNING: Message content type could not be rendered"); + eprintln!("WARNING: Message content type could not be rendered"); } } } From ec89e62c4de765cf1f4872cc9fba1e288dfa99e3 Mon Sep 17 00:00:00 2001 From: dianed-square <73617011+dianed-square@users.noreply.github.com> Date: Thu, 19 Feb 2026 17:32:26 -0800 Subject: [PATCH 12/21] docs: search conversation history (#7370) --- .../guides/sessions/session-management.md | 25 +++++-------------- 1 file changed, 6 insertions(+), 19 deletions(-) diff --git a/documentation/docs/guides/sessions/session-management.md b/documentation/docs/guides/sessions/session-management.md index 701a690cec..d5d112615a 100644 --- a/documentation/docs/guides/sessions/session-management.md +++ b/documentation/docs/guides/sessions/session-management.md @@ -182,35 +182,22 @@ Search allows you to find specific content within sessions or find specific sess 2. Enter your search term 3. Use shortcuts and search bar buttons to navigate the results - #### Search For Session By Name or Path + #### Search Across Sessions - To search all your sessions by name or working directory path: + To search conversation history across all your sessions: 1. Click the button in the top-left to open the sidebar 2. Click `View All` at the bottom of the `Chat` section - 3. Use `Cmd+F` to open the search bar + 3. Use `Cmd+F` (or `Ctrl+F`) to open the search bar 4. Enter your search term 5. Use keyboard shortcuts and search bar buttons to navigate the results (`Cmd+E` not supported) - This is a metadata-only search. It doesn't search conversation content. Note that searching by session ID (e.g. `20251108_1`) is supported, but this property isn't displayed in the UI. - - :::tip - You can [rename sessions](#name-session) to give them descriptive names that you'll remember later. - ::: - - #### Search Across All Session Content - - To search conversation content across all your sessions, ask goose directly in any chat session. For example: + This searches the content of messages in your conversations. The search is limited to the 10 most recent matching messages across sessions. If your search term appears in many messages, the search will only return a subset of sessions. + :::tip Ask goose directly + You can also use the built-in [Chat Recall extension](/docs/mcp/chatrecall-mcp) to ask goose to search your conversation history: - "Find my earlier conversation about React hooks from last week" - "Show me sessions where I worked on database migrations" - - goose will search your session history and show relevant conversations with context from matching sessions. - - :::info - This functionality requires the built-in [Chatrecall extension](/docs/mcp/chatrecall-mcp) to be enabled. You can enable it manually or, if [Extension Manager](/docs/mcp/extension-manager-mcp) is enabled, simply ask goose to use it: - - - "Use chatrecall to find the latest status of the database migration project" ::: From dd3fd25a650d9d70423040d1565da93528e9af19 Mon Sep 17 00:00:00 2001 From: dianed-square <73617011+dianed-square@users.noreply.github.com> Date: Thu, 19 Feb 2026 17:32:41 -0800 Subject: [PATCH 13/21] docs: type-to-search goose configure lists (#7371) --- documentation/docs/getting-started/providers.md | 4 ++-- documentation/docs/guides/goose-cli-commands.md | 4 ++++ 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/documentation/docs/getting-started/providers.md b/documentation/docs/getting-started/providers.md index 6af9286822..97c448f22d 100644 --- a/documentation/docs/getting-started/providers.md +++ b/documentation/docs/getting-started/providers.md @@ -168,7 +168,7 @@ To configure your chosen provider, see available options, or select a model, vis │ ○ goose Settings └ ``` - 3. Choose a model provider and press `Enter`. Use the arrow keys (↑/↓) to move through the options. + 3. Choose a model provider and press `Enter`. Use the arrow keys (↑/↓) to move through the options, or start typing to filter the list. ``` ┌ goose-configure @@ -526,7 +526,7 @@ Custom providers must use OpenAI, Anthropic, or Ollama compatible API formats. T └ ``` - 3. Select the custom provider you want to update and press `Enter`. Use the arrow keys (↑/↓) to move through the options. + 3. Select the custom provider you want to update and press `Enter`. Use the arrow keys (↑/↓) to move through the options, or start typing to filter the list. ```sh ┌ goose-configure diff --git a/documentation/docs/guides/goose-cli-commands.md b/documentation/docs/guides/goose-cli-commands.md index c893a75278..50d026632c 100644 --- a/documentation/docs/guides/goose-cli-commands.md +++ b/documentation/docs/guides/goose-cli-commands.md @@ -45,6 +45,10 @@ Configure goose settings - providers, extensions, etc. goose configure ``` +:::tip Type to Filter +When selecting from menus in `goose configure`, start typing to filter options in real-time. This works for lists of providers, extensions, and tools. +::: + --- #### info [options] From cf0af380daa2e564316d379c084feb44e44d4b8f Mon Sep 17 00:00:00 2001 From: Rizel Scarlett Date: Thu, 19 Feb 2026 20:33:41 -0500 Subject: [PATCH 14/21] Add blog post: Gastown Explained: How to Use Goosetown for Parallel Agentic Engineering (#7372) Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> --- .../goosetown.png | Bin 0 -> 1403573 bytes .../index.md | 120 ++++++++++++++++++ 2 files changed, 120 insertions(+) create mode 100644 documentation/blog/2026-02-19-gastown-explained-goosetown/goosetown.png create mode 100644 documentation/blog/2026-02-19-gastown-explained-goosetown/index.md diff --git a/documentation/blog/2026-02-19-gastown-explained-goosetown/goosetown.png b/documentation/blog/2026-02-19-gastown-explained-goosetown/goosetown.png new file mode 100644 index 0000000000000000000000000000000000000000..c4f8ec33fee770714e94938f8ff3f4d38c65f8cd GIT binary patch literal 1403573 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 z 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�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∈RSs#-~HfmiE&L4S7s=;e#&0{HNJ)eq(Rc1r-EbL705MA0PT z+LlB6^5(V}wyR}dV6*QJ!=PZ!IUky~ZQG^^A+&Ad_#P8U$(zmEQfeKsiuWXjMa4Ja z?EIbp?S~<>GsmuveSg^3q6;)(gvypM5CJ#@N7fL`Ti-?|o3yx~y$?8vyjdw@uqLZB5K0 zM70{_h{m3Skr^r!6$5a<2INvvCKS*j07NDrNjhd?7>k){&XTj3DWf825osHzA~{Pg z5@XpN1~i_yK+UxQoNKV5Cu*ESK{P@|ATw)x)3mKXjlV;)sdC%Qkl92Ov=(W>G1(l6 zY6(IWVdqK9&Q<(a!x#aK5gl>86^$SuGz1Q5)iDAdG&UY*T~mswj2Tf87{N0E5NRnn z+Bi5Z^?IlPA0gD}J_I3<#jNSt0FvXP0cVfSn{Ih>eljP5PcAoVBAw4U?1u5#moMLc z=gF*VJVQxC9D6CH@9pQmeD>`5t8aYgH=exrE6C1(YWPL9W-?XS6Dj~&y-cD4Y7W6b zL90`*=CA<~9;;%fJZ>h0dZ*cO1)%D61T`sA#l};#;E}ojM{EEUT$oaACP4?93K%d} zvk)lMl7iZ~ST|a$6K>aZi?)G@h^T*5#bQpI_2&BKX1m>8T-t;aqD5lKbOfT#wU zRtBRANpyk^t2`BmYx#$oYBg@5V66|H%#W(2+B1MaN-`kY+iC~)SeuOn) zlCeq^rjg)D#AUTXOQtHf9Y+2xW2z&j4i z#JE~?yL~^Vymi`;y}ld2yu5q-<>m7JId`TxZtgaB*Vkh#MDFQ(?>22Pa0O}>Bpe;h zM@0MhL=8i)CA*1|10xuQL)Pqrw;|RSs10=b@bu#1e0l%r$%BVP43$Exk+`PQ^n+9i z{Ops@KmO#4q;f*lOO!qKl&&C(7=B3qaU;5 z2ag`GbL6J(LNfrAiaZdp5oFC$#8gyNwbTR|&yE;G6j@0TYgOr_^|uPEr~(0+VvePx zT+b!n1m_(RqM?e4iX%j@Izp6YbFgq|@-McsIe1G$DfBSNC{qmEK zKXReF_vq>AgU7C2QfPg*YUV3opNnP@M5be&5-Ajszx6lT#OBnI+e{6N5rHgc0TlqU zW3@<)a((>P{onen@BZMA|J})I@jKuDk9?|#0J?zeK}A%IY8aQH7BJ1<{KnJ&;eY&Z z|Hc3OzujEkJbZ9+e-@UUPaBGR_{Hr`CBOa7#eeeqztSyNZR<&O81vn_e}4J;m!DsK z{xa=FM}ugf2!U}ib7!ZE^OMDDIcq{=U|LGf`EI>QJuYWm*Mz(6=H=DRlP3?~d-w4V ze|Z)6DM7CR5Rg0)b171PsETClIry$^nJ~r}hoPjD#Ex+_HWd)5As`cIfw#`WfAgRJ z#;q`E^@w(IN7 z>zAs@6k<-VZ|?5y)f$ zZX07Ff_dlJ2P77=n&Gcgn3fSCGX#&0FvSR>T}$)E&AK2`hGBFJi}~C;S4tu@*90Jz z`bDyh!_W`8r~*O=&O7HrmlcP7e>e;&3$vw?Q%PckNCxVhQ_)le2pO3v5DFnW=MXTC zgCR&MX&k$zX}uG&wxN=^Yk1kY(|NGcsN|+;R`W0m*mxGPl+Am5aIyUMx8M8L_kQi{ z>+j=iZl;){jR)J@j#sZw7Kp<+>kib4amZR!fBxC>h=Mg}t=MIwmIc0Z~zr zqFMq|W-&~n1uPc%{OV>jx4Qr6_2xR`?reFwa7~J1EEx+J`IJ=I`=;H;(U51WlhI&( zIP@vI(4NdgXxp~wm|cY-wa7TeLw|^4Pf`}aIjE+Hpny|nAiG&ND{6flQ!c6+yq_A{ zOihcKkaLJkOb*S11;j<5RTrB23v!+rk&ux@G>Zjd0uL0&RSY6T+^KNL+po=cM$_~SkAxm{?oJNY_mJe zmnZClAQO@qAWcqs10bCI+4QEX5D^&PNU0F?=$T=I+H_WJnw54ME zW)Ie*7ZI6UWpfbTm>_G$VAXE`PIq>FutCkFLar#2@o$Q`Fh^uXO|^hdEf%I`3TEUO zkY2uez1{7ezWwyUg9~C#sT^hXpsK0`Ny!mf?Lc`GIEtofXj~^(nkYj;0D@^rn@~fL zlE{$(-Q8U~a;Imf75}e`Y&B=rjaStWNzBMl!JsNe%>YU3qK$}Vr4}1c0oOogh$KY` zD~w!W=?Up5qNY*@elt;^F-iTkRM$fF1Pa=;UJ_&dZB70#tr|D)xe1<-QyfGmZ=_Ws zQ3T9HRaB)|{hBt_Mj@e!3Rs<^vCdJ5h`Aj01EBLwH`y-%fY6Am(yYFHF{Rth?(*{G zvoF7T@$%}>53%Ha7>0fruoTt541*lj~QQz_#x)HDd^yvQU@u3AZ`xYVRN)%|YG0Fuk3Kvf;bNbEy5 zkJpIrU$A5VN~^1^!(M$5C7(8esOZ%;y%7~%sIxI2wy{5 zy(dDuxPSH^|K4x^(f{@5|Hr@jqyO|D{6T2=>cxxYayDBoOpJ&TtcC~bB-K`4X-}Q!ux2M+S3P5 zAHDtl$-_r&H&bGr6ygem?x@WM1T}O_$D^=1!?cp`gj1NR85m(ziPwzQ4?cMJ`uh4W z|NKu+&llhR&2IuE^mW=4W>C=*g%RpIB?ZQ9{IzdC{pbJeAN=qC>%Yolwvu)18_vJ| z8}}bPdh6T2`tHTWxo58cVgi7Mm=%XnE?=!b{Q0vV{`iZ}UTu?=#cF=<{Pb)!58f5A zaZERxyY1mH^kYedOfOEt2X8-WnueXfzB{Zpy9W>NfAIFbum0xBO2#ntf2b&ciik)l zs>B?cCbR(%0uca`^Hok-ebgc%IhQP23Y$H-=>F+{_Upg?!Q*G2e)^-o`Sj=cmhg*CK%AEVVfWtZh2yLzOc)=EZz=`QpXhdOwWg{fm2H zXpqo1o%ewdRPs0uD!B_y@R-t&#_SN0fEkgUuXPiMjKpY;T)|XIah?#c6j3DtGJsN) zOLpS56v_#Buz{^59rGshHj5|P7U-#FJafeBL_#-TS=$4uVkk^@55c*6O9x8H4UiS}Ck zc4_d=1?N;G7u8aRu^)#a#*|YwQ;NlV*Lrr|d9G*xAW@9EzT11y-GfaYBM}4D)w~|H zRl8Ah7Il*SOt>AW0hl6Fl|of`2$71&_3c&c_edPGT;Fc@`=RMpE_jJC0qtVh^m&LN z2FW6VNU<2p&3Z>g7lFboD8hEXLn&RuO;bBClPD9CA(kQr$o0lGZI}v!CtJ;$z_6N! z#?$}D)O&u}m0a1K$3(<6&!hzswt%u^(RMdQHCt>WX{~Ws*2c+S=arz?uIN%j@5E96*V<(4zoR0U+tRb8Dtxcl)Bzw_`r->#02AvjAJhK&uk zdUG+Jo}E2^_2Su^)h2EgzIkkTHEYbHLuE#a%A~u2IY9;>GSv_&16Cc; zh>;bnsl#Hq^i^#@W6C*878S5&KEMAc%r~3so14{oowL>LEYwXmj{UYX~T?r`E1^<+UuL^+uPeA#^3`N-8z+!pvmvX&N~;1w*yU`sHtg@ z4vIh)O9?FXp*+=x`wxvg-r%Xh+-BEz^1^^ z^0ta%(Y2N$LlmI2?nnTR&{0V|H|MYlb?rH8Du(==bIKXa*nmq~0jcGw5Z6hNJ7rZ6 z?Fi>Zn+yn$hQ2o-Ge-zzH)#{^3q@_c-hB1-^Dmx#^Wx>3tJ_sKjAoiu%HLlu=CfJr z9nEL+VT|j|8V%XeYQ1qjIOlQ}af*P`?G2=6&U;gfNswq9Q%;g4NzP#Ay?5T#b<=uA zBIlg|-+z|B-Uwr-L*Qf2#y}Ai|drMP|Q+9|L$MNTpKRn**Is+PsF zifSCj*!OW5Q_O|95PYyKI>u1>qO%1sO&NCvC{-~*$qI@)*(<`NV>d~X#hB353lEm! zz|HF5V2^YJ$uW);)9Lx???3`fE5?eZqf)w%!*iy9_-wo{OAYWu>JKX|NQXD;r_jaL7I%&qNwH_ShAE-?vo_Q zQPZ}1a_`{b{iD+tXE95XeCKHI-#>T&RIR)1SO4<`h?3QyD3Jh=?0DN9FPo;VyKeLP^y2v5-5-4C zz2CpMdAU_0GXez@%_2F+D3Sru*TH*7>)X>+?vaS7_Hc5%H;m(pm!~3fw7<8%oO_3+l1)L4n5(L;>RNYk zI-#nN1Cf9A=H+_ZnQ0a3*<#LsrXq33q69W;8)lXqV~hmA-a(0&0`m+dLRFxotJ_<} zFlxC*)DfDfim8CAktv8^9syaADG;$IN03Tz0+t+M1QwNIF+nmH zs)ptZAg3{dG6kfl&S4E$1vi@?AMWiF*s$F!7E2^MJv}qcj@VRkQq57b^NyQP?LRo_ z$MO31b{ON)!O?uVx8AHR4dfk|q&R9$U;>~x>FGdK4Bg&x&oTGih6$?Ro5oijnH>|C zg9IltX)z#{^vbt>j|p~AhT1z*3>6!Fa*%!&4G<(zB4!2<%{fZWRj32|a!PY?ksvrGr9!7R&)7Cq9bBp$Xz(ZHQXw`&z3q}3F4_u!vS?0OGz(BBiV9=aQB;9lRXZO5?Q9zl+%mL>*WKoJHO{K4 zX(}QFk3bYf`;@YUF>4|>-(UJ>4$fz>m{QJJbB-x>UDtJ8j1gecBLt>-TQA$DTd#6T zDN8@bl(MR35d&cFm{?VFj;7)r*TIvoOxRQ%p+_K7kmSKP-gySk<_H{`BLhSc%P|fy zb$#rI=ycq#Jha4wk`m;BvU>D{OvRQIHK~}0^L2rEDIzdA@166efQ;U`oCOJI%{+^e z>wHzs_x5hroAqYn*dy`vYP;HW-g`AmXa!BAC|XJ$q->-#}4SD`*SJZ_q1 zz1@ssl$4~1j2H=#*%6YO=9~e*JJ+^NTU9P+DU~x5DS{=9V1cOQ!cGkmnya{}8bTb$ zq-KB)33ARR1uu+X5VOXl<0w(Ik6DvgfQrc!R(-$f`dMA4tRYN#Gnmd+gPjX&w_YTe zj&GY>3FT|bp$L$teHvJ)f|*TCB$q^J++k52b6^XM!J#TTB4%>MCa(%54hs!UP?Z3J zX9CZOn8`WcHucsv3|fAJ378nDNG@S>NW_kPkSxG zRq&2IvnV;HI#8fWgC7iq*^~s{+5utLl9i&89E!eQ007MGaySYUhtv=e z$_)oLjN38sY0 z>H3JdVZ~g5wZsAXL$q zsARwxib2sV0io#>7zMVYyzLgzyZ&4?Put+K)Kvm-j5--vQOvro|KiJMpZw<2)647i zw(rIffY@r|sXY2LG%<3xKuB0FOz2#o1WZHJN>9zpa%-S)EC<601Ca@G! z)*@^MAVTNdY}N)Jy!SqMGfS!|rA^<*RZKCBNm7a`CQ~5e1Y%(40Wqh7P$kpc$GojP zA!b5H2*3c8LB+5jc*-GyCJxP!GUV2i&FhUPz2!)&n#bjmnAm33z54nb5Fb2w`d5GblYjZ=PyYFze*PCf{kI3lhr1)Q#0)YpnSltH6)7SU zyJ?3e2+mZcJTWSz!IA949acK6J4}v0Iecf{!W*(c$&01c}eRzKT`px;PPp{v6 z`DL?Q9NfKobnpJ*g9rP^cbdhXt19DNE{>V0p#c!7iUKlFHo>=N;FNFxrOYbZp~c?p zZ~o&?-@JKl)@vlqBS7BG$5f*b0LDDrthehyG7Oz<2EKDVKYw%n`r>vmt8Q-A7n_S$ zXY14R)#`R&wE4`nH8E)wcsXzO_U56fhIC=BesXf$)bIVnFF*U^vsc@sSxhEB8d9l) z5dmQsWxeSRW>sB>G}7tm)x*oH$B*v);9CzbfBE$oM__NrDM?H*#|WS<1Y$-eopc{y z0M7d=1V&U-0U5gJWxTWJK7M-VN8f$C*ZQwM|NIYMy!qn!=4`DPs_%U8jzb)7PM5QA zbA5Atv-aNYA1r2V%|y%`*dvm2-g#Ht(FovuCNj`ZCf859hfQZy1|_^p!6Wq*sshS%NQB~CVEP-X@DT0 zp-#$~-Ix$TMGAnsTo+}RI57lD&oZ6MlWCC*6#+m63~;CRff8%03JB=fcJfyPutM-d zLMED!az*L`mUVl(Ie&Bh^7+~G=V!x^)L_$%n@v9rwXl>9&VaLG21|lNmkecyc^qXF zNm+?#xu}=(`GW`dnyR|GI7{7XZ&B~<@7KW%LnOj9Ce`d6ftlnqYr~VLkC)5k#nsit z)#b_EyLazBeE#Ca%jeGt(GljxXQ^|_+kWW#F2;xej%m4Q-hKMGZJW>k_*opr;Mg;J zht6}|)NVI#diw&Go2%TJglMK_TJB#nASxb2DzhiRDa|g-W_RvByt!HR+kWrxxL(-j zU%l#A+c{TBY>YXpGLx@KmAtQjc=gA>=(hG_j3(rDXNzPT7L&-%;D?dA3P>D9|`Zf;k3 zNH&NLT{Ipz)Y-b6#n>YOJ44nn+ptZmtc~}Gn1qsOQWdid)Mt%q#8jhet65WqN5QLi z?Ao#K6mZN1(xGMsNI*??BB1STK40z|xiMuKMuS`y5~^09uQ;irkO?a9+PbRiDh@8E zlts5PmVqU^VsXMD#u!J*$x+FP&UL6fBQg;HnX(##HV#{l6#=O*kVn#-#+1f!Oeqt& z{k{2vhxhBYxxBi$zP=@dIP~4NODTg!B(_Y*tmZ`WFpeBXWRD6t#bHdffwePa1To3d zcN;)HIzADAZ8wM}Vz;-qKbtQBpswrv!-MB9Uv0MAP*;vQ#x%qZu^;FGa$y4`o7=x{TO4O&s<3+BHVFFRGER838+9o z#0*i}X116wyX~qUBXe=Qpn_#Bi#|lanDJ)Q4^bpbKV(n^%!I)dWk{Fnt&ubGz+`0| zg=Qv2UtW%E+mSiIEO>sqoY^HlO!fLSM}ytmuILX`L^D7rZ6p&Cs%LWL2qEN>u4R^D zDyLQDy+c3~Fawa3qLUbin!29Nn&ZR0S?x3p5)*@vW|ah*%}`AXu--XGj*wv1`29t* zY{IPeew)1K9C3^hh(ZX=fcl$E1F2@)>){Gu8yH%8e50u!mIps5-omfS)lP%yMY04?8A`FD$Xt-wVm zRv;6W`%G+7W-0>clr>LW5d3y^yVfkrgCj%~ozOYu<}2T6QEW2dq&Ic|8Dq|x)HzqO zq=>LYGk~GQH1umQSuR=xV6digO@Kh=U95-~%et=TMf?e7>rGy7$8DecC>fmq6HV9g zv|6-Xwq$worbnwZ!evwp1XI>6Gf#gAMvUbdaEy+LkVGWKs9H8MrSP7>LrRS<0ztT4GKq8&cJ_ zsy5$SX0Xk+XM>bw7`Cd4Sjro8AyieU>#C4-RV9h`+b*wiPAO^5q9w9PO6cVDvX?P2 zB4Tjd)U_(CbxVj<@Ix4BnJjf3In(F{Rb@b*O^o zG^^X@aG^1E-S*YXm!2Jn#W>u#^I#mu^?F@)&PYVWOzes_#WO0$QL}0Y9u&beiC(X} zAzNr>W1lpdV|MI4ql&CIt3Hi22svKt?V-g_KKb1@-<<#8&wlvlfBxg&{N{I`{Nh)8 z2a9`;A4!J7&chN`1f}ycX0>e0Q$ZWrU%s2|PFZkG>T`efI44 zx2rcZPPL=GIX}KXPn-UF9U+@u_vhE=XJ33q&8*!&KDz(l%0_toYKKSSzgTZ1Cc}Qa?l0sk?Djmnw&28>e9`mpo z`aY+`qf}4dy)&lq)y?Y7b@$DytBXzCYy}M--Jk#9JCELfdeYQ>eSP!#)vL?%t8pCe z+&Ne-7wfLOc=?r^9X@?WXM`^{Z&kNhAjss=%PR-)!=BwIq4+ zbpPY`?mfJ-XKDE3XWu+~arMn2;Jb-5bHSU1gbId5mJ z51z0DNEB`)h=`eaUx&Iz=a}7thxdr-)tfh~)%y14CdKsf)vKmm)NNH3UZNr?GjrWE z%!CMFH7&-@JNdsGooS#bPm^Et)Ej0{-h6U$QoF8j`+kNx(qCXeS)8NpDfcYLf)2(7wv$ zRoWIno9YrXBGR{rtFj3zyHTAcyl+=v)6K3Eju^QBqInX`6q6+GN*~@uTv(Cx=*{Kz z*I#_|;@RudH#Zkon_(eHsNxXsxIM9ON}a?TlCpLZ3wgVrX7ZjfsVzKmYyjKcBVppZ@h<-L9{H z`H%nY&i#9b`*Y2smJyv<7Km9=Rs~Yy%iGQATcWPO`g*V~JW{^F{;xxG1Gou03+Z}Jc! z2^61mUU!Sd(pBxvdgE&c$jIh`VYYsh?KT&gB{Hd@7-X}o78MkTfrf0X*0{Q!&8pxK zfqZSgMgtBEYB9zvQdQM#Hp?nqH~0|9S8AY^C)Yhesi?i<#08nEj-Yl_F%g(a!ne=| z0%G>gF_VaHyJ75m1gk68R>6~jh>X1po)H<*5uj-xnAfgm@Tg!Ghnygm<70nsd3bcV zzkd*_(2x1{b`!V#=IUnAx}$l0vOGWoH5rH4k7FNWl$3#^a!RA2Lk=+JaodfHmlofr0VeKIJ6Cz#yA=fJLjD@12njQ@9xRnyKl};*XvdAfrvNTZQpIP3ZxX( z`pqVb06y`hMuHZ*QGvR3I}ci#1Q^ z*%2t1F_*y%0AO7=v-y0z-Snff0~9dO!ZDe$_{5S}A9Xu+WCVf$Kt?Q9 zXDd^#T|dVNrtEOhRth2XWF{{88DL20y*HT@A_Rbj%w;=RZUkUvGZn>M zi1cpWIVs4d-a^$xl>QYngQ{wl!O$@y01~hv1ByZMe3sXz*b)gz8Iy<{5kQg(k7>(fY&Rt@!I@uHr0Ei3>#HP0h z4G73U$rusQ1L8Qwam*oj?|m^DfI*DodUJDoebF{y)?gfl%CWaFj5b=T0%p%76-iT7 zz70-tQlI9BL2AXR2~2_ zg=CUNsh~S>+BG6i*IN-$Ln#5uTSdE98_RYNi@;ST<0Oo!cq|nvs6yp^00d_M$Vj4M zDQC(^SO_;}Mur84z&r`6O4m<>;Mh6m2#w1$W>Ti2BIGRBmlqe87u&vz*#OWvS5@_P zyUkh3ffQ4AJ~Xpt7)SP%57ihGdl#zu`uc{}+s%4=y;>8yPzN8pbD`uSs*0%s;t=E5 z5B)f#6pQn=ytd3!=7j;6B~t+aGE|(v@`O;=b<@--Wj9c$y!W9WhAfuEHbe9X!Bgek ztZACy17xSYOqZp(D=iWN)~Dj+hEiL!HmkW-AqC@D)yF(%1ba*>driGg7@ z17##Y0aD6LkRY%l2ZUI59)RM``xD&n)dMc?xRPK-hcAw$>aUwyLB_ml2eLk zQc7-`lBS<~bm8q1LIGB(p4eG>MpV?zh{k&T|OP$MyF1>SpND7 zV9S>m=PzDeygFUKzRG87_` zDv3-SF`DFfm&fX}V+cN>-#H=$jqMZn+ zOwO^}b}yg5eDT$bi}Uqr-FHJ8q9!rtoUdvhDh`zko{+>;#ux<(-Ykov^Hp89vsqQw zM7-Vh7Z>N7^?Fu$Pbe{^IG&xI->g<`J99obS8~vZ2~9;(G?lZn(=WfMymw_U@2je= zYD5;1K_xiH%vo{>et&Oy@9weWcy@N)tylf}_SWNa-Xb0h+bts?XkGbGSFj6$-eu?P z?1<$pn>IvmUx(61sahhUg0Y=mf2OLg4~~vf&TrnFee?YJFeVYY-E7xm$|AE_v#cs9 z01+2bLZ&edUSeWNm4}M4t$8+cP2-8B8#XcT9UY&%gAnsLMtk?^gYW*}d$ZZ{<8OaJ zjMq2oAO7f1qvc=y>gR{|AO6i>{y9^Y97~_81}W#1#MmSF&p&_m_y6#Z>uvI(7PVo_ z>urC#>9$=;lbgDL5KMG3VdY}gkV4&rDg+-~N;#$M$bt`xc~fp)=h#dL(K|9R$4p2r zd17DJ)%9w8{_OSGceS_ge*ejje)4CJzx`gjzd#}zJCLY-mpALQz8!9FyQ|CY>NaiT z_4&>D#p-q|U7}GT0Vq&b7{{#KS9N3Ce%lYes*%cE!bmJ89kN*xASpRdYLHYE(T6J3 zH9040V~lm%AUS3<;y{c5!8^y~Q%)%%A^T7{?_8}g*|K<-9^t^DFT;LOl?aL^fv9#A z9OXE6X;cx%OiaQ1(j0dE*!P3vSb4W->!x;r2{h*x|i3%?6HnjHBGh(ZS*S zPoA7#T;ASXGxOfPyE*6eW;2ds2*EkO-mEXKFUNj6Yv)y6#~4>REzH{4%sXZxN+nB& z0c?PA90xUHc8kTluB)!^+^h;}nxm>HG1NYI?{ZFHVxpx>G_YkdezEt8G2Rx*ykLTrB$igX6ZHnOMvbRGssHJf`&3 zi|6dz<9D8D8NCrrLR14P;axjJ+O#U!C5)RY!4#2O$WDe>e6mCyIf!u-%fK$QMm(mx z8E#{eoHL?Tgw!BALbL7ddbk~4%kcQgJNHiR#j!JqNn+7dA{fEH;y@7%O{+k)pYm)8 zkxT4103k9U6J#(ZU?v6tE>KY@I$$e#eP{*jhCqxgdAC_rLmo zB{Vf548wSRb2W~gh{hPNuP|j%64e4$FbKNTzqsnM&d%A{GaGOqFJ^0NwOL-X3J_BiFZUk z1T@bM4cM8Al!!|+Q&Z;2)j467z__&hs-{>_A8B${O*>pBcHRS6jH#e0iu02R1<5fM zs{h;4K~CstR1uWuBt<*0By6~%68MT zZa14*Acw|G#|Mkx-1;_!)>8;T?#^D*4QUg#ivqxMlhyhvoVT+t=ZpDbG3&c+eGolX zL)V$)oZ|ZSdU~zcH|JMpm#d3)ycso7h0L0Dv+Xvk8_8+W zHjAbvi3V}I?N3k7gYAFt-qTPuKl|Cw|Ng)J_n-XqNAEv(WE@fCTNUI zWqW9XV2DK&hYV&+swk2riYrle|FxHqKg@aWwiw2QsVXTRNaSHWc7^4-I# ztr|j*oVs3Wrwvmtu)jr;O^0fAHVZ+*Dj+gG!3+)5e^6pH8@ zt(?i_<3r?jD;_X0FtMD*u8+f3#$mhOT%BK7GVd!>==;3w(-1*12w|TjL(NqqOo}vX z?f?2ee(+a6`Qhco<=_4NKaKscXq(3mjz0X>dw>3yKi)q&_`Co7-@krw@dPb!#Tw%< z?zhc@gDRcL%;ST-+Q$uT)6+YP=g0Hw+iL==L)BC@$_R|14%2k3M?mXhwE*dG*bU z^Ovu0PcQn@n|$3vsQ9C&cc0wdYf(Oaa=-BiafOmoOw3rO-xnDJDQxwcFdZfz4-)XUsVc`$```ao2=K+1U$Xz?PnL((UZX@J zz~~M1;^K8bq-k*nWI;kIyb}U5BR9Dc3JuHvm=Q`!!LCI? zE*&Ef)1(*%Lo5RtLZ(R@WCa;t$bYJ$I8jxmn2oX!!{XH_TTsMlE?T}VgrdFQ2`tUb zQp){y=!et~c{8LTSrUw584NrI7nFklrz|PwoJ6L60~X8W@yWe*HU~t>d9_+!U0=O^ za|)_^?NM6?mALJkyJ2UEw4&N&x+2t`EVn2A{>n@Xs{ z(ZT+#skhsW<*{iw^<9|Le%q`?a_Z461m`@J+`mFyV47~UvK%Y&sp8ZuQ&#{W08vpS z1Vn~OYHCV|+pd59{Q0X_FITsln6j&U95h8K+mgj{-Y#d|n7VDU64R4~G&f|G#z{N2x_ZCUFX4sE$z3tZPZX7ZqI>%Zd|3qSzvQDgZ zvqBOE#47khS1%S<+wDeG$q^tpH`U6Bq?(~TV6GU!$$JODrx&Z={qc1_#Dk^#$zS}* z|MGwS`-4Y!%mgJ`$`(i6Zqjoav3qLqjN6oo7r z*WC7v-8u-*Do)={KM7J;r#yng9iumdk6FL>&-WB zt}j=EW(8#$F6MXdt~c9Z=$bn0FCOgeEzZs_R4sTPn6GbdFUO=JbzLD-j8WB^rVT#u zj1ZvfJ5g~=)zp$#Yy#@MBM$(kP*tvKYqdO%qhuifFuJ*3-`=jrBuPn70gb(5M0Uv2 ziVIcDq|i%*km>*#%p_`#71JO+!Ilx4s%o3H_ZN%#>E2?$uByOpF`FrncP1i3%sS@P zraN3Ni@am<3Sen4XeUZF+es_SI8G$nBs*XvQd0#oa-%s<9$dSQvc6uey4c4&rry91 zClMW&BmyEtOrnZ-_u%Bs+3Wx3@BaDY?|ks&(Zk9FeBU^6W-VPpy^ff^CjRA6)jYPw^-7v~-!7=ZAI zj0GlMrkureB~ZjprEe57B=W>brX#+Tm}UPeQW`B217c!A6)`X(5-S!LZlLP=zUz7s zNjcqI-ws1>mg6vteHu2noVPg%N;0%MP!<^mb!?KOq@*cbUYcawcOW(BhCq1+#=jh9@Ff0otYkgOn%5UrM5?07kn+ zuZ$%Q#EP&_02qi7m?(JPgsQ14?-`K=pf(eO(F{rY7)cdXnF*Mf9TEaU-PHZiU*FvB zFPDIDb#-M1F-saoA|iIfnCA2OK~V2a5iw^JG0QoT z#;ndc@3qMP4AevcfQXUHX9Urp_M!65z$6KlEG5mL;Fy~#%<9TBYnJu6Ld}ii<=*Vh zyz<`Vl)Q6@n)}W-A@yD5+rTgjxL3R5{f0LAW<7L(X883*1YEIy)y$h8|M8qE|zWnO_kKUaxW@a>wd9mDUXS4Oq`kkjwFD@_7 z&d+^t1*RodI(<(rz~o-Fx~UEi51M&%^7z5MhmXGe=JntH{Xaeb!?S23I^T7Dzugkp z!T#a0Z7dIC9~mX(^ybys?b#btefa3z|MZ{!*Ps9MFMjnepY)sU)A!!#H{E=1&lqfq zu%9+)4uF{fsi2C8z(5F{uLul4O;uGuq?8|!Mstp#6lK$S4#Z?8h=yRqC^~IJN{TEy z@>S)WD_L;GEQADRhz>mi5@bdYoB+Ixz(|V3Xi5O!4FKw#qewkF@kH+S`5(P(!&bsJ z5-NcaLlZ!IRm~vaYOXymTDcyM?`uXd>|J#3g=l#b&{5RkG&JVx$@X^CCuXC9n zgA-L#DZ43}6n4a9nsdxqVq}xREXI8=AV}cPudYlxA`j%EP&N{!l+D1BWIziZ8RW13 z-G_hqlRy3WFF*ay|K%4K7k%U5U{1@{ef-&1|KUIUu;|2j^|k| zj}Z_K=i&UaZv!tEGfjEuReb~Hd`GAnKVP=FhrSbb!PR!#4WE7SwGrKWaPNQn>+gU3 z(SuJueg4_kSDQX#-r{XvJW5`nLcF`AyN7%4Jvn~w@!bb^4w?Y#+skJ!FP^`;d2zNm zyNs6`-3)Ma(0upX_wOIB=W^?f7?{`-8=gt8F{KFn6VtRCIH0KMOTQ^ zjN}UbWZJoxD~xtNkV$3&IA6}pCWTJv8UYlPfXfzfs_hHFZTd0GR97eKhpCzgp#x%~ zw?VuwkOKFEl#4MuhcvSiAMst>g;J{YPP3ktYG?tXhCL9qM$+7EGLgFa);?>1^ zlR^cbfA;Xd{~!N;|IWU}9axswS-X?A?Uswp<<<53tMfNk?_Qi=UiM(Lbdi_@C>mvh zteVvNl(JD)5U{k`jK-6CG~Vvo+$Uo1h&|b;^1H6YY?X)?P=hLjz4>f5-wPqYjf0fT z5TtT-U4_ANMHrl`LO{fnQp(wT?|cx^B)RRQs+fkr1FbI#^>;$r*q3imt zs_H6K2H5v~jQ!sJY&@DA9vr?ueSf*QIygL>&ZdOWb{#Pv>>Z4o$!53Fq|D9~&aW;{ zPfw?_sduhamD|mBHk*a2LZT1?U`bnr%2%!qWCp?erV25}&2~$eXS0c8?)$dgwW&|0 zrfPlGEFcO3K%UJ=09C+{f_DHQ8j~e0;|0(xxh0VtLG!qBzC=ysrjRjcdDdtatej>!cEkij!XM8PY#*JnMA&#t!J{$zCb_I~gq zATo@KV4zvEfdG`%qJriUyXlC8(W4QlX+p~dEX8Oy98M#^!j4cJyy(T|P&{J=8Ubi( zRA_D@Wx7_NY(;g824*@S`ifo!6q$-?#2CRLT3L7+DBoBM3kAQJau7>gpDJZhF;NBb zPR&xuq6REdcttWSWEWBc9Vo0t;9Fh>is}Fu9|DU&&B_`RZo-QP*~p;N1yNxIBC>%W zV+CCefZqGYY^%HFa<$oQyRI`;Nip^vShC8C*{<)%vI9eGh*7Mh+9;aswi^J*S=x42 zc}7wIsphj=N6mC{>;2j8?fdPn1pqPuGb`M65i#q`YzXKb*0%~KHmpD(7v2vQ%O;i& zBHXBThZ%2HS0)fdj?g>u>~Pp5qw@}tx)iqUPE;5X&1A3+8f5DrGoz>)L<8{b5P^vu znV_UW&}775Hi(D+s>CVoNg~JO%B~KLkk}yuBC#QORRFAmFEJBPzEFfYN#FHIpla8P z>$cr`;?8kZ)syLzohyZvDwtW@w!5~AImMLwJ|@Yf#{j_Kxv6~Py>nz{F{LiXHi{@J zKo+^7vZ`cJ6)^SQdq+hkO#qd5v7}jIv_S=!m5pfThq~W!a1I=cUg@x*S5Kz}sZr#_rk1mq zLV*P$gO!*S03`5LU}kolQb7rr8EBzZ1DIKnW0Ykmx&lm4(BjO3oFamH3q%3S!c?_z zGzblWZ>W;QjL0Mcsy1lv;b!DSfMsir=v-~$q(?u$Gs;q>Wfu41`9-^2RScfdJ4Aw- zk-)l~CBq)mXo|;UzlnIhO5gwC+duu=_p{@F_{q;d`fvWbUqAlvQB_v}%ERnTsZ3uq z^?hPC&&cezUAlbtZo9Z<5YNdJ4n8#8r;O&tyo=C^Mh zkGp<68NYphc7ArgT&#`{=b>_=$~nTxxMns8!7~#Rn2MM(5IQ3RO}X!#wA20iu;VNK6o%c zKA6s?sqaAzaOk;^L5C3tfFmB%n^pp*%9OM01P!2kh{0~c(g}+q#)jaFva>I;W-uUf zP~r*!5ll=4wMhJLRFFu9Dw0(d3(LJM=!+SEezdKZ+g^*d(ryxMfe;Ki(8=xFw{E?A z_xfrw!O8x?YS&*}E;MC;KBY`d-Z@0r+n*oo%|}hOe|V4;zkmMXFW-ElW^Erg+ji4- zZPzDJCRG4*E>t5QTJ(J`QGGC!jAby2WDLe+pn25zpMCzx;oj`GzyHJg^CcjuNES_5 z?B)?6fMbXVT^lP;qbjt0WX7EO6myC_Gl=uC@4K$8b5n+jKXN8+9EOMk<<`nl7wiT! zSMFs(Vg!&JW0HQcIJ-PQ?fX89rrh~3n$PAOn)jENwvEn!Q3&!VP-NO!B9+GThfg2< z{lEKn_fF>B=6bul*qe=x4-ZB)ua-xX`FJ+pM-IR|-P@lU0&ysK$^ zw)^BKpa1rEzkBoc?1P7QkQ9jw2htrfw!8kjXWxDQ{qw%e4#fh4(4{oelZ)g}VUsHVNS z|NFoH<>ASm^*hsOeVaF{xL)tB7wgNb#o6NWbbWcg$wK$;A0@@>RlD5wZ5CrnKwZuv z11B2*C2QB^XxqAOTvc~{1WicHgpMe9Kt>b;HAV8ok$Z$6t&%pj&rib&{~96{~f zbkr~*B056vTonQl^?mGOv?4oqY^Ei9iiv$7W-?VrV5t*?tb(8-nLwQ*ha{@~F7Dbk zri=)|``~F@`B8A5N}UX*N@&Euj2>W8(a7Vi!^xeagMZxxaOIK*vXSx7+URoAZnJ z?+iJNCl5|$`+It|>9054wojmj3cGJmp zI+--%$<@{6)%D`wV83dbD6-wP2H4bf2>XTOTGur@KD)f!ZMNg_*gFU6y0%R@*L4E` zMQG}LnGdS-fgSrgI5*(XDg*>bgcclf?bVl6S*AX#WHBwPVO2y%O_D_osH!UV6tngs zphk!aic(YnK0(30aAv6EnjNvI39-ODoy=zxr!+#fo40xw?SpCD6cK!I-Z_B6JOeT6G)K|3rkpYmC()!tJ`fqCgk-=Th)fibgZE4T zAcTm-?1LJ$Nrg!L_-v7$zx-jB_0G|(bzHlKT$3c_C?<+%CITv`8B`paCs0OaBM^e@ z5j+7DFB<@Y5-Ou+)IwyW;=0CRhKXgX38i@?E6@c(D>;TYGfOigG)0h`wh_RFsbn!M z0;*`)C;%7_TPFhm0`nBuF(QIv5tS^NKopAcPyrorS?I$ck2C;O(DF0WjUCjqSkiBX zus{SqLZ!?G92fiuFGWKz$Ah616r`+55r!Ug(AXH5dG7#lz1y{IFQPdm05!lAGa;@v zUFDtS2sy===F_Hf*nv3EmSelwPR3R2GpRsDk`tlfEJ&YO=;6b|(RB3u`-|l&E3yKD zVj+&I6a@=vv5J`ebp{N0GcY!l!5WcNkpY3g22zWnnOF(5FhpX9H(O$`60arfsCKO0 zcTs}A)$8_K@u^9avyjCL{P_WGM>!F4Vxwb z8IMxsop+2V1Fyg;$MvWlkD59JN3`0kyH&)!8v1sBIv$Ot_wU!c?K-wQ_GoHm8oRD$ z^Nl}jCeruM->%j%8>0}sIPJ-Gu6QcTSFhs85LowZeeYsq1P!oo=tM zckA_hK0}rDa{2Q6=iY}~ckX=u&G*~&WAEU;p9Hp{_pto1b&26%_%sWE7TwSp#CoC9RaqObLLP35l4T_o_0)=M{hk z7=RM9fw>|*$RG$Mpqrqmax9e_%v3=u2;>|(haQSv44H3=OC&^Nz)~_{nd{+=7kH2s z0ss<`4>+1NdPmm2+Dqn}ZP#Xpj)Aj{M{YFoQ%8N2^)78&>5^8Ub-?KX9Z$pirM!NB z`5)h0{Q1jo{`S{D`T5^`@#x9J+1|`~1ThsQ z>&-S_UvF;R+CMzpyFH&gJf87zuN0FrrkuMzu2$RESF6jb)!F6de9@jSy5%}=do#e> zhm%hppFFyA)C5X>rzxQ-s;X+Ax|HHD^aDghH3dRqF8PZ&3lX`hCSp}FHRqhF5MdQU zAG;WP(~^#)Ovp&PP20w|mG`^0U2VHAig*0z!SOhFDh@O*6gC4jPz3=~W>bkBLkrNc@M7cZ_lC^d^l13g?DU)v8f_@4?;Y z-@Vy&OK{9sl$i>Kg-e`boXw_ReDTHOM-N{9@M5`K^w};iuV24AGoX?W+^5{fTzC)z zOMH06TZ4qe&V@2nV#3&xAC+qEet?fWF!?;jo=o}3t(=w$*!GPF#8|*L`f6%{kh%yH@1kqlb6y-CzCNSL1*==tqxkfB4AWMBhD^4{-Fr_=GM3N9zfpivSE21gDc5R8MX>wso_!+JCT1QkgsOJNc* zm?y3rm#Q~7Cg#|Kbgl!FoJ^&1iPbI&{Ji*>{ zd^DTvPsay))1!j}@BCu9eE$2d&QH&`n+>RX$0u`l`_}X)Up#nlcRC&=;>0eI&%h1{ z$R%z3v8f|egCq)QA`o*HRVEH0cpuuX-*#PH*D1^P>N<&zMvbai&rOhFVGCzBBZph`-usd!J- zC^&Me*7v&Hw2N)O>ouDoa4GI{%qfegF|!&V~Vn z*VWYqNgXhPf(e=ss3R+)Pedg!M(~6{zyw6#3=Iv@2vk83xRhKsc0CC|BFtIa$ zAu6g!0jmrY83MSeUTsJ+yivE5J(#K@DiKi`{tswx1I?&V0E3LI1YXg=L_oBd8c`4; z76m*Cnwb$ok)c8XQG*pB&hUYTGK{&o$_lI13}B!s5+Wd!01`D*MJUFz0T4G_szVYI zQjGa(v080*soD*&{h*03=_HLN#VG)TA0y7C?4Bq?0ZS~gO2MX})>-W1|MsPChH*cJ;g?Oqzme@)+roW=j8+@2UTW*Fo5dx^?K$kKK zLc^p=sA|cS$p)6YL3vyy?^_3tDai1c0JOX;MG!L-g%Er(0Rs-HUu>XIY$7HiL;pW? zhgh7gXdpQu6pacY0T~gxI&jkZ@L+#7ow&=5m`ToME9#uD>Z-14a!x_}KK0uaQ|e=E z`#z>LboBs?#b<$o!4&`r>cF#cJsUTHiNFX^)rcsIio||cMU(eFI2SdWLKQ;r6%Srp zs)C<1^>|d9Wb4#BR?Ru~hUC3#s-_@uO5>MO?31h)R|k{2u9_J04=-K;!gw?~+~2!( z_rN<)%{eDE9aX_q4SN^v9gc#3_WJ62lP$n5*}KcguvYyc_W75;`pMmUw}^SU+62d% zdIF^~7iZqzn_r#!{r$;o-n@DB`sKIJCgbtFCr{7by?g!q`}w#@8Hq>@#ITr%VW{F! zf3#B*m|7AMfwS|=%d3TmBC&T|q;RU5QuY+;%41R_agNIWH&pJ!j~ell+dQA*!Mq8zn-V$Bb&{AQX060(hQ@K@?Yf0-x%|if z>!1GgyFY*Y>62gm-7h}<;?v1|io~Fq%?0QC+^0UKHW8*OH23d6AcNPhUSD0W6^LCx z42EP_2;ZQnNG1kZrQLRQNx9_csHy>pYT@k1K9z9>0{9Tvv8kri6EP8}i1VCtY;(4+P%)@N(0o*>rUJ=1tsgKK|sx zQ4>sM=sXJJTg&AG$U{h!nhvc;aU_Y}3_5k-)7)HaMGtJ{2EYNTGT32mTyp?sC3U$B zn9$0C@TQ_Mc8oeO#D<-jN|ADuiK-1|nxW`{zcz_O5+f2!=hMBt`RV)Ra<%GuK|mrJ zPbYWp-S1*|eR+9u`}V^}kA3a0t`}c@{q44mn_U~TsU{>=vlw&EQquO23D_}__koy! z#5w1^XQVRNosR3K@{m%F8_0knKRo;1K>BT8I~D`S?3l7z5{g-}C>oU^s{k;dC~dag zW}VTDNvGq+6jDlOrx&A9bysDwH>*cAFvHEO7^depLudrlA9J|?2mujPWw%+MpT3X% z&Hz@+^{$I*hD7XqUDxyZZ2#~e<&<*T_FWbL6-4wj*Pc@{`X~yPZ9MaeO#&q#r-M zHyKsZuF~pydw#Y$Jzbq&Y_2!Eb=P*%C0uS~vDFGKLtJk9Rhzo38BoLoH41hLQ9w}y zDT*b>fjyac;nSX z3`~v&hwI_q^cP=zd~$fuwcYA^{oV7|7pK>Yt1C#|eC!_I8J`?Y_GUFfJlJpUKb}(P z5hJo95jsW(SHv2zMixW`R~fmCF1kAG9f!&I@c6K~yjZHTs)=7?%vsskfrMOzJSG!%)G$D8Z5RqNm z&f;uuJ`XOiV`jeH+^Up zvl1GqAu$q|acD+n5c7sZZK{w3iD>|N000d8wxU`1QOyCUNPW^xn|g(q%~uQ|VAUk# zHy7(xRPnfRl;FAwMwV{fK2jr9DN$^J3>g9%TSgVel39+$pvXpw#-Ip_<%!*hCCb>0 zN}fcKU7D2zgldT;gaY2w!d5c{1_sRKahUy>112Un>pNw_!nq{Eq0BV}1xX5^Os=f; z$$10FQfL&GMHPt&gh>_3?7TEKSxs-+d@3B50iiiGi^EgZK@CqdP+0(tk%DJtR<*2J zrm(|eZg~7As(>h>7gvkR#j1-^c2-)+)QT&WiE8hT4-bwH_g=ic$h|V5V;4d| zA_Ls@eZO9Jee82m(WIKQW-b3R5D$ZlA`2lx&qQF%G_I>jQ;z}%CP#z_Sv0HfqVIY! z(QLrp)uA#~kxYoe1@E}j&j3b%ecx;9Q|x2vvxs+YJQ+7t!^}*mk|pO-!}&TiA;g_; z>UuVxP95awsO{SIcJt?No_kk4xPN@-_Tgwc0bh%GRWZZHx#_4LH~y>d&#u=I5R$;v zCRZ1&qc_`4`}oP-ryqYf-=70m+HJa}4|PqB331ef+Vf_ySg)4XXP1ZjM-Lx7JbnBA ztKWa=kVchX=WJ#&>_y5)itHwNrcn0>jULeTV*ULOuNKP{5d)H>yxD93Y(AS};oqYH zVajrKaeZ+*!g+mhdj96s`@@5ilV2Radj9IGKmO^XPo8}C$IqQ0tu2wQ0 zxyqws3Ke^=K4qV@GDFl@**G}xRhwk9+x+=ozkK`h#rI!-^S8hL)xF0LLhve@Qn4n8 z^nKrMHp}bXW|g8$CiAX?4YRQ^T z4r(UnJ*xte72!Zday-72w!`>(?X6tg2UtcZS^)kga^~dx1*gJ|y zWk1SOhb=k)Qdxq*V4o>Mn(}9gML?n5?Fg~1Yx}V*D7FqPDc@5htzc+w<@ zMj~oaY&MP-STSVOy9hE{r1(1 z&z?S*G}N^hj&khQ-c_LsJ@cw{I?Azge7JY?r&fO*uhS?#=H6uDT?t6@y*MNlV68`2=DTiK0#(Z*qRN8ZcC%q<>PA&_jFuB3YC_GmNkoYrtIByv zB3Vtv6i|f;z{rpc5rNpb5X>{j*aHr7LQp|7N8}03H0G2fBjI>7nog#%-?i=5F$T}5 zj3x$(hMp-fAOQo8t6-wvJ%9P~`P<9Wjpc4qgbKC7!a`GWGbxp)w>|EPL1S8U{WMHD|7%eAIDNh_k z2o#)ncB6`I)|jd-ciWgufe<}&Rs$P?*O^F%ocEHhXM|YN?M*eA5JK?4>`Et)vpB@{ zZu{!pyNs@FdmsYRlyk~iL>vJ!!;P|0RX4ls)zx{<(L|EEydtW2DU(J>*RBo)iK*Rm*JW+Kn* zoC6UO5h4^)53al>Z&=1!YDNU21>9yo?k%wd&X;Lfxq-=`IOWU;hkKa_2*G0K*yiPzHk~+n}5PgRRuB_J0{+rP3{~YPV1L3M<7P$ zQ<5lM8)M2EMRI8g8FTqMGnxW(83X_tFj{epJBHxc0gWp^sYC6E5$f8RDw+mHhu{gb zA~8D`7@LAVd&zf#&nEKb(zbPrm;8`M2M_{>xuBFJ8PpIXOBxIX*f*Qn48Ou5Bsi4^E~Y z<-1px>vgmQv9qgXacM=K5)VhfHKAte(9i7Cc(ay0ww z!+TATcQ3wMFIT2|G;&NxltoO`5W%?+W^;r2YQ4K!Y!-`cROmBw0=+^KO9o|QV+PDP z2{fDVPoLiV;_1V^>8SEJ3a)BG?&Is1FJHfYo3e#anPEwt$vNvlOmii`M+dWj0$9pP zO~JHncLW3=q8R~lA7hH9CT2NH?Biy$SzIkt($W6t{=Jiv3X>w)xig62B;Q1-#$Ki{NV1maaN7qU+up9>iqOgdwh3ybUZ!UbGWu&e17uD zle?Si2$j6^S}M>U#~7UCwESM{>#rk`Sj^{JVr+5A%j!Xqb^J0vMv0u%i&X^X#1)H`RRappDswdbwD< zJ3Bi)JvXz{voq&iAEiqgladEDXuH^@tg1{r9*vr&w%oUU-1WVg?fO1tDSA(IR6-aC zL31`X)l4dmjLiZe7-j`gBStm=CU%t~1s`13ZQDMH8kmT=s+!IB*u+#iwUnYrPV3z` zc^mnQi>25L$>NBQ?%e`MW{O0niU1ecfcqEFa z@85>X-@X6v{=*L{U!9-7-|g19Z$WZ!kaCu2sk0cnoD&oJx^d(Jp$ECRT>WnM$HTcl z-mg!NXZ2{jzjrvE%IuA0%;&tCle=bw(M zVPgUes#4X}$De*uk0#H)dtv;#YR13*^{+nq=;K=_C-2{#_I;esrv1^;^Y4D32J2Bs zB01(H+*A}?+1W4wgvu>OH4}kpRne&Nb?xegV@|Ao@95y@&h5KTpU&^y=c=}T>qtfw z*Ph0;^Okn!r`K=aT)cjDeRjE9w<$`_s1SN^s|c;Sh;F@$ifHA4LoCHi1|#olPl}{K zQ86Vgxuw8PBzIlf#auM8fQZQ1EQ#iv&8!J7C)}-b>RT$b;F4sHN}8Ny)WjejJrhKg zoHGChhe$yI)kp>_QrS$JNlH1ZO5b)}yUVdR5d~BcQ6*+(uBs3`gSZIDWRAAkwDURz4-m_uG&rN+dK~Z;YWv`Jvn}GGTIwk;KYtFO0tCDCzFY) zwlR*)N=oGZ-d+`|w(msEJMVpHn#Of80hnXVYN8gLfT?Nr2na@?nMp*N;A-!g*t457 zp-(wWY;$txgs2qHR9skUCB(p$gRL0qj5#=F08=!LS+={jgkm`+W)!un)pFH#$y}L} zDS}$jB%zs#h?=y!-TU|NU%Yzr`uu9WXfp<=ymO4`g7;|ZLjXxk#?BK3q>^OELoE+b z1nWo?yl2F0sRRTR*h@L?#jH&^$GqNl0+4divyuVDn6s#JHBwmak|J)CJ3TwwCi&>; z<7TqAKktop>+Pm*qodwa@~j?($rQm8c*0z$V<4XWZo5k{&G+_*$c%>kL@*j|Bq^Bf zvX(6(3q~X|Q7r%(M9L10lCimL3L=gF4W2-Q#FTpKf~!6E4m8HLjZCH~ z^&>ZFoT;Brs_AG<&Zq4*_ifxR!g$0Zd-CzE?QVN@9+85oS)pfuAr}%1hzNrj87OAF zsSFUcR0e89q~)Pm(TWbvyrCrnL;xx6fdPSK%>yE)eA?9n)G;#_4HRZk$E1U*S_uKc zV#;Q!rT|ddJ|sXYUJVnGB0$2Ss3;~cC;-Qz-6aE4%O-`(iw;MXzkmDqaBq@qx9xS+ zw!5ys(IS_Us4#`maS>dV{HbAq38suj0N&y8;cQYhtHrYR*aY@O-eKjON)|*A!7>#? z1fsxXrieDKtGe>2+Vv4k5Y#hIM&t2#G^(q@JVT7ezSC-CUjY`S-OwS4jN-Phm#aBy(==<(gVcW>|S?Ok78ri;s?#?3!D zxm>PK-*38JVh5L3Q5CvQ7OU>;V)5kBy+;D%cq}w#D>!CiY7$MS_9F_SIA7n2)Nh)$}$BRsc@0aBxge<$IOlf8=)1R#|_7$ zjP%8|eY@MGz6X&ZKvfh8Oc1g#5|kKkAaq#H^np&41rQxGIyPV?&yFd0Qw0?>MFKMd zG7kP~wRv-PwGo6)Ex@#PCfWHx1Kuaww0e0hKHzNTXR|OKHIv3|^JcM%4gnAdv`gRq)&RY z**9cDs^IG;5V4r9*4y**tHt#tbM^S%@uR!9 zUY%XMdbjLT1^`Fo95zIy=LinR7441vFMj&u<453{j3U%q<%5C7+XK0m!^nsHeZlw+%;T|4IxFi8>>99-J!eeoqGavnelG^X6OJrHQt zq#9$szFxgQJKt<~2YZv-w~y}KyEU1NQB@?TRPVNa8z^?vw%GT5*LK_O7K;~MC8hl4 z&G~Y*xqJKY;_~{-FJHfWxo+4VzPdg-9RIg}{}Hjfd+#vy{kLELaQ=R^Yo+bLSL6Tq zpZ@V`z4@>I!{2}Y>CeCX{h!X>UVg=29qvuXPaY%jj~W+%n^-0+czc6F{X*1IHmax@ z4s$;P(438!v3%&P=t>5MK*1@NEq$4Wl&mOX0xN!mA;t}e%zz11hBj3RM3ey03`;!? zsw!|3ko*5Jb!JbNB-vR%i@Qg}jeB!nYOmg^7qxn3S^@?nOh^c0kpRQskr)0smIpwF z3?XC)(}JN{m=#UWOi!;>omIJ1u6K(FcR%Ow;E^@dOTJ{Ll||l&@bjJT`+YyqPbffDiR-dv9}dc6oJu(>-6U7OCsC zcwmu;$cMU}PU|YHma^`K#e4|}T|bB@60vg#z(h>s9eW1LQ7y9wnFPj)iOGpbpH$Qw zJ75Nf>_c4>IW~Y*A63+dL#Tb#468X1BfFvRBo5Q8ufFr0Z;ROG*5o(-&Nm-Dy5DuH-Sx?f`NidW z(dT3e!K!+l@NC{)E>bcNzIMbJ(11iCt3}BIfb7Xtz+?)Nbr6Ya*&r$mNk(h2;;l#p z05o=qnpTdzXC^R_+;`47W)})&!C~VlAk?0Haeg`gU=$TKL~@RieJ<&DLp2i>G<5_5 z+Q%Ud>lFLacVd#k%ri3>0niu&mV&b`&o`5C1|!1Y(Hk=%TV%+q^sAAa-K9__Tk zuqN$66PX|>7_==73eFpOHU@AEA#l^ebPB$~re)38OrWVDXTXfL9BZIY}8&Ij)piDJq*3lpKIV)Yv1 zN@fOSwbqfFBfxyV@ID+I>^tYy%Vpa%2mAY_&8V&`=UqRfEE=j%Rl#K`Rv>eLMMx$x zFw1BR##n&R=*--xa3v&d0>_DmXhSTKF@|viW)8^_hCrSf5n_%}k`Xw^-ZO%UWX-AX zdq(u$RgOIaBbwT}?+3$dPRwGAtM&TE(c=1AO$?y4LtbB9FPF=Q_a9_;d3?2WRjBJ) zL>zHJQkP~!7!!K8{7^uB<=rg7es;wvML>pu1g1V|B!lTgi4&Z1Ht z+0OIU?#^Vk_4y~CzPz|zM_b%1e5l`ka+u?=SX{R)5oS->v3XQOLl8#sqz0LR8DxHS zetms4Yu^o_F;l#)1XV3O9vfTM(af~;rk8C~Y2+oxD(VpdononB2N5ftQUlbYT_PAj zGIfYqY>3GKoO5OAWOy6AGfl&gG1C~aLoAeUL?jdxG$?)82n2?X?6wCOwD^9B2q6`7 zCm4@lvRuxnJVrJQ0An0N05C;DH=5MQ5C~mXu`I(77t5un0#MFbaxxKOvXm{WQtCS+ z1WyD?mIW$jMrzrNea6^zT}(s(SwJ(0Q%Rr+AXhnroO0KbLyZeSt)}j+w+=sAKkZfn zBHza1$L10RK`;Q75>0{PE-HyjLqi)|1V%0pXnFIZsuGNa#|FlPqDG)VNoq%q#-CZ=#3)w&J-6^2`BF(I=8kuv6TsxSr1lKP~gLWGFsh}b!>QV@se z07O0E!}|x1@9lT}bIrqL-v#DSH|TiT4YKZZl+LXVl>w-hoJ=XFFe-2c&D+z--}{Yk zZqGLU@-O}(4yjx^M^uH%%w^T$PeKzn{;(k;dash=Fqo-xuBn=)uIdnib6_^~ok}j5 z&q-VFZSMlWy6e36afn%RP8kV<4+%|y`YfxIC%IzB4zcTni0a^`jo*Fq;iHFlj*ict zy*T~rAAfZG)$@lB?(Obw-@ku1=i~yeSIe`#%j47Qo0~3Yy}63(g;W*a+zcBjT;AcPo#VVB`Kf9)k>I%^ z3=VhqCV%@kp4{BTXHTDZ>-D?uz4iVF?;kyX`qzK`lQ)O8udC3uK+KF{RFsHU^bHxA zqed`NI$niIu|!LOKtT;fRYbsyn2-sX$vYxc$+dS}`5cqxEHPk^glMRilt48Z0+QnrZ5YjzfM)0>)tm3V^RtgWdwKDt^E};Z?`&5VdrgC> z7=Qw#3^BnF_3AoZ-K4gS8{2ILza9p|T-6Q{K%}@@X2I2t*M0ipXP-R#$n_C<0bUK-M16*~((=U&H^rMfCpT9WRJNWRO2lw|kzIbtdaor^&=W8P8n874C zYn(m0fAF;@um9i&KmPdV&)7Fv@ao0Q7tgM~|NW1@`OUZg@jw0DfA%ka|4;ttPmaDi zaaBXaRn0?IfPCwdR26lBQB}aaXXiP_{*`p4l43ukoB<*BdC?7LXP1|kS1HG>&5e79 zdxv-S+IAAW1F)2gQL8X*8rQE}YW)yvNfIho)fF=@7VFc~tCy$qZ-4jG;J#R{QWtG9 zb@z8F=Wss1+1O}_-O;m?)6>hdvxO>e?QYl2)_?uOZ~fU{ejF7J2o#v_ zZ2-S4{gkY1WC2vP^!%78jR%wxB{x;Ua)JR=mGPkgL`a6Em>1A+jPIL?6iA+>m;tce zn5{a!SuBrEE-tR-%Ptxcd*?$nBssgd>Qi>)ChhEI9b?xcVpThG9ssHk3Mqz(a*k@~ zn3-J3vsccwb<@;7Fjq{dQHM38>^aw-b~f6Lc7k9jrd6L;U5sMcNYK#4GfkViBuZiw zWU4|9fL$L=Ei3ecn3#wmLd?<+Sq+@yqoWhi{54Jc5ASmokW053me*e?5q`yAHa1f$ z38$*5clQo9Hg}AxgTuSt2Q}N;*&#&9eYc)#?wBm4#7H~SnZ?Blx~-;`#>HqN36(T4 zAQR?|&1QRR=Wu^InYQE{IfuSNAj?Tri?%z??to^{w&DHv-uVxI@W;=O|K0Una(EdY$n+xYsy2_gx6kw_}%aNt<70gRRH<@ci*^w|Df+X zB5}-~UF^EAo<2Q3dV$QSIH}yM@klalLp$|tTW#-bz4rENhp#=VcelYgvy7?J^%k{qo}KVm`m=pFVw=mOd^PLnlcXxJl-&)^aglU9D4}Nl?L=`AV{ODaWi)1Q6K; zc6C&XA}MPU=(Db4?)p54_EFSE8Wfc*7ZNe4ST-&1;wCspNT5W>gu!zaymPK?>bCYF zkavV&F-1gVVnYHE9Wy)Nh;z<4i-=~)k_D|42jn6yTL_X3vLXTzX(mu%0t7V`L@||d z=YK2qFk@+Vuh<1-2Fr0s%S3q%X^vosJ-S=~n?UGm=h4}ajM3GVI#lPdn!t1u+70jl zn$}V@-v9?N1jp(eR32*w9s$UKL*N9Mdqcv$@0N?DY9O>MG37C7%Z?$NsvvXuHf~{q@7$` zT;0ESZ*yzQRn^lfRW+rgBIQwE zJcFXDMrKe{k=N}ckgaZ zt4eyE)_e^~F*y=OV^Y%O$aS&1ID4^Jt|YCws)~EGOcbsh->m4CN`OFI2q~&k4Elr! zs*bRL*tjT;rUdAi^Z5Lv@sEoLfZ2=yBx%+}Bw$uhc327(n2Xp`*!BhhAfpa zsW74eh)9W_YUv{Zy!Gjss5%@|i8zJ}Va(jBLTQRB5E{Hqe*vlqmW>aTaSi|=kIW&< zB&C_rF|#N$I|mM^^sOM!-qyy4@4vHLuE4IkzV1bR#o3V12!Y2-jGn1&CuTPE{Wt@R z`Y8ay_SWY6@4Ul^A^03K0jR11vm+JoE>vEsFjSR5Hbuy>FAzP)SOpiH52137&}`_t z!8ABOY3gdy5K|Vdnou`&-wg-|hJ$1PAoj>4K#RU##w>Aw=jV&f$=!aCH`wyCSY42s~r8@ko$$?5Tw?`$@X zImdW$v3T<2$s11|eEHcIUwr=A>uzpnGpJbs>6@01bpb?a ziTn{05vsgWSj$eD05FRwBo( z0i+NRz_LMBlEUt1aHiwuEU9WyHju{!4*-hc{^JMV_*);IozBmmUtRWs3!#)6(isDj z5rTQ-sWYM>+hUoQotzxc`wWXtFK+r!QK(&2`^qB|5Gj~7o+_?lmKUErfBy7r_i*d+ zn-8}4_kcK=Qw;1I%!8sxRs$w-=m;`oMFEqfIa@YZELLuN>fIQ}&7za(=H~vvPd|C_ z`O%`S2@xifz>c~uWdR~qlPty#ouY|uPeawzyBqbiA{mxjv+A9gCKRH{(JOmF; z!FzCEJJagzHy=Lz^4Tvwe)j0${`+5hZ?RfG`{H@G?$^uiCqMk;=Hl}A{`o)n&ENXX z|MH*z_~hjcSAm?*0HWxTvxu10Rqee?sdvQQJJW2YD%pFdqQj74%5li+u77!PeR*}W zT=mZJ-tO+b!=0V&S=)rBa>X9(7{QT9nl!Es)0`_)W#*=?h^Zf<87`OoYBJ1kVwbd? zhQqd=PO6QX7QOuJ(+kzJKEunKcy<;0q}vnvoi`4ySMopp?C0xbhr7+`@!5a+_y6(t z|J6Tv_t$>Ku~QW*-O45KZALJ| zi#}LpMI;!(*X5oglW`rWSxS1dpm7S~+Q1B?u&|0J+(cAJC37()8=5KJ+5t?B3}T;e zF6Pg_IypHxzr36upU=-O=2!FeYRE|qkwaBgN{Bc=U*0TMJKHsBE+ilmuFX>fAU!~oopTKmm114 zycZO<-Lh)R>XyhM0-!ne?bNdmCWgp6yL-q42=nW!qi0{79zT~9D`pef-kQDk`jeaM z<+Jv9YwN(*?aQ;vuZ~VHFPB4B?Qw6rdFSo79zVWAm=Ll^UM-fJ+m-XKAiKsV>S(qp z{}Fin+QYB^>bw8#PrtM53{?O3w|@BG?(T7#eBHDyn1$Wd33tCT&`F7{30S>_k9yg&^Rj(g4gTreBQ4Ug0Cg; zkYpGnsbtY;memXxk&}}2DXT@XtTtrplk`dYC@B~H8ko^LA^<{S$3T>G#thz3TXA6X zT*gCmgiY{u9jXxO5JK>tSyJk|H8Bx7?}3P!S<%F-w1R?)t4XHsn9X{fXyb(c5N~PBCMx448S#zS1zvKZ5FJH<#X2$; zE5-PYL{wK^fkcP(AU0Zx$PrcKJTicpXwD*Hxv0lx%;d)BFc~2gYA*m0h@py6X$S&H zDaD+SrT{RVPOB=g<51NpXE1Qi6|;YFW)@2wArrBd#Xlkd>G(bXQ!SS95_c;{{&L|B zKvZK&h*sgKa;r(sSxoIVmp&!{L=eF_E{Lisgkm76r_)eR42ZZAr7xd8GdsL(>ef>~rY&LpaqbID^!Nif;%(GSK2EtV;2 zG~_5DATl5@kts4-mXWnmwp@Hm9I{(0TEvt9KvZ&yDw&J* zRx^O&E!$197=kIGTIASAnp8o=4Z}cYl>(?PI|UWT=E-@64vk22j^r$NYwyNH-|qh8 z@_fFSi`iIKQJ|t=W>$b&rM9Y+7?+cQmD3><7m1ad=$9oe#Sc_|k(nWuQo$lQkJBNJ znzIog1C-S<8aOQXoRsA-BHlt|6>dNHLq9k-a)}X%$VzZ*96?2ZP!y6N5hhg@^-k45 z5j+Ap05s3^)*BCoVZa~#R87ur)_qPftE5E5r$GQ%V;Vm5DBv9jIkh1QXF1MJx{~Wf4Mh%DBRiR$ubL)ji8;q1^?koycU{-@U1y@_SBtMaZ!~^qW3swewE zoJ6x`wb&{42~{gkwZqnP+xk0u8=JE#_RHEMQ*l|7G}J-6xOxA%6DIrvz_hP z)~pSl2o+2U_SQ6mW&~wIavtjdSgL?vNO|4G#bVucaWbh64)(osASw3oX3?LXcd5%x zEqJ_%c(h1M0RwoH3_?3!r|Xq86Zhch;C-^QX_BeR+Ixe06@gJiA<8 zEY_=DRxuAEMG;p3a*oMC%qdIE(oCABX+$lAYBFt!oQT92$JrIodtZg%ykllUszcb? zoNdh}Bm!|wI;_6=hyR_tE-LOEo3w(Wzx4RUU;Q@kBt{4 zP@1z8Qv?8(=Dx9JSq;<((37i!n@sA*j~~7H_~Fg$rgnUI_@Hg4XNTK6)9UH77bmCZ zIi&1-^6DC$9vl9FIrBDv2lS%mXzwwQaKK<%vzjz@) zPro|*!$10S1pE3o-tmr9(kr|0cyKK?WF$nGwauOV-QB&-dk+r|?rs%d7on;MJIsB5 z_TuRD`SH!wbygrIU;E7scjxZTlXoA#_Qr#Q`*$Zh8|Dad#N2B)&-3f<;_~|B{QSk$ z<;l%z5zTlIcz(LdVl}IQrL3zYi(UqU1f(i}R@hfj%n-%UkPS!`L@lXiwImQl`y@k> zlr4*@nIjC2f4K)=wKx0VG3@BxaAWI#h7+?s&1Yz-z-TFA3w??a!9q%19F)pN2xiXIIG@8L0HP*5_yS}Ya+!e8 z6xkJJRhAVo8)6gzVq}UUaY%|!Kjna7-d6?-MmBu|5E%^h4_O)lg8?DqO-6uO38j!i zFGx@n8RJnE5lN`(2#eeeg2HcmV znr${3WVl#!BbDWYgY1Sa#JsPY<%=DD3fwUR(`?PUxy-Wl6p+w{Kp)hbz~v0P5CP>u zCM!q{@`nRp077|0V9f1|`RUCo=kj_vo=nD*k(mro2BeH@=QUNbu^xxxm(yWW zzrQZnEjG=h9z`(%Wwww~h@t8FE`%ro2&MPVdqO78khuVpV=jtfG8tDz5mO|9vM7<5 zaqt5HlG?C;cQI|Z&1SpZHeK6wF-BD-K+l}a7F}F!`!Y2~eSzD%G%E{@ z(05T|C_LZV+n3On&U{@vqQ!Fk^5tpaii5-b+ee27`}?=o>&xrw^=6Zji2yklOiy22 zq_(?zdw+N0t=}B()o;FbH^uPc*~&8_XilQilvLu4uu@|PF+@|mx?X(q-P7l1mrkcg6$C5EY6o>y@9*zV3wZV7X}f9PdHao% zv-5Aid)#)L*Is*6kL$0#{N{(}ua0jW%y(y3SJ#uhy`8cIVA}@b@`OVi~ zy#K*_)1BAIx#0_qmMzRSENB_L2O?%iSv>&&x$Ac5-!ubabja+`djK#|69o~?M-Kq1 zX%a*=H4xF1AdBkprY>9+vx?ni>Qyr*lO^BveDd)xKRGx)`tm?lk0#DI`1?~q6t5@BQ3$Jn)IU8Gek9o8OZCC_Rqogqm{$Ya+>xjMaCEI0Me zWICVi?CsX$nS(a9T}pjO(x=okDJF46Nq*FZv~J?Ml}Q(Ob|%hywb(~^^5fNy=k0YX z4xsQM6Tc(FYD^ox`EeEi`D_y6ekKYaM;w)g&npMQvifAxR<_2v25Y`%MIf4beq^}1(v z1U8zCiqYuvFTQ_yy4~F^fgq-EaejGzasB>B@BG0pKR!CB9)I!m>8rDEA3uKh@cw*v zcKO4VIk2F$0T)R{RZ`Pz3AOMJOkwnLM|L7M# za|P!eE2q(9bT!Wo!{dz%IU^i0lXipL<%t1uM^!Fv&-uc`Vvq$`H|)@mW|m^?+cw6a zW@to2>^u`80ueh`VD8%(Ql1bIIrjkPYegX?5vN4%r^B8Q4Gk4Qtlcy(e|Yij*H2Gh zUaZ#r^|HHKwO8wI)y6()(tN$L^F>jV>^+n7MFD8+oGXf|szQj)ap8-c=jUAC_noQ| zg5w;4XgQpwEPUlXYm&a9*z8n%Fe+HK>#%@!sZk8T8Av$ko}Y%-aGV}u-507x{QPHrC^hi2JzTcGOr`1b3MUaN}gqCa&Y4q|GTl(rA= z%ns(|S6|D^m#<1Egn>!js5A}R&33z4NQzaR>d}!e)ZM!Zu@Vy?e>>{_!(z~ly z%d^w-ZPSNnUEd!Z@4WxfJ9i)5KD=|Vf4n!Ijo5oLv95*C%4X4DUpAK)%k!)2)79m9 zdvO_-8xv#l#bVtSjaD8+MGb;cAZ&vMm1v6O3@8Fd$ZIvKp%|oG$ZXIjjiPvO!Gnx*DRZ~aI&gK6Ll{~Yf8%kxEQl9cMIWM6=4j3G&KIWN;p08MR3 zK}S;nWdvg~00ztYT}NaFCdy2t>)yArAFqa{nxY;@jXSsYdo&13=$Lk>TRZ9I0s5 zo0>tca5K#CLGG}~u`~nzl?NUeJdg&6fJ`?*vV+cTcr10`9vzc+T$bKDhM{C!V@h3= z(~GO+V%hewk72P~HO*FHOiYfz041d)Ldb)|Dn}-&AzDZpW9*4yj0H1*6_BDQf}&v8 z1uZ!d0-Bg~#6EUgWXo$Rqnk`!Rbk)##De7OC|BEKrcZNSm4TWn;&4m+gdz@@aL!s& z%y|QYa@2r`vp4{6Vj%#O7|{l~bB>wBp+gH0vZilX#)%*!)?k|Lpo_%{&{b7UNCRV& zdFGoDKPQwJqKa}>j*0?E9+jLK5fd{Yd8YT?d1JlVoL&B>HbUVziWOvJK#ZP=20g7b z+jR`x-rm8%{{H3F)wXF3FeH8U^1N^k0ZPN9fM%=~McY1hAtuS$?v&$IlZYj8>_&A} z*A)>Wap65P#~5|^If^1cM9v#x8$#EHw(Fa=-)^@dM#&Eqa#8xy7n7=T41LpfT^D0o zb#dLs)9cO4%hmnE`Ge!V{n@AhWN=-O7}Kb(CzDY%n%us92xQk+iziQ?efrtgkE>^I zzy08i*X|!59b8{uU0hsrT^LO!by>)kg;;&Ag@9&N0lVZCKOv+>gDrzb* z#$H7R6RMer#y-TZ`{vsx-#&fT^+^ynP1|&xZ`#uP{k=W8xXdV7Qfr%L+caRtMBe$* zQ%Nv#MO{|RJe!Tk?tb}CpP!ulc=zsu$tJU?rd$(1U@TNi&0g!btQssmQgzWA9370U{ z{Ny_tF!aF!fkqAq$r+k~sHv#vPhiPiOm0xM)HfV@xUr7GesD&Wbj~O&2$< zuA3-^lj-F0s#|R0@+!8;)W9=NN~}E9b$NDq-33kNLXtjNNT5hS3>Gz{b+4~K+Ijo! zyX)=x%dft_xN527$~j`EhTCml)y2`#(b?(MtFz7X^X}Qn^89T1=YRIcufP2O)ZTjk z&E@6gumAEN7T4F~o%!CpZrWZ{kX=<3%jM?j^9y!Vc&thn`=%cGkACmH_kZvG@ziN- zB!#ApUw{2%|LD%$`?tRN{t5w;LKmb=5@KrG)-+Y6SG5>p2tgz!F%ylF`o6!sT5L9L zJ*wurv+1ZFjlB21E{n4C5~FHDW0j~$l0=b|bI=MdvZ>5WV@Pe=HQV;;YJG9lELWlH zmxeFbtL^vC&qGuIWTu@RfA4s9=hpspdzO8*1h6|PcE;6Z+e{qX-7gPzD~IX$cxS#d zdim<|?|=Q<2XDM~aO>~})WZQI9kix8IPQnD8;1}Wvz*|GKpCO8O!#pQIe;ukx;a@h zAUy~^Lf5Spi_muL*^x7YY@7l$c3joi zv+Z*A-Iw2f_x00@v(;wZEt_z;?iQP{?Ion4hoE3j?DF)@%uMWkL5yWtdgtq^>bpMA zm(IIEx`x)bZ6+TOz*JNdp)mnkh+S~f?N+qw5Sq)_UyU%$k4CO^=(yQ7)5&;mXR=x> zudmyyMObdP+YsuVR8RL1xs3?~tSC~7WM(2cjz6FFNhL-BguV~!Z6AVSgwyoEw zXy|yji3!b=kOyV%fP?1&Pcy&0U9V%3-Q5G9YZY&-Eh5@=UElZKxx=Gdj~=}-o6Z-P z7w2a$x=r&kv?3|SxVyVI9T#;Wqf(jr#r5fU?2zc{^77*BJcV$0czEaTLj+5Tz9^Xs zfV{hd84!^uFyTkip{ZY_(XV^F=ye$*RZB3SX75jmswb-LVoSH4#l9g3t@dz`8&( z%yu(1RD-0@i$&2Wmc&Am5G7^$U>NGbGnS4-gb+Pv8Y;grR$1xC;aEuoJFs6ZiT-)oG}tv5j}h&hLKRYVX= z7Hz25$*T?`p@2#ndU}ST6u<-q9w<*)8M*-Pi?Xb!?Yh2~L0pDe+s=;BKn-)uN*|+% zs0fAF_MJ+KeGnA~Km#dbDriZR2QMiYVy?g?Qzj_bIae|PqM{ii0is9*;L>|U+F0N9 zF)0MljF~Bb0tk|rNXj|1V2-%(S=t*?(v%$IKquw-R|h#qANscIVv0ec28l^xl)eu! zr9Lwf8Dz_jIx{qgF-Q!I4v~{2Omw5d#N76jzmckH7R`(qz4J^(!RT{Ag`??syuUN4 z3SKXlo#@WEOeqzPh(JuUbRovp5QsU7Bvm9v1Y&Z|Y3{5;9_+n!UDngZ>e;K8%bodn zwccDU*7Ji~$M^0ZA0NN@+9O|&kM?&(K+yygvO0p$)bysIJ>Mlary)R=o~jX9?n}>0 zqvrM`0~N{oPCz68WXST1yeJR1CEhqQ2~|}MLX1erH-&eE2+SEn$duUttEvf#cRpuP zU|#F6AkpH`8%s=l8Fd1JEClCB+JT7BBo(Y z^v*F3xsjCLF96Gn8D(hlpQn(VW|Wt9MijNS>8m=#G>|DGf&e$aJR9i^00?pdm{OJr zh(<6l6%pqgsY4_{D!lvX{da#nIsNtj_a#Oxm<$|&sHW0mRX7m=&%mya>3VTFne0p_ zv!u{;J)ld72$)UN**dF$U5NR3GDOj=OcP%gRatuH%c7{tf|;_l8VE&{h?rasp8~`n z+J)41?Y3>ZHVj=7YQ#k3yyvng3U;OE*|;7R-lmhTZ@1f~ZMzU+igJ3ry;`>4zqmNw zo7~!)9nDA6CiqbZ3XqYtfRTj&|_IJPg=E>vlA3eH#|K9D_9zE>(u5J4e z;=yd}Q&+IfrzJLZT_BTyB_v=*Ff|c0A++2Wz=TENnK6X!{Ot7mAHH92n*7nm*ss@{ zQ9UBG$#@ob;`L$~lcugS)!LUu!G-r#>AfeCRBBgvuaZJ&$94VS!Gq6!_xWd^|I>p9 z58inF^;Nrib#^kD&h9-7o*O2pFa&JNGVaBwgY(d(;C zGU|i&(YgddaR^E_NI|Dl_uf0Vz~t%oKW>{a*{KCMMCHPbr!zPNR2hvuIYc5?xR~_Q zPrr9)|HJgZ-ap(G)i>UG?T7E4J$d{Rxv45oj8PQ`5pliQn8f`Zf9q&c5@={Y`Q+V) zZ@!7%9)I!W>B(u|#T4P>1U z1L&x(@7=pSn~bZGCsXH$*_Bm+W>K?)9T7kzX_9Q=W-bsxC8Z=WrLGHI*KgXcX+zgb z)9YfjesQ{0KoR@oqlcxVlOJErM-@i>`m3i`i+;}$7ko5zfAH4PyhaQ;Rl8s&vTS&Qfbt1T*^2`V4V^3kTV~ z%3%E%2q73wW>xR~xEd8ziNv55`p~p(w{2oDb~!a~IOjDxglXXI2W~?!v{9n%Bqh#j zNdho53r&CW{j+C}pDr&~+jVn!-CVA_b)VV@eKIlhRaMp_q+HQ~-WT2#23Xf+;r*y8 zi^3CFUlv{8LCzIt=HX%!i=Fq52xHKUPcfRto)CBIVwc6Xml{@kJ8nL$>UmjC$BOQ| zC(q{d>e0jFt8=Uio0NEQ4X4-r`trP17|#!gOXw3Idgrq0$$RHAU&*cyano$opzr#w zi;U(AW=~NP7jCvYXYYm?D96iMwpSryb_pdWG6OPGPiOP4ZC{WV@&hNc5-Z{Ob8-J5PU*H4~olgM_xZ8mM+ z#r0~_w&C#Tc2Q5~^8@eDvO+k!br1+qE#A9x>ywY)KRr2n=dIU&^{ao;wcFqR{cryA z|M{ECvx`6Z)gM24bib^sY;*!bB(KU}efjvG{^@rge)!R3Ix!8%c~!H@^LSLAzr1?! z?D=-xc5RsL)c?(Y`>#IuFMq)#W&)rf(PF1>$8jX)#~zmdwt!nws5(& z%Z;vk4Vb`{uJCQ>S8Xav4ifu5bx9L|A*o^(okal!5~FA;hA~+iVizQ9(bNDDIJYu5 zMgT%{WCR&rF*C`ZOZFOp2^wg!t}z=Ibvc{PcG!6Yy7Ay-BRn}@6h+~j%j^XW(4+#G zbI#0IGovL*Qr~xN+lJWpeXlxjiHwNeBZ%|N%s8}Iql%bH=3NG?NJYh5QI5w`(x|ad zNz~M0a1edPNJSq_(UB|6agI3wKqcgYTv3V`00R#VQu#JScH}$~0~!$JxTa}6hH?ai zsKHX+4^a)bZS14QsJ$k0&bxBty?`hS^lCw(8Z(g@k`o2h2xbL4^iEVmOrVlYU)f=l z(qD-lRD*$xhx{ROvXn$EB}9mlHk)le&-xJE;4uS=N!0{UiO>;w zM}|h(QaI$yCL%68J9b6EOe7*^5~2VS6BA*!m=IzdayKDoy(<7B&&@7OucvMZIYivb~Cq-~kDc5DB5fBy6L-o4r^%L3P3M-m_gjUmU6Wo?@R zbRmS804$}Hm!A+q{-+f4_Kir6*txQtO!k_l{o<=<#;0$*+xxOUdv(FZ@~zh%7WJ$j zs_B^tk_n+1nwVhjYB$Tt*aNvZ@S;Puq=@DvNmPcr3~ySoZ-Oq_<=zEW(LobA)Oid5 zX2w&^Y@n?e9S|UiC=4xsHq@(`5x}bExE>f!sGml&b)g093n9 zQ%v455i>h*Lus2U3SW&B%oh<*LnqD=ARrSEB$b#FGfNOgbd1TgaO@ptOQab%hgDrU zv$`bKn>L{4zb{Ot1&U!1<33SSxZ0G^)G-4-aA&XSK56FVjY04U1Ru@kjT+isiYYPnjhR$a!Q0M&BhjxW6P zg)fT26O&o&`^L1IO(u0Ysf+n!)HKaz+jdtnn zhQ9IM?Up;fD5|0?Jewwo(fS4zQ%n-mX5FLpuJCtm-~IaACtrN|#l8FY9z1#gMC*3* z^7J&3o6HZaoSt1>{pPoy*E636L^*f}AO*DnpDF0D*#JwK7uvlDAz1)p}fInG5EzH;2|TVTM@{Occ=^AsUFp z{CzP^62ZZsk5MF3RT;$d*?q?Wzx>r79NaqmKmON$_xW!hH*NHUZmR{T=fTNs z08uO|Dqs{7G12TFMo$>gLW0FsnpSELHQ_u9?8+#A$ zSIICaOlGs`Y_C z`@Vbi@?6BO&d=J=Y?m7{Gw0d>+t8kzUz0BgK>-CY38bVkiU@4Cq3?#lPey&tEC3^L|(+5KRqz$^``yszpS=JTvXWa4at%;0tgYvHFI2q}rS zT||hIG{dH53ZjG%+GcTn6*i5f)NH%udfRoH1af48E6bhv{&>0*V(k0gRGo9qI{+xy zSKgC}^jlJx)&--eCX>X4Lv+l9ppZgU7ECONh(KTr<{j*fs)L$j@yf~OXs_JeEhbYe z=k@sLAcFhu{(x@ay;0nC^;O^1UG0>pGg&Yzf#*|A}aTqE@5K)z4*QYM_U07T#X1hB- zrHP|iS@^@lD*!hc z&yJ4nc5RF?xS}47rqi80SCnd+s|hd*8a!uz2!^%;JpWb z^H=}zH^2Gp>60Hm{@I7`e(=uG;Za$Z3b0yUe*XE_|M-vp_~^9t$Ls zy6Lb}Hg@O@1VfApAPKIQ+wrUh#Gn*SyJ&(K%`}-Hh+Ou-pl4z!L3YWb^ z=5nF7W7DLPOd{txrJFicg6vXJGDG0l%X)b|uKajZjjF1uYIffFf^zDp7%~$MMKF2J zR0Cq?z0d59qDjsYNwM$yzVBiTNKjWb0W|9rV^3&RQB-Bc1ezp^#fd1JB@lpsa@-3b zdRH>Bq%KJm5l_l!qtR%8Z(P^7UU%ztzc(9auTieTL?l24Uxd_EQORHk7_pSWRixa? z1dtmVld>;?JRkrj$Uke85^lF4MPXl#i>e+^&AG*Of?ld7n_TQyA=qM0E%5Eyb7(HIc(il5hUO*DuD z!6D}EO#wtOB=k3CQpM?~n<@+OG}7R8#7qGHp>b<;EcdW-#?%4PQoufF6%L&AUXp?R0p7_N|x(Dhz(5peuIWpH9{mXB-BhN0wU#BS+mSF zQ;44u^>MYX3TjRHOky1Dx!!EfEW=15+ehUB*<}upfB=TlW&lem zbDwz_Hc!OPIYx3r42@}$p{_auB9JB1oYUJ?LEt}Yqa2`eL=aO(&JLJ7juE-67l=s* zxiyl7WNbuPI}NHf8&`k&$A7rDzx&1G@2?h{ab3Ol?xT<1eQ$4f)~9suyMw>^yWgH( zt;x_iiYcWGMF|%tn ztIc{{6#Ulf53e_?ZM%N*!;^#KWAbG{e);OM7^ms{pq%VKKU@FZr(docef;>F$6tRj ztE-PcdV6{C>fzmkina7Z&O;XV-$>u`?ItN^Q$LAlo}>vKA^~TsvZScUUe_0L8OLGqb`GGqgdQR@ei% zM2>}^Ra-S;zWBpW-oL!Mm><-4?%yjsk7qMA+HAX%^R?n?8>JDm-qx+2o?YHQ-uw8S zdk^od+D%(A%qG=rR$pGP&o9?qqD|6mu?|H3UUpZ2RptYCvk6h|FC`XRlTV^E##O{PSm#wDQe#b00WiK zYYaV@I$}hVlyZQdhyYW71c)NicYO#kV~)&Nm+a>Cs4ljn*!6O~>_p(VpM7(Bw%Tsu z;jH}G2Y24Od*m70wrQ5jXA617>On^(q1pa+K00`3XLqmMnZI}I{?DJjXp`+99qG+e zO@ucsO+N+8zZlFm3ats+lwr}4wjan{| z$r4U910bdROOOUFPm;#M zu@NB{ITDp@GQ9Cg8yD!9>XItYMFF?(9KQGA2i17|Q`mu;ssIsZj9dq1Si#VgETzq+ z2_dQIVzJy`Z>PIE+0~%{#KmN~leu3}K!mca4)zbEZ(`S)8CTWu-Ma_-`^|R6-nQ+! zX;<5(W9Rqw=J)Ttu`@pqQ4y`HdOVsUIUUjW?Rr$}~83DW^y!+wreNfhHaSIaCcGa(zVY`;LzkYf8>dE)1X*JPm9nY@g zqS2rj4b?g4-DK=b!*$b#ZBK=dBG>EI6$Lt0Vs)vHmJFgmGEEA-Krl_of=E_W0U{EX z1(l8+LXLhR#0(x9BQtm=W-_G^lZfPnsu;@cv|vKhzHQcvD-Z=qfru8P8g4i+^gDvC0t=$MGe zc}|f$QC<2F!eSXnqbDnwJoC=9+MCs6>Ed#gPMgtAy?c8P3I?PhQ36SUs3=pnmA<18 z!3RqnI+veVK!%VM+7J+|O=+=hnzoA~o33j^B<4-q zh8WGVQBzD4T0$Vu1S+7YKP@E)WmysZk0z7(bUGfD+p4?U67+{HkIBqE{;W)ek25J^8RZSu|JPvlSzkhhJ|KqE3&n!q; zA&fV*4oJk=V>vX~8ki6p!8*NdeB zk^Br)9T7P{(BOcO1ZjvMWh4=k+|8<{1`G&*Ixs3XZx>`ScAg+I=c|auICLl*7y$^F zS#AWC1d=CdAOa9H_Do=oh>#gg2WJ8f#IT4ekeXx@#!Z0gupdGO&GR^tZ?2(COEq^$ z59~6E$c^4u4WgMLkgDxY%75{*_uqZ}!M5w_vfkaDIfT%y3-4dQclXuFtHtuM7z(nI zGtsC<%rT`P303OCi>iTiu}AYvR2FPNoTHEj$uoi>F^Nhx8%5E$ZK9;6Y1iAP>AE5D z1QZa7xhRTJJ*w-v@P(;#ZP)i*485dCW*(6cySBUN+Vx^J9#!MXXjIjsx~@lcN)keB z`@ZYi5Mv5*zU{BSJ9+x@ay}a!?a%Jt-aX!(Rg9yuRB}oB6yt0>e(SCKM@M_-=U1y{ z`}EoKCr_X6?ac1nKG>g+r+Y`KTc2HTm+L-6BXV`=Rg$RWjNc({OjXsE>+O0a7mM|B z-E5nb#EQb3%FEN!ot+&=ldf&2qfwYmSF26mc5T}MfQV=cAkkEi5ow5rb7jSS=(?^L zmG}4VZkzscx%mEv7XrL$qZM^Rw}}$b_fY)q>*tT3yp(SH`lEZl`1l=&>+=_U=hnf= z>GQ&K_JZf=ggo{dYC=&-x?F6~bbs#<$PfexH3LJ0 zgrEqFH)=Y^XqZ*Gl*kf-YL;f05~7+w79fHuFp~!nzM;S&n-Ub_?$PXD{l$Ov+M5r5 z^H;zA=8MOn=^R+*@kMejk^c?JJtF^Q;>t* z>fyuP7Z|&qC-;tBQT_dIzkGFak#PLmPoIhM!ORtot5F@(a@z$X*95&@hob~dZ*3=H zi5QRXjNA1l2;RMQXJ>!+yT?C#`|ZhQ8v(KHZLw-yZ>tvSkcdzPRA8}e`gS!M(c!^l zcW+*m-aGaM*Hu|nMd5r^Qo+c~2%2KbIxdNpd;J_cB#V8YV(k0ShhV0T*%buWE?(4^k^X233o}XQ8LsCL4J&qV> zHI=B3HtmCt-YKU$T-RKTKKSHk)nuohO(b?V4vCC`>Thk;JB{$_~C%KEnf z>jY#l%Rxhfo+F=SBFP5m^v2RSs3NniDL;5OQR~A!ImkhBdfsq)0{}qi!)moga!H|L z2QvIEU|N*rXgnfBRvmda9akJ7fom19mp(y=u^KQMa>Rw>y7Z*BSzfiPD{opkGO^Te za5NfC_8b=q$)T_>2%H61`GSeE1EOFiP*O?V7B|;>mCdJImg*|1CRMdR#7zt5o6xM6q%Z12iKx5x-S1K{4qyz4Ps=~yKjvXNo5;|rPO=3E*WjV(Y3DIT4P7Xm-2Fej>l5JA# z8~})l4&i5rn13%a60(D;atMUhY+Lm(t-UXNRnT-?PD|gn?Rv53ww-~zd~x+~(@)2h z66OgL0D*{0Z-BAusqd%=AQ2?ygdH#i6$3!E)CGw`NFWBNki=qC5mR2R`fU@D902!i zh)oD$3CKBD8YIwUkXv3HXUH8?6wsKdb~PY|Bz=rArc9LK&{l<6eoUYUXv7eM0kEcu zG3U3Y937cMN|Bft5D-~aV~A!$i@eLy&z!vi@c%RQp1-ynNuF4k%q(-vC;V#=k6+2b(el)>OI#vvu=_;G(oxc~@&5*V0($y}2~fCP+0 zO^bx01rbWl5@nWaRyQ9JBDvt5V@K%FJV*%Cb$+$5NRLyJ-{Q*K(RrfWW0!y`IfT_+_Jy8Ybx*8GI zRSt-d2p!Ls#ge6(K}bzzlt)Db0oj3O2uzo!r|;fh>yauHkph}c5Ls)5aShVac}G0N zsHWaK0u+^8BzTX+MP!Uo3sE0p){(3Ws3|R0p=m=Gzz0+Ui6xKu5Xb!^guY=HPzeEv zC|7>%xX~$~h$?CkoomN!7R~6lVM1zD14xOHkPsP^3Go=@c)U@lB0hCGAfj3YQou}1 zB-cI&Ga({hLq!1@kjNA%%N%Zlgm~=Tsu4AFT&*b?&zG1T#Y~kMp4$_lp0H}=+vJ4$ zJ3Zl(lU`u~fGW|<7)?v+Lip(Ai{F3wrVKe7E3pUCK!Q1|RHqF9I_KEXLPHxO;bvx#FSEzB3kue&IRwAwrhhA^>K{jV~X)OWMJ!qBk+Ws z&2p^)Q09{y)LQj5Br=;h0i@R zd-f0-EI>5Iq&ZKAZOMgQ1B6K+bp5GscjJc-*SAw)zg+u%m4voq8Z)Fg1+pJ~^6amF z{?m`1pWR)@%_pyztfbhqE!I9ns}aRem86J>#A;}BeDutgWD)1kX_X-eC?HxX0s?B7 zvm84+4X`pXHT((%3<;>lTk$LzCFd}+N&(exTVv+WYwk`|MI{Ci#JMDipa$84`j&tA zmp^>=^78-t#lQaQ7yo+m_MOCR3e{mSPZWTvRib?yDG>?H2W|qFqA4q(xP~UxRICUj z(xf1<7`G>9&;R3p{x9#|y}f(bKkmm;%6C3~{?Y5c0Dhb99AlBrmtyyKkHc<9h$aF= zMl>aOjCwcf{U8s?VyS$?9FA=YtF;Hf$L;udNcX$)I6=&kzP@it{)_LQ|KOwbV!_}4 z^g>HK+XTVo!;pXV`DefX;wB*xP$;?o(`|XaXdDW#67R=cxJ^K}yZo?EL~beu2>Y?T zeZRfEek8Ev`fz=_|HB{N=8UV&YJZ4|S&`q}?)K5>Zo64E%;=qSo_70m*0wKSK3gxE zs-PhPW(vUt&x}9>o?)7D&I#0z>%^vYjME}T%Q#Lcr5cB324cwoQp%;2S&}7cpdonY zz2^dAIZFuWn7rxPY5Sv3o?M3z%XYRRY1pDfSL zDKzNZI36}aJMkD5Qh}rgN^N}zc=j~XkRev)80>l`1yMyD9iy|^GfC&N_VQ9kn<@sXO z54({GJyFAmK)_DGXGw9Ia!OThgG`NQ53t|fjoaG=5V{`<;p*SYcG93;nb$Qosy1ql-kndc7vJRUKv>lsoPfpx&0U==1;(FDct(V)~ zbcn;CXKNU;jl;f)lk+Vz`4E_0$+_MXjrYMbfSM?idWUU8r>E^te)hc|{NzWWZ@zUT z!*N2Sqd$4JhXU4NX&U1+Mk!WF!kZ6w>yypN*{1FWc1)EM5dcLn6)lwlA-6uceD?fR z+bs>%z=(0VToBwox9 z|L}kR{onu1|M>4NF3u5P)imq%`sK@4YUW&nvyn|rljdPO?B2b3^M}v>_{Ha6J={Kg z_oFAlk(FeUYZUO=*}C7BZkrD2?rQt~>uXKaH_OAA?+*F)pxXqcZYyLW zFr<`<7!t9g;EG~h+8{|1O;MtlAPRC3n~J4ec`QUQM0AY7b8r+GyT6bG`>`oQdn z$OrGee|$U)+xunf*C&f%7#{A1?d{{{`I$Ma=KOj9a0uRc$=OnblAt7z3;>!ZCr<5wd7fh()#b{DC>|Du*Okvgs_^GJ_%l z3IHTx0OGhxG7M|>GoS*bT+C)`H8T-05{MayAtDkwL^PmE@Fb3@0Fd{AnM6x2^6fxe z%T)--kc)@`dZ_#eA~G1xl#RiZa_#&cQUNst9mXl;A_kA!U6E2vTxg1*O$focI&n+M z#pe2in)za8NPxA5lbIM1nV6`ia{>^E=2Aq|ybGaQgwvML7R)GeJ7qa+x5Ht-S)Vi^ zXilf=bzoTb&9JpLaKkvL1V_PfiKz~U^&G6ed@%9c)Ukkxh?x-4%oDcWnTbdd$iM;| zfEnP}l0=H8IUS~P3y{?;rGvCRldry9m>DJmJC;Y7Rq;zHU@n1!gJ=kaHnGQ3Ygn zj>&mqG!ZE=riPmmaEt{~RtqU61|#+%H0&BQci6>uZ?@=%eziO~ISC;kDH7EQ#;js1 zDo7##prz<6^94pjB{fq7z-lh6_LTaD%y4vVvZ=DSdb`2#zakMZ5n|oP!AwgoSVsyX zFhiWPfz7~>V=5vF)dW``4VukdrTrN$pPxPw9t$?B5DyJ){s!T3PO5(|V+{vZI}R@O zheQKrINPjG*UQ~-kKRWGVsJ>#j7ll0h{TTBF)IY-;JIe0n`JOFu?)q=(TCvJ<&vj3 ziC9c&N-2v1K(#Bg_ul!YXzB*E>$}x@)AbVLG)>bqPAR1%`r%=`eH_1hcXPh(pI>ZV zKR^BG+4;F&GD_dHMT8MvJUi_@s(o~K_xSdk5AUvSuC8yNK0SN>{K-e3{y4||^>%7~ z6>rZe5S0K>fRsv%8k6KANQ}(HjH0FJ_08?mi;E{0=TdUhb|;&)nWg{%LH@pyVD_LF zl^k=K3jYHFSi^Xz%x?zt3+^*Nih;@ZCB+z0^ zJ~R!Jw^QYHa%SJFC^g zbs;@YdyCUmO&%V6A+otnP`}0?qFP@(K?zdlj`PJLM{L4>%`lIiZ z@$pAL{m$vrCq^t;?ryK!eobtpq@(M;KKo-QR@HaFtT{E9L#CnXw2mDU05-Q5R(`#T zuxBqhfE}3)tQh~drpH;*F+)Vh(^XaHa1*F8z%xIF#}oiHOEC|J$WBu%bE3oi51?~r zPtISweztwsj&W)|Wic{vgpDK5Je4B3gr;RiPaFuR{dRb~?MR<&`enlmrE43}W}MQH zGK`NNQHe-1V^s+m0R-o~bA=(GIkYkz0CNbP^ALL1t{2UEg?$ek0D@~fasiNmJvJ?^ zmhF1cKkoZoTC}$8cp6KIqYs_;-g}2gC7Vhnv^F^BP)Z(#k<=DVdwIF~?hjx8{I7m` z`sD10=+w`O0HCrNvn!)+j{pE@V$+yXEKguXdCFlO^hsaeyaxd^g9 zfAakK%a0c)r${6c&9n)jfBGbqxZmw#j9SL4o3B)LxjIp?S|i!EeQ1_*g5Zq8!aVYT z&gMkY*B`yafA?>H@rz&l-QWHDzxvC+e*N)Bsg%cu`!tQGrzcOIJqhH&#H^r|6d!jF zSDw?4zW-4J@Y@(0@6iC}<53y8501uNoF1p!4{7%p57RWtH(z{sc!(#P&5-l`q&ElI z7f6T#2aBh)3c@viX>hyf{h_RNmCY1+_seb+l5 za?ZmrP+&&mJ+52 z+yH`(gQf{3Bao#$Z4XwAD&T2iB2a{ZV$$v7p=4uc>|KLg6ibY%!pxq@krE1+)sE9@ zXaX}w#6&r#lINH>CZ^yTKmpY(SwvJTQ&hcfpirafq0Xv=iNF;DRj9vGix#N6x?@sd zN7Q)dRH1^|bx*Ap6DB6Asx;I&t49AD(FK+o#RLX~{B1T4AObpOaVQERAR<|clwx4S zM0G|rEkzwO)_6-pHFR?`B^iN~xljUCVJD!c~x)?fUW|$R$RGZ&LEf*;zSsD{*OLn&K7ps<r7nJKu+q>)Vurp#39E2;K+ zJI_RQ%Ze$LQXI3YlE>Bs6D%dhn3i2TPT3Wi=`7O7YJ|bB5ZcAEd->7H6zwp@!{OkV zJu@Mc8d@+{@Dek~v5Z1%;t$o_EC58Vo|eiU0#eOqFf;(qj*wKP`UzDPp=L-D6ES10 zi(~>&tM<_=;4S3eJrwvv;d{kL&1z0AgxpbE6E*ei)cr zD(gFJM+m%9Ni~b1s`ZSp?ytC7bjwB0^jMLAO0p8MV<)*FLhY+SQbY^vnkE2X%Gtma ztdvp!Vi8e`DW;TFw5Zg;OYdCMHtf9jo`_44!#LFv3pJf>?1aSZozL~_irh9$=eTdE zanyPW4yobT`m$)*yIsutDetC->&I=|G@I38vtD(pb-!HY6o=t3j$=$oa@j`N-)!IA z?tcIE)${Z9ryoCg_3Z3p*O;=FLQIUhTC~gVa?ysI_3>eUb#wjAo2&ElvzITPG|Lr2 zE^&w{Yi*V>5fLCLss^*p-Z}QciYcj6a$)S-*qvi@jmYNyBK3hQ6*c+ zUL&SP;r06DTtprp?{6QrS2yoY_rux6h3^*%KC2sYqOm}l_J=8D@dy{2<&Qr3==qcL zlFJ|e@Wns<^KZWU@#Sfc!*2KftFPMSNq2f-$a)-T%}k0wwNGoEs&TfV%n-SX!u-uL zi>d5~@!U5aolvpaF$)F;G@mAjC|MPi91$|Pxd*iRu&jU;F;GN91P2I)DvFF1Ge&?a z@dD!6^QAzD#Z0ZZ#=ZRB>x-9{-~Wpr{O+HB`Pr|3cYl4CLD{h0j&QVQ&qyvpO6l=Y zL-6dq8mMJrsJ=>3L%^K%pZ@uuPfphR-QGDe(O3WhANS*SyLTZtu174GTFx>VN)jI& z0A+`D6Tin$InhrI%v~<=SqOw zGD*ygk`9N%9s|RA*=V8woK({=?Wa7%;xTUzX-rnojLev$$%p%W+cj;!I1K3!#Uu8s zreF85NEB^|w-3`WPEFUmc=`PHVfW$gV1$O`T=3qP5*cjS`JD4K3|;661i-xOnlRhi zt4uzpEICo_WOD4usg&ybEi=?)#{?GzHIrJxqyT2BDd$r1V$rvalVUZFuL<0E@=l+h zub*9>TwmS&{_DFB+pK^$yY!F0{9+m|z{=^y|Ly%B=WEnv)~f!C&YT9!gOmN)d0ZQkj_=ZO zIh@tpXmA902LCQOQIY zoSQL75m5C6-cxWatYuP_#NeJiJ^krVe)#0YGxk)m>3XYHxzO>E{h4&Fn_n99co=JE za*Z=5;O)ci{_f%2opEr)R54R#H!Fb=x^{8-^yPZBS)HC5V)ap12~22!*a-V^z};@V zy?VQQ+@7q@)nFV30DSWF)wAahCHLKO)>67!mZ+E-LHFmyr%%x0+Jl(Gr`0VK=h~2+?k5V*cE7?+_T0Nm6!*KZU zA@1*{yX$z^=P3JwU0oe^gN$V;MIOiam^Bd(woQDZ>f@5hImdk^5-CYF@rBt=d1 z_UeAx4a-%l^P4@-RKzZigQmRARe zGc6*e6xI37m}h-LhRTgmU`}e;KvYN&8QS355WII(t#61#?2xK7h=|~L$73l1)praQ zoM&P%5HkWZ1IL7F09soU#LTQx?MR3URz!+OWhQDN1R|;wfGUif#|HreG3UueQnH?0Y`TN;V-)ZB;^MSxn_aUzjE5Y@H(!6V-`-8b)6>n#$FDwW8n%;_ zV`9=ACoRPxl4?cxz!U)4`O4y9MYGM&i~t-0SkaPH4XlVH_P&TC?~O>zVj6~Fo6}G< zn`z4XVR90|akE;UGPf|ts?|Gt{v?=CD}GROGiIOX?1dnN#?>Uvd9BncCavXnR#`bi zQ)9x~!%<1ZDhY-fLNn8bGbamHWER(H{nZ8tss#*9QB}wh%_Qz@&o@G1CZcNdoy$Cm z8XCTO{_LAKZw^yx8$S+gYN{I8AwVfbN)Zt)**5{fM1+wYxjJ^3nuz$oBB}(Q7=5S# zyrOC4xMD~`Kp7_#UO1!HwabfVtq4uAjMFG0#8lZ-5KuEFgt^DJX3ml!N`0nS8A6FbB$u1KS}{W5K&bf4u_ml z2%+&VTM?~+$8*&M)+uKWm92r2Iy=k&DrakGKm?%mz^kv(ELE+oJpg7}^?~z+OxOh9 zhroozETy!cCILcbQzgWjK2l+MsqSaQnU69svy_Vz5w%=Ok@^dWoC{4`i{pW~h)yxa zX_s;?QtF>jKU-#F1TbL+3IV};s-GP>_O*-Ua2R&G{V+vFaEx7W#jwOYiKN5uxF6d4 z$IWVSezI9E`pe})avrC{VSgB>DaDdhZ};(Wxc%z={j^KY-lgR9 zyI=n6_3iz4e)!X;uRn2ZZ+et^8knh=s(~mWIjDJkL|CyrQBgopMBMGhH{ZN_yuJ6{ zot&=eThNedpBsWv-3Y2mp^oGnW_JNH0uq3t&^({d0bMXFR!vJ09R~7+h@l?whK5Gf z8G>l2&9eFEXFquM-Pb?;w}17g&p&_v^*7W0FbzYTl896�SU3TI_MVyS_f$JPv@I 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%0DVv#h=pA!$(tw$2(sE%}^mKKx{@Kqy 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
  • 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

    5AJoL^AIg#&~|h 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%0A!WP%q){b}p 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 }WkIiIF1$ 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ÝM4_D4wi{X=^V<=&87e_&*w-fG46Rb}N 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

    j>Tu)ct#%VA*-TD&6lDJ@K54^5Yj32vrTLGn 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 + +## The Paradigm Shift of Agentic Engineering + +Most people use AI agents sequentially. The workflow can look like this: + +* **1:00 PM:** You: "goose, build the API endpoint." +* *[Wait 10 minutes, check back.]* +* **1:10 PM:** You: "Now build the frontend." +* *[Wait 10 minutes, check back.]* +* **1:20 PM:** You: "Now write the tests." +* *[Wait 10 minutes, check back.]* +* **1:30 PM:** Project complete. + +You've built a project in 30 minutes, which is fast, but you spent most of that time just watching a progress bar. Some engineers started to realize that if we are running one agent, we can run another five at the same time. + +For example, Agent A builds the API, Agent B can start the frontend, Agent C can write tests, and Agent D can investigate a bug in that legacy codebase you've been avoiding. + +This is how people are buying their time back. They're getting entire sprints done in an hour by running parallel threads. (Just don't tell your boss because the reward for finishing work is always more work.) + +However, since agents don't communicate with each other, this approach introduces new problems: + +* **Merge conflicts**: Two agents change the same line in the same file and break everything. +* **Lost context**: Sessions crash or the agent starts hallucinating because it's been talking too long, and suddenly an hour of "work" vanishes. +* **Human bottleneck**: You end up constantly checking your phone at a party on the weekend or in bed to see if your agents are still on track making you a babysitter for agents. + +## Gas Town Explained + +Gas Town is designed to stop the babysitting. It coordinates the distribution of tasks among parallel agents so you don't have to. The system uses: + +* **Worktrees**: These automatically put each agent in its own separate workspace so they don't step on each other's toes. +* **Beads**: It uses beads to track progress. If a session crashes, the next agent session can pick up exactly where the last agent left off. +* **Communication**: Each agent reports aloud what it's up to or observing, so other agents gain the necessary context. + +This system also introduces a cast of characters: + +* **The Mayor**: your main agent interface that coordinates all the other agents +* **The Polecat(s)**: These are worker agents. They work on separate work trees, and take instruction from the Mayor. +* **The Witness**: Observes the worker agents, nudges them when they get stuck, and escalates issues to keep the system running + +I won't list every single character here (it gets deep), but the takeaway is: Gas Town creates a chain of command with a shared way to communicate. + +## Introducing Goosetown + +This is exactly the kind of futuristic thinking we're building toward at [goose](https://block.github.io/goose). So the goose team, specifically Tyler Longwell, built our own take on this called [Goosetown](https://github.com/block/goosetown). + +Goosetown is a multi-agent orchestration layer built on top of goose. Like Gas Town, it coordinates parallel agents. Unlike Gas Town, it's deliberately minimal and built for research-first parallel work. + +When you give Goosetown a task, the main agent acts as an Orchestrator, breaking the job into phases: research, build, and review. Then, it spawns parallel delegates to get it done. Each delegate communicates via a shared Town Wall, an append-only log where every agent posts what they're doing and what they've found. + +Here's a real Town Wall snippet from a session where parallel researchers converged on a pivot quickly: + +* **[10:14] researcher-api-auth** - 🚨 POTENTIAL SHOWSTOPPER: Service callers have EMPTY capabilities. Planned auth path will silently reject every request. This needs a code change, not just config. +* **[10:14] researcher-endpoints** - 💡 Found: native endpoint already exists with minimal deps. Alternative path viable. +* **[10:15] researcher-source** - ✅ Done. Confirmed: native path requires zero new dependencies. Recommending pivot. + +Goosetown operates on 4 components: [skills](/docs/guides/context-engineering/using-skills), [subagents](/docs/guides/subagents), [beads](https://github.com/steveyegge/beads), and a [gtwall](https://github.com/block/goosetown/blob/main/gtwall). + +### Skills + +[Skills](/docs/guides/context-engineering/using-skills) are Markdown files that describe how to do something like "how to deploy to production." Goosetown uses these to tell each Delegate how to do its specific job. When a Delegate spawns, it's "pre-loaded" with the skill for its role (Orchestrator, Researcher, Writer, Reviewer). + +### Subagents + +Instead of doing everything in one long conversation that eventually hits a "context cliff," Goosetown uses [subagents](/docs/guides/subagents), ephemeral agent instances. These are triggered by the [summon extension](/docs/mcp/summon-mcp), using `delegate()` to hand off work to a fresh agent instance. They do the work in their own clean context and return a summary, keeping your main session fast and focused. + +### Beads + +Goosetown uses [Beads](https://github.com/steveyegge/beads) to track progress so work survives crashes. It's a local issue tracker based on Git. The Orchestrator creates issues, delegates update them, and if a session fails, the next agent picks up the "bead" and continues the work. + +### gtwall + +[gtwall](https://github.com/block/goosetown/blob/main/gtwall) is an append-only log that delegates use to communicate and coordinate. All delegates post and read activity. + +## A Note from the Creator + +> *I mostly use Goosetown when I'm trying to answer something that has a lot of independent angles, where missing a constraint is more expensive than spending extra tokens. For example, integration research ('how does system X actually authenticate?') or migration planning ('what would break first if we moved?')* +> +> *There's a real tax to running multiple agents. If I can describe the task in one paragraph and I already know where to start, I don't need Goosetown. Parallelism improves throughput, but it adds coordination overhead.* +> +> *The next improvements I care about are mostly about making failure modes cheaper. The system already has turn limits and a flat hierarchy, but it doesn't yet have good cost controls beyond that. Token budgets and basic circuit breakers would make it harder for a delegate to burn a surprising amount of compute in a tight loop.* +> +> *On the coordination side, I'm interested in adding a little more structure without turning it into a framework. Even lightweight conventions, like consistent prefixes on wall messages or a clearer artifact layout, can reduce synthesis work.* +> +> *Longer term, goose has roadmap work around more structured agent-to-agent communication. If that lands, it might replace parts of the wall. The tradeoff is the one we've been making all along: structure buys you scale and tooling; simplicity buys you debuggability and the ability to change policy by editing a markdown file.* +> +> — Tyler Longwell + +## Get Started + +Ready to try parallel agentic engineering for yourself? [Goosetown](https://github.com/block/goosetown) is open source and available on GitHub. Clone the [repo](https://github.com/block/goosetown), follow the setup instructions in the README, and you'll be orchestrating multiple agents in no time. If you're new to this workflow, watching the video below is a great way to see what a real session looks like before diving in. + + + + + + + + + + + + + + + From 62d2aa8bb5174185a4f9f268300b6369edcdcc72 Mon Sep 17 00:00:00 2001 From: Michael Neale Date: Fri, 20 Feb 2026 12:38:41 +1100 Subject: [PATCH 15/21] feat: computer controller overhaul, adding peekaboo (#7342) --- Cargo.lock | 7 + crates/goose-mcp/Cargo.toml | 1 + .../goose-mcp/src/computercontroller/mod.rs | 369 ++++++++++++++++-- .../src/computercontroller/platform/mod.rs | 1 + crates/goose-mcp/src/lib.rs | 2 + crates/goose-mcp/src/peekaboo/mod.rs | 85 ++++ 6 files changed, 423 insertions(+), 42 deletions(-) create mode 100644 crates/goose-mcp/src/peekaboo/mod.rs diff --git a/Cargo.lock b/Cargo.lock index c4252b9ea5..c5409c4e14 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4451,6 +4451,7 @@ dependencies = [ "serde", "serde_json", "serial_test", + "shell-words", "shellexpand", "tempfile", "tokio", @@ -8934,6 +8935,12 @@ dependencies = [ "lazy_static", ] +[[package]] +name = "shell-words" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc6fe69c597f9c37bfeeeeeb33da3530379845f10be461a66d16d03eca2ded77" + [[package]] name = "shellexpand" version = "3.1.1" diff --git a/crates/goose-mcp/Cargo.toml b/crates/goose-mcp/Cargo.toml index a54c337e72..c928ce00cd 100644 --- a/crates/goose-mcp/Cargo.toml +++ b/crates/goose-mcp/Cargo.toml @@ -66,6 +66,7 @@ libc = "0.2" # ~1000 downloads). Pinned to exact version to prevent supply chain attacks. mpatch = "=0.2.0" tokio-util = { workspace = true } +shell-words = "1.1.1" [dev-dependencies] serial_test = { workspace = true } diff --git a/crates/goose-mcp/src/computercontroller/mod.rs b/crates/goose-mcp/src/computercontroller/mod.rs index 785d612578..d957e73138 100644 --- a/crates/goose-mcp/src/computercontroller/mod.rs +++ b/crates/goose-mcp/src/computercontroller/mod.rs @@ -1,4 +1,6 @@ use crate::subprocess::SubprocessExt; +#[cfg(target_os = "macos")] +use base64::Engine; use etcetera::{choose_app_strategy, AppStrategy}; use indoc::{formatdoc, indoc}; use reqwest::{Client, Url}; @@ -17,6 +19,11 @@ use serde::{Deserialize, Serialize}; use std::{collections::HashMap, fs, path::PathBuf, sync::Arc, sync::Mutex}; use tokio::process::Command; +#[cfg(target_os = "macos")] +use rmcp::model::Role; +#[cfg(target_os = "macos")] +use std::sync::atomic::{AtomicBool, Ordering}; + #[cfg(unix)] use std::os::unix::fs::PermissionsExt; @@ -91,16 +98,38 @@ pub struct AutomationScriptParams { pub save_output: bool, } -/// Parameters for the computer_control tool +/// Parameters for the computer_control tool (Windows, Linux) +#[cfg(not(target_os = "macos"))] #[derive(Debug, Serialize, Deserialize, JsonSchema)] pub struct ComputerControlParams { - /// The automation script content (PowerShell for Windows, AppleScript for macOS) + /// The automation script content (PowerShell for Windows, shell for Linux) pub script: String, /// Whether to save the script output to a file #[serde(default)] pub save_output: bool, } +/// Parameters for the computer_control tool (macOS — Peekaboo CLI passthrough) +#[cfg(target_os = "macos")] +#[derive(Debug, Serialize, Deserialize, JsonSchema)] +pub struct ComputerControlParams { + /// The peekaboo subcommand and arguments as a single string. + /// Examples: + /// "see --app Safari --annotate" + /// "click --on B1" + /// "type --text \"hello\" --return" + /// "hotkey --keys cmd,c" + /// "app launch Safari --open https://example.com" + /// "window list --app Safari --json" + /// "press tab --count 3" + /// "clipboard --action get" + pub command: String, + /// Whether to capture and return a screenshot as part of the result. + /// Useful after click/type actions to see the updated UI state. + #[serde(default)] + pub capture_screenshot: bool, +} + /// Parameters for the cache tool #[derive(Debug, Serialize, Deserialize, JsonSchema)] pub struct CacheParams { @@ -285,6 +314,8 @@ pub struct ComputerControllerServer { http_client: Client, instructions: String, system_automation: Arc>, + #[cfg(target_os = "macos")] + peekaboo_installed: Arc, } impl Default for ComputerControllerServer { @@ -334,25 +365,96 @@ impl ComputerControllerServer { "macos" => indoc! {r#" Here are some extra tools: automation_script - - Create and run Shell and Ruby scripts - - Shell (bash) is recommended for most tasks + - Create and run Shell, Ruby, or AppleScript scripts - Scripts can save their output to files - - macOS-specific features: - - AppleScript for system and UI control - - Integration with macOS apps and services - - Use the screenshot tool if needed to help with tasks - computer_control - - System automation using AppleScript - - Consider the screenshot tool to work out what is on screen and what to do to help with the control task. + computer_control — Peekaboo CLI for macOS UI automation (auto-installed via Homebrew). + Peekaboo captures/inspects screens, targets UI elements, drives input, and manages + apps/windows/menus. Pass a peekaboo subcommand string as the `command` parameter. + Set `capture_screenshot: true` to capture the screen after actions (click, type, etc.). + Commands support `--json`/`-j` for structured output. Run `peekaboo --help` for + full flags if needed. - When you need to interact with websites or web applications, consider using the computer_control tool with AppleScript, which can automate Safari or other browsers to: - - Open specific URLs - - Fill in forms - - Click buttons - - Extract content - - Handle web-based workflows - This is often more reliable than web scraping for modern web applications. + Quickstart (most reliable flow): + 1. command: "see --app Safari --annotate" — get annotated screenshot with element IDs + 2. command: "click --on B3 --app Safari" — click element B3 + 3. command: "type \"user@example.com\" --app Safari" — type text + 4. command: "press tab --count 1 --app Safari" — press tab + 5. command: "type \"password\" --app Safari --return" — type and press enter + + Vision: + - see — annotated UI map with element IDs and optional AI analysis + `see --app Safari --annotate`, `see --mode screen --screen-index 0` + `see --app Notes --analyze "describe what's on screen"` + - image — capture screenshots without annotation + `image --mode frontmost`, `image --mode screen --screen-index 1 --retina` + `image --app Safari --window-title "Dashboard" --analyze "Summarize KPIs"` + - capture — live motion-aware capture + `capture live --mode region --region 100,100,800,600 --duration 30` + + Interaction: + - click — by element ID, query, or coordinates with smart waits + `click --on B1`, `click --coords 100,200`, `click --on B1 --double`, `click --on B1 --right` + - type — text input with optional control keys + `type "hello" --return`, `type "text" --clear --app Notes`, `type "slow" --wpm 80` + - press — special key sequences with repeats + `press tab --count 3`, `press escape`, `press return`, `press space` + - hotkey — modifier key combos (comma-separated) + `hotkey --keys cmd,c`, `hotkey --keys cmd,shift,t`, `hotkey --keys cmd,a` + - paste — set clipboard then paste (more reliable than type for long text) + `paste --text "long multi-line content"` + - scroll — directional scrolling with optional targeting + `scroll --direction down --amount 5 --smooth`, `scroll --direction up --amount 3` + - drag — drag between elements or coordinates + `drag --from B1 --to T2`, `drag --from-coords 100,100 --to-coords 500,300` + - swipe — gesture-style drags + `swipe --from-coords 100,500 --to-coords 100,200 --duration 800` + - move — cursor positioning + `move 500,300 --smooth` + + Apps & Windows: + - app — launch, quit, switch, list applications + `app launch Safari --open https://example.com`, `app quit Safari` + `app switch Safari`, `app list`, `app hide Safari`, `app unhide Safari` + - window — manage window position, size, focus, list + `window list --app Safari --json`, `window focus --app Safari` + `window set-bounds --app Safari --x 50 --y 50 --width 1200 --height 800` + `window close --app Safari`, `window minimize --app Safari` + - list — enumerate apps, windows, screens + `list apps --json`, `list windows --json`, `list screens --json` + - space — macOS Spaces (virtual desktops) + `space list`, `space switch --index 2` + + Menus & System: + - menu — click application menu items + `menu click --app Safari --item "New Window"` + `menu click --app TextEdit --path "Format > Font > Show Fonts"` + - menubar — status bar / menu extras + `menubar list --json`, `menubar click --title "WiFi"` + - dock — Dock items + `dock launch Safari`, `dock list --json` + - dialog — system dialogs and alerts + `dialog click --button "OK"`, `dialog list` + - clipboard — read/write clipboard + `clipboard --action get`, `clipboard --action set --text "content"` + - open — open URLs or files with app targeting + `open https://example.com --app Safari` + - permissions — check Screen Recording / Accessibility status + `permissions status` + + Common targeting parameters (work across most commands): + - App/window: `--app Name`, `--pid 1234`, `--window-title "title"`, `--window-id 5678`, `--window-index 0` + - Elements: `--on B1` (element ID from see), `--coords 100,200` + - Snapshot reuse: `--snapshot ` (reuse a previous see result without re-capturing) + - Focus: `--no-auto-focus`, `--space-switch`, `--bring-to-current-space` + + Tips: + - Always `see --annotate` first to identify element IDs before clicking + - Use `--json` for structured output on list/query commands + - Use `paste` over `type` for long or multi-line text + - Use `--screen-index` for multi-monitor setups + - If something fails, check `permissions status` for missing permissions + - Use `capture_screenshot: true` on click/type/press actions to verify the result "#}, _ => indoc! {r#" Here are some extra tools: @@ -421,6 +523,8 @@ impl ComputerControllerServer { http_client: Client::builder().user_agent("goose/1.0").build().unwrap(), instructions, system_automation, + #[cfg(target_os = "macos")] + peekaboo_installed: Arc::new(AtomicBool::new(crate::peekaboo::is_peekaboo_installed())), } } @@ -592,20 +696,36 @@ impl ComputerControllerServer { } /// Create and run small scripts for automation tasks - #[cfg(not(target_os = "windows"))] + #[cfg(target_os = "macos")] #[tool( name = "automation_script", description = " - Create and run small scripts for automation tasks. - Supports Shell and Ruby (on macOS). + Create and run Shell, Ruby, or AppleScript (via osascript) scripts. + Use shell (bash) for most tasks. AppleScript for app scripting and system settings. + Examples: + - sort file.txt | uniq + - awk -F ',' '{ print $2}' file.csv + - osascript -e 'tell app \"Finder\" to get name of every window' + " + )] + pub async fn automation_script( + &self, + params: Parameters, + ) -> Result { + self.automation_script_impl(params).await + } - The script is saved to a temporary file and executed. + /// Create and run small scripts for automation tasks + #[cfg(not(any(target_os = "windows", target_os = "macos")))] + #[tool( + name = "automation_script", + description = " + Create and run Shell scripts for automation tasks. Consider using shell script (bash) for most simple tasks first. - Ruby is useful for text processing or when you need more sophisticated scripting capabilities. - Some examples of shell: - - create a sorted list of unique lines: sort file.txt | uniq - - extract 2nd column in csv: awk -F ',' '{ print $2}' - - pattern matching: grep pattern file.txt + Examples: + - sort file.txt | uniq + - awk -F ',' '{ print $2}' file.csv + - grep pattern file.txt " )] pub async fn automation_script( @@ -788,33 +908,33 @@ impl ComputerControllerServer { self.computer_control_impl(params).await } - /// Control the computer using system automation + /// Control the computer using Peekaboo CLI for macOS GUI automation. + /// Auto-installs via Homebrew on first use. #[cfg(target_os = "macos")] #[tool( name = "computer_control", description = " - Control the computer using AppleScript (macOS only). Automate applications and system features. + macOS UI automation via Peekaboo CLI. Pass a subcommand string as `command`. - Key capabilities: - - Control Applications: Launch, quit, manage apps (Mail, Safari, iTunes, etc) - - Interact with app-specific feature: (e.g, edit documents, process photos) - - Perform tasks in third-party apps that support AppleScript - - UI Automation: Simulate user interactions like, clicking buttons, select menus, type text, filling out forms - - System Control: Manage settings (volume, brightness, wifi), shutdown/restart, monitor events - - Web & Email: Open URLs, web automation, send/organize emails, handle attachments - - Media: Manage music libraries, photo collections, playlists - - File Operations: Organize files/folders - - Integration: Calendar, reminders, messages - - Data: Interact with spreadsheets and documents + Core workflow: see → click → type + 1. see --app Safari --annotate (get annotated screenshot with element IDs) + 2. click --on B3 (click element by ID) + 3. type \"hello\" --return (type text, press enter) - Can be combined with screenshot tool for visual task assistance. + Key commands: see, image, click, type, press, hotkey, paste, scroll, drag, + swipe, move, app, window, list, menu, menubar, dock, dialog, clipboard, + space, open, permissions. + + Targeting: --app Name, --window-title, --window-id, --on ID, --coords x,y + Set capture_screenshot=true to verify UI state after actions. + See extension instructions for full command reference and examples. " )] pub async fn computer_control( &self, params: Parameters, ) -> Result { - self.computer_control_impl(params).await + self.peekaboo_impl(params).await } /// Control the computer using system automation @@ -856,6 +976,7 @@ impl ComputerControllerServer { self.computer_control_impl(params).await } + #[cfg(not(target_os = "macos"))] async fn computer_control_impl( &self, params: Parameters, @@ -892,6 +1013,170 @@ impl ComputerControllerServer { Ok(CallToolResult::success(vec![Content::text(result)])) } + #[cfg(target_os = "macos")] + fn ensure_peekaboo(&self) -> Result<(), ErrorData> { + if self.peekaboo_installed.load(Ordering::Relaxed) { + return Ok(()); + } + if crate::peekaboo::is_peekaboo_installed() { + self.peekaboo_installed.store(true, Ordering::Relaxed); + return Ok(()); + } + tracing::info!("Peekaboo not found, attempting auto-install via brew"); + match crate::peekaboo::auto_install_peekaboo() { + Ok(()) => { + self.peekaboo_installed.store(true, Ordering::Relaxed); + tracing::info!("Peekaboo installed successfully"); + Ok(()) + } + Err(msg) => Err(ErrorData::new( + ErrorCode::INTERNAL_ERROR, + format!( + "Peekaboo is not installed and auto-install failed: {}\n\ + Install manually with: brew install steipete/tap/peekaboo\n\ + Peekaboo requires macOS 15+ (Sequoia) with Screen Recording and Accessibility permissions.", + msg + ), + None, + )), + } + } + + #[cfg(target_os = "macos")] + fn run_peekaboo_cmd(&self, args: &[&str]) -> Result { + let output = std::process::Command::new("peekaboo") + .args(args) + .output() + .map_err(|e| { + ErrorData::new( + ErrorCode::INTERNAL_ERROR, + format!("Failed to run peekaboo: {}", e), + None, + ) + })?; + let stdout = String::from_utf8_lossy(&output.stdout).into_owned(); + let stderr = String::from_utf8_lossy(&output.stderr).into_owned(); + if !output.status.success() { + return Err(ErrorData::new( + ErrorCode::INTERNAL_ERROR, + format!( + "peekaboo {} failed (exit {}):\n{}\n{}", + args.first().unwrap_or(&""), + output.status, + stderr.trim(), + stdout.trim() + ), + None, + )); + } + Ok(stdout) + } + + #[cfg(target_os = "macos")] + async fn peekaboo_impl( + &self, + params: Parameters, + ) -> Result { + self.ensure_peekaboo()?; + let params = params.0; + + let args = shell_words::split(¶ms.command).map_err(|e| { + ErrorData::new( + ErrorCode::INVALID_PARAMS, + format!("Failed to parse command: {}", e), + None, + ) + })?; + if args.is_empty() { + return Err(ErrorData::new( + ErrorCode::INVALID_PARAMS, + "Command cannot be empty".to_string(), + None, + )); + } + + let is_see = args[0] == "see"; + let is_image = args[0] == "image"; + let screenshot_path = if is_see || is_image { + Some(self.get_cache_path(&args[0], "png")) + } else { + None + }; + + let mut full_args: Vec = args.clone(); + + if let Some(ref path) = screenshot_path { + if !full_args.iter().any(|a| a == "--path") { + full_args.push("--path".to_string()); + full_args.push(path.to_string_lossy().to_string()); + } + } + if is_see && !full_args.iter().any(|a| a == "--json-output") { + full_args.push("--json-output".to_string()); + } + + let wants_json = matches!( + args[0].as_str(), + "list" | "window" | "menubar" | "permissions" | "clipboard" + ); + if wants_json + && !full_args.iter().any(|a| a == "--json" || a == "-j") + && !full_args.iter().any(|a| a == "--json-output") + { + full_args.push("--json".to_string()); + } + + let arg_refs: Vec<&str> = full_args.iter().map(|s| s.as_str()).collect(); + let stdout = self.run_peekaboo_cmd(&arg_refs)?; + + let mut contents = Vec::new(); + + if let Some(ref path) = screenshot_path { + let annotated = path.to_string_lossy().replace(".png", "_annotated.png"); + let image_path = if is_see && std::path::Path::new(&annotated).exists() { + PathBuf::from(&annotated) + } else { + path.clone() + }; + if image_path.exists() { + if let Ok(bytes) = fs::read(&image_path) { + let data = base64::prelude::BASE64_STANDARD.encode(&bytes); + contents.push(Content::image(data, "image/png").with_priority(0.0)); + } + } + } + + if params.capture_screenshot && screenshot_path.is_none() { + let cap_path = self.get_cache_path("peekaboo_capture", "png"); + let cap_path_str = cap_path.to_string_lossy().to_string(); + if self + .run_peekaboo_cmd(&["image", "--mode", "frontmost", "--path", &cap_path_str]) + .is_ok() + && cap_path.exists() + { + if let Ok(bytes) = fs::read(&cap_path) { + let data = base64::prelude::BASE64_STANDARD.encode(&bytes); + contents.push(Content::image(data, "image/png").with_priority(0.0)); + } + } + } + + let text = if stdout.len() > 12000 { + let truncated: String = stdout.chars().take(12000).collect(); + format!( + "{}\n\n[Output truncated. {} total chars.]", + truncated, + stdout.len() + ) + } else { + stdout + }; + + contents.insert(0, Content::text(&text).with_audience(vec![Role::Assistant])); + + Ok(CallToolResult::success(contents)) + } + /// Process Excel (XLSX) files to read and manipulate spreadsheet data #[tool( name = "xlsx_tool", diff --git a/crates/goose-mcp/src/computercontroller/platform/mod.rs b/crates/goose-mcp/src/computercontroller/platform/mod.rs index 5a456ca896..ea1ea8f108 100644 --- a/crates/goose-mcp/src/computercontroller/platform/mod.rs +++ b/crates/goose-mcp/src/computercontroller/platform/mod.rs @@ -14,6 +14,7 @@ pub use self::macos::MacOSAutomation; #[cfg(any(target_os = "linux", target_os = "android"))] pub use self::linux::LinuxAutomation; +#[allow(dead_code)] pub trait SystemAutomation: Send + Sync { fn execute_system_script(&self, script: &str) -> std::io::Result; fn get_shell_command(&self) -> (&'static str, &'static str); // (shell, arg) diff --git a/crates/goose-mcp/src/lib.rs b/crates/goose-mcp/src/lib.rs index e1077683c9..530c30dfb9 100644 --- a/crates/goose-mcp/src/lib.rs +++ b/crates/goose-mcp/src/lib.rs @@ -14,6 +14,8 @@ pub mod computercontroller; pub mod developer; pub mod mcp_server_runner; mod memory; +#[cfg(target_os = "macos")] +pub mod peekaboo; pub mod subprocess; pub mod tutorial; diff --git a/crates/goose-mcp/src/peekaboo/mod.rs b/crates/goose-mcp/src/peekaboo/mod.rs new file mode 100644 index 0000000000..2754f63222 --- /dev/null +++ b/crates/goose-mcp/src/peekaboo/mod.rs @@ -0,0 +1,85 @@ +//! Peekaboo helper functions for macOS GUI automation via the Peekaboo CLI. +//! +//! These are used by `ComputerControllerServer` on macOS to auto-install +//! and invoke peekaboo. This module does not expose its own MCP server — +//! peekaboo is accessed through the `computer_control` tool on macOS. + +const BREW_FORMULA: &str = "steipete/tap/peekaboo"; + +pub fn is_peekaboo_installed() -> bool { + std::process::Command::new("which") + .arg("peekaboo") + .output() + .map(|o| o.status.success()) + .unwrap_or(false) +} + +pub fn resolve_brew() -> Option { + if let Ok(output) = std::process::Command::new("which").arg("brew").output() { + if output.status.success() { + let path = String::from_utf8_lossy(&output.stdout).trim().to_string(); + if !path.is_empty() { + return Some(path); + } + } + } + + for candidate in &["/opt/homebrew/bin/brew", "/usr/local/bin/brew"] { + if std::path::Path::new(candidate).exists() { + return Some(candidate.to_string()); + } + } + + None +} + +pub fn auto_install_peekaboo() -> Result<(), String> { + let brew = resolve_brew().ok_or_else(|| { + "Homebrew is not installed. Install Homebrew first (https://brew.sh), then run: brew install steipete/tap/peekaboo".to_string() + })?; + + tracing::info!("Running: {} install {}", brew, BREW_FORMULA); + + let output = std::process::Command::new(&brew) + .args(["install", BREW_FORMULA]) + .output() + .map_err(|e| format!("Failed to run brew: {}", e))?; + + if output.status.success() { + if is_peekaboo_installed() { + return Ok(()); + } + // brew succeeded but binary not on PATH — try adding brew bin + if let Ok(prefix_output) = std::process::Command::new(&brew) + .args(["--prefix"]) + .output() + { + let prefix = String::from_utf8_lossy(&prefix_output.stdout) + .trim() + .to_string(); + let bin_path = format!("{}/bin/peekaboo", prefix); + if std::path::Path::new(&bin_path).exists() { + if let Ok(current_path) = std::env::var("PATH") { + std::env::set_var("PATH", format!("{}/bin:{}", prefix, current_path)); + if is_peekaboo_installed() { + return Ok(()); + } + } + } + } + Err("brew install succeeded but peekaboo binary not found on PATH".to_string()) + } else { + let stderr = String::from_utf8_lossy(&output.stderr); + let stdout = String::from_utf8_lossy(&output.stdout); + Err(format!( + "brew install failed (exit {}):\n{}{}", + output.status, + stderr.trim(), + if stdout.trim().is_empty() { + String::new() + } else { + format!("\n{}", stdout.trim()) + } + )) + } +} From 78fe007775ca091d3945b864c538f043bbc4570f Mon Sep 17 00:00:00 2001 From: conrado <98063131+conrado44@users.noreply.github.com> Date: Thu, 19 Feb 2026 23:28:28 -0500 Subject: [PATCH 16/21] feat: add Neighborhood extension to the Extensions Library (#7328) Co-authored-by: Claude Opus 4.6 Co-authored-by: Angie Jones Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> --- documentation/docs/mcp/neighborhood-mcp.md | 237 +++++++++++++++++++++ documentation/static/servers.json | 12 ++ 2 files changed, 249 insertions(+) create mode 100644 documentation/docs/mcp/neighborhood-mcp.md diff --git a/documentation/docs/mcp/neighborhood-mcp.md b/documentation/docs/mcp/neighborhood-mcp.md new file mode 100644 index 0000000000..6024d0e593 --- /dev/null +++ b/documentation/docs/mcp/neighborhood-mcp.md @@ -0,0 +1,237 @@ +--- +title: Neighborhood Extension +description: Add Neighborhood as a goose Extension +--- + +import Tabs from '@theme/Tabs'; +import TabItem from '@theme/TabItem'; +import GooseDesktopInstaller from '@site/src/components/GooseDesktopInstaller'; +import CLIExtensionInstructions from '@site/src/components/CLIExtensionInstructions'; + +This tutorial covers how to add the Neighborhood extension to goose, enabling you to discover nearby restaurants, browse menus, and place takeout orders through natural conversation. Sellers are US-based. + +:::tip TLDR + + + [Launch the installer](goose://extension?type=streamable_http&url=https%3A%2F%2Fconnect.squareup.com%2Fv2%2Fmcp%2Fneighborhood&id=neighborhood&name=Neighborhood&description=Discover%20nearby%20restaurants%2C%20browse%20menus%2C%20and%20place%20takeout%20orders%20through%20natural%20conversation.) + + + + 1. Run the `configure` command: + + ```sh + goose configure + ``` + + 2. Choose to add a `Remote Extension` + + ```sh + ┌ goose-configure + │ + ◇ What would you like to configure? + │ Add Extension (Connect to a new extension) + │ + ◆ What type of extension would you like to add? + │ ○ Built-in Extension + │ ○ Command-line Extension (Run a local command or script) + // highlight-start + │ ● Remote Extension + // highlight-end + └ + ``` + + 3. Give your extension a name + + ```sh + ┌ goose-configure + │ + ◇ What would you like to configure? + │ Add Extension (Connect to a new extension) + │ + ◇ What type of extension would you like to add? + │ Remote Extension + │ + // highlight-start + ◆ What would you like to call this extension? + │ Neighborhood + // highlight-end + └ + ``` + + 4. Enter the remote endpoint URL + + ```sh + ┌ goose-configure + │ + ◇ What would you like to configure? + │ Add Extension (Connect to a new extension) + │ + ◇ What type of extension would you like to add? + │ Remote Extension + │ + ◇ What would you like to call this extension? + │ Neighborhood + │ + // highlight-start + ◆ What is the SSE endpoint URI? + │ https://connect.squareup.com/v2/mcp/neighborhood + // highlight-end + └ + ``` + + 5. Enter the number of seconds goose should wait for actions to complete before timing out. Default is 300s + + ```sh + ┌ goose-configure + │ + ◇ What would you like to configure? + │ Add Extension (Connect to a new extension) + │ + ◇ What type of extension would you like to add? + │ Remote Extension + │ + ◇ What would you like to call this extension? + │ Neighborhood + │ + ◇ What is the SSE endpoint URI? + │ https://connect.squareup.com/v2/mcp/neighborhood + │ + // highlight-start + ◆ Please set the timeout for this tool (in secs): + │ 300 + // highlight-end + └ + ``` + + 6. Add a description if you want, otherwise select No to leave it blank. + + ```sh + ┌ goose-configure + │ + ◇ What would you like to configure? + │ Add Extension (Connect to a new extension) + │ + ◇ What type of extension would you like to add? + │ Remote Extension + │ + ◇ What would you like to call this extension? + │ Neighborhood + │ + ◇ What is the SSE endpoint URI? + │ https://connect.squareup.com/v2/mcp/neighborhood + │ + ◇ Please set the timeout for this tool (in secs): + │ 300 + │ + // highlight-start + ◆ Would you like to add a description? + │ ○ Yes / ● No + // highlight-end + │ + └ + ``` + + 7. No environment variables are needed, so select No. + + ```sh + ┌ goose-configure + │ + ◇ What would you like to configure? + │ Add Extension (Connect to a new extension) + │ + ◇ What type of extension would you like to add? + │ Remote Extension + │ + ◇ What would you like to call this extension? + │ Neighborhood + │ + ◇ What is the SSE endpoint URI? + │ https://connect.squareup.com/v2/mcp/neighborhood + │ + ◇ Please set the timeout for this tool (in secs): + │ 300 + │ + ◇ Would you like to add a description? + │ No + │ + // highlight-start + ◆ Would you like to add environment variables? + │ ○ Yes / ● No + // highlight-end + └ Added Neighborhood extension + ``` + + + +::: + +## Configuration + + + + + + + + + + +## Example Usage + +Neighborhood is most powerful when goose combines it with context from your day — your schedule, your goals, your dietary needs. Instead of just searching for food, you can ask goose to reason about what to eat based on what you're doing. + +### Finding a meal that fits your activity + +#### goose Prompt +``` +Use the neighborhood extension for this. I'm looking to get lunch today. +I'm at 375 W Broadway in New York. I'm playing tennis later tonight. +Could you suggest some options so I can play well? +``` + +#### goose Output + +``` +Here are some restaurants near 375 W Broadway in SoHo! For pre-tennis fuel, +I'd recommend these options: + +Best picks for athletic performance: + +Kale & Things - Perfect for a healthy, nutrient-dense meal with greens and +lean proteins to give you sustained energy without feeling heavy + +Simply Natural Grill House NY (684 Broadway) - Great for grilled proteins +and wholesome meals that'll fuel your game + +Ba'al Falafel (71 Sullivan St) - Mediterranean food with falafel, hummus, +and fresh veggies provides good carbs and protein + +Tips for eating before tennis: + +- Eat 2-3 hours before playing to allow digestion +- Focus on complex carbs + lean protein (avoid heavy, fatty foods) +- Stay hydrated - consider grabbing a drink from Steam & Sip or Drip Drop Café + +Would you like me to pull up the menu for any of these restaurants so you can +see what they offer? Kale & Things sounds like it could be ideal for your +pre-match meal! +``` + +### More Prompt Ideas + +Try combining Neighborhood with other goose extensions for even more useful workflows: + +- **Pair with your calendar:** *"Check my calendar for today and find somewhere I can grab a quick pickup lunch before my 1pm meeting. I'm near Union Square."* +- **Track what you eat:** *"Order me a chicken bowl from that place on Sullivan St, and log the macros to my food diary."* +- **Plan for a group:** *"I'm meeting 3 friends near Bryant Park tonight. Find somewhere with good vegetarian options that's not too loud."* diff --git a/documentation/static/servers.json b/documentation/static/servers.json index 3c0c6f8597..f3f7939d74 100644 --- a/documentation/static/servers.json +++ b/documentation/static/servers.json @@ -756,5 +756,17 @@ "is_builtin": false, "endorsed": false, "environmentVariables": [] + }, + { + "id": "neighborhood", + "name": "Neighborhood", + "description": "Discover nearby restaurants, browse menus, and place takeout orders through natural conversation. Sellers are US-based.", + "type": "streamable-http", + "url": "https://connect.squareup.com/v2/mcp/neighborhood", + "link": "", + "installation_notes": "No local setup required. This extension connects to a remote service. Use the install button or run the command below.", + "is_builtin": false, + "endorsed": true, + "environmentVariables": [] } ] From 93f123280efbae80ae44232e262950a9ecc52a15 Mon Sep 17 00:00:00 2001 From: Douwe Osinga Date: Fri, 20 Feb 2026 12:19:43 +0000 Subject: [PATCH 17/21] Completely pointless ascii art (#7329) Co-authored-by: Douwe Osinga --- crates/goose-cli/src/session/mod.rs | 1 - crates/goose-cli/src/session/output.rs | 39 ++++++++++++++------------ 2 files changed, 21 insertions(+), 19 deletions(-) diff --git a/crates/goose-cli/src/session/mod.rs b/crates/goose-cli/src/session/mod.rs index 2ab1183b06..fcc22dc4b0 100644 --- a/crates/goose-cli/src/session/mod.rs +++ b/crates/goose-cli/src/session/mod.rs @@ -479,7 +479,6 @@ impl CliSession { let history_manager = HistoryManager::new(); history_manager.load(&mut editor); - output::display_greeting(); loop { self.display_context_usage().await?; diff --git a/crates/goose-cli/src/session/output.rs b/crates/goose-cli/src/session/output.rs index 8a73bf4d93..c458744b09 100644 --- a/crates/goose-cli/src/session/output.rs +++ b/crates/goose-cli/src/session/output.rs @@ -1252,6 +1252,8 @@ pub fn display_session_info( session_id: &Option, provider_instance: Option<&Arc>, ) { + set_terminal_title(); + let status = if resume { "resuming" } else if session_id.is_none() { @@ -1271,8 +1273,16 @@ pub fn display_session_info( model.to_string() }; + let cwd_display = std::env::current_dir() + .ok() + .map(|p| p.display().to_string()) + .unwrap_or_else(|| "unknown".to_string()); + + // ASCII art goose with session info on the right + println!(); println!( - "\n {} {} {} {} {}", + " {} {} {} {} {} {}", + style(" __( O)>").white(), style("●").green(), style(status).dim(), style("·").dim(), @@ -1280,28 +1290,30 @@ pub fn display_session_info( style(&model_display).cyan(), ); - let cwd_display = std::env::current_dir() - .ok() - .map(|p| p.display().to_string()) - .unwrap_or_else(|| "unknown".to_string()); - if let Some(id) = session_id { println!( - " {} {} {}", + " {} {} {} {}", + style(r" \____)").white(), style(" ").dim(), style(id).dim(), style(format!("· {}", cwd_display)).dim(), ); } else { println!( - " {} {}", + " {} {} {}", + style(r" \____)").white(), style(" ").dim(), style(format!(" {}", cwd_display)).dim(), ); } + println!( + " {} {}", + style(" L L").white(), + style(" goose is ready").white() + ); } -pub fn set_terminal_title() { +fn set_terminal_title() { if !std::io::stdout().is_terminal() { return; } @@ -1316,15 +1328,6 @@ pub fn set_terminal_title() { let _ = std::io::stdout().flush(); } -pub fn display_greeting() { - set_terminal_title(); - println!( - "\n{} {}\n", - style("🪿 goose").bold(), - style("ready — type a message to get started").dim() - ); -} - pub fn display_context_usage(total_tokens: usize, context_limit: usize) { use console::style; From c8c8a1237c7010b8301ea50bccbdcfbec102cb87 Mon Sep 17 00:00:00 2001 From: Rabi Mishra Date: Fri, 20 Feb 2026 18:34:09 +0530 Subject: [PATCH 18/21] fix(summon): stop MOIM from telling models to sleep while waiting for tasks (#7377) Signed-off-by: rabi --- .../src/agents/platform_extensions/summon.rs | 84 ++++++++----------- 1 file changed, 36 insertions(+), 48 deletions(-) diff --git a/crates/goose/src/agents/platform_extensions/summon.rs b/crates/goose/src/agents/platform_extensions/summon.rs index 91a0b4a3ad..9ec4f73b6d 100644 --- a/crates/goose/src/agents/platform_extensions/summon.rs +++ b/crates/goose/src/agents/platform_extensions/summon.rs @@ -330,10 +330,12 @@ impl SummonClient { "Load knowledge into your current context or discover available sources.\n\n\ Call with no arguments to list all available sources (subrecipes, recipes, skills, agents).\n\ Call with a source name to load its content into your context.\n\ - For background tasks: load(source: \"task_id\", cancel: true) stops and returns output.\n\n\ + For background tasks: load(source: \"task_id\") waits for the task and returns the result.\n\ + To cancel a running task: load(source: \"task_id\", cancel: true) stops and returns output.\n\n\ Examples:\n\ - load() → Lists available sources\n\ - - load(source: \"rust-patterns\") → Loads the rust-patterns skill" + - load(source: \"rust-patterns\") → Loads the rust-patterns skill\n\ + - load(source: \"20260219_1\") → Waits for background task, then returns result" .to_string(), schema.as_object().unwrap().clone(), ) @@ -880,7 +882,7 @@ impl SummonClient { // Wait for the running task to complete, keeping the tool call // alive so notifications (subagent tool calls) stream in real time. - let task = running.remove(task_id).unwrap(); + let mut task = running.remove(task_id).unwrap(); drop(running); let buffered = { @@ -896,45 +898,37 @@ impl SummonClient { } } - let description = task.description.clone(); - let mut handle = task.handle; - - let (output, timed_out) = tokio::select! { - result = &mut handle => { - let s = match result { + tokio::select! { + result = &mut task.handle => { + let output = match result { Ok(Ok(s)) => s, Ok(Err(e)) => format!("Error: {}", e), Err(e) => format!("Task panicked: {}", e), }; - (s, false) + + return Ok(vec![Content::text(format!( + "# Background Task Result: {}\n\n\ + **Task:** {}\n\ + **Status:** ✓ Completed\n\ + **Duration:** {} ({} turns)\n\n\ + ## Output\n\n{}", + task_id, + task.description, + round_duration(task.started_at.elapsed()), + task.turns.load(Ordering::Relaxed), + output + ))]); } _ = tokio::time::sleep(Duration::from_secs(300)) => { - handle.abort(); - ("Task timed out waiting for completion (aborted after 5 min)".to_string(), true) + self.background_tasks.lock().await.insert(task_id.to_string(), task); + + return Err(format!( + "Task '{task_id}' is still running after waiting 5 min. \ + Use load(source: \"{task_id}\") to wait again, or \ + load(source: \"{task_id}\", cancel: true) to stop." + )); } - }; - - let duration = task.started_at.elapsed(); - let turns_taken = task.turns.load(Ordering::Relaxed); - let status = if timed_out { - "⏱ Timed out" - } else { - "✓ Completed" - }; - - return Ok(vec![Content::text(format!( - "# Background Task Result: {}\n\n\ - **Task:** {}\n\ - **Status:** {}\n\ - **Duration:** {} ({} turns)\n\n\ - ## Output\n\n{}", - task_id, - description, - status, - round_duration(duration), - turns_taken, - output - ))]); + } } Err(format!("Task '{}' not found.", task_id)) @@ -1628,7 +1622,8 @@ impl SummonClient { .insert(task_id.clone(), task); Ok(vec![Content::text(format!( - "Task {} started in background: \"{}\"\nUse load(source: \"{}\") to wait for the result (it will block until complete).", + "Task {} started in background: \"{}\"\n\ + Continue with other work. When you need the result, use load(source: \"{}\").", task_id, description, task_id ))]) } @@ -1714,8 +1709,6 @@ impl McpClientTrait for SummonClient { let mut lines = vec!["Background tasks:".to_string()]; let now = current_epoch_millis(); - let mut shortest_elapsed_secs: Option = None; - let mut sorted_running: Vec<_> = running.values().collect(); sorted_running.sort_by_key(|t| &t.id); @@ -1723,10 +1716,6 @@ impl McpClientTrait for SummonClient { let elapsed = task.started_at.elapsed(); let idle_ms = now.saturating_sub(task.last_activity.load(Ordering::Relaxed)); - let elapsed_secs = elapsed.as_secs(); - shortest_elapsed_secs = - Some(shortest_elapsed_secs.map_or(elapsed_secs, |s| s.min(elapsed_secs))); - lines.push(format!( "• {}: \"{}\" - running {}, {} turns, idle {}", task.id, @@ -1757,12 +1746,11 @@ impl McpClientTrait for SummonClient { )); } - if let Some(shortest) = shortest_elapsed_secs { - let sleep_secs = 300u64.saturating_sub(shortest).max(10); - lines.push(format!( - "\n→ sleep {} to wait, or load(source: \"id\", cancel: true) to stop", - sleep_secs - )); + if !running.is_empty() { + lines.push( + "\n→ Use load(source: \"\") to wait for a task, or load(source: \"\", cancel: true) to stop it" + .to_string(), + ); } Some(lines.join("\n")) From 966bbba8198326c77c35bcc19bf26d9a4f26a90e Mon Sep 17 00:00:00 2001 From: jh-block Date: Fri, 20 Feb 2026 14:11:56 +0100 Subject: [PATCH 19/21] Remove display_name from local model API and use model ID everywhere (#7382) --- crates/goose-cli/src/cli.rs | 15 ++++++--------- .../goose-server/src/routes/local_inference.rs | 11 +++-------- .../local_inference/local_model_registry.rs | 12 ------------ ui/desktop/openapi.json | 4 ---- ui/desktop/src/api/types.gen.ts | 1 - ui/desktop/src/components/LocalModelSetup.tsx | 10 +++++----- .../localInference/LocalInferenceSettings.tsx | 17 ++++------------- 7 files changed, 18 insertions(+), 52 deletions(-) diff --git a/crates/goose-cli/src/cli.rs b/crates/goose-cli/src/cli.rs index 26487713ae..080e8975e6 100644 --- a/crates/goose-cli/src/cli.rs +++ b/crates/goose-cli/src/cli.rs @@ -1443,7 +1443,7 @@ async fn handle_term_subcommand(command: TermCommand) -> Result<()> { async fn handle_local_models_command(command: LocalModelsCommand) -> Result<()> { use goose::providers::local_inference::hf_models; use goose::providers::local_inference::local_model_registry::{ - display_name_from_repo, get_registry, model_id_from_repo, LocalModelEntry, + get_registry, model_id_from_repo, LocalModelEntry, }; match command { @@ -1482,13 +1482,12 @@ async fn handle_local_models_command(command: LocalModelsCommand) -> Result<()> println!("Resolving {}...", spec); let (repo_id, file) = hf_models::resolve_model_spec(&spec).await?; let model_id = model_id_from_repo(&repo_id, &file.quantization); - let display_name = display_name_from_repo(&repo_id, &file.quantization); let local_path = goose::config::paths::Paths::in_data_dir("models").join(&file.filename); println!( "Downloading {} ({})...", - display_name, + model_id, if file.size_bytes > 0 { format!( "{:.1}GB", @@ -1502,7 +1501,6 @@ async fn handle_local_models_command(command: LocalModelsCommand) -> Result<()> // Register let entry = LocalModelEntry { id: model_id.clone(), - display_name: display_name.clone(), repo_id: repo_id.clone(), filename: file.filename.clone(), quantization: file.quantization.clone(), @@ -1545,7 +1543,7 @@ async fn handle_local_models_command(command: LocalModelsCommand) -> Result<()> std::io::stdout().flush().ok(); } goose::download_manager::DownloadStatus::Completed => { - println!("\nDownloaded: {} (id: {})", display_name, model_id); + println!("\nDownloaded: {}", model_id); break; } goose::download_manager::DownloadStatus::Failed => { @@ -1572,13 +1570,12 @@ async fn handle_local_models_command(command: LocalModelsCommand) -> Result<()> return Ok(()); } - println!("{:<40} {:<20} {:<10} Downloaded", "ID", "Name", "Quant"); - println!("{}", "-".repeat(80)); + println!("{:<50} {:<10} Downloaded", "ID", "Quant"); + println!("{}", "-".repeat(70)); for m in models { println!( - "{:<40} {:<20} {:<10} {}", + "{:<50} {:<10} {}", m.id, - m.display_name, m.quantization, if m.is_downloaded() { "✓" } else { "✗" } ); diff --git a/crates/goose-server/src/routes/local_inference.rs b/crates/goose-server/src/routes/local_inference.rs index 321b1b3984..d93518e369 100644 --- a/crates/goose-server/src/routes/local_inference.rs +++ b/crates/goose-server/src/routes/local_inference.rs @@ -13,9 +13,8 @@ use goose::providers::local_inference::{ available_inference_memory_bytes, hf_models::{resolve_model_spec, HfGgufFile}, local_model_registry::{ - display_name_from_repo, get_registry, is_featured_model, model_id_from_repo, - LocalModelEntry, ModelDownloadStatus as RegistryDownloadStatus, ModelSettings, - FEATURED_MODELS, + get_registry, is_featured_model, model_id_from_repo, LocalModelEntry, + ModelDownloadStatus as RegistryDownloadStatus, ModelSettings, FEATURED_MODELS, }, recommend_local_model, }; @@ -40,7 +39,6 @@ pub enum ModelDownloadStatus { #[derive(Debug, Clone, Serialize, Deserialize, ToSchema)] pub struct LocalModelResponse { pub id: String, - pub display_name: String, pub repo_id: String, pub filename: String, pub quantization: String, @@ -94,7 +92,6 @@ async fn ensure_featured_models_in_registry() -> Result<(), ErrorResponse> { entries_to_add.push(LocalModelEntry { id: model_id, - display_name: display_name_from_repo(&repo_id, &quantization), repo_id, filename: hf_file.filename, quantization, @@ -158,7 +155,6 @@ pub async fn list_local_models( models.push(LocalModelResponse { id: entry.id.clone(), - display_name: entry.display_name.clone(), repo_id: entry.repo_id.clone(), filename: entry.filename.clone(), quantization: entry.quantization.clone(), @@ -175,7 +171,7 @@ pub async fn list_local_models( match (b_downloaded, a_downloaded) { (true, false) => std::cmp::Ordering::Greater, (false, true) => std::cmp::Ordering::Less, - _ => a.display_name.cmp(&b.display_name), + _ => a.id.cmp(&b.id), } }); @@ -272,7 +268,6 @@ pub async fn download_hf_model( let entry = LocalModelEntry { id: model_id.clone(), - display_name: display_name_from_repo(&repo_id, &quantization), repo_id, filename: hf_file.filename, quantization, diff --git a/crates/goose/src/providers/local_inference/local_model_registry.rs b/crates/goose/src/providers/local_inference/local_model_registry.rs index 898a138912..3ef80c6ae1 100644 --- a/crates/goose/src/providers/local_inference/local_model_registry.rs +++ b/crates/goose/src/providers/local_inference/local_model_registry.rs @@ -123,7 +123,6 @@ pub fn get_registry() -> &'static Mutex { #[derive(Debug, Clone, Serialize, Deserialize)] pub struct LocalModelEntry { pub id: String, - pub display_name: String, pub repo_id: String, pub filename: String, pub quantization: String, @@ -306,14 +305,3 @@ impl LocalModelRegistry { pub fn model_id_from_repo(repo_id: &str, quantization: &str) -> String { format!("{}:{}", repo_id, quantization) } - -/// Generate a display name from repo_id and quantization. -pub fn display_name_from_repo(repo_id: &str, quantization: &str) -> String { - let model_name = repo_id - .split('/') - .next_back() - .unwrap_or(repo_id) - .trim_end_matches("-GGUF") - .trim_end_matches("-gguf"); - format!("{} ({})", model_name, quantization) -} diff --git a/ui/desktop/openapi.json b/ui/desktop/openapi.json index 2fee277007..71d5b69936 100644 --- a/ui/desktop/openapi.json +++ b/ui/desktop/openapi.json @@ -5185,7 +5185,6 @@ "type": "object", "required": [ "id", - "display_name", "repo_id", "filename", "quantization", @@ -5195,9 +5194,6 @@ "settings" ], "properties": { - "display_name": { - "type": "string" - }, "filename": { "type": "string" }, diff --git a/ui/desktop/src/api/types.gen.ts b/ui/desktop/src/api/types.gen.ts index a4bc570102..936ad95354 100644 --- a/ui/desktop/src/api/types.gen.ts +++ b/ui/desktop/src/api/types.gen.ts @@ -549,7 +549,6 @@ export type LoadedProvider = { }; export type LocalModelResponse = { - display_name: string; filename: string; id: string; quantization: string; diff --git a/ui/desktop/src/components/LocalModelSetup.tsx b/ui/desktop/src/components/LocalModelSetup.tsx index 4fe469d3a8..e26b514563 100644 --- a/ui/desktop/src/components/LocalModelSetup.tsx +++ b/ui/desktop/src/components/LocalModelSetup.tsx @@ -239,7 +239,7 @@ export function LocalModelSetup({ onSuccess, onCancel }: LocalModelSetupProps) {

    - {recommended.display_name} + {recommended.id} {recommended.status.state === 'Downloaded' && ( @@ -294,7 +294,7 @@ export function LocalModelSetup({ onSuccess, onCancel }: LocalModelSetupProps) { />
    - {model.display_name} + {model.id} {formatSize(model.size_bytes)} {model.status.state === 'Downloaded' && ( @@ -318,9 +318,9 @@ export function LocalModelSetup({ onSuccess, onCancel }: LocalModelSetupProps) { className="w-full px-6 py-3 bg-background-muted text-text-default rounded-lg transition-colors font-medium disabled:opacity-40 disabled:cursor-not-allowed hover:bg-background-muted/80" > {selectedModel?.status.state === 'Downloaded' - ? `Use ${selectedModel.display_name}` + ? `Use ${selectedModel.id}` : selectedModel - ? `Download ${selectedModel.display_name} (${formatSize(selectedModel.size_bytes)})` + ? `Download ${selectedModel.id} (${formatSize(selectedModel.size_bytes)})` : 'Select a model'} @@ -338,7 +338,7 @@ export function LocalModelSetup({ onSuccess, onCancel }: LocalModelSetupProps) {

    - Downloading {selectedModel.display_name} + Downloading {selectedModel.id}

    {downloadProgress ? ( diff --git a/ui/desktop/src/components/settings/localInference/LocalInferenceSettings.tsx b/ui/desktop/src/components/settings/localInference/LocalInferenceSettings.tsx index dc97643585..cdb6fccfa9 100644 --- a/ui/desktop/src/components/settings/localInference/LocalInferenceSettings.tsx +++ b/ui/desktop/src/components/settings/localInference/LocalInferenceSettings.tsx @@ -37,14 +37,6 @@ export const LocalInferenceSettings = () => { const downloadSectionRef = useRef(null); const selectedModelId = currentProvider === 'local' ? currentModel : null; - const getDisplayName = useCallback( - (modelId: string): string => { - const model = models.find((m) => m.id === modelId); - return model?.display_name || modelId; - }, - [models] - ); - const loadModels = useCallback(async () => { try { const response = await listLocalModels(); @@ -195,7 +187,6 @@ export const LocalInferenceSettings = () => {
    {Array.from(downloads.entries()).map(([modelId, progress]) => { if (progress.status === 'completed') return null; - const displayName = getDisplayName(modelId); return (
    { >
    - {displayName} + {modelId} {progress.status === 'downloading' && (

    $@(L@ljBjomYMr=g@oU}au=*d@K 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%0A`|b9B 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