use crate::cli::StreamableHttpOptions; use super::output; use super::CliSession; use console::style; use goose::agents::{Agent, Container, ExtensionError}; use goose::config::resolve_extensions_for_new_session; use goose::config::{get_all_extensions, Config, ExtensionConfig, GooseMode}; use goose::providers::create; use goose::recipe::Recipe; use goose::session::session_manager::SessionType; use goose::session::EnabledExtensionsState; use rustyline::EditMode; use std::collections::BTreeSet; use std::process; use std::sync::Arc; use tokio::task::JoinSet; const EXTENSION_HINT_MAX_LEN: usize = 5; fn truncate_with_ellipsis(s: &str, max_len: usize) -> String { let truncated: String = s.chars().take(max_len).collect(); if s.chars().count() > max_len { format!("{}…", truncated) } else { truncated } } fn parse_cli_flag_extensions( extensions: &[String], streamable_http_extensions: &[StreamableHttpOptions], builtins: &[String], ) -> Vec<(String, ExtensionConfig)> { let mut extensions_to_load = Vec::new(); for (idx, ext_str) in extensions.iter().enumerate() { match CliSession::parse_stdio_extension(ext_str) { Ok(config) => { let hint = truncate_with_ellipsis(ext_str, EXTENSION_HINT_MAX_LEN); let label = format!("stdio #{}({})", idx + 1, hint); extensions_to_load.push((label, config)); } Err(e) => { eprintln!( "{}", style(format!( "Warning: Invalid --extension value '{}' ({}); ignoring", ext_str, e )) .yellow() ); } } } for (idx, opts) in streamable_http_extensions.iter().enumerate() { let config = CliSession::parse_streamable_http_extension(&opts.url, opts.timeout); let hint = truncate_with_ellipsis(&opts.url, EXTENSION_HINT_MAX_LEN); let label = format!("http #{}({})", idx + 1, hint); extensions_to_load.push((label, config)); } for builtin_str in builtins { let configs = CliSession::parse_builtin_extensions(builtin_str); for config in configs { extensions_to_load.push((config.name(), config)); } } extensions_to_load } /// Configuration for building a new Goose session /// /// This struct contains all the parameters needed to create a new session, /// including session identification, extension configuration, and debug settings. #[derive(Clone, Debug)] pub struct SessionBuilderConfig { /// Session id, optional need to deduce from context pub session_id: Option, /// Whether to resume an existing session pub resume: bool, /// Whether to fork an existing session (creates a copy of the original/existing session then resumes the copy) pub fork: bool, /// Whether to run without a session file pub no_session: bool, /// List of stdio extension commands to add pub extensions: Vec, /// List of streamable HTTP extension commands to add pub streamable_http_extensions: Vec, /// List of builtin extension commands to add pub builtins: Vec, pub no_profile: bool, /// Recipe for the session pub recipe: Option, /// Any additional system prompt to append to the default pub additional_system_prompt: Option, /// Provider override from CLI arguments pub provider: Option, /// Model override from CLI arguments pub model: Option, /// Enable debug printing pub debug: bool, /// Maximum number of consecutive identical tool calls allowed pub max_tool_repetitions: Option, /// Maximum number of turns (iterations) allowed without user input pub max_turns: Option, /// ID of the scheduled job that triggered this session (if any) pub scheduled_job_id: Option, /// Whether this session will be used interactively (affects debugging prompts) pub interactive: bool, /// Quiet mode - suppress non-response output pub quiet: bool, /// Output format (text, json) pub output_format: String, /// Docker container to run stdio extensions inside pub container: Option, } /// Manual implementation of Default to ensure proper initialization of output_format /// This struct requires explicit default value for output_format field impl Default for SessionBuilderConfig { fn default() -> Self { SessionBuilderConfig { session_id: None, resume: false, fork: false, no_session: false, extensions: Vec::new(), streamable_http_extensions: Vec::new(), builtins: Vec::new(), no_profile: false, recipe: None, additional_system_prompt: None, provider: None, model: None, debug: false, max_tool_repetitions: None, max_turns: None, scheduled_job_id: None, interactive: false, quiet: false, output_format: "text".to_string(), container: None, } } } /// Offers to help debug an extension failure by creating a minimal debugging session async fn offer_extension_debugging_help( extension_name: &str, error_message: &str, provider: Arc, interactive: bool, ) -> Result<(), anyhow::Error> { // Only offer debugging help in interactive mode if !interactive { return Ok(()); } let help_prompt = format!( "Would you like me to help debug the '{}' extension failure?", extension_name ); let should_help = match cliclack::confirm(help_prompt) .initial_value(false) .interact() { Ok(choice) => choice, Err(e) => { if e.kind() == std::io::ErrorKind::Interrupted { return Ok(()); } else { return Err(e.into()); } } }; if !should_help { return Ok(()); } println!("{}", style("🔧 Starting debugging session...").cyan()); // Create a debugging prompt with context about the extension failure let debug_prompt = format!( "I'm having trouble starting an extension called '{}'. Here's the error I encountered:\n\n{}\n\nCan you help me diagnose what might be wrong and suggest how to fix it? Please consider common issues like:\n- Missing dependencies or tools\n- Configuration problems\n- Network connectivity (for remote extensions)\n- Permission issues\n- Path or environment variable problems", extension_name, error_message ); // Create a minimal agent for debugging let debug_agent = Agent::new(); let session = debug_agent .config .session_manager .create_session( std::env::current_dir()?, "CLI Session".to_string(), SessionType::Hidden, debug_agent.config.goose_mode, ) .await?; debug_agent.update_provider(provider, &session.id).await?; // Add the developer extension if available to help with debugging let extensions = get_all_extensions(); for ext_wrapper in extensions { if ext_wrapper.enabled && ext_wrapper.config.name() == "developer" { if let Err(e) = debug_agent .add_extension(ext_wrapper.config, &session.id) .await { // If we can't add developer extension, continue without it eprintln!( "Note: Could not load developer extension for debugging: {}", e ); } break; } } let mut debug_session = CliSession::new( debug_agent, session.id, false, None, None, None, None, "text".to_string(), ) .await; // Process the debugging request println!("{}", style("Analyzing the extension failure...").yellow()); match debug_session.headless(debug_prompt).await { Ok(_) => { println!( "{}", style("✅ Debugging session completed. Check the suggestions above.").green() ); } Err(e) => { eprintln!( "{}", style(format!("❌ Debugging session failed: {}", e)).red() ); } } Ok(()) } async fn load_extensions( agent: Agent, extensions_to_load: Vec<(String, ExtensionConfig)>, provider_for_debug: Arc, interactive: bool, session_id: &str, ) -> Arc { let mut set = JoinSet::new(); let agent_ptr = Arc::new(agent); let mut waiting_ids: BTreeSet = (0..extensions_to_load.len()).collect(); for (id, (_label, extension)) in extensions_to_load.iter().enumerate() { let agent_ptr = agent_ptr.clone(); let cfg = extension.clone(); let sid = session_id.to_string(); set.spawn(async move { (id, agent_ptr.add_extension(cfg, &sid).await) }); } let get_message = |waiting_ids: &BTreeSet| { let labels: Vec = waiting_ids .iter() .map(|id| { extensions_to_load .get(*id) .map(|e| e.0.clone()) .unwrap_or_default() }) .collect(); format!( "starting {} extensions: {}", waiting_ids.len(), labels.join(", ") ) }; let spinner = cliclack::spinner(); spinner.start(get_message(&waiting_ids)); let mut offer_debug: Vec<(usize, anyhow::Error)> = Vec::new(); while let Some(result) = set.join_next().await { match result { Ok((id, Ok(_))) => { waiting_ids.remove(&id); spinner.set_message(get_message(&waiting_ids)); } Ok((id, Err(e))) => offer_debug.push((id, e.into())), Err(e) => tracing::error!("failed to add extension: {}", e), } } spinner.clear(); for (id, err) in offer_debug { let label = extensions_to_load .get(id) .map(|e| e.0.clone()) .unwrap_or_default(); eprintln!( "{}", style(format!( "Warning: Failed to start extension '{}' ({}), continuing without it", label, err )) .yellow() ); if let Err(debug_err) = offer_extension_debugging_help( &label, &err.to_string(), Arc::clone(&provider_for_debug), interactive, ) .await { eprintln!("Note: Could not start debugging session: {}", debug_err); } } agent_ptr } struct ResolvedProviderConfig { provider_name: String, model_name: String, model_config: goose::model::ModelConfig, } fn resolve_provider_and_model( session_config: &SessionBuilderConfig, config: &Config, saved_provider: Option, saved_model_config: Option, ) -> ResolvedProviderConfig { let recipe_settings = session_config .recipe .as_ref() .and_then(|r| r.settings.as_ref()); let provider_name = session_config .provider .clone() .or(saved_provider) .or_else(|| recipe_settings.and_then(|s| s.goose_provider.clone())) .or_else(|| config.get_goose_provider().ok()) .unwrap_or_else(|| { output::render_error("No provider configured. Run 'goose configure' first."); process::exit(1); }); let model_name = session_config .model .clone() .or_else(|| saved_model_config.as_ref().map(|mc| mc.model_name.clone())) .or_else(|| recipe_settings.and_then(|s| s.goose_model.clone())) .or_else(|| config.get_goose_model().ok()) .unwrap_or_else(|| { output::render_error("No model configured. Run 'goose configure' first."); process::exit(1); }); let model_config = if session_config.resume && saved_model_config .as_ref() .is_some_and(|mc| mc.model_name == model_name) { let mut config = saved_model_config.unwrap(); if let Some(temp) = recipe_settings.and_then(|s| s.temperature) { config = config.with_temperature(Some(temp)); } config } else { let temperature = recipe_settings.and_then(|s| s.temperature); goose::model::ModelConfig::new(&model_name) .unwrap_or_else(|e| { output::render_error(&format!("Failed to create model configuration: {}", e)); process::exit(1); }) .with_canonical_limits(&provider_name) .with_temperature(temperature) }; ResolvedProviderConfig { provider_name, model_name, model_config, } } async fn resolve_session_id( session_config: &SessionBuilderConfig, session_manager: &goose::session::session_manager::SessionManager, goose_mode: GooseMode, ) -> String { if session_config.no_session { let working_dir = std::env::current_dir().unwrap_or_else(|e| { output::render_error(&format!("Could not get working directory: {}", e)); process::exit(1); }); let session = session_manager .create_session( working_dir, "CLI Session".to_string(), SessionType::Hidden, goose_mode, ) .await .unwrap_or_else(|e| { output::render_error(&format!("Could not create session: {}", e)); process::exit(1); }); session.id } else if session_config.resume { if let Some(ref session_id) = session_config.session_id { match session_manager.get_session(session_id, false).await { Ok(_) => session_id.clone(), Err(_) => { output::render_error(&format!( "Cannot resume session {} - no such session exists", style(session_id).cyan() )); process::exit(1); } } } else { match session_manager.list_sessions().await { Ok(sessions) if !sessions.is_empty() => sessions[0].id.clone(), _ => { output::render_error("Cannot resume - no previous sessions found"); process::exit(1); } } } } else { session_config.session_id.clone().unwrap() } } async fn handle_resumed_session_workdir(agent: &Agent, session_id: &str, interactive: bool) { let session = agent .config .session_manager .get_session(session_id, false) .await .unwrap_or_else(|e| { output::render_error(&format!("Failed to read session metadata: {}", e)); process::exit(1); }); let current_workdir = std::env::current_dir().unwrap_or_else(|e| { output::render_error(&format!("Failed to get current working directory: {}", e)); process::exit(1); }); if current_workdir == session.working_dir { return; } if interactive { let change_workdir = cliclack::confirm(format!( "{} The original working directory of this session was set to {}. \ Your current directory is {}. \ Do you want to switch back to the original working directory?", style("WARNING:").yellow(), style(session.working_dir.display()).cyan(), style(current_workdir.display()).cyan(), )) .initial_value(true) .interact() .unwrap_or_else(|e| { output::render_error(&format!("Failed to get user input: {}", e)); process::exit(1); }); if change_workdir { if !session.working_dir.exists() { output::render_error(&format!( "Cannot switch to original working directory - {} no longer exists", style(session.working_dir.display()).cyan() )); } else if let Err(e) = std::env::set_current_dir(&session.working_dir) { output::render_error(&format!( "Failed to switch to original working directory: {}", e )); } } } else { eprintln!( "{}", style(format!( "Warning: Working directory differs from session (current: {}, session: {}). \ Staying in current directory.", current_workdir.display(), session.working_dir.display() )) .yellow() ); } } async fn collect_extension_configs( agent: &Agent, session_config: &SessionBuilderConfig, recipe: Option<&Recipe>, session_id: &str, ) -> Result, ExtensionError> { let configured_extensions: Vec = if session_config.resume { EnabledExtensionsState::for_session( &agent.config.session_manager, session_id, Config::global(), ) .await } else if session_config.no_profile { Vec::new() } else { resolve_extensions_for_new_session(recipe.and_then(|r| r.extensions.as_deref()), None) }; let cli_flag_extensions = parse_cli_flag_extensions( &session_config.extensions, &session_config.streamable_http_extensions, &session_config.builtins, ); let mut all: Vec = configured_extensions; all.extend(cli_flag_extensions.into_iter().map(|(_, cfg)| cfg)); Ok(all) } async fn resolve_and_load_extensions( agent: Agent, extensions: Vec, provider_for_debug: Arc, interactive: bool, session_id: &str, ) -> Arc { for warning in goose::config::get_warnings() { eprintln!("{}", style(format!("Warning: {}", warning)).yellow()); } let extensions_to_load: Vec<(String, ExtensionConfig)> = extensions .into_iter() .map(|cfg| (cfg.name(), cfg)) .collect(); load_extensions( agent, extensions_to_load, provider_for_debug, interactive, session_id, ) .await } async fn configure_session_prompts( session: &CliSession, config: &Config, session_config: &SessionBuilderConfig, session_id: &str, ) { if let Err(e) = session.agent.persist_extension_state(session_id).await { tracing::warn!("Failed to save extension state: {}", e); } if let Some(ref additional_prompt) = session_config.additional_system_prompt { session .agent .extend_system_prompt("additional".to_string(), additional_prompt.clone()) .await; } let system_prompt_file: Option = config.get_param("GOOSE_SYSTEM_PROMPT_FILE_PATH").ok(); if let Some(ref path) = system_prompt_file { let override_prompt = std::fs::read_to_string(path).unwrap_or_else(|e| { output::render_error(&format!( "Failed to read system prompt file '{}': {}", path, e )); process::exit(1); }); session.agent.override_system_prompt(override_prompt).await; } } pub async fn build_session(session_config: SessionBuilderConfig) -> CliSession { #[cfg(feature = "telemetry")] goose::posthog::set_session_context("cli", session_config.resume); let config = Config::global(); let agent: Agent = Agent::new(); if session_config.container.is_some() { agent.set_container(session_config.container.clone()).await; } let session_manager = agent.config.session_manager.clone(); let (saved_provider, saved_model_config) = if session_config.resume { if let Some(ref session_id) = session_config.session_id { match session_manager.get_session(session_id, false).await { Ok(session_data) => (session_data.provider_name, session_data.model_config), Err(_) => (None, None), } } else { (None, None) } } else { (None, None) }; let resolved = resolve_provider_and_model(&session_config, config, saved_provider, saved_model_config); let recipe = session_config.recipe.as_ref(); agent .apply_recipe_components(recipe.and_then(|r| r.response.clone()), true) .await; let session_id = resolve_session_id(&session_config, &session_manager, agent.config.goose_mode).await; if session_config.resume { handle_resumed_session_workdir(&agent, &session_id, session_config.interactive).await; } let extensions_for_provider = match collect_extension_configs(&agent, &session_config, recipe, &session_id).await { Ok(exts) => exts, Err(e) => { output::render_error(&format!("Failed to collect extensions: {}", e)); process::exit(1); } }; let new_provider = match create( &resolved.provider_name, resolved.model_config, extensions_for_provider.clone(), ) .await { Ok(provider) => provider, Err(e) => { output::render_error(&format!( "Error {}.\n\ Please check your system keychain and run 'goose configure' again.\n\ If your system is unable to use the keyring, please try setting secret key(s) via environment variables.\n\ For more info, see: https://goose-docs.ai/docs/troubleshooting/#keychainkeyring-errors", e )); process::exit(1); } }; let provider_for_debug = Arc::clone(&new_provider); tracing::info!("🤖 Using model: {}", resolved.model_name); agent .update_provider(new_provider, &session_id) .await .unwrap_or_else(|e| { output::render_error(&format!("Failed to initialize agent: {}", e)); process::exit(1); }); agent .update_goose_mode(agent.config.goose_mode, &session_id) .await .unwrap_or_else(|e| { output::render_error(&format!("Failed to set session mode: {}", e)); process::exit(1); }); if let Some(recipe) = session_config.recipe.clone() { if let Err(e) = session_manager .update(&session_id) .recipe(Some(recipe)) .apply() .await { tracing::warn!("Failed to store recipe on session: {}", e); } } // Extensions are loaded after session creation because we may change directory when resuming let agent_ptr = resolve_and_load_extensions( agent, extensions_for_provider, Arc::clone(&provider_for_debug), session_config.interactive, &session_id, ) .await; let edit_mode = config .get_param::("EDIT_MODE") .ok() .and_then(|edit_mode| match edit_mode.to_lowercase().as_str() { "emacs" => Some(EditMode::Emacs), "vi" => Some(EditMode::Vi), _ => { eprintln!("Invalid EDIT_MODE specified, defaulting to Emacs"); None } }); let debug_mode = session_config.debug || config.get_param("GOOSE_DEBUG").unwrap_or(false); let session = CliSession::new( Arc::try_unwrap(agent_ptr).unwrap_or_else(|_| panic!("There should be no more references")), session_id.clone(), debug_mode, session_config.scheduled_job_id.clone(), session_config.max_turns, edit_mode, recipe.and_then(|r| r.retry.clone()), session_config.output_format.clone(), ) .await; configure_session_prompts(&session, config, &session_config, &session_id).await; if !session_config.quiet { output::display_session_info( session_config.resume, &resolved.provider_name, &resolved.model_name, &Some(session_id), ); } session } #[cfg(test)] mod tests { use super::*; #[test] fn test_session_builder_config_creation() { let config = SessionBuilderConfig { session_id: None, resume: false, fork: false, no_session: false, extensions: vec!["echo test".to_string()], streamable_http_extensions: vec![StreamableHttpOptions { url: "http://localhost:8080/mcp".to_string(), timeout: goose::config::DEFAULT_EXTENSION_TIMEOUT, }], builtins: vec!["developer".to_string()], no_profile: false, recipe: None, additional_system_prompt: Some("Test prompt".to_string()), provider: None, model: None, debug: true, max_tool_repetitions: Some(5), max_turns: None, scheduled_job_id: None, interactive: true, quiet: false, output_format: "text".to_string(), container: None, }; assert_eq!(config.extensions.len(), 1); assert_eq!(config.streamable_http_extensions.len(), 1); assert_eq!(config.builtins.len(), 1); assert!(config.debug); assert_eq!(config.max_tool_repetitions, Some(5)); assert!(config.max_turns.is_none()); assert!(config.scheduled_job_id.is_none()); assert!(config.interactive); assert!(!config.quiet); } #[test] fn test_session_builder_config_default() { let config = SessionBuilderConfig::default(); assert!(config.session_id.is_none()); assert!(!config.resume); assert!(!config.no_session); assert!(config.extensions.is_empty()); assert!(config.streamable_http_extensions.is_empty()); assert!(config.builtins.is_empty()); assert!(!config.no_profile); assert!(config.recipe.is_none()); assert!(config.additional_system_prompt.is_none()); assert!(!config.debug); assert!(config.max_tool_repetitions.is_none()); assert!(config.max_turns.is_none()); assert!(config.scheduled_job_id.is_none()); assert!(!config.interactive); assert!(!config.quiet); assert!(!config.fork); } #[tokio::test] async fn test_offer_extension_debugging_help_function_exists() { // This test just verifies the function compiles and can be called // We can't easily test the interactive parts without mocking // We can't actually test the full function without a real provider and user interaction // But we can at least verify it compiles and the function signature is correct let extension_name = "test-extension"; let error_message = "test error"; // This test mainly serves as a compilation check assert_eq!(extension_name, "test-extension"); assert_eq!(error_message, "test error"); } #[test] fn test_truncate_with_ellipsis() { assert_eq!(truncate_with_ellipsis("abc", 5), "abc"); assert_eq!(truncate_with_ellipsis("abcde", 5), "abcde"); assert_eq!(truncate_with_ellipsis("abcdef", 5), "abcde…"); assert_eq!(truncate_with_ellipsis("hello world", 5), "hello…"); assert_eq!(truncate_with_ellipsis("", 5), ""); } }