feat: MCP support for agentic CLI providers

Thread ExtensionConfig through ProviderDef::from_env so CLI providers
(claude-code, codex) connect to MCP servers at construction time and
call tools internally.

Extract McpFixture and test assets into goose-test-support crate,
shared by goose-acp and providers.rs integration tests. Both CLI
providers now run the full test suite (basic response, tool usage,
context length, image content) against a real MCP fixture server.

Improve claude_code.rs with persistent stream-json sessions and content
blocks. Replace codex.rs two-pass message handling with single-pass
prepare_input. Convert all 23 ProviderDef implementations from manual
BoxFuture to #[async_trait] and inline from_env into the trait impl.

Signed-off-by: Adrian Cole <adrian@tetrate.io>

Author: codefromthecrypt

Cargo.lock

@@ -724,7 +724,7 @@ impl GooseAcpAgent {
         let config = Config::new(&config_path, "goose")?;
         let model_id = config.get_goose_model()?;
         let model_config = goose::model::ModelConfig::new(&model_id)?;
-        let provider = (self.provider_factory)(model_config).await?;
+        let provider = (self.provider_factory)(model_config, Vec::new()).await?;
         self.agent.update_provider(provider, &session.id).await?;
         Ok(model_id)
     }

crates/goose-acp/src/server.rs

@@ -33,15 +33,15 @@ impl AcpServer {
         let disable_session_naming = config.get_goose_disable_session_naming().unwrap_or(false);
 
         let config_dir = self.config.config_dir.clone();
-        let provider_factory: ProviderConstructor = Arc::new(move |model_config| {
+        let provider_factory: ProviderConstructor = Arc::new(move |model_config, extensions| {
             let config_dir = config_dir.clone();
             Box::pin(async move {
                 let config_path = config_dir.join(goose::config::base::CONFIG_YAML_NAME);
                 let config = goose::config::Config::new(&config_path, "goose")?;
                 let provider_name = config
                     .get_goose_provider()
                     .map_err(|_| anyhow::anyhow!("No provider configured"))?;
-                goose::providers::create(&provider_name, model_config).await
+                goose::providers::create(&provider_name, model_config, extensions).await
             })
         });
 

crates/goose-acp/src/server_factory.rs

@@ -191,7 +191,7 @@ pub async fn spawn_acp_server_in_process(
         fs::write(&config_path, "GOOSE_MODEL: gpt-5-nano\n").unwrap();
     }
     let base_url = openai_base_url.to_string();
-    let provider_factory: ProviderConstructor = Arc::new(move |model_config| {
+    let provider_factory: ProviderConstructor = Arc::new(move |model_config, _extensions| {
         let base_url = base_url.clone();
         Box::pin(async move {
             let api_client =

crates/goose-acp/tests/fixtures/mod.rs

@@ -47,7 +47,7 @@ fn test_initialize_without_provider() {
         let temp_dir = tempfile::tempdir().unwrap();
 
         let provider_factory: ProviderConstructor =
-            Arc::new(|_| Box::pin(async { Err(anyhow::anyhow!("no provider configured")) }));
+            Arc::new(|_, _| Box::pin(async { Err(anyhow::anyhow!("no provider configured")) }));
 
         let agent = Arc::new(
             GooseAcpAgent::new(

crates/goose-acp/tests/server_test.rs

@@ -53,6 +53,7 @@ indicatif = "0.18.1"
 tokio-util = { version = "0.7.15", features = ["compat", "rt"] }
 anstream = "0.6.18"
 open = "5.3.2"
+url = { workspace = true }
 urlencoding = "2.1"
 clap_complete = "4.5.62"
 

crates/goose-cli/Cargo.toml

@@ -328,7 +328,7 @@ async fn handle_oauth_configuration(provider_name: &str, key_name: &str) -> anyh
 
     // Create a temporary provider instance to handle OAuth
     let temp_model = ModelConfig::new("temp")?;
-    match create(provider_name, temp_model).await {
+    match create(provider_name, temp_model, Vec::new()).await {
         Ok(provider) => match provider.configure_oauth().await {
             Ok(_) => {
                 let _ = cliclack::log::success("OAuth authentication completed successfully!");
@@ -683,7 +683,7 @@ pub async fn configure_provider_dialog() -> anyhow::Result<bool> {
     spin.start("Attempting to fetch supported models...");
     let models_res = {
         let temp_model_config = ModelConfig::new(&provider_meta.default_model)?;
-        let temp_provider = create(provider_name, temp_model_config).await?;
+        let temp_provider = create(provider_name, temp_model_config, Vec::new()).await?;
         retry_operation(&RetryConfig::default(), || async {
             temp_provider.fetch_recommended_models().await
         })
@@ -1445,7 +1445,6 @@ pub async fn configure_tool_permissions_dialog() -> anyhow::Result<()> {
     let model_config = ModelConfig::new(&model)?;
 
     let agent = Agent::new();
-    let new_provider = create(&provider_name, model_config).await?;
 
     let session = agent
         .config
@@ -1457,8 +1456,8 @@ pub async fn configure_tool_permissions_dialog() -> anyhow::Result<()> {
         )
         .await?;
 
-    agent.update_provider(new_provider, &session.id).await?;
-    if let Some(config) = get_extension_by_name(&selected_extension_name) {
+    let extension_config = get_extension_by_name(&selected_extension_name);
+    if let Some(config) = extension_config.as_ref() {
         agent
             .add_extension(config.clone(), &session.id)
             .await
@@ -1478,6 +1477,10 @@ pub async fn configure_tool_permissions_dialog() -> anyhow::Result<()> {
         return Ok(());
     }
 
+    let extensions = extension_config.into_iter().collect::<Vec<_>>();
+    let new_provider = create(&provider_name, model_config, extensions).await?;
+    agent.update_provider(new_provider, &session.id).await?;
+
     let permission_manager = PermissionManager::instance();
     let selected_tools = agent
         .list_tools(&session.id, Some(selected_extension_name.clone()))
@@ -1667,7 +1670,7 @@ pub async fn handle_openrouter_auth() -> anyhow::Result<()> {
         }
     };
 
-    match create("openrouter", model_config).await {
+    match create("openrouter", model_config, Vec::new()).await {
         Ok(provider) => {
             let model_config = provider.get_model_config();
             let test_result = provider
@@ -1747,7 +1750,7 @@ pub async fn handle_tetrate_auth() -> anyhow::Result<()> {
         }
     };
 
-    match create("tetrate", model_config).await {
+    match create("tetrate", model_config, Vec::new()).await {
         Ok(provider) => {
             let test_result = provider.fetch_supported_models().await;
 

crates/goose-cli/src/commands/configure.rs

@@ -181,16 +181,16 @@ async fn create_agent(provider_name: &str, model: &str) -> Result<Agent> {
         )
         .await?;
 
-    let provider = goose::providers::create(provider_name, model_config).await?;
-    agent.update_provider(provider, &init_session.id).await?;
-
     let enabled_configs = goose::config::get_enabled_extensions();
-    for config in enabled_configs {
+    for config in &enabled_configs {
         if let Err(e) = agent.add_extension(config.clone(), &init_session.id).await {
             eprintln!("Warning: Failed to load extension {}: {}", config.name(), e);
         }
     }
 
+    let provider = goose::providers::create(provider_name, model_config, enabled_configs).await?;
+    agent.update_provider(provider, &init_session.id).await?;
+
     Ok(agent)
 }
 

crates/goose-cli/src/commands/web.rs

@@ -187,7 +187,12 @@ where
 
         let original_env = setup_environment(config)?;
 
-        let inner_provider = create(&factory_name, ModelConfig::new(config.model_name)?).await?;
+        let inner_provider = create(
+            &factory_name,
+            ModelConfig::new(config.model_name)?,
+            Vec::new(),
+        )
+        .await?;
 
         let test_provider = Arc::new(TestProvider::new_recording(inner_provider, &file_path));
         (

crates/goose-cli/src/scenario_tests/scenario_runner.rs

@@ -490,17 +490,12 @@ async fn handle_resumed_session_workdir(agent: &Agent, session_id: &str, interac
     }
 }
 
-async fn resolve_and_load_extensions(
-    agent: Agent,
+async fn resolve_extension_configs(
+    agent: &Agent,
     session_config: &SessionBuilderConfig,
     recipe: Option<&Recipe>,
     session_id: &str,
-    provider_for_debug: Arc<dyn goose::providers::base::Provider>,
-) -> Arc<Agent> {
-    for warning in goose::config::get_warnings() {
-        eprintln!("{}", style(format!("Warning: {}", warning)).yellow());
-    }
-
+) -> Vec<ExtensionConfig> {
     let configured_extensions: Vec<ExtensionConfig> = if session_config.resume {
         agent
             .config
@@ -523,11 +518,27 @@ async fn resolve_and_load_extensions(
         &session_config.builtins,
     );
 
-    let mut extensions_to_load: Vec<(String, ExtensionConfig)> = configured_extensions
-        .iter()
-        .map(|cfg| (cfg.name(), cfg.clone()))
+    let mut all: Vec<ExtensionConfig> = configured_extensions;
+    all.extend(cli_flag_extensions.into_iter().map(|(_, cfg)| cfg));
+    all
+}
+
+async fn resolve_and_load_extensions(
+    agent: Agent,
+    session_config: &SessionBuilderConfig,
+    recipe: Option<&Recipe>,
+    session_id: &str,
+    provider_for_debug: Arc<dyn goose::providers::base::Provider>,
+) -> Arc<Agent> {
+    for warning in goose::config::get_warnings() {
+        eprintln!("{}", style(format!("Warning: {}", warning)).yellow());
+    }
+
+    let extensions = resolve_extension_configs(&agent, session_config, recipe, session_id).await;
+    let extensions_to_load: Vec<(String, ExtensionConfig)> = extensions
+        .into_iter()
+        .map(|cfg| (cfg.name(), cfg))
         .collect();
-    extensions_to_load.extend(cli_flag_extensions);
 
     load_extensions(
         agent,
@@ -607,7 +618,22 @@ pub async fn build_session(session_config: SessionBuilderConfig) -> CliSession {
         )
         .await;
 
-    let new_provider = match create(&resolved.provider_name, resolved.model_config).await {
+    let session_id = resolve_session_id(&session_config, &session_manager).await;
+
+    if session_config.resume {
+        handle_resumed_session_workdir(&agent, &session_id, session_config.interactive).await;
+    }
+
+    let extensions_for_provider =
+        resolve_extension_configs(&agent, &session_config, recipe, &session_id).await;
+
+    let new_provider = match create(
+        &resolved.provider_name,
+        resolved.model_config,
+        extensions_for_provider,
+    )
+    .await
+    {
         Ok(provider) => provider,
         Err(e) => {
             output::render_error(&format!(
@@ -633,8 +659,6 @@ pub async fn build_session(session_config: SessionBuilderConfig) -> CliSession {
         tracing::info!("🤖 Using model: {}", resolved.model_name);
     }
 
-    let session_id = resolve_session_id(&session_config, &session_manager).await;
-
     agent
         .update_provider(new_provider, &session_id)
         .await
@@ -643,10 +667,6 @@ pub async fn build_session(session_config: SessionBuilderConfig) -> CliSession {
             process::exit(1);
         });
 
-    if session_config.resume {
-        handle_resumed_session_workdir(&agent, &session_id, session_config.interactive).await;
-    }
-
     // Extensions are loaded after session creation because we may change directory when resuming
     let agent_ptr = resolve_and_load_extensions(
         agent,