use agent::{RequestKind, Thread, ThreadEvent, ThreadStore};use anyhow::anyhow;use assistant_tool::ToolWorkingSet;use client::{Client, UserStore};use collections::HashMap;use dap::DapRegistry;use gpui::{App, Entity, SemanticVersion, Subscription, Task, prelude::*};use language::LanguageRegistry;use language_model::{    AuthenticateError, LanguageModel, LanguageModelProviderId, LanguageModelRegistry,};use node_runtime::NodeRuntime;use project::{Project, RealFs};use prompt_store::PromptBuilder;use settings::SettingsStore;use smol::channel;use std::sync::Arc; /// Subset of `workspace::AppState` needed by `HeadlessAssistant`, with additional fields.pub struct HeadlessAppState {    pub languages: Arc<LanguageRegistry>,    pub client: Arc<Client>,    pub user_store: Entity<UserStore>,    pub fs: Arc<dyn fs::Fs>,    pub node_runtime: NodeRuntime,     // Additional fields not present in `workspace::AppState`.    pub prompt_builder: Arc<PromptBuilder>,} pub struct HeadlessAssistant {    pub thread: Entity<Thread>,    pub project: Entity<Project>,    #[allow(dead_code)]    pub thread_store: Entity<ThreadStore>,    pub tool_use_counts: HashMap<Arc<str>, u32>,    pub done_tx: channel::Sender<anyhow::Result<()>>,    _subscription: Subscription,} impl HeadlessAssistant {    pub fn new(        app_state: Arc<HeadlessAppState>,        cx: &mut App,    ) -> anyhow::Result<(Entity<Self>, channel::Receiver<anyhow::Result<()>>)> {        let env = None;        let project = Project::local(            app_state.client.clone(),            app_state.node_runtime.clone(),            app_state.user_store.clone(),            app_state.languages.clone(),            Arc::new(DapRegistry::default()),            app_state.fs.clone(),            env,            cx,        );         let tools = Arc::new(ToolWorkingSet::default());        let thread_store =            ThreadStore::new(project.clone(), tools, app_state.prompt_builder.clone(), cx)?;         let thread = thread_store.update(cx, |thread_store, cx| thread_store.create_thread(cx));         let (done_tx, done_rx) = channel::unbounded::<anyhow::Result<()>>();         let headless_thread = cx.new(move |cx| Self {            _subscription: cx.subscribe(&thread, Self::handle_thread_event),            thread,            project,            thread_store,            tool_use_counts: HashMap::default(),            done_tx,        });         Ok((headless_thread, done_rx))    }     fn handle_thread_event(        &mut self,        thread: Entity<Thread>,        event: &ThreadEvent,        cx: &mut Context<Self>,    ) {        match event {            ThreadEvent::ShowError(err) => self                .done_tx                .send_blocking(Err(anyhow!("{:?}", err)))                .unwrap(),            ThreadEvent::DoneStreaming => {                let thread = thread.read(cx);                if let Some(message) = thread.messages().last() {                    println!("Message: {}", message.to_string());                }                if thread.all_tools_finished() {                    self.done_tx.send_blocking(Ok(())).unwrap()                }            }            ThreadEvent::UsePendingTools => {                thread.update(cx, |thread, cx| {                    thread.use_pending_tools(cx);                });            }            ThreadEvent::ToolConfirmationNeeded => {                // Automatically approve all tools that need confirmation in headless mode                println!("Tool confirmation needed - automatically approving in headless mode");                 // Get the tools needing confirmation                let tools_needing_confirmation: Vec<_> = thread                    .read(cx)                    .tools_needing_confirmation()                    .cloned()                    .collect();                 // Run each tool that needs confirmation                for tool_use in tools_needing_confirmation {                    if let Some(tool) = thread.read(cx).tools().tool(&tool_use.name, cx) {                        thread.update(cx, |thread, cx| {                            println!("Auto-approving tool: {}", tool_use.name);                             // Create a request to send to the tool                            let request = thread.to_completion_request(RequestKind::Chat, cx);                            let messages = Arc::new(request.messages);                             // Run the tool                            thread.run_tool(                                tool_use.id.clone(),                                tool_use.ui_text.clone(),                                tool_use.input.clone(),                                &messages,                                tool,                                cx,                            );                        });                    }                }            }            ThreadEvent::ToolFinished {                tool_use_id,                pending_tool_use,                ..            } => {                if let Some(pending_tool_use) = pending_tool_use {                    println!(                        "Used tool {} with input: {}",                        pending_tool_use.name, pending_tool_use.input                    );                    *self                        .tool_use_counts                        .entry(pending_tool_use.name.clone())                        .or_insert(0) += 1;                }                if let Some(tool_result) = thread.read(cx).tool_result(tool_use_id) {                    println!("Tool result: {:?}", tool_result);                }                if thread.read(cx).all_tools_finished() {                    let model_registry = LanguageModelRegistry::read_global(cx);                    if let Some(model) = model_registry.default_model() {                        thread.update(cx, |thread, cx| {                            thread.attach_tool_results(cx);                            thread.send_to_model(model.model, RequestKind::Chat, cx);                        });                    } else {                        println!(                            "Warning: No active language model available to continue conversation"                        );                    }                }            }            _ => {}        }    }} pub fn init(cx: &mut App) -> Arc<HeadlessAppState> {    release_channel::init(SemanticVersion::default(), cx);    gpui_tokio::init(cx);     let mut settings_store = SettingsStore::new(cx);    settings_store        .set_default_settings(settings::default_settings().as_ref(), cx)        .unwrap();    cx.set_global(settings_store);    client::init_settings(cx);    Project::init_settings(cx);     let client = Client::production(cx);    cx.set_http_client(client.http_client().clone());     let git_binary_path = None;    let fs = Arc::new(RealFs::new(        git_binary_path,        cx.background_executor().clone(),    ));     let languages = Arc::new(LanguageRegistry::new(cx.background_executor().clone()));     let user_store = cx.new(|cx| UserStore::new(client.clone(), cx));     language::init(cx);    language_model::init(client.clone(), cx);    language_models::init(user_store.clone(), client.clone(), fs.clone(), cx);    assistant_tools::init(client.http_client().clone(), cx);    context_server::init(cx);    let stdout_is_a_pty = false;    let prompt_builder = PromptBuilder::load(fs.clone(), stdout_is_a_pty, cx);    agent::init(fs.clone(), client.clone(), prompt_builder.clone(), cx);     Arc::new(HeadlessAppState {        languages,        client,        user_store,        fs,        node_runtime: NodeRuntime::unavailable(),        prompt_builder,    })} pub fn find_model(model_name: &str, cx: &App) -> anyhow::Result<Arc<dyn LanguageModel>> {    let model_registry = LanguageModelRegistry::read_global(cx);    let model = model_registry        .available_models(cx)        .find(|model| model.id().0 == model_name);     let Some(model) = model else {        return Err(anyhow!(            "No language model named {} was available. Available models: {}",            model_name,            model_registry                .available_models(cx)                .map(|model| model.id().0.clone())                .collect::<Vec<_>>()                .join(", ")        ));    };     Ok(model)} pub fn authenticate_model_provider(    provider_id: LanguageModelProviderId,    cx: &mut App,) -> Task<std::result::Result<(), AuthenticateError>> {    let model_registry = LanguageModelRegistry::read_global(cx);    let model_provider = model_registry.provider(&provider_id).unwrap();    model_provider.authenticate(cx)}