Remove lead/worker provider

crates/goose-cli/src/session/builder.rs

@@ -648,18 +648,8 @@ pub async fn build_session(session_config: SessionBuilderConfig) -> CliSession {
             process::exit(1);
         }
     };
-    let provider_for_display = Arc::clone(&new_provider);
-
-    if let Some(lead_worker) = new_provider.as_lead_worker() {
-        let (lead_model, worker_model) = lead_worker.get_model_info();
-        tracing::info!(
-            "🤖 Lead/Worker Mode Enabled: Lead model (first 3 turns): {}, Worker model (turn 4+): {}, Auto-fallback on failures: Enabled",
-            lead_model,
-            worker_model
-        );
-    } else {
-        tracing::info!("🤖 Using model: {}", resolved.model_name);
-    }
+    let provider_for_debug = Arc::clone(&new_provider);
+    tracing::info!("🤖 Using model: {}", resolved.model_name);
 
     agent
         .update_provider(new_provider, &session_id)
@@ -692,7 +682,7 @@ pub async fn build_session(session_config: SessionBuilderConfig) -> CliSession {
     let agent_ptr = resolve_and_load_extensions(
         agent,
         extensions_for_provider,
-        Arc::clone(&provider_for_display),
+        Arc::clone(&provider_for_debug),
         session_config.interactive,
         &session_id,
     )
@@ -732,7 +722,6 @@ pub async fn build_session(session_config: SessionBuilderConfig) -> CliSession {
             &resolved.provider_name,
             &resolved.model_name,
             &Some(session_id),
-            Some(&provider_for_display),
         );
     }
     session

crates/goose-cli/src/session/mod.rs

@@ -79,10 +79,6 @@ enum StreamEvent {
         #[serde(flatten)]
         data: NotificationData,
     },
-    ModelChange {
-        model: String,
-        mode: String,
-    },
     Error {
         error: String,
     },
@@ -1070,13 +1066,6 @@ impl CliSession {
                         Some(Ok(AgentEvent::HistoryReplaced(updated_conversation))) => {
                             self.messages = updated_conversation;
                         }
-                        Some(Ok(AgentEvent::ModelChange { model, mode })) => {
-                            if is_stream_json_mode {
-                                emit_stream_event(&StreamEvent::ModelChange { model: model.clone(), mode: mode.clone() });
-                            } else if self.debug {
-                                eprintln!("Model changed to {} in {} mode", model, mode);
-                            }
-                        }
                         Some(Err(e)) => {
                             handle_agent_error(&e, is_stream_json_mode);
                             cancel_token_clone.cancel();

crates/goose-cli/src/session/output.rs

@@ -17,7 +17,7 @@ use std::cell::RefCell;
 use std::collections::HashMap;
 use std::io::{Error, IsTerminal, Write};
 use std::path::Path;
-use std::sync::{Arc, LazyLock};
+use std::sync::LazyLock;
 use std::time::Duration;
 
 use super::streaming_buffer::MarkdownBuffer;
@@ -1251,7 +1251,6 @@ pub fn display_session_info(
     provider: &str,
     model: &str,
     session_id: &Option<String>,
-    provider_instance: Option<&Arc<dyn goose::providers::base::Provider>>,
 ) {
     set_terminal_title();
 
@@ -1263,16 +1262,7 @@ pub fn display_session_info(
         "new session"
     };
 
-    let model_display = if let Some(provider_inst) = provider_instance {
-        if let Some(lead_worker) = provider_inst.as_lead_worker() {
-            let (lead_model, worker_model) = lead_worker.get_model_info();
-            format!("{} → {}", lead_model, worker_model)
-        } else {
-            model.to_string()
-        }
-    } else {
-        model.to_string()
-    };
+    let model_display = model.to_string();
 
     let cwd_display = std::env::current_dir()
         .ok()

crates/goose-server/src/routes/reply.rs

@@ -137,10 +137,6 @@ pub enum MessageEvent {
         reason: String,
         token_state: TokenState,
     },
-    ModelChange {
-        model: String,
-        mode: String,
-    },
     Notification {
         request_id: String,
         #[schema(value_type = Object)]
@@ -364,9 +360,6 @@ pub async fn reply(
                             stream_event(MessageEvent::UpdateConversation {conversation: new_messages}, &tx, &cancel_token).await;
 
                         }
-                        Ok(Some(Ok(AgentEvent::ModelChange { model, mode }))) => {
-                            stream_event(MessageEvent::ModelChange { model, mode }, &tx, &cancel_token).await;
-                        }
                         Ok(Some(Ok(AgentEvent::McpNotification((request_id, n))))) => {
                             stream_event(MessageEvent::Notification{
                                 request_id: request_id.clone(),

crates/goose-server/src/routes/session_events.rs

@@ -462,13 +462,6 @@ pub async fn session_reply(
                             )
                             .await;
                         }
-                        Ok(Some(Ok(AgentEvent::ModelChange { model, mode }))) => {
-                            publish(
-                                Some(task_request_id.clone()),
-                                MessageEvent::ModelChange { model, mode },
-                            )
-                            .await;
-                        }
                         Ok(Some(Ok(AgentEvent::McpNotification((notification_request_id, n))))) => {
                             publish(
                                 Some(task_request_id.clone()),

crates/goose/src/agents/agent.rs

@@ -158,7 +158,6 @@ pub struct Agent {
 pub enum AgentEvent {
     Message(Message),
     McpNotification((String, ServerNotification)),
-    ModelChange { model: String, mode: String },
     HistoryReplaced(Conversation),
 }
 
@@ -1230,27 +1229,6 @@ impl Agent {
                         Ok((response, usage)) => {
                             compaction_attempts = 0;
 
-                            // Emit model change event if provider is lead-worker
-                            let provider = self.provider().await?;
-                            if let Some(lead_worker) = provider.as_lead_worker() {
-                                if let Some(ref usage) = usage {
-                                    let active_model = usage.model.clone();
-                                    let (lead_model, worker_model) = lead_worker.get_model_info();
-                                    let mode = if active_model == lead_model {
-                                        "lead"
-                                    } else if active_model == worker_model {
-                                        "worker"
-                                    } else {
-                                        "unknown"
-                                    };
-
-                                    yield AgentEvent::ModelChange {
-                                        model: active_model,
-                                        mode: mode.to_string(),
-                                    };
-                                }
-                            }
-
                             if let Some(ref usage) = usage {
                                 self.update_session_metrics(&session_config.id, session_config.schedule_id.clone(), usage, false).await?;
                             }

crates/goose/src/agents/reply_parts.rs

@@ -208,8 +208,6 @@ impl Agent {
         Ok((tools, toolshim_tools, system_prompt))
     }
 
-    // Don't add gen_ai.request.model here — provider.get_model_config()
-    // returns the wrong model for LeadWorkerProvider.
     #[tracing::instrument(
         skip(provider, session_id, system_prompt, messages, tools, toolshim_tools),
         fields(session.id = %session_id)

crates/goose/src/agents/subagent_handler.rs

@@ -208,7 +208,7 @@ fn get_agent_messages(params: SubagentRunParams) -> AgentMessagesFuture {
                     }
                     conversation.push(msg);
                 }
-                Ok(AgentEvent::McpNotification(_)) | Ok(AgentEvent::ModelChange { .. }) => {}
+                Ok(AgentEvent::McpNotification(_)) => {}
                 Ok(AgentEvent::HistoryReplaced(updated_conversation)) => {
                     conversation = updated_conversation;
                 }

crates/goose/src/gateway/handler.rs

@@ -445,17 +445,6 @@ impl GatewayHandler {
                         "gateway stream: mcp notification #{event_count}"
                     );
                 }
-                Ok(AgentEvent::ModelChange {
-                    ref model,
-                    ref mode,
-                }) => {
-                    tracing::debug!(
-                        session_id,
-                        model,
-                        mode,
-                        "gateway stream: model change #{event_count}"
-                    );
-                }
                 Ok(AgentEvent::HistoryReplaced(_)) => {
                     tracing::debug!(
                         session_id,

crates/goose/src/posthog.rs

@@ -421,30 +421,6 @@ async fn send_session_event(installation: &InstallationData) -> Result<(), Strin
         insert(&mut props, "setting_max_turns", max_turns);
     }
 
-    if let Ok(lead_model) = config.get_param::<String>("GOOSE_LEAD_MODEL") {
-        insert(&mut props, "setting_lead_model", lead_model);
-    }
-    if let Ok(lead_provider) = config.get_param::<String>("GOOSE_LEAD_PROVIDER") {
-        insert(&mut props, "setting_lead_provider", lead_provider);
-    }
-    if let Ok(lead_turns) = config.get_param::<i64>("GOOSE_LEAD_TURNS") {
-        insert(&mut props, "setting_lead_turns", lead_turns);
-    }
-    if let Ok(lead_failure_threshold) = config.get_param::<i64>("GOOSE_LEAD_FAILURE_THRESHOLD") {
-        insert(
-            &mut props,
-            "setting_lead_failure_threshold",
-            lead_failure_threshold,
-        );
-    }
-    if let Ok(lead_fallback_turns) = config.get_param::<i64>("GOOSE_LEAD_FALLBACK_TURNS") {
-        insert(
-            &mut props,
-            "setting_lead_fallback_turns",
-            lead_fallback_turns,
-        );
-    }
-
     let extensions = get_enabled_extensions();
     insert(&mut props, "extensions_count", extensions.len() as u64);
     let extension_names: Vec<String> = extensions.iter().map(|e| e.name()).collect();

crates/goose/src/providers/base.rs

@@ -450,18 +450,6 @@ pub enum PermissionRouting {
     Noop,
 }
 
-/// Trait for LeadWorkerProvider-specific functionality
-pub trait LeadWorkerProviderTrait {
-    /// Get information about the lead and worker models for logging
-    fn get_model_info(&self) -> (String, String);
-
-    /// Get the currently active model name
-    fn get_active_model(&self) -> String;
-
-    /// Get (lead_turns, failure_threshold, fallback_turns)
-    fn get_settings(&self) -> (usize, usize, usize);
-}
-
 /// Base trait for AI providers (OpenAI, Anthropic, etc)
 #[async_trait]
 pub trait Provider: Send + Sync {
@@ -645,23 +633,6 @@ pub trait Provider: Send + Sync {
         ))
     }
 
-    /// Check if this provider is a LeadWorkerProvider
-    /// This is used for logging model information at startup
-    fn as_lead_worker(&self) -> Option<&dyn LeadWorkerProviderTrait> {
-        None
-    }
-
-    /// Get the currently active model name
-    /// For regular providers, this returns the configured model
-    /// For LeadWorkerProvider, this returns the currently active model (lead or worker)
-    fn get_active_model_name(&self) -> String {
-        if let Some(lead_worker) = self.as_lead_worker() {
-            lead_worker.get_active_model()
-        } else {
-            self.get_model_config().model_name
-        }
-    }
-
     /// Returns the first 3 user messages as strings for session naming
     fn get_initial_user_messages(&self, messages: &Conversation) -> Vec<String> {
         messages