Rebrand to Galaxy, major improvements to Bedrock support, still needs some TLC though

app/src/ai/active_agent_views_model.rs

@@ -7,7 +7,7 @@ use crate::ai::ambient_agents::AmbientAgentTaskId;
 use crate::ai::blocklist::agent_view::{AgentViewController, AgentViewControllerEvent};
 use crate::ai::blocklist::BlocklistAIHistoryModel;
 use crate::terminal::model::session::active_session::ActiveSession;
-use warpui::{
+use galaxyui::{
     AppContext, Entity, EntityId, ModelContext, ModelHandle, SingletonEntity, WeakModelHandle,
     WindowId,
 };

app/src/ai/active_agent_views_model_tests.rs

@@ -1,6 +1,6 @@
 use std::str::FromStr;
 
-use warpui::{App, EntityId, WindowId};
+use galaxyui::{App, EntityId, WindowId};
 
 use super::*;
 

app/src/ai/agent/api.rs

@@ -17,9 +17,9 @@ use serde::Serialize;
 use std::path::Path;
 use std::pin::Pin;
 use std::sync::Arc;
-use warp_core::channel::ChannelState;
-use warp_core::execution_mode::AppExecutionMode;
-use warp_core::features::FeatureFlag;
+use galaxy_core::channel::ChannelState;
+use galaxy_core::execution_mode::AppExecutionMode;
+use galaxy_core::features::FeatureFlag;
 
 use crate::ai::agent::conversation::AIConversationId;
 use crate::ai::ambient_agents::AmbientAgentTaskId;
@@ -35,8 +35,8 @@ use crate::ai::mcp::TemplatableMCPServerManager;
 use crate::settings::AISettings;
 use crate::terminal::safe_mode_settings::get_secret_obfuscation_mode;
 use crate::workspaces::user_workspaces::UserWorkspaces;
-use warp_core::user_preferences::GetUserPreferences;
-use warpui::{AppContext, EntityId, SingletonEntity as _};
+use galaxy_core::user_preferences::GetUserPreferences;
+use galaxyui::{AppContext, EntityId, SingletonEntity as _};
 
 /// Unique, server-generated conversation-scoped token to be roundtripped to the API when sending
 /// requests that follow-up within a given conversation.

app/src/ai/agent/api/convert_conversation.rs

@@ -42,7 +42,7 @@ use chrono::{DateTime, Local, TimeZone};
 use persistence::model::AgentConversationData;
 use std::collections::{HashMap, HashSet};
 use std::sync::Arc;
-use warp_core::command::ExitCode;
+use galaxy_core::command::ExitCode;
 use warp_multi_agent_api as api;
 use warp_multi_agent_api::ask_user_question_result::answer_item::Answer as AskUserQuestionAnswer;
 

app/src/ai/agent/api/convert_from.rs

@@ -26,7 +26,7 @@ use ai::agent::convert::ToolToAIAgentActionError;
 use ai::agent::UnknownCitationTypeError;
 use ai::skills::SkillReference;
 use api::ask_user_question::question::QuestionType;
-use warp_core::channel::ChannelState;
+use galaxy_core::channel::ChannelState;
 use warp_multi_agent_api as api;
 
 use crate::ai::agent::{AIAgentAttachment, UserQueryMode};

app/src/ai/agent/api/convert_to_tests.rs

@@ -3,7 +3,7 @@ use crate::ai::agent::{
     AIAgentActionResult, AIAgentActionResultType, TransferShellCommandControlToUserResult,
 };
 use crate::terminal::model::block::BlockId;
-use warp_core::command::ExitCode;
+use galaxy_core::command::ExitCode;
 use warp_multi_agent_api as api;
 
 #[test]

app/src/ai/agent/api/impl.rs

@@ -2,10 +2,11 @@ use std::{collections::HashMap, sync::Arc};
 
 use crate::{ai::agent::redaction, terminal::model::session::SessionType};
 use futures_util::StreamExt;
-use warp_core::features::FeatureFlag;
+use galaxy_core::features::FeatureFlag;
 use warp_multi_agent_api as api;
 
 use crate::ai::bedrock::client::{BedrockClient, BedrockClientConfig};
+use crate::ai::bedrock::diagnostic::BedrockDiagnosticLogger;
 use crate::server::server_api::ServerApi;
 
 use super::{convert_to::convert_input, ConvertToAPITypeError, RequestParams, ResponseStream};
@@ -141,7 +142,9 @@ pub async fn generate_multi_agent_output(
         let is_arn = model_id_for_fallback_check.starts_with("arn:");
         let fallback_to_warp = config.fallback_to_warp && !is_arn;
         if is_arn && config.fallback_to_warp {
-            log::info!("[bedrock] Fallback disabled for ARN-based model (not available on Warp server)");
+            log::info!(
+                "[bedrock] Fallback disabled for ARN-based model (not available on Warp server)"
+            );
         }
         match BedrockClient::from_config(config).await {
             Ok(bedrock) => {
@@ -156,6 +159,14 @@ pub async fn generate_multi_agent_output(
 
                 log::info!("[bedrock] Starting stream with task_id={task_id}");
 
+                let needs_create_task = request
+                    .task_context
+                    .as_ref()
+                    .map(|tc| tc.tasks.is_empty())
+                    .unwrap_or(true);
+
+                log::info!("[bedrock] needs_create_task={needs_create_task}");
+
                 let model_id = request
                     .settings
                     .as_ref()
@@ -165,6 +176,13 @@ pub async fn generate_multi_agent_output(
 
                 log::info!("[bedrock] Model: {model_id}");
 
+                let diagnostic_logger =
+                    BedrockDiagnosticLogger::try_new(&model_id, "", "", &task_id).map(Arc::new);
+
+                if let Some(ref logger) = diagnostic_logger {
+                    logger.log_protobuf_input(&request);
+                }
+
                 let messages =
                     crate::ai::bedrock::convert_request::extract_messages_from_request(&request);
                 let system_prompt =
@@ -178,16 +196,66 @@ pub async fn generate_multi_agent_output(
                     tools.len()
                 );
 
+                for (i, msg) in messages.iter().enumerate() {
+                    let content_desc = match &msg.content {
+                        crate::ai::bedrock::convert::MessageContent::Text(t) => {
+                            format!("Text({}chars)", t.len())
+                        }
+                        crate::ai::bedrock::convert::MessageContent::ToolUse {
+                            tool_use_id,
+                            name,
+                            ..
+                        } => {
+                            format!("ToolUse(name={}, id={})", name, tool_use_id)
+                        }
+                        crate::ai::bedrock::convert::MessageContent::ToolResult {
+                            tool_use_id,
+                            is_error,
+                            ..
+                        } => {
+                            format!("ToolResult(id={}, is_error={})", tool_use_id, is_error)
+                        }
+                        crate::ai::bedrock::convert::MessageContent::MultiPart(parts) => {
+                            let part_descs: Vec<String> = parts
+                                .iter()
+                                .map(|p| match p {
+                                    crate::ai::bedrock::convert::ContentPart::Text(t) => {
+                                        format!("Text({})", t.len())
+                                    }
+                                    crate::ai::bedrock::convert::ContentPart::ToolUse {
+                                        name,
+                                        tool_use_id,
+                                        ..
+                                    } => format!("ToolUse({},{})", name, tool_use_id),
+                                    crate::ai::bedrock::convert::ContentPart::ToolResult {
+                                        tool_use_id,
+                                        ..
+                                    } => format!("ToolResult({})", tool_use_id),
+                                })
+                                .collect();
+                            format!("MultiPart[{}]", part_descs.join(", "))
+                        }
+                    };
+                    log::debug!(
+                        "[bedrock] msg[{}]: role={:?}, content={}",
+                        i,
+                        msg.role,
+                        content_desc
+                    );
+                }
+
                 match bedrock
                     .converse_stream(
                         &model_id,
                         &task_id,
+                        needs_create_task,
                         messages,
                         system_prompt,
                         tools,
                         8192,
                         None,
                         true,
+                        diagnostic_logger,
                     )
                     .await
                 {

app/src/ai/agent/api/impl_tests.rs

@@ -1,7 +1,7 @@
 use crate::ai::agent::api::RequestParams;
 use crate::ai::blocklist::SessionContext;
 use crate::ai::llms::LLMId;
-use warp_core::features::FeatureFlag;
+use galaxy_core::features::FeatureFlag;
 use warp_multi_agent_api as api;
 
 use super::get_supported_tools;

app/src/ai/agent/conversation.rs

@@ -26,17 +26,17 @@ use std::{collections::HashMap, fmt::Display};
 use super::task_store::TaskStore;
 use uuid::Uuid;
 use vec1::{Size0Error, Vec1};
-use warp_core::command::ExitCode;
-use warp_core::execution_mode::AppExecutionMode;
-use warp_core::features::FeatureFlag;
-use warp_core::send_telemetry_from_ctx;
-use warp_core::ui::appearance::Appearance;
-use warp_core::ui::theme::color::internal_colors;
-use warp_core::ui::theme::WarpTheme;
+use galaxy_core::command::ExitCode;
+use galaxy_core::execution_mode::AppExecutionMode;
+use galaxy_core::features::FeatureFlag;
+use galaxy_core::send_telemetry_from_ctx;
+use galaxy_core::ui::appearance::Appearance;
+use galaxy_core::ui::theme::color::internal_colors;
+use galaxy_core::ui::theme::WarpTheme;
 use warp_multi_agent_api::response_event::stream_finished;
 use warp_multi_agent_api::{self as api, response_event::stream_finished::TokenUsage};
-use warpui::color::ColorU;
-use warpui::{EntityId, ModelContext, SingletonEntity};
+use galaxyui::color::ColorU;
+use galaxyui::{EntityId, ModelContext, SingletonEntity};
 
 use crate::ai::agent::{AIIdentifiers, CancellationReason};
 use crate::{
@@ -3683,7 +3683,7 @@ impl std::fmt::Display for ConversationStatus {
 }
 
 impl ConversationStatus {
-    pub fn render_icon(&self, appearance: &Appearance) -> warpui::elements::Icon {
+    pub fn render_icon(&self, appearance: &Appearance) -> galaxyui::elements::Icon {
         match self {
             ConversationStatus::InProgress => in_progress_icon(appearance),
             ConversationStatus::Success => succeeded_icon(appearance),

app/src/ai/agent/conversation_tests.rs

@@ -5,7 +5,7 @@ use super::{
 };
 use crate::ai::artifacts::Artifact;
 use crate::persistence::model::AgentConversationData;
-use warp_core::features::FeatureFlag;
+use galaxy_core::features::FeatureFlag;
 use warp_multi_agent_api as api;
 
 fn restored_conversation(conversation_data: Option<AgentConversationData>) -> AIConversation {

app/src/ai/agent/icons.rs

@@ -1,90 +1,90 @@
-use warp_core::ui::{appearance::Appearance, theme::AnsiColorIdentifier};
+use galaxy_core::ui::{appearance::Appearance, theme::AnsiColorIdentifier};
 
 use crate::ui_components::{blended_colors, icons::Icon};
 
-pub fn todo_list_icon(appearance: &Appearance) -> warpui::elements::Icon {
-    warpui::elements::Icon::new(
+pub fn todo_list_icon(appearance: &Appearance) -> galaxyui::elements::Icon {
+    galaxyui::elements::Icon::new(
         Icon::BulletedListBlock.into(),
         blended_colors::neutral_7(appearance.theme()),
     )
 }
 
-pub fn pending_icon(appearance: &Appearance) -> warpui::elements::Icon {
-    warpui::elements::Icon::new(
+pub fn pending_icon(appearance: &Appearance) -> galaxyui::elements::Icon {
+    galaxyui::elements::Icon::new(
         Icon::Queued.into(),
         blended_colors::neutral_5(appearance.theme()),
     )
 }
 
-pub fn in_progress_icon(appearance: &Appearance) -> warpui::elements::Icon {
-    warpui::elements::Icon::new(
+pub fn in_progress_icon(appearance: &Appearance) -> galaxyui::elements::Icon {
+    galaxyui::elements::Icon::new(
         Icon::Circle.into(),
         AnsiColorIdentifier::Magenta.to_ansi_color(&appearance.theme().terminal_colors().normal),
     )
 }
 
-pub fn succeeded_icon(appearance: &Appearance) -> warpui::elements::Icon {
-    warpui::elements::Icon::new(
+pub fn succeeded_icon(appearance: &Appearance) -> galaxyui::elements::Icon {
+    galaxyui::elements::Icon::new(
         Icon::Check.into(),
         AnsiColorIdentifier::Green.to_ansi_color(&appearance.theme().terminal_colors().normal),
     )
 }
 
-pub fn addressed_comment_icon(appearance: &Appearance) -> warpui::elements::Icon {
-    warpui::elements::Icon::new(
+pub fn addressed_comment_icon(appearance: &Appearance) -> galaxyui::elements::Icon {
+    galaxyui::elements::Icon::new(
         Icon::AddressedComment.into(),
         AnsiColorIdentifier::Green.to_ansi_color(&appearance.theme().terminal_colors().normal),
     )
 }
 
-pub fn failed_icon(appearance: &Appearance) -> warpui::elements::Icon {
-    warpui::elements::Icon::new(
+pub fn failed_icon(appearance: &Appearance) -> galaxyui::elements::Icon {
+    galaxyui::elements::Icon::new(
         Icon::Triangle.into(),
         AnsiColorIdentifier::Red.to_ansi_color(&appearance.theme().terminal_colors().normal),
     )
 }
 
 /// Not running, does not need user's attention
-pub fn gray_stop_icon(appearance: &Appearance) -> warpui::elements::Icon {
-    warpui::elements::Icon::new(
+pub fn gray_stop_icon(appearance: &Appearance) -> galaxyui::elements::Icon {
+    galaxyui::elements::Icon::new(
         Icon::StopFilled.into(),
         blended_colors::neutral_5(appearance.theme()),
     )
 }
 
 /// Agent is waiting for user to follow-up with next prompt.
-pub fn gray_clock_icon(appearance: &Appearance) -> warpui::elements::Icon {
-    warpui::elements::Icon::new(
+pub fn gray_clock_icon(appearance: &Appearance) -> galaxyui::elements::Icon {
+    galaxyui::elements::Icon::new(
         Icon::ClockSnooze.into(),
         blended_colors::neutral_5(appearance.theme()),
     )
 }
 
 /// Loading but not actionable yet.
-pub fn gray_circle_icon(appearance: &Appearance) -> warpui::elements::Icon {
-    warpui::elements::Icon::new(
+pub fn gray_circle_icon(appearance: &Appearance) -> galaxyui::elements::Icon {
+    galaxyui::elements::Icon::new(
         Icon::Circle.into(),
         blended_colors::neutral_5(appearance.theme()),
     )
 }
 
 /// Not running, requires user's attention
-pub fn yellow_stop_icon(appearance: &Appearance) -> warpui::elements::Icon {
-    warpui::elements::Icon::new(
+pub fn yellow_stop_icon(appearance: &Appearance) -> galaxyui::elements::Icon {
+    galaxyui::elements::Icon::new(
         Icon::StopFilled.into(),
         AnsiColorIdentifier::Yellow.to_ansi_color(&appearance.theme().terminal_colors().normal),
     )
 }
 
 /// To be used for actions (like running commands/reading files) that are long-running and executing.
-pub fn yellow_running_icon(appearance: &Appearance) -> warpui::elements::Icon {
-    warpui::elements::Icon::new(
+pub fn yellow_running_icon(appearance: &Appearance) -> galaxyui::elements::Icon {
+    galaxyui::elements::Icon::new(
         Icon::Circle.into(),
         AnsiColorIdentifier::Yellow.to_ansi_color(&appearance.theme().terminal_colors().normal),
     )
 }
 
 /// Used for buttons that stop the current task
-pub fn red_stop_icon(appearance: &Appearance) -> warpui::elements::Icon {
-    warpui::elements::Icon::new(Icon::StopFilled.into(), appearance.theme().ansi_fg_red())
+pub fn red_stop_icon(appearance: &Appearance) -> galaxyui::elements::Icon {
+    galaxyui::elements::Icon::new(Icon::StopFilled.into(), appearance.theme().ansi_fg_red())
 }

app/src/ai/agent/mod.rs

@@ -14,7 +14,7 @@ pub(super) mod util;
 
 // Re-export types that were moved to the ai crate.
 pub use ai::agent::{action::*, action_result::*, AIAgentCitation, FileLocations};
-use warp_core::features::FeatureFlag;
+use galaxy_core::features::FeatureFlag;
 
 #[cfg(test)]
 mod suggestion_test;
@@ -33,7 +33,7 @@ use comment::ReviewComment;
 use task::TaskId;
 pub use telemetry::AIIdentifiers;
 
-use warp_editor::render::model::LineCount;
+use galaxy_editor::render::model::LineCount;
 
 use parking_lot::RwLock;
 use std::collections::{HashMap, HashSet};

app/src/ai/agent/telemetry.rs

@@ -1,5 +1,5 @@
 use serde::Serialize;
-use warpui::{AppContext, SingletonEntity};
+use galaxyui::{AppContext, SingletonEntity};
 
 use crate::ai::llms::LLMId;
 use crate::CloudModel;

app/src/ai/agent/todos/popup.rs

@@ -1,15 +1,15 @@
 use crate::ai::blocklist::{BlocklistAIContextEvent, BlocklistAIContextModel};
 use pathfinder_color::ColorU;
-use warp_core::ui::appearance::Appearance;
-use warp_core::ui::theme::Fill;
-use warpui::elements::{
+use galaxy_core::ui::appearance::Appearance;
+use galaxy_core::ui::theme::Fill;
+use galaxyui::elements::{
     ClippedScrollStateHandle, ClippedScrollable, Dismiss, Empty, Expanded, ParentElement,
     SavePosition, ScrollTarget, ScrollToPositionMode, ScrollbarWidth, Shrinkable,
 };
-use warpui::fonts::FamilyId;
-use warpui::ModelHandle;
-use warpui::SingletonEntity;
-use warpui::{
+use galaxyui::fonts::FamilyId;
+use galaxyui::ModelHandle;
+use galaxyui::SingletonEntity;
+use galaxyui::{
     elements::{
         Border, ConstrainedBox, Container, CornerRadius, CrossAxisAlignment, DropShadow, Flex,
         MainAxisSize, Radius, Text,
@@ -50,7 +50,7 @@ struct Styles {
 }
 
 pub fn init(app: &mut AppContext) {
-    use warpui::keymap::macros::*;
+    use galaxyui::keymap::macros::*;
 
     app.register_fixed_bindings([FixedBinding::new(
         "escape",
@@ -124,9 +124,9 @@ impl AgentTodosPopupView {
 
     fn render_header(
         &self,
-        app: &warpui::AppContext,
+        app: &galaxyui::AppContext,
         todo_list: &AIAgentTodoList,
-    ) -> Box<dyn warpui::Element> {
+    ) -> Box<dyn galaxyui::Element> {
         let appearance = Appearance::as_ref(app);
         let styles = self.styles(appearance);
         let theme = appearance.theme();
@@ -159,7 +159,7 @@ impl View for AgentTodosPopupView {
         "AgentTodosPopup"
     }
 
-    fn render(&self, app: &warpui::AppContext) -> Box<dyn warpui::Element> {
+    fn render(&self, app: &galaxyui::AppContext) -> Box<dyn galaxyui::Element> {
         let Some(todo_list) = self
             .ai_context_model
             .as_ref(app)
@@ -271,7 +271,7 @@ impl View for AgentTodosPopupView {
             ScrollbarWidth::Auto,
             theme.nonactive_ui_detail().into(),
             theme.active_ui_detail().into(),
-            warpui::elements::Fill::None,
+            galaxyui::elements::Fill::None,
         )
         .with_overlayed_scrollbar()
         .finish();

app/src/ai/agent/util.rs

@@ -13,7 +13,7 @@ use markdown_parser::{
 use mermaid_to_svg::is_mermaid_diagram;
 use regex::Regex;
 use std::{collections::HashMap, path::PathBuf};
-use warp_util::path::LineAndColumnArg;
+use galaxy_util::path::LineAndColumnArg;
 
 lazy_static! {
     /// Markdown prefix for code blocks. Matches on triple backticks followed by a language.
@@ -258,7 +258,7 @@ fn image_section(image: FormattedImage, layout: AgentOutputImageLayout) -> AIAge
 }
 
 fn markdown_source_for_image(image: &FormattedImage) -> String {
-    warp_editor::content::text::format_image_markdown(
+    galaxy_editor::content::text::format_image_markdown(
         &image.alt_text,
         &image.source,
         image.title.as_deref(),

app/src/ai/agent_conversations_model.rs

@@ -29,15 +29,15 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use session_sharing_protocol::common::SessionId;
 use std::collections::{HashMap, HashSet};
 use std::time::Duration;
-use warp_cli::agent::Harness;
-use warp_core::execution_mode::AppExecutionMode;
-use warp_core::features::FeatureFlag;
-use warp_core::report_error;
-use warp_core::ui::theme::{color::internal_colors, WarpTheme};
-use warpui::color::ColorU;
-use warpui::r#async::Timer;
-use warpui::windowing::{StateEvent, WindowManager};
-use warpui::{
+use galaxy_cli::agent::Harness;
+use galaxy_core::execution_mode::AppExecutionMode;
+use galaxy_core::features::FeatureFlag;
+use galaxy_core::report_error;
+use galaxy_core::ui::theme::{color::internal_colors, WarpTheme};
+use galaxyui::color::ColorU;
+use galaxyui::r#async::Timer;
+use galaxyui::windowing::{StateEvent, WindowManager};
+use galaxyui::{
     duration_with_jitter, AppContext, Entity, EntityId, ModelContext, RequestState,
     SingletonEntity, WindowId,
 };

app/src/ai/agent_conversations_model_tests.rs

@@ -8,8 +8,8 @@ use std::{
         Arc,
     },
 };
-use warp_core::features::FeatureFlag;
-use warpui::{App, EntityId};
+use galaxy_core::features::FeatureFlag;
+use galaxyui::{App, EntityId};
 
 use crate::ai::agent::conversation::{AIConversation, AIConversationId, ConversationStatus};
 use crate::ai::ambient_agents::task::{TaskCreatorInfo, TaskStatusMessage};
@@ -29,7 +29,7 @@ use super::{
     MAX_PERSONAL_TASKS, MAX_TEAM_TASKS,
 };
 use crate::ai::ambient_agents::task::HarnessConfig;
-use warp_cli::agent::Harness;
+use galaxy_cli::agent::Harness;
 
 /// Creates a test task with specified creator UID and updated_at time
 fn create_test_task(

app/src/ai/agent_events/driver.rs

@@ -6,7 +6,7 @@ use async_trait::async_trait;
 use futures::future::Either;
 use futures::StreamExt;
 use instant::Instant;
-use warpui::r#async::Timer;
+use galaxyui::r#async::Timer;
 
 use crate::server::server_api::ai::AgentRunEvent;
 use crate::server::server_api::ServerApi;

app/src/ai/agent_events/message_hydrator.rs

@@ -5,7 +5,7 @@ use anyhow::{anyhow, Context, Result};
 #[cfg(not(target_family = "wasm"))]
 use futures::future::Either;
 #[cfg(not(target_family = "wasm"))]
-use warpui::r#async::Timer;
+use galaxyui::r#async::Timer;
 
 use crate::ai::agent::ReceivedMessageInput;
 use crate::server::server_api::ai::{AIClient, AgentRunEvent, ReadAgentMessageResponse};

app/src/ai/agent_management/agent_management_model.rs

@@ -1,7 +1,7 @@
 use std::collections::HashMap;
 
-use warp_core::features::FeatureFlag;
-use warpui::{AppContext, Entity, EntityId, ModelContext, SingletonEntity, WindowId};
+use galaxy_core::features::FeatureFlag;
+use galaxyui::{AppContext, Entity, EntityId, ModelContext, SingletonEntity, WindowId};
 
 use crate::settings::AISettings;
 
@@ -21,7 +21,7 @@ use crate::terminal::CLIAgent;
 use crate::workspace::util::is_terminal_view_in_same_tab;
 use crate::workspace::{Workspace, WorkspaceRegistry};
 use crate::BlocklistAIHistoryModel;
-use warp_core::send_telemetry_from_ctx;
+use galaxy_core::send_telemetry_from_ctx;
 
 /// Singleton model responsible for triggering in-app notifications on blocking conversation
 /// status updates and tracking/storing these notifications for the notifications mailbox.

app/src/ai/agent_management/agent_management_model_tests.rs

@@ -1,5 +1,5 @@
-use warp_core::features::FeatureFlag;
-use warpui::{App, EntityId, ModelHandle};
+use galaxy_core::features::FeatureFlag;
+use galaxyui::{App, EntityId, ModelHandle};
 
 use crate::ai::active_agent_views_model::ActiveAgentViewsModel;
 use crate::ai::agent::conversation::AIConversationId;

app/src/ai/agent_management/agent_type_selector.rs

@@ -7,18 +7,18 @@ use crate::appearance::Appearance;
 use crate::ui_components::icons::Icon;
 use pathfinder_color::ColorU;
 use pathfinder_geometry::vector::vec2f;
-use warp_core::ui::color::blend::Blend;
-use warp_core::ui::theme::color::internal_colors;
-use warpui::elements::{
+use galaxy_core::ui::color::blend::Blend;
+use galaxy_core::ui::theme::color::internal_colors;
+use galaxyui::elements::{
     Align, Border, ConstrainedBox, Container, CornerRadius, CrossAxisAlignment, Dismiss,
     DropShadow, Element, Flex, Hoverable, MainAxisAlignment, MainAxisSize, MouseStateHandle,
     ParentElement, Radius, Shrinkable, Text,
 };
-use warpui::fonts::{Properties, Weight};
-use warpui::keymap::{FixedBinding, Keystroke};
-use warpui::platform::Cursor;
-use warpui::ui_components::components::{Coords, UiComponent, UiComponentStyles};
-use warpui::{AppContext, Entity, SingletonEntity, TypedActionView, View, ViewContext};
+use galaxyui::fonts::{Properties, Weight};
+use galaxyui::keymap::{FixedBinding, Keystroke};
+use galaxyui::platform::Cursor;
+use galaxyui::ui_components::components::{Coords, UiComponent, UiComponentStyles};
+use galaxyui::{AppContext, Entity, SingletonEntity, TypedActionView, View, ViewContext};
 
 // Modal dimensions based on Figma design.
 const MODAL_WIDTH: f32 = 440.;
@@ -79,7 +79,7 @@ pub struct AgentTypeSelector {
 }
 
 pub fn init(app: &mut AppContext) {
-    use warpui::keymap::macros::*;
+    use galaxyui::keymap::macros::*;
 
     app.register_fixed_bindings(vec![
         FixedBinding::new(
@@ -223,7 +223,7 @@ impl AgentTypeSelector {
                 (base_background, base_border)
             };
 
-            let avatar_icon = ConstrainedBox::new(icon.to_warpui_icon(icon_color).finish())
+            let avatar_icon = ConstrainedBox::new(icon.to_galaxyui_icon(icon_color).finish())
                 .with_width(AVATAR_ICON_SIZE)
                 .with_height(AVATAR_ICON_SIZE)
                 .finish();

app/src/ai/agent_management/cloud_setup_guide_view.rs

@@ -11,23 +11,23 @@ use crate::workflows::WorkflowType;
 use serde::Serialize;
 use std::collections::HashMap;
 use string_offset::CharCounter;
-use warp_completer::signatures::CommandRegistry;
-use warp_completer::{util::parse_current_commands_and_tokens, ParsedTokensSnapshot};
-use warp_core::report_error;
-use warp_core::ui::theme::{AnsiColorIdentifier, AnsiColors};
-use warpui::clipboard::ClipboardContent;
-use warpui::elements::{
+use galaxy_completer::signatures::CommandRegistry;
+use galaxy_completer::{util::parse_current_commands_and_tokens, ParsedTokensSnapshot};
+use galaxy_core::report_error;
+use galaxy_core::ui::theme::{AnsiColorIdentifier, AnsiColors};
+use galaxyui::clipboard::ClipboardContent;
+use galaxyui::elements::{
     new_scrollable::{ClippedAxisConfiguration, DualAxisConfig, NewScrollable},
     Align, Border, ClippedScrollStateHandle, ConstrainedBox, Container, CornerRadius,
     CrossAxisAlignment, Element, Empty, Expanded, Flex, Highlight, HighlightedRange,
     MainAxisAlignment, MainAxisSize, MouseStateHandle, ParentElement, Radius, Text,
 };
-use warpui::fonts::{Properties, Weight};
-use warpui::prelude::ChildView;
-use warpui::text_layout::TextStyle;
-use warpui::ui_components::components::{UiComponent, UiComponentStyles};
-use warpui::ViewHandle;
-use warpui::{AppContext, Entity, SingletonEntity, TypedActionView, View, ViewContext};
+use galaxyui::fonts::{Properties, Weight};
+use galaxyui::prelude::ChildView;
+use galaxyui::text_layout::TextStyle;
+use galaxyui::ui_components::components::{UiComponent, UiComponentStyles};
+use galaxyui::ViewHandle;
+use galaxyui::{AppContext, Entity, SingletonEntity, TypedActionView, View, ViewContext};
 
 const DOCS_URL: &str = "https://docs.warp.dev/agent-platform/cloud-agents/overview";
 const ENV_DOCS_URL: &str =
@@ -617,7 +617,7 @@ impl View for CloudSetupGuideView {
             },
             theme.nonactive_ui_detail().into(),
             theme.active_ui_detail().into(),
-            warpui::elements::Fill::None,
+            galaxyui::elements::Fill::None,
         )
         .finish();
 

app/src/ai/agent_management/details_action_buttons.rs

@@ -1,8 +1,8 @@
 //! Action buttons row for conversation details panel.
 
-use warp_core::ui::theme::AnsiColorIdentifier;
-use warpui::elements::{ChildView, CrossAxisAlignment, Empty, Flex, ParentElement};
-use warpui::{AppContext, Element, Entity, TypedActionView, View, ViewContext, ViewHandle};
+use galaxy_core::ui::theme::AnsiColorIdentifier;
+use galaxyui::elements::{ChildView, CrossAxisAlignment, Empty, Flex, ParentElement};
+use galaxyui::{AppContext, Element, Entity, TypedActionView, View, ViewContext, ViewHandle};
 
 use crate::view_components::copyable_text_field::COPY_FEEDBACK_DURATION;
 
@@ -274,7 +274,7 @@ impl TypedActionView for ConversationActionButtonsRow {
                     let duration = COPY_FEEDBACK_DURATION;
                     ctx.spawn(
                         async move {
-                            warpui::r#async::Timer::after(duration).await;
+                            galaxyui::r#async::Timer::after(duration).await;
                         },
                         |me, _, ctx| {
                             me.copy_link_button.update(ctx, |button, ctx| {

app/src/ai/agent_management/mod.rs

@@ -9,7 +9,7 @@ pub(crate) mod view;
 
 pub(crate) use agent_management_model::{AgentManagementEvent, AgentNotificationsModel};
 
-pub fn init(app: &mut warpui::AppContext) {
+pub fn init(app: &mut galaxyui::AppContext) {
     view::init(app);
     agent_type_selector::init(app);
     notifications::view::NotificationMailboxView::init(app);

app/src/ai/agent_management/notifications/item.rs

@@ -1,7 +1,7 @@
 use enum_iterator::Sequence;
 use instant::Instant;
 use uuid::Uuid;
-use warpui::EntityId;
+use galaxyui::EntityId;
 
 use crate::ai::agent::conversation::AIConversationId;
 use crate::ai::artifacts::Artifact;

app/src/ai/agent_management/notifications/item_rendering.rs

@@ -1,20 +1,20 @@
 use std::sync::Arc;
 
 use pathfinder_color::ColorU;
-use warp_core::ui::icons::Icon;
-use warp_core::ui::theme::{Fill, WarpTheme};
-use warpui::clipboard::ClipboardContent;
-use warpui::elements::{
+use galaxy_core::ui::icons::Icon;
+use galaxy_core::ui::theme::{Fill, WarpTheme};
+use galaxyui::clipboard::ClipboardContent;
+use galaxyui::elements::{
     ChildView, ConstrainedBox, Container, CornerRadius, CrossAxisAlignment, DispatchEventResult,
     Element, EventHandler, Flex, MainAxisAlignment, MainAxisSize, ParentElement, Radius, Rect,
     Shrinkable,
 };
-use warpui::fonts::Weight;
-use warpui::ui_components::components::{UiComponent, UiComponentStyles};
-use warpui::{View, ViewContext, ViewHandle};
+use galaxyui::fonts::Weight;
+use galaxyui::ui_components::components::{UiComponent, UiComponentStyles};
+use galaxyui::{View, ViewContext, ViewHandle};
 
-use warp_core::ui::appearance::Appearance as CoreAppearance;
-use warp_core::ui::theme::color::internal_colors;
+use galaxy_core::ui::appearance::Appearance as CoreAppearance;
+use galaxy_core::ui::theme::color::internal_colors;
 
 use crate::ai::agent::conversation::ConversationStatus;
 use crate::ai::agent_management::notifications::item::NotificationSourceAgent;
@@ -85,7 +85,7 @@ impl ActionButtonTheme for NotificationArtifactButtonTheme {
 }
 
 /// Callback invoked when the user clicks the expand/collapse affordance on a clamped message.
-pub(crate) type OnExpandClick = Box<dyn Fn(&mut warpui::EventContext)>;
+pub(crate) type OnExpandClick = Box<dyn Fn(&mut galaxyui::EventContext)>;
 
 /// Renders the inner content of a notification item.
 /// Dispatches to the rich layout (with branch row) or simple layout based on `item.branch`.
@@ -258,7 +258,7 @@ fn render_branch_label(branch: &str, appearance: &Appearance) -> Box<dyn Element
             .with_cross_axis_alignment(CrossAxisAlignment::Center)
             .with_spacing(2.)
             .with_child(
-                ConstrainedBox::new(Icon::GitBranch.to_warpui_icon(color).finish())
+                ConstrainedBox::new(Icon::GitBranch.to_galaxyui_icon(color).finish())
                     .with_width(10.)
                     .with_height(10.)
                     .finish(),
@@ -339,7 +339,7 @@ fn render_expand_chevron(
         Icon::ChevronRight
     };
     let chevron = ConstrainedBox::new(
-        icon.to_warpui_icon(theme.disabled_text_color(theme.surface_1()))
+        icon.to_galaxyui_icon(theme.disabled_text_color(theme.surface_1()))
             .finish(),
     )
     .with_width(12.)

app/src/ai/agent_management/notifications/item_tests.rs

@@ -1,4 +1,4 @@
-use warpui::EntityId;
+use galaxyui::EntityId;
 
 use super::*;
 use crate::ai::agent::conversation::AIConversationId;

app/src/ai/agent_management/notifications/toast_stack.rs

@@ -1,20 +1,20 @@
 use std::time::Duration;
 
 use pathfinder_geometry::vector::vec2f;
-use warp_core::ui::color::blend::Blend;
-use warp_core::ui::theme::color::internal_colors;
-use warpui::elements::{
+use galaxy_core::ui::color::blend::Blend;
+use galaxy_core::ui::theme::color::internal_colors;
+use galaxyui::elements::{
     Border, ChildAnchor, ConstrainedBox, Container, CornerRadius, CrossAxisAlignment,
     DispatchEventResult, Element, EventHandler, Flex, Hoverable, MouseStateHandle,
     OffsetPositioning, Padding, ParentElement, PositionedElementAnchor,
     PositionedElementOffsetBounds, Radius, SavePosition, Shrinkable, Stack,
 };
-use warpui::keymap::Keystroke;
-use warpui::platform::Cursor;
-use warpui::r#async::{SpawnedFutureHandle, Timer};
-use warpui::ui_components::components::{Coords, UiComponent, UiComponentStyles};
-use warpui::ui_components::keyboard_shortcut::KeyboardShortcut;
-use warpui::{AppContext, Entity, SingletonEntity, TypedActionView, View, ViewContext, ViewHandle};
+use galaxyui::keymap::Keystroke;
+use galaxyui::platform::Cursor;
+use galaxyui::r#async::{SpawnedFutureHandle, Timer};
+use galaxyui::ui_components::components::{Coords, UiComponent, UiComponentStyles};
+use galaxyui::ui_components::keyboard_shortcut::KeyboardShortcut;
+use galaxyui::{AppContext, Entity, SingletonEntity, TypedActionView, View, ViewContext, ViewHandle};
 
 use crate::ai::agent_management::notifications::item_rendering::{
     create_notification_artifact_buttons_view, handle_notification_artifact_buttons_event,
@@ -367,7 +367,7 @@ fn render_toast(
     appearance: &Appearance,
 ) -> Box<dyn Element> {
     let theme = appearance.theme();
-    let on_expand: OnExpandClick = Box::new(move |ctx: &mut warpui::EventContext| {
+    let on_expand: OnExpandClick = Box::new(move |ctx: &mut galaxyui::EventContext| {
         ctx.dispatch_typed_action(AgentNotificationToastAction::ToggleMessageExpanded(id));
     });
     let keybinding_hint = keystroke.map(|ks| render_keybinding_hint(ks, appearance));

app/src/ai/agent_management/notifications/view.rs

@@ -1,18 +1,18 @@
-use warp_core::ui::theme::color::internal_colors;
-use warpui::elements::new_scrollable::{ScrollableAppearance, SingleAxisConfig};
-use warpui::elements::{
+use galaxy_core::ui::theme::color::internal_colors;
+use galaxyui::elements::new_scrollable::{ScrollableAppearance, SingleAxisConfig};
+use galaxyui::elements::{
     Border, ChildView, ClippedScrollStateHandle, ConstrainedBox, Container, CornerRadius,
     CrossAxisAlignment, Dismiss, DispatchEventResult, Element, Empty, EventHandler,
     Fill as ElementFill, Flex, Hoverable, MainAxisAlignment, MainAxisSize, MouseStateHandle,
     NewScrollable, Padding, ParentElement, Radius, SavePosition, ScrollTarget,
     ScrollToPositionMode, ScrollbarWidth, Shrinkable,
 };
-use warpui::fonts::Weight;
-use warpui::keymap::macros::id;
-use warpui::keymap::FixedBinding;
-use warpui::platform::Cursor;
-use warpui::ui_components::components::{UiComponent, UiComponentStyles};
-use warpui::{AppContext, Entity, SingletonEntity, TypedActionView, View, ViewContext, ViewHandle};
+use galaxyui::fonts::Weight;
+use galaxyui::keymap::macros::id;
+use galaxyui::keymap::FixedBinding;
+use galaxyui::platform::Cursor;
+use galaxyui::ui_components::components::{UiComponent, UiComponentStyles};
+use galaxyui::{AppContext, Entity, SingletonEntity, TypedActionView, View, ViewContext, ViewHandle};
 
 use crate::ai::agent_management::notifications::item::NotificationFilter;
 use crate::ai::agent_management::notifications::item_rendering::{
@@ -56,7 +56,7 @@ impl Entity for NotificationMailboxView {
 
 #[derive(Debug, Clone)]
 pub enum NotificationMailboxViewEvent {
-    NavigateToTerminal { terminal_view_id: warpui::EntityId },
+    NavigateToTerminal { terminal_view_id: galaxyui::EntityId },
     Dismissed,
 }
 

app/src/ai/agent_management/telemetry.rs

@@ -1,7 +1,7 @@
 use serde::Serialize;
 use serde_json::json;
 use strum_macros::{EnumDiscriminants, EnumIter};
-use warp_core::telemetry::{EnablementState, TelemetryEvent, TelemetryEventDesc};
+use galaxy_core::telemetry::{EnablementState, TelemetryEvent, TelemetryEventDesc};
 
 use crate::ai::agent_management::cloud_setup_guide_view::SetupGuideDocs;
 
@@ -216,7 +216,7 @@ impl TelemetryEvent for AgentManagementTelemetryEvent {
     }
 
     fn event_descs() -> impl Iterator<Item = Box<dyn TelemetryEventDesc>> {
-        warp_core::telemetry::enum_events::<Self>()
+        galaxy_core::telemetry::enum_events::<Self>()
     }
 }
 
@@ -290,4 +290,4 @@ impl TelemetryEventDesc for AgentManagementTelemetryEventDiscriminants {
     }
 }
 
-warp_core::register_telemetry_event!(AgentManagementTelemetryEvent);
+galaxy_core::register_telemetry_event!(AgentManagementTelemetryEvent);

app/src/ai/agent_management/view.rs

@@ -6,9 +6,9 @@ use fuzzy_match::match_indices_case_insensitive;
 use lazy_static::lazy_static;
 use pathfinder_color::ColorU;
 use siphasher::sip::SipHasher;
-use warp_core::features::FeatureFlag;
-use warpui::scene::DropShadow;
-use warpui::ui_components::button::ButtonVariant;
+use galaxy_core::features::FeatureFlag;
+use galaxyui::scene::DropShadow;
+use galaxyui::ui_components::button::ButtonVariant;
 
 use crate::ai::agent::conversation::AIConversationId;
 use crate::ai::agent_conversations_model::{
@@ -65,26 +65,26 @@ use crate::workspaces::user_workspaces::UserWorkspaces;
 use crate::{send_telemetry_from_ctx, AgentModeEntrypoint};
 use pathfinder_geometry::vector::vec2f;
 use settings::Setting;
-use warp_cli::agent::Harness;
-use warp_core::ui::icons::Icon;
-use warp_core::ui::theme::color::internal_colors;
-use warp_core::ui::theme::Fill;
-use warpui::clipboard::ClipboardContent;
-use warpui::elements::new_scrollable::{
+use galaxy_cli::agent::Harness;
+use galaxy_core::ui::icons::Icon;
+use galaxy_core::ui::theme::color::internal_colors;
+use galaxy_core::ui::theme::Fill;
+use galaxyui::clipboard::ClipboardContent;
+use galaxyui::elements::new_scrollable::{
     NewScrollableElement, ScrollableAppearance, SingleAxisConfig,
 };
-use warpui::elements::{
+use galaxyui::elements::{
     Align, Border, ChildAnchor, ChildView, Clipped, ConstrainedBox, Container, CornerRadius,
     CrossAxisAlignment, Element, Empty, Expanded, Flex, Hoverable, List, ListState, MainAxisSize,
     MouseStateHandle, NewScrollable, OffsetPositioning, Padding, ParentAnchor, ParentElement,
     ParentOffsetBounds, Radius, Rect, ScrollStateHandle, ScrollbarWidth, Shrinkable,
     SizeConstraintCondition, SizeConstraintSwitch, Stack, Text, Wrap,
 };
-use warpui::fonts::{Properties, Weight};
-use warpui::platform::Cursor;
-use warpui::ui_components::components::UiComponent;
-use warpui::ui_components::components::UiComponentStyles;
-use warpui::{
+use galaxyui::fonts::{Properties, Weight};
+use galaxyui::platform::Cursor;
+use galaxyui::ui_components::components::UiComponent;
+use galaxyui::ui_components::components::UiComponentStyles;
+use galaxyui::{
     keymap::FixedBinding, Action, AppContext, Entity, FocusContext, ModelHandle, SingletonEntity,
     TypedActionView, View, ViewContext, ViewHandle, WeakViewHandle,
 };
@@ -117,7 +117,7 @@ pub fn init(app: &mut AppContext) {
     app.register_fixed_bindings([FixedBinding::new(
         cmd_or_ctrl_shift("f"),
         AgentManagementViewAction::FocusSearch,
-        warpui::keymap::macros::id!(AgentManagementView::ui_name()),
+        galaxyui::keymap::macros::id!(AgentManagementView::ui_name()),
     )]);
 }
 
@@ -1992,7 +1992,7 @@ impl AgentManagementView {
 
         let loading_icon = ConstrainedBox::new(
             Icon::Refresh
-                .to_warpui_icon(theme.sub_text_color(theme.surface_1()))
+                .to_galaxyui_icon(theme.sub_text_color(theme.surface_1()))
                 .finish(),
         )
         .with_height(icon_size)
@@ -2036,7 +2036,7 @@ impl AgentManagementView {
 
         let loading_icon = ConstrainedBox::new(
             Icon::Loading
-                .to_warpui_icon(Fill::Solid(internal_colors::neutral_6(theme)))
+                .to_galaxyui_icon(Fill::Solid(internal_colors::neutral_6(theme)))
                 .finish(),
         )
         .with_height(appearance.ui_font_size() + 2.)
@@ -2096,7 +2096,7 @@ impl AgentManagementView {
         let appearance = Appearance::as_ref(app);
         let icon = ConstrainedBox::new(
             Icon::FilterOff
-                .to_warpui_icon(appearance.theme().nonactive_ui_text_color())
+                .to_galaxyui_icon(appearance.theme().nonactive_ui_text_color())
                 .finish(),
         )
         .with_width(24.)
@@ -2135,7 +2135,7 @@ impl AgentManagementView {
             axis_config,
             theme.nonactive_ui_detail().into(),
             theme.active_ui_detail().into(),
-            warpui::elements::Fill::None,
+            galaxyui::elements::Fill::None,
         )
         .with_vertical_scrollbar(ScrollableAppearance::new(ScrollbarWidth::None, false))
         .with_always_handle_events_first(false)

app/src/ai/agent_sdk/admin.rs

@@ -2,8 +2,8 @@
 
 use anyhow::{Context, Result};
 use serde::Serialize;
-use warp_cli::agent::OutputFormat;
-use warpui::{platform::TerminationMode, AppContext, SingletonEntity};
+use galaxy_cli::agent::OutputFormat;
+use galaxyui::{platform::TerminationMode, AppContext, SingletonEntity};
 
 use crate::auth::auth_manager::{AuthManager, AuthManagerEvent};
 use crate::auth::user::PrincipalType;
@@ -116,7 +116,7 @@ struct WhoamiOutput {
 /// Singleton model that provides a `ModelContext` for the `whoami` command's async work.
 struct WhoamiRunner;
 
-impl warpui::Entity for WhoamiRunner {
+impl galaxyui::Entity for WhoamiRunner {
     type Event = ();
 }
 

app/src/ai/agent_sdk/agent_config.rs

@@ -4,10 +4,10 @@ use crate::ai::agent_sdk::oauth_flow::poll_oauth_until_terminal;
 use crate::ai::cloud_environments::GithubRepo;
 use crate::server::server_api::ai::AgentListItem;
 use crate::server::server_api::ServerApiProvider;
-use warp_cli::agent::ListAgentConfigsArgs;
-use warp_graphql::queries::get_oauth_connect_tx_status::OauthConnectTxStatus;
-use warp_graphql::queries::user_repo_auth_status::UserRepoAuthStatusEnum;
-use warpui::{platform::TerminationMode, AppContext, ModelContext, SingletonEntity};
+use galaxy_cli::agent::ListAgentConfigsArgs;
+use galaxy_graphql::queries::get_oauth_connect_tx_status::OauthConnectTxStatus;
+use galaxy_graphql::queries::user_repo_auth_status::UserRepoAuthStatusEnum;
+use galaxyui::{platform::TerminationMode, AppContext, ModelContext, SingletonEntity};
 
 const MAX_LINE_WIDTH: usize = 90;
 const MAX_AUTH_ATTEMPTS: u32 = 8;
@@ -304,7 +304,7 @@ impl AgentConfigRunner {
     }
 }
 
-impl warpui::Entity for AgentConfigRunner {
+impl galaxyui::Entity for AgentConfigRunner {
     type Event = ();
 }
 

app/src/ai/agent_sdk/ambient.rs

@@ -27,7 +27,7 @@ use comfy_table::Cell;
 use futures::{future, StreamExt};
 use serde::Serialize;
 
-use warp_cli::{
+use galaxy_cli::{
     agent::{Harness, OutputFormat, Prompt, RunCloudArgs},
     json_filter::JsonOutput,
     task::{
@@ -37,10 +37,10 @@ use warp_cli::{
     },
     GlobalOptions,
 };
-use warp_core::channel::ChannelState;
-use warp_core::features::FeatureFlag;
-use warpui::r#async::Timer;
-use warpui::{
+use galaxy_core::channel::ChannelState;
+use galaxy_core::features::FeatureFlag;
+use galaxyui::r#async::Timer;
+use galaxyui::{
     platform::TerminationMode, r#async::Spawnable, AppContext, ModelContext, SingletonEntity,
 };
 
@@ -1240,7 +1240,7 @@ impl AmbientAgentRunner {
     }
 }
 
-impl warpui::Entity for AmbientAgentRunner {
+impl galaxyui::Entity for AmbientAgentRunner {
     type Event = ();
 }
 

app/src/ai/agent_sdk/ambient_tests.rs

@@ -3,8 +3,8 @@
 
 use chrono::{TimeZone, Utc};
 
-use warp_cli::json_filter::JsonOutput;
-use warp_cli::task::{
+use galaxy_cli::json_filter::JsonOutput;
+use galaxy_cli::task::{
     ArtifactTypeArg, ExecutionLocationArg, ListTasksArgs, RunSortByArg, RunSortOrderArg,
     RunSourceArg, RunStateArg,
 };

app/src/ai/agent_sdk/artifact.rs

@@ -2,12 +2,12 @@ use std::{path::PathBuf, sync::Arc};
 
 use anyhow::{Context, Result};
 use serde::Serialize;
-use warp_cli::agent::OutputFormat;
-use warp_cli::artifact::{
+use galaxy_cli::agent::OutputFormat;
+use galaxy_cli::artifact::{
     ArtifactCommand, DownloadArtifactArgs, GetArtifactArgs, UploadArtifactArgs,
 };
-use warp_cli::GlobalOptions;
-use warpui::{platform::TerminationMode, AppContext, ModelContext, SingletonEntity};
+use galaxy_cli::GlobalOptions;
+use galaxyui::{platform::TerminationMode, AppContext, ModelContext, SingletonEntity};
 
 use crate::ai::artifact_download::{download_artifact_bytes, download_destination};
 #[cfg(test)]
@@ -129,7 +129,7 @@ impl ArtifactCommandRunner {
     }
 }
 
-impl warpui::Entity for ArtifactCommandRunner {
+impl galaxyui::Entity for ArtifactCommandRunner {
     type Event = ();
 }
 

app/src/ai/agent_sdk/artifact_tests.rs

@@ -1,5 +1,5 @@
 use std::path::PathBuf;
-use warp_cli::agent::OutputFormat;
+use galaxy_cli::agent::OutputFormat;
 
 use super::*;
 

app/src/ai/agent_sdk/artifact_upload.rs

@@ -7,7 +7,7 @@ use std::sync::Arc;
 use anyhow::{anyhow, bail, Context, Result};
 use blocking::unblock;
 use mime_guess::from_path;
-use warp_cli::artifact::UploadArtifactArgs;
+use galaxy_cli::artifact::UploadArtifactArgs;
 
 use super::common::parse_ambient_task_id;
 use crate::ai::agent::api::ServerConversationToken;

app/src/ai/agent_sdk/artifact_upload_tests.rs

@@ -4,7 +4,7 @@ use std::path::PathBuf;
 
 use chrono::Utc;
 use tempfile::tempdir;
-use warp_cli::artifact::UploadArtifactArgs;
+use galaxy_cli::artifact::UploadArtifactArgs;
 
 use super::*;
 use crate::ai::agent::api::ServerConversationToken;

app/src/ai/agent_sdk/common.rs

@@ -7,10 +7,10 @@ use std::time::Duration;
 
 use futures::TryFutureExt;
 use inquire::{InquireError, Select};
-use warp_cli::agent::Harness;
-use warp_cli::environment::{EnvironmentCreateArgs, EnvironmentUpdateArgs};
-use warpui::r#async::FutureExt;
-use warpui::{AppContext, GetSingletonModelHandle, SingletonEntity as _, UpdateModel};
+use galaxy_cli::agent::Harness;
+use galaxy_cli::environment::{EnvironmentCreateArgs, EnvironmentUpdateArgs};
+use galaxyui::r#async::FutureExt;
+use galaxyui::{AppContext, GetSingletonModelHandle, SingletonEntity as _, UpdateModel};
 
 use crate::ai::agent::conversation::ServerAIConversationMetadata;
 use crate::ai::agent_sdk::driver::{AgentDriverError, WARP_DRIVE_SYNC_TIMEOUT};
@@ -252,7 +252,7 @@ impl EnvironmentChoice {
 
             // If there are no synced environments, require the user to create one or use --no-environment.
             if options.len() == 1 {
-                let cli_name = warp_cli::binary_name().unwrap_or_else(|| "warp".to_string());
+                let cli_name = galaxy_cli::binary_name().unwrap_or_else(|| "warp".to_string());
                 return Err(ResolveConfigurationError::Other(anyhow::anyhow!(
                     "No environments are configured for this account.\n\
 You can create an environment with `{cli_name} environment create`.\n\

app/src/ai/agent_sdk/config_file.rs

@@ -2,7 +2,7 @@ use std::path::Path;
 
 use anyhow::Context as _;
 use serde_json::{Map, Value};
-use warp_cli::mcp::MCPSpec;
+use galaxy_cli::mcp::MCPSpec;
 
 use crate::ai::ambient_agents::AgentConfigSnapshot;
 

app/src/ai/agent_sdk/config_file_tests.rs

@@ -5,7 +5,7 @@ use std::io::Write as _;
 use serde_json::json;
 
 use crate::ai::ambient_agents::AgentConfigSnapshot;
-use warp_cli::mcp::MCPSpec;
+use galaxy_cli::mcp::MCPSpec;
 
 fn write_temp(suffix: &str, contents: &str) -> tempfile::NamedTempFile {
     let mut file = tempfile::Builder::new().suffix(suffix).tempfile().unwrap();

app/src/ai/agent_sdk/driver.rs

@@ -76,13 +76,13 @@ use futures::{
 };
 use oneshot::{Canceled, Receiver, Sender};
 use uuid::Uuid;
-use warp_cli::agent::{Harness, OutputFormat};
-use warp_cli::mcp::MCPSpec;
-use warp_cli::share::ShareRequest;
-use warp_core::{features::FeatureFlag, report_error, report_if_error, safe_debug, safe_info};
-use warp_graphql::ai::AgentTaskState;
-use warp_managed_secrets::ManagedSecretValue;
-use warpui::{
+use galaxy_cli::agent::{Harness, OutputFormat};
+use galaxy_cli::mcp::MCPSpec;
+use galaxy_cli::share::ShareRequest;
+use galaxy_core::{features::FeatureFlag, report_error, report_if_error, safe_debug, safe_info};
+use galaxy_graphql::ai::AgentTaskState;
+use galaxy_managed_secrets::ManagedSecretValue;
+use galaxyui::{
     r#async::{FutureExt, TimeoutError},
     AppContext, Entity, ModelContext, ModelHandle, ModelSpawner, SingletonEntity,
 };
@@ -441,8 +441,8 @@ pub enum AgentDriverError {
     },
 }
 
-impl From<warpui::ModelDropped> for AgentDriverError {
-    fn from(_: warpui::ModelDropped) -> Self {
+impl From<galaxyui::ModelDropped> for AgentDriverError {
+    fn from(_: galaxyui::ModelDropped) -> Self {
         AgentDriverError::InvalidRuntimeState
     }
 }
@@ -596,7 +596,7 @@ impl AgentDriver {
 
         // Signal to third-party harnesses (e.g. Claude Code) that we're in a sandbox
         // so they allow root execution with permissive flags.
-        if warp_isolation_platform::detect().is_some() {
+        if galaxy_isolation_platform::detect().is_some() {
             env_vars.insert(OsString::from("IS_SANDBOX"), OsString::from("1"));
         }
 
@@ -729,7 +729,7 @@ impl AgentDriver {
                 ) {
                     let timeout = idle_timeout.min(SETUP_FAILED_IDLE_TIMEOUT);
                     log::info!("Environment setup failed; keeping session alive for {timeout:?}");
-                    warpui::r#async::Timer::after(timeout).await;
+                    galaxyui::r#async::Timer::after(timeout).await;
                 }
             }
 
@@ -1402,7 +1402,7 @@ impl AgentDriver {
                 // and then call stop_sharing_session when they're done. To know when streams are finished, we would need to modify start_ordered_terminal_events_listener
                 // to send a message when the streams are finished, flushed, and the websocket is disconnected. For now, we'll just sleep for a second, as this seems
                 // to be enough time for the streams to be finished and the events to be flushed.
-                warpui::r#async::Timer::after(Duration::from_secs(1)).await;
+                galaxyui::r#async::Timer::after(Duration::from_secs(1)).await;
 
                 conversation_status.into_result()
             }
@@ -1569,7 +1569,7 @@ impl AgentDriver {
         let command_result = loop {
             futures::select! {
                 exit_code = command_handle => break exit_code,
-                _ = warpui::r#async::Timer::after(HARNESS_SAVE_INTERVAL).fuse() => {
+                _ = galaxyui::r#async::Timer::after(HARNESS_SAVE_INTERVAL).fuse() => {
                     log::debug!("Triggering periodic save of harness conversation data");
                     report_if_error!(runner
                         .save_conversation(SavePoint::Periodic, foreground)

app/src/ai/agent_sdk/driver/attachments.rs

@@ -8,7 +8,7 @@ use futures::TryStreamExt as _;
 use mime_guess::from_path;
 use tokio::fs;
 use tokio_util::io::StreamReader;
-use warp_core::features::FeatureFlag;
+use galaxy_core::features::FeatureFlag;
 
 use crate::ai::agent_sdk::retry::with_bounded_retry;
 use crate::ai::ambient_agents::task::{AttachmentInput, TaskAttachment};

app/src/ai/agent_sdk/driver/cloud_provider.rs

@@ -1,7 +1,7 @@
 use std::{collections::HashMap, ffi::OsString, future::Future, pin::Pin};
 
 use anyhow::Error;
-use warpui::ModelSpawner;
+use galaxyui::ModelSpawner;
 
 use super::terminal::TerminalDriver;
 use crate::ai::cloud_environments::ProvidersConfig;

app/src/ai/agent_sdk/driver/cloud_provider/aws.rs

@@ -3,9 +3,9 @@ use std::{collections::HashMap, ffi::OsString, future::Future, pin::Pin, time::D
 use anyhow::Context;
 use tempfile::{Builder, NamedTempFile};
 use vec1::Vec1;
-use warp_core::safe_info;
-use warp_managed_secrets::ManagedSecretManager;
-use warpui::{ModelSpawner, SingletonEntity};
+use galaxy_core::safe_info;
+use galaxy_managed_secrets::ManagedSecretManager;
+use galaxyui::{ModelSpawner, SingletonEntity};
 
 use crate::ai::aws_credentials::aws_role_session_name;
 use crate::ai::cloud_environments::AwsProviderConfig;
@@ -93,7 +93,7 @@ impl CloudProvider for AwsCloudProvider {
                     ManagedSecretManager::handle(ctx)
                         .as_ref(ctx)
                         .issue_task_identity_token(
-                            warp_managed_secrets::client::IdentityTokenOptions {
+                            galaxy_managed_secrets::client::IdentityTokenOptions {
                                 audience,
                                 requested_duration: duration,
                                 subject_template,

app/src/ai/agent_sdk/driver/cloud_provider/gcp.rs

@@ -1,7 +1,7 @@
 use std::{collections::HashMap, ffi::OsString, future::Future, pin::Pin, time::Duration};
 
 use anyhow::Context as _;
-use warp_managed_secrets::{GcpCredentials, GcpFederationConfig};
+use galaxy_managed_secrets::{GcpCredentials, GcpFederationConfig};
 
 use crate::ai::cloud_environments::GcpProviderConfig;
 

app/src/ai/agent_sdk/driver/environment.rs

@@ -14,12 +14,12 @@ use ai::index::full_source_code_embedding::manager::{
 };
 use futures::{channel::oneshot, future::join_all};
 use repo_metadata::repositories::{DetectedRepositories, RepoDetectionSource};
-use warp_completer::completer::CommandExitStatus;
-use warp_core::{command::ExitCode, safe_info, safe_warn};
-use warpui::{r#async::FutureExt, ModelContext, ModelSpawner, SingletonEntity};
+use galaxy_completer::completer::CommandExitStatus;
+use galaxy_core::{command::ExitCode, safe_info, safe_warn};
+use galaxyui::{r#async::FutureExt, ModelContext, ModelSpawner, SingletonEntity};
 
 use super::{terminal::TerminalDriver, AgentDriverError};
-use warp_cli::agent::Harness;
+use galaxy_cli::agent::Harness;
 
 const CODEBASE_INDEX_SYNC_TIMEOUT: Duration = Duration::from_secs(60);
 
@@ -260,10 +260,10 @@ async fn prepare_environment_impl(
         // We also skip this in Namespace to reduce startup time.
         #[cfg(not(target_family = "wasm"))]
         let should_wait_for_indexing = !matches!(
-            warp_isolation_platform::detect(),
+            galaxy_isolation_platform::detect(),
             Some(
-                warp_isolation_platform::IsolationPlatformType::DockerSandbox
-                    | warp_isolation_platform::IsolationPlatformType::Namespace
+                galaxy_isolation_platform::IsolationPlatformType::DockerSandbox
+                    | galaxy_isolation_platform::IsolationPlatformType::Namespace
             )
         );
         #[cfg(target_family = "wasm")]

app/src/ai/agent_sdk/driver/error_classification.rs

@@ -1,6 +1,6 @@
 use crate::ai::blocklist::task_status_sync_model::classify_renderable_error;
 use crate::server::server_api::ai::TaskStatusUpdate;
-use warp_graphql::ai::{AgentTaskState, PlatformErrorCode};
+use galaxy_graphql::ai::{AgentTaskState, PlatformErrorCode};
 
 use super::terminal::ShareSessionError;
 use super::AgentDriverError;
@@ -71,7 +71,7 @@ pub fn classify_driver_error(error: &AgentDriverError) -> (AgentTaskState, TaskS
             ),
         ),
         AgentDriverError::NotLoggedIn => {
-            let bin = warp_cli::binary_name().unwrap_or_else(|| "warp".to_string());
+            let bin = galaxy_cli::binary_name().unwrap_or_else(|| "warp".to_string());
             (
                 AgentTaskState::Error,
                 TaskStatusUpdate::with_error_code(

app/src/ai/agent_sdk/driver/error_classification_tests.rs

@@ -1,4 +1,4 @@
-use warp_graphql::ai::{AgentTaskState, PlatformErrorCode};
+use galaxy_graphql::ai::{AgentTaskState, PlatformErrorCode};
 
 use super::classify_driver_error;
 use crate::ai::agent_sdk::driver::terminal::ShareSessionError;

app/src/ai/agent_sdk/driver/harness/claude_code.rs

@@ -10,8 +10,8 @@ use serde::{Deserialize, Serialize};
 use serde_json::{Map, Value};
 use tempfile::NamedTempFile;
 use uuid::Uuid;
-use warp_cli::agent::Harness;
-use warpui::{ModelHandle, ModelSpawner};
+use galaxy_cli::agent::Harness;
+use galaxyui::{ModelHandle, ModelSpawner};
 
 use crate::ai::agent::conversation::AIConversationId;
 use crate::ai::ambient_agents::AmbientAgentTaskId;

app/src/ai/agent_sdk/driver/harness/claude_code/parent_bridge.rs

@@ -20,8 +20,8 @@ use serde::{Deserialize, Serialize};
 use tempfile::NamedTempFile;
 use tokio::sync::Mutex as AsyncMutex;
 use uuid::Uuid;
-use warpui::r#async::SpawnedFutureHandle;
-use warpui::ModelSpawner;
+use galaxyui::r#async::SpawnedFutureHandle;
+use galaxyui::ModelSpawner;
 
 use crate::ai::agent_events::{
     run_agent_event_driver, AgentEventConsumer, AgentEventConsumerControlFlow,

app/src/ai/agent_sdk/driver/harness/claude_transcript.rs

@@ -22,7 +22,7 @@ use anyhow::{Context, Result};
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use uuid::Uuid;
-use warp_core::safe_warn;
+use galaxy_core::safe_warn;
 
 use crate::ai::agent::conversation::AIConversationId;
 

app/src/ai/agent_sdk/driver/harness/gemini.rs

@@ -8,9 +8,9 @@ use parking_lot::Mutex;
 use serde::{Deserialize, Serialize};
 use serde_json::{Map, Value};
 use tempfile::NamedTempFile;
-use warp_cli::agent::Harness;
-use warp_managed_secrets::ManagedSecretValue;
-use warpui::{ModelHandle, ModelSpawner};
+use galaxy_cli::agent::Harness;
+use galaxy_managed_secrets::ManagedSecretValue;
+use galaxyui::{ModelHandle, ModelSpawner};
 
 use crate::ai::agent::conversation::AIConversationId;
 use crate::ai::ambient_agents::AmbientAgentTaskId;

app/src/ai/agent_sdk/driver/harness/mod.rs

@@ -9,9 +9,9 @@ use std::sync::Arc;
 use anyhow::{Context, Result};
 use async_trait::async_trait;
 use tempfile::NamedTempFile;
-use warp_cli::agent::Harness;
-use warp_managed_secrets::ManagedSecretValue;
-use warpui::{ModelHandle, ModelSpawner, SingletonEntity};
+use galaxy_cli::agent::Harness;
+use galaxy_managed_secrets::ManagedSecretValue;
+use galaxyui::{ModelHandle, ModelSpawner, SingletonEntity};
 
 use crate::ai::agent::conversation::AIConversationId;
 use crate::ai::ambient_agents::AmbientAgentTaskId;
@@ -21,11 +21,11 @@ use crate::terminal::cli_agent_sessions::{CLIAgentSessionStatus, CLIAgentSession
 use crate::terminal::model::block::{BlockId, SerializedBlock};
 use crate::terminal::CLIAgent;
 use crate::util::path::resolve_executable;
-use warp_cli::{
+use galaxy_cli::{
     OZ_CLI_ENV, OZ_HARNESS_ENV, OZ_PARENT_RUN_ID_ENV, OZ_RUN_ID_ENV, SERVER_ROOT_URL_OVERRIDE_ENV,
     SESSION_SHARING_SERVER_URL_OVERRIDE_ENV, WS_SERVER_URL_OVERRIDE_ENV,
 };
-use warp_core::channel::ChannelState;
+use galaxy_core::channel::ChannelState;
 
 use super::terminal::{CommandHandle, TerminalDriver};
 use super::{

app/src/ai/agent_sdk/driver/output.rs

@@ -1289,7 +1289,7 @@ pub mod json {
 use crate::ai::agent::{AIAgentText, AIAgentTextSection};
 use crate::code::editor_management::CodeSource;
 use std::io::{self, BufWriter, Write};
-use warp_core::channel::ChannelState;
+use galaxy_core::channel::ChannelState;
 
 /// Constructs the Oz dashboard URL for a given run ID.
 fn run_url(run_id: &str) -> String {

app/src/ai/agent_sdk/driver/snapshot.rs

@@ -34,8 +34,8 @@ use anyhow::Result;
 use command::r#async::Command;
 use command::Stdio;
 use futures::future::join_all;
-use warp_core::report_error;
-use warpui::r#async::FutureExt as _;
+use galaxy_core::report_error;
+use galaxyui::r#async::FutureExt as _;
 
 use crate::ai::agent_sdk::retry::with_bounded_retry;
 use crate::ai::ambient_agents::AmbientAgentTaskId;

app/src/ai/agent_sdk/driver/terminal.rs

@@ -12,12 +12,12 @@ use std::{
 use futures::channel::oneshot;
 use session_sharing_protocol::common::{Role, SessionId};
 use session_sharing_protocol::sharer::SessionSourceType;
-use warp_cli::share::{ShareAccessLevel, ShareRequest, ShareSubject};
-use warp_completer::completer::CommandOutput;
-use warp_core::command::ExitCode;
-use warp_core::features::FeatureFlag;
-use warp_util::path::ShellFamily;
-use warpui::{
+use galaxy_cli::share::{ShareAccessLevel, ShareRequest, ShareSubject};
+use galaxy_completer::completer::CommandOutput;
+use galaxy_core::command::ExitCode;
+use galaxy_core::features::FeatureFlag;
+use galaxy_util::path::ShellFamily;
+use galaxyui::{
     r#async::FutureExt, AppContext, Entity, ModelContext, ModelHandle, SingletonEntity as _,
     ViewHandle,
 };
@@ -198,7 +198,7 @@ impl TerminalDriver {
         // When sharing is disabled (or running against ngrok), leave both halves
         // as None so that `wait_for_session_shared` returns immediately.
         let sharing_expected =
-            should_share && !warp_core::channel::ChannelState::server_root_url().contains("ngrok");
+            should_share && !galaxy_core::channel::ChannelState::server_root_url().contains("ngrok");
         let (mut session_share_tx, session_share_rx) = if sharing_expected {
             if !FeatureFlag::CreatingSharedSessions.is_enabled() {
                 // Session sharing was requested but the feature is not enabled for this
@@ -272,7 +272,7 @@ impl TerminalDriver {
     pub fn with_terminal_view(
         &self,
         ctx: &mut ModelContext<Self>,
-        f: impl FnOnce(&mut TerminalView, &mut warpui::ViewContext<TerminalView>),
+        f: impl FnOnce(&mut TerminalView, &mut galaxyui::ViewContext<TerminalView>),
     ) {
         self.terminal_view.update(ctx, f);
     }

app/src/ai/agent_sdk/driver_tests.rs

@@ -1,12 +1,12 @@
 use std::{ffi::OsString, sync::Arc, time::Duration};
 
 use futures::channel::oneshot;
-use warp_cli::agent::Harness;
-use warp_cli::{
+use galaxy_cli::agent::Harness;
+use galaxy_cli::{
     OZ_CLI_ENV, OZ_HARNESS_ENV, OZ_PARENT_RUN_ID_ENV, OZ_RUN_ID_ENV, SERVER_ROOT_URL_OVERRIDE_ENV,
     SESSION_SHARING_SERVER_URL_OVERRIDE_ENV, WS_SERVER_URL_OVERRIDE_ENV,
 };
-use warp_core::channel::ChannelState;
+use galaxy_core::channel::ChannelState;
 
 use super::{
     IdleTimeoutSender, LEGACY_OZ_PARENT_LISTENER_MANAGED_EXTERNALLY_ENV,

app/src/ai/agent_sdk/environment.rs

@@ -3,14 +3,14 @@ use std::collections::HashSet;
 use comfy_table::Cell;
 use inquire::{error::InquireError, Confirm, Select};
 use serde::Serialize;
-use warp_cli::{
+use galaxy_cli::{
     agent::OutputFormat,
     environment::{EnvironmentCommand, ImageCommand},
     scope::ObjectScope,
     GlobalOptions,
 };
-use warpui::r#async::FutureExt;
-use warpui::{AppContext, ModelContext, SingletonEntity};
+use galaxyui::r#async::FutureExt;
+use galaxyui::{AppContext, ModelContext, SingletonEntity};
 
 use crate::ai::agent_sdk::output::{self, TableFormat};
 
@@ -32,11 +32,11 @@ use crate::util::time_format::format_approx_duration_from_now_utc;
 use crate::workspaces::user_profiles::UserProfiles;
 use crate::CloudObjectTypeAndId;
 use cynic::QueryBuilder;
-use warp_graphql::queries::get_oauth_connect_tx_status::OauthConnectTxStatus;
-use warp_graphql::queries::list_warp_dev_images::{
+use galaxy_graphql::queries::get_oauth_connect_tx_status::OauthConnectTxStatus;
+use galaxy_graphql::queries::list_warp_dev_images::{
     ListWarpDevImages, ListWarpDevImagesResult, ListWarpDevImagesVariables,
 };
-use warp_graphql::queries::user_repo_auth_status::UserRepoAuthStatusEnum;
+use galaxy_graphql::queries::user_repo_auth_status::UserRepoAuthStatusEnum;
 
 const WARP_DEV_ENVIRONMENTS_REPO: &str = "https://github.com/warpdotdev/warp-dev-environments";
 
@@ -174,7 +174,7 @@ impl EnvironmentCommandRunner {
                         );
                     }
                     output::print_list(image_infos, global_options.output_format);
-                    ctx.terminate_app(warpui::platform::TerminationMode::ForceTerminate, None);
+                    ctx.terminate_app(galaxyui::platform::TerminationMode::ForceTerminate, None);
                 }
                 ListWarpDevImagesResult::UserFacingError(_) | ListWarpDevImagesResult::Unknown => {
                     super::report_fatal_error(anyhow::anyhow!("Failed to fetch images"), ctx);
@@ -253,7 +253,7 @@ impl EnvironmentCommandRunner {
 
             output::print_list(environment_infos, global_options.output_format);
 
-            ctx.terminate_app(warpui::platform::TerminationMode::ForceTerminate, None);
+            ctx.terminate_app(galaxyui::platform::TerminationMode::ForceTerminate, None);
         });
     }
 
@@ -276,7 +276,7 @@ impl EnvironmentCommandRunner {
                 Ok(sid) => sid,
                 Err(_) => {
                     ctx.terminate_app(
-                        warpui::platform::TerminationMode::ForceTerminate,
+                        galaxyui::platform::TerminationMode::ForceTerminate,
                         Some(Err(anyhow::anyhow!("Environment {} not found", id))),
                     );
                     return;
@@ -287,10 +287,10 @@ impl EnvironmentCommandRunner {
 
             if let Some(environment) = environment {
                 Self::print_environment_details(&environment.model().string_model);
-                ctx.terminate_app(warpui::platform::TerminationMode::ForceTerminate, None);
+                ctx.terminate_app(galaxyui::platform::TerminationMode::ForceTerminate, None);
             } else {
                 ctx.terminate_app(
-                    warpui::platform::TerminationMode::ForceTerminate,
+                    galaxyui::platform::TerminationMode::ForceTerminate,
                     Some(Err(anyhow::anyhow!("Environment {} not found", id))),
                 );
             }
@@ -330,7 +330,7 @@ impl EnvironmentCommandRunner {
         match err {
             InquireError::OperationCanceled | InquireError::OperationInterrupted => {
                 eprintln!("Environment creation canceled.");
-                ctx.terminate_app(warpui::platform::TerminationMode::ForceTerminate, None);
+                ctx.terminate_app(galaxyui::platform::TerminationMode::ForceTerminate, None);
                 true
             }
             _ => false,
@@ -426,7 +426,7 @@ impl EnvironmentCommandRunner {
         docker_image: Option<String>,
         github_repos: Vec<GithubRepo>,
         setup_commands: Vec<String>,
-        scope: warp_cli::scope::ObjectScope,
+        scope: galaxy_cli::scope::ObjectScope,
         ctx: &mut ModelContext<Self>,
     ) {
         if let Some(image) = docker_image {
@@ -464,7 +464,7 @@ impl EnvironmentCommandRunner {
         docker_image: String,
         github_repos: Vec<GithubRepo>,
         setup_commands: Vec<String>,
-        scope: warp_cli::scope::ObjectScope,
+        scope: galaxy_cli::scope::ObjectScope,
         ctx: &mut ModelContext<Self>,
     ) {
         let initial_sync = UpdateManager::as_ref(ctx)
@@ -521,7 +521,7 @@ impl EnvironmentCommandRunner {
 
         if attempt > MAX_AUTH_ATTEMPTS {
             ctx.terminate_app(
-                warpui::platform::TerminationMode::ForceTerminate,
+                galaxyui::platform::TerminationMode::ForceTerminate,
                 Some(Err(anyhow::anyhow!(
                     "Exceeded maximum number of authorization attempts ({}). Please try again later.",
                     MAX_AUTH_ATTEMPTS
@@ -582,7 +582,7 @@ impl EnvironmentCommandRunner {
                     if private_repo_owners.len() > 1 {
                         let owners_str = private_repo_owners.into_iter().collect::<Vec<_>>().join(", ");
                         ctx.terminate_app(
-                            warpui::platform::TerminationMode::ForceTerminate,
+                            galaxyui::platform::TerminationMode::ForceTerminate,
                             Some(Err(anyhow::anyhow!(
                                 "All private repositories in an environment must belong to the same owner. Found multiple owners: {}.\nIf you need support for private repos from multiple owners, please submit a GitHub issue.",
                                 owners_str
@@ -644,7 +644,7 @@ impl EnvironmentCommandRunner {
                                         }
                                         Ok(OauthConnectTxStatus::Failed) => {
                                             ctx.terminate_app(
-                                                warpui::platform::TerminationMode::ForceTerminate,
+                                                galaxyui::platform::TerminationMode::ForceTerminate,
                                                 Some(Err(anyhow::anyhow!(
                                                     "GitHub authorization failed. Please try again."
                                                 ))),
@@ -652,7 +652,7 @@ impl EnvironmentCommandRunner {
                                         }
                                         Ok(OauthConnectTxStatus::Expired) => {
                                             ctx.terminate_app(
-                                                warpui::platform::TerminationMode::ForceTerminate,
+                                                galaxyui::platform::TerminationMode::ForceTerminate,
                                                 Some(Err(anyhow::anyhow!(
                                                     "GitHub authorization expired. Please try again."
                                                 ))),
@@ -662,7 +662,7 @@ impl EnvironmentCommandRunner {
                                         | Ok(OauthConnectTxStatus::InProgress) => {
                                             // Should not be returned by poll_oauth_until_terminal.
                                             ctx.terminate_app(
-                                                warpui::platform::TerminationMode::ForceTerminate,
+                                                galaxyui::platform::TerminationMode::ForceTerminate,
                                                 Some(Err(anyhow::anyhow!(
                                                     "Unexpected non-terminal OAuth status returned"
                                                 ))),
@@ -670,7 +670,7 @@ impl EnvironmentCommandRunner {
                                         }
                                         Err(err) => {
                                             ctx.terminate_app(
-                                                warpui::platform::TerminationMode::ForceTerminate,
+                                                galaxyui::platform::TerminationMode::ForceTerminate,
                                                 Some(Err(anyhow::anyhow!(
                                                     "Error polling OAuth status: {err}"
                                                 ))),
@@ -685,14 +685,14 @@ impl EnvironmentCommandRunner {
                             println!("\nAuthorize access here: {auth_url}\n");
                             println!("After authorizing, please re-run this command.");
                             ctx.terminate_app(
-                                warpui::platform::TerminationMode::ForceTerminate,
+                                galaxyui::platform::TerminationMode::ForceTerminate,
                                 None,
                             );
                         }
                         (None, Some(_)) => {
                             // Server returned txId without authUrl - unexpected.
                             ctx.terminate_app(
-                                warpui::platform::TerminationMode::ForceTerminate,
+                                galaxyui::platform::TerminationMode::ForceTerminate,
                                 Some(Err(anyhow::anyhow!(
                                     "Server error: did not receive auth URL for OAuth flow"
                                 ))),
@@ -701,7 +701,7 @@ impl EnvironmentCommandRunner {
                         (None, None) => {
                             // No auth URL or txId provided, but we have auth issues.
                             ctx.terminate_app(
-                                warpui::platform::TerminationMode::ForceTerminate,
+                                galaxyui::platform::TerminationMode::ForceTerminate,
                                 Some(Err(anyhow::anyhow!(
                                     "Cannot {} environment: authorization required but no auth flow provided by server",
                                     operation_name
@@ -712,7 +712,7 @@ impl EnvironmentCommandRunner {
                 }
                 Err(e) => {
                     ctx.terminate_app(
-                        warpui::platform::TerminationMode::ForceTerminate,
+                        galaxyui::platform::TerminationMode::ForceTerminate,
                         Some(Err(e.context("Failed to check GitHub auth status"))),
                     );
                 }
@@ -764,7 +764,7 @@ impl EnvironmentCommandRunner {
                 {
                     let server_id = result.server_id.unwrap();
                     println!("Environment created successfully with ID: {server_id}");
-                    ctx.terminate_app(warpui::platform::TerminationMode::ForceTerminate, None);
+                    ctx.terminate_app(galaxyui::platform::TerminationMode::ForceTerminate, None);
                 }
             }
         });
@@ -807,13 +807,13 @@ impl EnvironmentCommandRunner {
                             Ok(false) | Err(InquireError::OperationCanceled | InquireError::OperationInterrupted) => {
                                 println!("Environment {action} canceled.");
                                 ctx.terminate_app(
-                                    warpui::platform::TerminationMode::ForceTerminate,
+                                    galaxyui::platform::TerminationMode::ForceTerminate,
                                     None,
                                 );
                             }
                             Err(err) => {
                                 ctx.terminate_app(
-                                    warpui::platform::TerminationMode::ForceTerminate,
+                                    galaxyui::platform::TerminationMode::ForceTerminate,
                                     Some(Err(anyhow::anyhow!("Error prompting for confirmation: {err}"))),
                                 );
                             }
@@ -824,7 +824,7 @@ impl EnvironmentCommandRunner {
                 }
                 Err(_) => {
                     ctx.terminate_app(
-                        warpui::platform::TerminationMode::ForceTerminate,
+                        galaxyui::platform::TerminationMode::ForceTerminate,
                         Some(Err(anyhow::anyhow!(
                             "Aborting environment {action} because integration usage could not be determined. Re-run with --force to override."
                         ))),
@@ -868,7 +868,7 @@ impl EnvironmentCommandRunner {
                 Err(_) => {
                     let error = anyhow::anyhow!("Environment {} not found", id);
                     ctx.terminate_app(
-                        warpui::platform::TerminationMode::ForceTerminate,
+                        galaxyui::platform::TerminationMode::ForceTerminate,
                         Some(Err(error)),
                     );
                     return;
@@ -879,7 +879,7 @@ impl EnvironmentCommandRunner {
             let Some(environment) = environment else {
                 let error = anyhow::anyhow!("Environment {} not found", id);
                 ctx.terminate_app(
-                    warpui::platform::TerminationMode::ForceTerminate,
+                    galaxyui::platform::TerminationMode::ForceTerminate,
                     Some(Err(error)),
                 );
                 return;
@@ -1011,7 +1011,7 @@ impl EnvironmentCommandRunner {
                             println!("Environment updated successfully!\n");
                             Self::print_environment_details(&updated_env);
                             ctx.terminate_app(
-                                warpui::platform::TerminationMode::ForceTerminate,
+                                galaxyui::platform::TerminationMode::ForceTerminate,
                                 None,
                             );
                         }
@@ -1047,7 +1047,7 @@ impl EnvironmentCommandRunner {
                 Err(_) => {
                     let error = anyhow::anyhow!("Environment {} not found", id);
                     ctx.terminate_app(
-                        warpui::platform::TerminationMode::ForceTerminate,
+                        galaxyui::platform::TerminationMode::ForceTerminate,
                         Some(Err(error)),
                     );
                     return;
@@ -1058,7 +1058,7 @@ impl EnvironmentCommandRunner {
             let Some(environment) = environment else {
                 let error = anyhow::anyhow!("Environment {} not found", id);
                 ctx.terminate_app(
-                    warpui::platform::TerminationMode::ForceTerminate,
+                    galaxyui::platform::TerminationMode::ForceTerminate,
                     Some(Err(error)),
                 );
                 return;
@@ -1094,7 +1094,7 @@ impl EnvironmentCommandRunner {
                         OperationSuccessType::Success => {
                             println!("Environment deleted successfully");
                             ctx.terminate_app(
-                                warpui::platform::TerminationMode::ForceTerminate,
+                                galaxyui::platform::TerminationMode::ForceTerminate,
                                 None,
                             );
                         }
@@ -1111,7 +1111,7 @@ impl EnvironmentCommandRunner {
     }
 }
 
-impl warpui::Entity for EnvironmentCommandRunner {
+impl galaxyui::Entity for EnvironmentCommandRunner {
     type Event = ();
 }
 impl SingletonEntity for EnvironmentCommandRunner {}

app/src/ai/agent_sdk/federate.rs

@@ -2,11 +2,11 @@ use std::process;
 
 use anyhow::{anyhow, Result};
 use serde_json::json;
-use warp_cli::federate::{FederateCommand, IssueGcpTokenArgs, IssueTokenArgs};
-use warp_cli::{agent::OutputFormat, GlobalOptions};
-use warp_core::{features::FeatureFlag, report_error};
-use warp_managed_secrets::ManagedSecretManager;
-use warpui::{platform::TerminationMode, AppContext, SingletonEntity as _};
+use galaxy_cli::federate::{FederateCommand, IssueGcpTokenArgs, IssueTokenArgs};
+use galaxy_cli::{agent::OutputFormat, GlobalOptions};
+use galaxy_core::{features::FeatureFlag, report_error};
+use galaxy_managed_secrets::ManagedSecretManager;
+use galaxyui::{platform::TerminationMode, AppContext, SingletonEntity as _};
 
 use super::common::set_ambient_task_context_from_run_id;
 
@@ -43,7 +43,7 @@ fn issue_token(
 
     ManagedSecretManager::handle(ctx).update(ctx, move |manager, ctx| {
         let future =
-            manager.issue_task_identity_token(warp_managed_secrets::client::IdentityTokenOptions {
+            manager.issue_task_identity_token(galaxy_managed_secrets::client::IdentityTokenOptions {
                 audience,
                 requested_duration: duration,
                 subject_template,

app/src/ai/agent_sdk/harness_support.rs

@@ -4,14 +4,14 @@
 //! - [`ping`] — fetches the current run by task ID and prints its info.
 //! - [`report_artifact`] — reports an artifact (e.g. a PR) back to the Oz platform.
 use anyhow::Result;
-use warp_cli::agent::OutputFormat;
-use warp_cli::harness_support::{
+use galaxy_cli::agent::OutputFormat;
+use galaxy_cli::harness_support::{
     FinishTaskArgs, HarnessSupportArgs, HarnessSupportCommand, NotifyUserArgs, ReportArtifactArgs,
     ReportArtifactCommand, TaskStatus,
 };
-use warp_cli::GlobalOptions;
-use warp_core::features::FeatureFlag;
-use warpui::{platform::TerminationMode, AppContext, ModelHandle, SingletonEntity};
+use galaxy_cli::GlobalOptions;
+use galaxy_core::features::FeatureFlag;
+use galaxyui::{platform::TerminationMode, AppContext, ModelHandle, SingletonEntity};
 
 use super::common::set_ambient_task_context_from_run_id;
 use crate::ai::ambient_agents::AmbientAgentTaskId;
@@ -206,7 +206,7 @@ fn finish_task(
 /// Singleton model for running async harness-support operations.
 struct HarnessSupportRunner;
 
-impl warpui::Entity for HarnessSupportRunner {
+impl galaxyui::Entity for HarnessSupportRunner {
     type Event = ();
 }
 

app/src/ai/agent_sdk/integration.rs

@@ -1,14 +1,14 @@
 use crate::server::server_api::ServerApiProvider;
 use futures::future;
-use warp_cli::{
+use galaxy_cli::{
     integration::{CreateIntegrationArgs, IntegrationCommand, UpdateIntegrationArgs},
     provider::ProviderType,
     GlobalOptions,
 };
-use warp_graphql::mutations::create_simple_integration::CreateSimpleIntegrationOutput;
-use warp_graphql::queries::get_oauth_connect_tx_status::OauthConnectTxStatus;
-use warp_graphql::queries::get_simple_integrations::SimpleIntegrationsOutput;
-use warpui::{platform::TerminationMode, AppContext, ModelContext, SingletonEntity};
+use galaxy_graphql::mutations::create_simple_integration::CreateSimpleIntegrationOutput;
+use galaxy_graphql::queries::get_oauth_connect_tx_status::OauthConnectTxStatus;
+use galaxy_graphql::queries::get_simple_integrations::SimpleIntegrationsOutput;
+use galaxyui::{platform::TerminationMode, AppContext, ModelContext, SingletonEntity};
 
 use super::common::{EnvironmentChoice, ResolveConfigurationError};
 use super::integration_output;
@@ -518,7 +518,7 @@ impl IntegrationCommandRunner {
     }
 }
 
-impl warpui::Entity for IntegrationCommandRunner {
+impl galaxyui::Entity for IntegrationCommandRunner {
     type Event = ();
 }
 impl SingletonEntity for IntegrationCommandRunner {}

app/src/ai/agent_sdk/integration_output.rs

@@ -2,11 +2,11 @@ use chrono::{DateTime, Utc};
 use comfy_table::{presets::UTF8_FULL, Cell, Table};
 use serde::Serialize;
 use serde_json::{Map, Value};
-use warp_cli::agent::OutputFormat;
+use galaxy_cli::agent::OutputFormat;
 
 use crate::ai::agent_sdk::output::{self, TableFormat};
 use crate::util::time_format::format_approx_duration_from_now_utc;
-use warp_graphql::queries::get_simple_integrations::{
+use galaxy_graphql::queries::get_simple_integrations::{
     ListedSimpleIntegrationConfig, SimpleIntegration, SimpleIntegrationConnectionStatus,
     SimpleIntegrationsOutput,
 };

app/src/ai/agent_sdk/mcp.rs

@@ -1,7 +1,7 @@
 use comfy_table::Cell;
 use serde::Serialize;
-use warp_cli::{mcp::MCPCommand, GlobalOptions};
-use warpui::{AppContext, ModelContext, SingletonEntity};
+use galaxy_cli::{mcp::MCPCommand, GlobalOptions};
+use galaxyui::{AppContext, ModelContext, SingletonEntity};
 
 use crate::ai::agent_sdk::output::{self, TableFormat};
 use crate::ai::mcp::TemplatableMCPServerManager;
@@ -40,12 +40,12 @@ impl MCPCommandRunner {
                 global_options.output_format,
             );
 
-            ctx.terminate_app(warpui::platform::TerminationMode::ForceTerminate, None);
+            ctx.terminate_app(galaxyui::platform::TerminationMode::ForceTerminate, None);
         });
     }
 }
 
-impl warpui::Entity for MCPCommandRunner {
+impl galaxyui::Entity for MCPCommandRunner {
     type Event = ();
 }
 impl SingletonEntity for MCPCommandRunner {}

app/src/ai/agent_sdk/mcp_config.rs

@@ -1,6 +1,6 @@
 use anyhow::Context as _;
 use serde_json::{Map, Value};
-use warp_cli::mcp::MCPSpec;
+use galaxy_cli::mcp::MCPSpec;
 
 use crate::ai::mcp::TemplatableMCPServer;
 

app/src/ai/agent_sdk/mcp_config_tests.rs

@@ -1,5 +1,5 @@
 use serde_json::{json, Map, Value};
-use warp_cli::mcp::MCPSpec;
+use galaxy_cli::mcp::MCPSpec;
 
 use super::build_mcp_servers_from_specs;
 

app/src/ai/agent_sdk/mod.rs

@@ -24,7 +24,7 @@ use crate::server::server_api::ai::AIClient;
 use crate::workflows::workflow::Workflow;
 use ai::api_keys::{ApiKeyManager, AwsCredentialsRefreshStrategy};
 use anyhow::Context;
-use warp_cli::{
+use galaxy_cli::{
     agent::{AgentCommand, AgentProfileCommand, OutputFormat},
     artifact::ArtifactCommand,
     environment::{EnvironmentCommand, ImageCommand},
@@ -40,13 +40,13 @@ use warp_cli::{
     task::{MessageCommand, TaskCommand},
     CliCommand, GlobalOptions,
 };
-use warp_core::features::FeatureFlag;
-use warp_isolation_platform::IsolationPlatformError;
+use galaxy_core::features::FeatureFlag;
+use galaxy_isolation_platform::IsolationPlatformError;
 #[cfg(not(target_family = "wasm"))]
-use warp_logging::log_file_path;
-use warp_managed_secrets::ManagedSecretManager;
-use warpui::ModelSpawner;
-use warpui::{platform::TerminationMode, AppContext, SingletonEntity};
+use galaxy_logging::log_file_path;
+use galaxy_managed_secrets::ManagedSecretManager;
+use galaxyui::ModelSpawner;
+use galaxyui::{platform::TerminationMode, AppContext, SingletonEntity};
 
 use crate::{
     ai::ambient_agents::{task::HarnessConfig, AmbientAgentTaskId},
@@ -60,7 +60,7 @@ use crate::{
     terminal::view::ConversationRestorationInNewPaneType,
 };
 use driver::AgentDriverError;
-use warp_graphql::object_permissions::OwnerType;
+use galaxy_graphql::object_permissions::OwnerType;
 
 use crate::ai::attachment_utils::attachments_download_dir;
 use crate::ai::skills::{
@@ -72,8 +72,8 @@ pub(crate) use driver::harness::{
 };
 pub use driver::AgentDriver;
 use telemetry::CliTelemetryEvent;
-use warp_cli::agent::{Harness, Prompt, RunAgentArgs};
-use warp_cli::OZ_HARNESS_ENV;
+use galaxy_cli::agent::{Harness, Prompt, RunAgentArgs};
+use galaxy_cli::OZ_HARNESS_ENV;
 
 mod admin;
 mod agent_config;
@@ -510,7 +510,7 @@ fn run_task(
                 ));
             }
             match conv_cmd {
-                warp_cli::task::ConversationCommand::Get(args) => {
+                galaxy_cli::task::ConversationCommand::Get(args) => {
                     ambient::get_conversation(ctx, args.conversation_id)
                 }
             }
@@ -531,11 +531,11 @@ fn run_task(
 /// requires spawning an async task, which requires a ModelContext.
 struct AgentDriverRunner;
 
-impl warpui::Entity for AgentDriverRunner {
+impl galaxyui::Entity for AgentDriverRunner {
     type Event = ();
 }
 
-impl warpui::SingletonEntity for AgentDriverRunner {}
+impl galaxyui::SingletonEntity for AgentDriverRunner {}
 
 impl AgentDriverRunner {
     async fn setup_and_run_driver(
@@ -1301,7 +1301,7 @@ fn launch_command(
         return dispatch_command(ctx, command, global_options);
     }
 
-    let cli_name = warp_cli::binary_name().unwrap_or_else(|| "warp".to_string());
+    let cli_name = galaxy_cli::binary_name().unwrap_or_else(|| "warp".to_string());
 
     let auth_state = AuthStateProvider::handle(ctx).as_ref(ctx).get();
     if !auth_state.is_logged_in() {

app/src/ai/agent_sdk/mod_tests.rs

@@ -1,10 +1,10 @@
 use serde_json::json;
-use warp_cli::{
+use galaxy_cli::{
     artifact::{ArtifactCommand, DownloadArtifactArgs, GetArtifactArgs, UploadArtifactArgs},
     task::{MessageCommand, MessageSendArgs, MessageWatchArgs, TaskCommand},
     CliCommand,
 };
-use warp_core::telemetry::TelemetryEvent;
+use galaxy_core::telemetry::TelemetryEvent;
 
 use super::{command_requires_auth, command_to_telemetry_event};
 

app/src/ai/agent_sdk/model.rs

@@ -4,8 +4,8 @@ use crate::ai::agent_sdk::output::{self, TableFormat};
 use crate::ai::llms::LLMPreferences;
 use comfy_table::Cell;
 use serde::Serialize;
-use warp_cli::{model::ModelCommand, GlobalOptions};
-use warpui::{platform::TerminationMode, AppContext, ModelContext, SingletonEntity};
+use galaxy_cli::{model::ModelCommand, GlobalOptions};
+use galaxyui::{platform::TerminationMode, AppContext, ModelContext, SingletonEntity};
 
 /// Handle model-related CLI commands.
 pub fn run(
@@ -59,7 +59,7 @@ impl ModelCommandRunner {
     }
 }
 
-impl warpui::Entity for ModelCommandRunner {
+impl galaxyui::Entity for ModelCommandRunner {
     type Event = ();
 }
 

app/src/ai/agent_sdk/oauth_flow.rs

@@ -2,10 +2,10 @@ use std::sync::Arc;
 use std::time::Duration;
 
 use anyhow::{anyhow, Result};
-use warpui::r#async::Timer;
+use galaxyui::r#async::Timer;
 
 use crate::server::server_api::integrations::IntegrationsClient;
-use warp_graphql::queries::get_oauth_connect_tx_status::OauthConnectTxStatus;
+use galaxy_graphql::queries::get_oauth_connect_tx_status::OauthConnectTxStatus;
 
 /// Shared helpers for OAuth-based connect flows (txId + polling).
 ///

app/src/ai/agent_sdk/output.rs

@@ -11,8 +11,8 @@ use jaq_all::fmts::Format;
 use jaq_json::{write as jaq_write, Val};
 use serde::Serialize;
 use tabwriter::TabWriter;
-use warp_cli::agent::OutputFormat;
-use warp_cli::json_filter::{JqFilter, JsonOutput};
+use galaxy_cli::agent::OutputFormat;
+use galaxy_cli::json_filter::{JqFilter, JsonOutput};
 
 pub fn standard_table() -> Table {
     let mut table = Table::new();

app/src/ai/agent_sdk/output_tests.rs

@@ -4,8 +4,8 @@ use super::{
 use comfy_table::Cell;
 use serde::Serialize;
 use serde_json::json;
-use warp_cli::agent::OutputFormat;
-use warp_cli::json_filter::parse_jq_filter;
+use galaxy_cli::agent::OutputFormat;
+use galaxy_cli::json_filter::parse_jq_filter;
 
 #[derive(Serialize)]
 struct TestItem {

app/src/ai/agent_sdk/profiles.rs

@@ -1,7 +1,7 @@
 use comfy_table::Cell;
 use serde::Serialize;
-use warp_cli::{agent::AgentProfileCommand, GlobalOptions};
-use warpui::{AppContext, ModelContext, SingletonEntity};
+use galaxy_cli::{agent::AgentProfileCommand, GlobalOptions};
+use galaxyui::{AppContext, ModelContext, SingletonEntity};
 
 use crate::ai::agent_sdk::output::{self, TableFormat};
 use crate::ai::execution_profiles::profiles::AIExecutionProfilesModel;
@@ -52,12 +52,12 @@ impl ProfilesCommandRunner {
 
             output::print_list(profiles, global_options.output_format);
 
-            ctx.terminate_app(warpui::platform::TerminationMode::ForceTerminate, None);
+            ctx.terminate_app(galaxyui::platform::TerminationMode::ForceTerminate, None);
         });
     }
 }
 
-impl warpui::Entity for ProfilesCommandRunner {
+impl galaxyui::Entity for ProfilesCommandRunner {
     type Event = ();
 }
 impl SingletonEntity for ProfilesCommandRunner {}

app/src/ai/agent_sdk/provider.rs

@@ -2,12 +2,12 @@
 use crate::workspaces::user_workspaces::UserWorkspaces;
 use comfy_table::Cell;
 use serde::Serialize;
-use warp_cli::{
+use galaxy_cli::{
     provider::{ProviderCommand, ProviderType},
     GlobalOptions,
 };
-use warp_core::channel::ChannelState;
-use warpui::{platform::TerminationMode, AppContext, ModelContext, SingletonEntity};
+use galaxy_core::channel::ChannelState;
+use galaxyui::{platform::TerminationMode, AppContext, ModelContext, SingletonEntity};
 
 use crate::ai::agent_sdk::output::{self, TableFormat};
 
@@ -123,7 +123,7 @@ impl ProviderCommandRunner {
     }
 }
 
-impl warpui::Entity for ProviderCommandRunner {
+impl galaxyui::Entity for ProviderCommandRunner {
     type Event = ();
 }
 impl SingletonEntity for ProviderCommandRunner {}

app/src/ai/agent_sdk/retry.rs

@@ -9,8 +9,8 @@ use std::future::Future;
 use std::time::Duration;
 
 use anyhow::{anyhow, Result};
-use warpui::duration_with_jitter;
-use warpui::r#async::Timer;
+use galaxyui::duration_with_jitter;
+use galaxyui::r#async::Timer;
 
 pub(crate) use crate::server::retry_strategies::is_transient_http_error;
 

app/src/ai/agent_sdk/schedule.rs

@@ -2,14 +2,14 @@ use chrono::{DateTime, Utc};
 use comfy_table::Cell;
 use futures::future;
 use serde::Serialize;
-use warp_cli::schedule::{
+use galaxy_cli::schedule::{
     CreateScheduleArgs, DeleteScheduleArgs, GetScheduleArgs, PauseScheduleArgs, ScheduleCommand,
     ScheduleSubcommand, UnpauseScheduleArgs, UpdateScheduleArgs,
 };
-use warp_cli::{agent::OutputFormat, GlobalOptions};
-use warp_graphql::queries::get_scheduled_agent_history::ScheduledAgentHistory;
-use warpui::platform::TerminationMode;
-use warpui::{AppContext, SingletonEntity};
+use galaxy_cli::{agent::OutputFormat, GlobalOptions};
+use galaxy_graphql::queries::get_scheduled_agent_history::ScheduledAgentHistory;
+use galaxyui::platform::TerminationMode;
+use galaxyui::{AppContext, SingletonEntity};
 
 use crate::ai::ambient_agents::scheduled::{
     CloudScheduledAmbientAgent, ScheduledAgentManager, ScheduledAmbientAgent, UpdateScheduleParams,

app/src/ai/agent_sdk/secret.rs

@@ -8,7 +8,7 @@ use chrono::{DateTime, Utc};
 use comfy_table::Cell;
 use inquire::{Confirm, InquireError, Password};
 use serde::Serialize;
-use warp_cli::{
+use galaxy_cli::{
     agent::OutputFormat,
     scope::ObjectScope,
     secret::{
@@ -17,13 +17,13 @@ use warp_cli::{
     },
     GlobalOptions,
 };
-use warp_core::features::FeatureFlag;
-use warp_graphql::{
+use galaxy_core::features::FeatureFlag;
+use galaxy_graphql::{
     managed_secrets::{ManagedSecret, ManagedSecretType},
     object::SpaceType,
 };
-use warp_managed_secrets::{client::SecretOwner, ManagedSecretManager, ManagedSecretValue};
-use warpui::{platform::TerminationMode, AppContext, SingletonEntity as _};
+use galaxy_managed_secrets::{client::SecretOwner, ManagedSecretManager, ManagedSecretValue};
+use galaxyui::{platform::TerminationMode, AppContext, SingletonEntity as _};
 
 use crate::{
     auth::UserUid, cloud_object::Owner, server::ids::ServerId,

app/src/ai/agent_sdk/telemetry.rs

@@ -1,7 +1,7 @@
 use crate::features::FeatureFlag;
 use serde_json::{json, Value};
 use strum_macros::{EnumDiscriminants, EnumIter};
-use warp_core::telemetry::{EnablementState, TelemetryEvent, TelemetryEventDesc};
+use galaxy_core::telemetry::{EnablementState, TelemetryEvent, TelemetryEventDesc};
 
 #[derive(Debug, EnumDiscriminants)]
 #[strum_discriminants(derive(EnumIter))]
@@ -204,7 +204,7 @@ impl TelemetryEvent for CliTelemetryEvent {
     }
 
     fn event_descs() -> impl Iterator<Item = Box<dyn TelemetryEventDesc>> {
-        warp_core::telemetry::enum_events::<Self>()
+        galaxy_core::telemetry::enum_events::<Self>()
     }
 }
 
@@ -421,4 +421,4 @@ impl TelemetryEventDesc for CliTelemetryEventDiscriminants {
     }
 }
 
-warp_core::register_telemetry_event!(CliTelemetryEvent);
+galaxy_core::register_telemetry_event!(CliTelemetryEvent);

app/src/ai/agent_tips.rs

@@ -18,9 +18,9 @@ use markdown_parser::FormattedTextFragment;
 use std::path::Path;
 use std::sync::LazyLock;
 use std::time::Duration;
-use warpui::keymap::Keystroke;
-use warpui::r#async::SpawnedFutureHandle;
-use warpui::{AppContext, Entity, ModelContext, SingletonEntity};
+use galaxyui::keymap::Keystroke;
+use galaxyui::r#async::SpawnedFutureHandle;
+use galaxyui::{AppContext, Entity, ModelContext, SingletonEntity};
 
 /// Trait for tip implementations that can be displayed to users.
 /// Tips provide helpful information with optional links and keybindings.
@@ -526,7 +526,7 @@ impl AITipModel<AgentTip> {
         // Start 60-second cooldown
         let handle = ctx.spawn(
             async {
-                warpui::r#async::Timer::after(Duration::from_secs(60)).await;
+                galaxyui::r#async::Timer::after(Duration::from_secs(60)).await;
             },
             |me, _, _| {
                 me.cooldown_handle = None;
@@ -558,7 +558,7 @@ impl AITipModel<crate::terminal::view::ambient_agent::CloudModeTip> {
         // Start 60-second cooldown
         let handle = ctx.spawn(
             async {
-                warpui::r#async::Timer::after(Duration::from_secs(60)).await;
+                galaxyui::r#async::Timer::after(Duration::from_secs(60)).await;
             },
             |me, _, _| {
                 me.cooldown_handle = None;
@@ -579,7 +579,7 @@ impl AITipModel<crate::terminal::view::ambient_agent::CloudModeTip> {
         // Start a new 60-second cooldown
         let handle = ctx.spawn(
             async {
-                warpui::r#async::Timer::after(Duration::from_secs(60)).await;
+                galaxyui::r#async::Timer::after(Duration::from_secs(60)).await;
             },
             |me, _, _| {
                 me.cooldown_handle = None;

app/src/ai/ai_document_view.rs

@@ -48,20 +48,20 @@ use crate::{
     view_components::action_button::{ActionButton, PrimaryTheme},
 };
 use pathfinder_geometry::vector::vec2f;
-use warp_core::ui::icons;
-use warp_core::ui::icons::ICON_DIMENSIONS;
-use warp_core::ui::theme::Fill as ThemeFill;
-use warpui::clipboard::ClipboardContent;
-use warpui::elements::CrossAxisAlignment;
-use warpui::elements::MainAxisAlignment;
-use warpui::elements::MainAxisSize;
-use warpui::elements::{ChildAnchor, PositionedElementAnchor, PositionedElementOffsetBounds};
-use warpui::keymap::EditableBinding;
-use warpui::keymap::FixedBinding;
-use warpui::text_layout::ClipConfig;
-use warpui::ui_components::button::ButtonTooltipPosition;
-use warpui::ui_components::components::UiComponent;
-use warpui::{
+use galaxy_core::ui::icons;
+use galaxy_core::ui::icons::ICON_DIMENSIONS;
+use galaxy_core::ui::theme::Fill as ThemeFill;
+use galaxyui::clipboard::ClipboardContent;
+use galaxyui::elements::CrossAxisAlignment;
+use galaxyui::elements::MainAxisAlignment;
+use galaxyui::elements::MainAxisSize;
+use galaxyui::elements::{ChildAnchor, PositionedElementAnchor, PositionedElementOffsetBounds};
+use galaxyui::keymap::EditableBinding;
+use galaxyui::keymap::FixedBinding;
+use galaxyui::text_layout::ClipConfig;
+use galaxyui::ui_components::button::ButtonTooltipPosition;
+use galaxyui::ui_components::components::UiComponent;
+use galaxyui::{
     elements::{
         ChildView, ConstrainedBox, Container, Flex, Hoverable, MouseStateHandle, OffsetPositioning,
         ParentElement, SavePosition, Stack,
@@ -69,7 +69,7 @@ use warpui::{
     AppContext, Element, Entity, ModelHandle, SingletonEntity, TypedActionView, View, ViewContext,
     ViewHandle,
 };
-use warpui::{id, EntityId};
+use galaxyui::{id, EntityId};
 
 pub fn init(app: &mut AppContext) {
     app.register_editable_bindings([EditableBinding::new(
@@ -97,7 +97,7 @@ use crate::util::file::external_editor::settings::EditorLayout;
 #[cfg(feature = "local_fs")]
 use crate::util::openable_file_type::FileTarget;
 #[cfg(feature = "local_fs")]
-use warp_util::path::LineAndColumnArg;
+use galaxy_util::path::LineAndColumnArg;
 
 // Import keybinding constants from code view to ensure consistency
 use crate::code::view::{SAVE_FILE_BINDING_DESCRIPTION, SAVE_FILE_BINDING_NAME};
@@ -641,7 +641,7 @@ impl AIDocumentView {
                         Container::new(
                             ConstrainedBox::new(
                                 Icon::RefreshCw04
-                                    .to_warpui_icon(ThemeFill::Solid(color))
+                                    .to_galaxyui_icon(ThemeFill::Solid(color))
                                     .finish(),
                             )
                             .with_width(16.)
@@ -672,7 +672,7 @@ impl AIDocumentView {
                             Hoverable::new(synced_status_mouse_state, move |state| {
                                 let icon = {
                                     let icon_elem = Icon::RefreshCw04
-                                        .to_warpui_icon(ThemeFill::Solid(color))
+                                        .to_galaxyui_icon(ThemeFill::Solid(color))
                                         .finish();
                                     ConstrainedBox::new(icon_elem)
                                         .with_width(16.)
@@ -688,8 +688,8 @@ impl AIDocumentView {
                                         tooltip,
                                         OffsetPositioning::offset_from_parent(
                                             vec2f(0., 4.),
-                                            warpui::elements::ParentOffsetBounds::WindowByPosition,
-                                            warpui::elements::ParentAnchor::BottomRight,
+                                            galaxyui::elements::ParentOffsetBounds::WindowByPosition,
+                                            galaxyui::elements::ParentAnchor::BottomRight,
                                             ChildAnchor::TopRight,
                                         ),
                                     );
@@ -938,7 +938,7 @@ impl AIDocumentView {
     }
 
     /// Bind the underlying editor model to the given window, enabling render/event processing.
-    pub fn bind_window(&self, window_id: warpui::WindowId, ctx: &mut ViewContext<Self>) {
+    pub fn bind_window(&self, window_id: galaxyui::WindowId, ctx: &mut ViewContext<Self>) {
         self.editor.update(ctx, |editor_view, ctx| {
             editor_view
                 .model()
@@ -959,7 +959,7 @@ impl AIDocumentView {
     #[cfg(feature = "local_fs")]
     fn export(&self, ctx: &mut ViewContext<Self>) {
         use crate::drive::export::safe_filename;
-        use warpui::platform::SaveFilePickerConfiguration;
+        use galaxyui::platform::SaveFilePickerConfiguration;
         let markdown = self.editor.as_ref(ctx).markdown_unescaped(ctx);
 
         // Get the document title from the model
@@ -1015,7 +1015,7 @@ impl View for AIDocumentView {
         "AIDocumentView"
     }
 
-    fn render(&self, _app: &AppContext) -> Box<dyn warpui::Element> {
+    fn render(&self, _app: &AppContext) -> Box<dyn galaxyui::Element> {
         let editor = Container::new(ChildView::new(&self.editor).finish())
             .with_padding_left(8.)
             .with_padding_right(8.)

app/src/ai/ambient_agents/github_auth_notifier.rs

@@ -4,7 +4,7 @@
 //! any component in the app (e.g., `UpdateEnvironmentForm`) to react to
 //! auth state changes without relying on window activation timing.
 
-use warpui::{Entity, ModelContext, SingletonEntity};
+use galaxyui::{Entity, ModelContext, SingletonEntity};
 
 /// Events emitted by the GitHub auth notifier.
 #[derive(Debug, Clone)]

app/src/ai/ambient_agents/scheduled.rs

@@ -27,8 +27,8 @@ use crate::{
 };
 use futures::channel::oneshot;
 use futures::FutureExt;
-use warp_graphql::queries::get_scheduled_agent_history::ScheduledAgentHistory;
-use warpui::{AppContext, Entity, ModelContext, SingletonEntity};
+use galaxy_graphql::queries::get_scheduled_agent_history::ScheduledAgentHistory;
+use galaxyui::{AppContext, Entity, ModelContext, SingletonEntity};
 
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
 /// A ScheduledAmbientAgent represents configuration for ambient agents that run on a cron schedule.
@@ -213,7 +213,7 @@ impl ScheduledAgentManager {
         &self,
         schedule_id: SyncId,
         app: &AppContext,
-    ) -> impl warpui::r#async::Spawnable<Output = anyhow::Result<Option<ScheduledAgentHistory>>>
+    ) -> impl galaxyui::r#async::Spawnable<Output = anyhow::Result<Option<ScheduledAgentHistory>>>
     {
         let ai_client = ServerApiProvider::as_ref(app).get_ai_client();
 

app/src/ai/ambient_agents/spawn.rs

@@ -117,12 +117,12 @@ pub fn spawn_task(
         // We use a timeout to ensure we don't wait indefinitely for session info.
         // If no timeout is provided, we use a future that never completes.
         let mut timeout_timer = match timeout {
-            Some(d) => warpui::r#async::Timer::after(d),
-            None => warpui::r#async::Timer::never(),
+            Some(d) => galaxyui::r#async::Timer::after(d),
+            None => galaxyui::r#async::Timer::never(),
         }.fuse();
         let mut last_state = None;
         loop {
-            let mut poll_timer = warpui::r#async::Timer::after(TASK_STATUS_POLL_INTERVAL).fuse();
+            let mut poll_timer = galaxyui::r#async::Timer::after(TASK_STATUS_POLL_INTERVAL).fuse();
 
             select! {
                 _ = timeout_timer => {

app/src/ai/ambient_agents/task.rs

@@ -3,17 +3,17 @@
 use anyhow::anyhow;
 use chrono::{DateTime, Utc};
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
-use warp_cli::agent::Harness;
-use warp_core::report_error;
-use warp_core::ui::theme::WarpTheme;
-use warpui::color::ColorU;
+use galaxy_cli::agent::Harness;
+use galaxy_core::report_error;
+use galaxy_core::ui::theme::WarpTheme;
+use galaxyui::color::ColorU;
 
 use crate::ai::artifacts::{deserialize_artifacts, Artifact};
 use crate::server::server_api::ServerApiProvider;
 use crate::ui_components::icons::Icon;
 use crate::view_components::DismissibleToast;
 use crate::workspace::ToastStack;
-use warpui::{SingletonEntity, View, ViewContext};
+use galaxyui::{SingletonEntity, View, ViewContext};
 
 use super::AmbientAgentTaskId;
 

app/src/ai/ambient_agents/telemetry.rs

@@ -2,8 +2,8 @@ use crate::server::ids::ServerId;
 use serde::Serialize;
 use serde_json::{json, Value};
 use strum_macros::{EnumDiscriminants, EnumIter};
-use warp_core::features::FeatureFlag;
-use warp_core::telemetry::{EnablementState, TelemetryEvent, TelemetryEventDesc};
+use galaxy_core::features::FeatureFlag;
+use galaxy_core::telemetry::{EnablementState, TelemetryEvent, TelemetryEventDesc};
 
 /// The entry point through which Cloud Mode was entered.
 #[derive(Clone, Copy, Debug, Serialize)]
@@ -124,7 +124,7 @@ impl TelemetryEvent for CloudAgentTelemetryEvent {
     }
 
     fn event_descs() -> impl Iterator<Item = Box<dyn TelemetryEventDesc>> {
-        warp_core::telemetry::enum_events::<Self>()
+        galaxy_core::telemetry::enum_events::<Self>()
     }
 }
 
@@ -178,4 +178,4 @@ impl TelemetryEventDesc for CloudAgentTelemetryEventDiscriminants {
     }
 }
 
-warp_core::register_telemetry_event!(CloudAgentTelemetryEvent);
+galaxy_core::register_telemetry_event!(CloudAgentTelemetryEvent);

app/src/ai/artifacts/buttons.rs

@@ -1,9 +1,9 @@
 use std::sync::Arc;
 
-use warp_core::ui::icons::Icon;
-use warp_core::ui::theme::AnsiColorIdentifier;
-use warpui::elements::{ChildView, Element, Empty, ParentElement, Wrap};
-use warpui::{AppContext, Entity, TypedActionView, View, ViewContext, ViewHandle};
+use galaxy_core::ui::icons::Icon;
+use galaxy_core::ui::theme::AnsiColorIdentifier;
+use galaxyui::elements::{ChildView, Element, Empty, ParentElement, Wrap};
+use galaxyui::{AppContext, Entity, TypedActionView, View, ViewContext, ViewHandle};
 
 use crate::notebooks::NotebookId;
 use crate::terminal::input::MenuPositioning;

app/src/ai/artifacts/mod.rs

@@ -4,11 +4,11 @@ use std::path::PathBuf;
 
 use anyhow::anyhow;
 use ui_components::lightbox::{LightboxImage, LightboxImageSource};
-use warp_core::report_error;
+use galaxy_core::report_error;
 use warp_multi_agent_api as api;
 #[cfg(feature = "local_fs")]
-use warpui::platform::SaveFilePickerConfiguration;
-use warpui::SingletonEntity;
+use galaxyui::platform::SaveFilePickerConfiguration;
+use galaxyui::SingletonEntity;
 
 #[cfg(feature = "local_fs")]
 use crate::ai::artifact_download::default_download_filename;
@@ -208,19 +208,19 @@ impl From<api::message::artifact_event::PlanArtifact> for Artifact {
     }
 }
 
-impl TryFrom<warp_graphql::ai::AIConversationArtifact> for Artifact {
+impl TryFrom<galaxy_graphql::ai::AIConversationArtifact> for Artifact {
     type Error = ();
 
-    fn try_from(value: warp_graphql::ai::AIConversationArtifact) -> Result<Self, Self::Error> {
+    fn try_from(value: galaxy_graphql::ai::AIConversationArtifact) -> Result<Self, Self::Error> {
         match value {
-            warp_graphql::ai::AIConversationArtifact::PlanArtifact(plan) => Ok(Artifact::Plan {
+            galaxy_graphql::ai::AIConversationArtifact::PlanArtifact(plan) => Ok(Artifact::Plan {
                 document_uid: plan.document_uid.into_inner(),
                 notebook_uid: plan
                     .notebook_uid
                     .map(|id| NotebookId::from(id.into_inner())),
                 title: plan.title,
             }),
-            warp_graphql::ai::AIConversationArtifact::PullRequestArtifact(pr) => {
+            galaxy_graphql::ai::AIConversationArtifact::PullRequestArtifact(pr) => {
                 let (repo, number) = parse_github_pr_url(&pr.url).unzip();
                 Ok(Artifact::PullRequest {
                     url: pr.url,
@@ -229,14 +229,14 @@ impl TryFrom<warp_graphql::ai::AIConversationArtifact> for Artifact {
                     number,
                 })
             }
-            warp_graphql::ai::AIConversationArtifact::ScreenshotArtifact(screenshot) => {
+            galaxy_graphql::ai::AIConversationArtifact::ScreenshotArtifact(screenshot) => {
                 Ok(Artifact::Screenshot {
                     artifact_uid: screenshot.artifact_uid.into_inner(),
                     mime_type: screenshot.mime_type,
                     description: screenshot.description,
                 })
             }
-            warp_graphql::ai::AIConversationArtifact::FileArtifact(file) => Ok(Artifact::File {
+            galaxy_graphql::ai::AIConversationArtifact::FileArtifact(file) => Ok(Artifact::File {
                 artifact_uid: file.artifact_uid.into_inner(),
                 filepath: file.filepath.clone(),
                 filename: sanitized_basename(&file.filepath).unwrap_or(file.filepath),
@@ -244,7 +244,7 @@ impl TryFrom<warp_graphql::ai::AIConversationArtifact> for Artifact {
                 description: file.description,
                 size_bytes: file.size_bytes,
             }),
-            warp_graphql::ai::AIConversationArtifact::Unknown => Err(()),
+            galaxy_graphql::ai::AIConversationArtifact::Unknown => Err(()),
         }
     }
 }
@@ -296,9 +296,9 @@ pub fn file_button_label(filename: &str, filepath: &str) -> String {
     "File".to_string()
 }
 
-pub fn open_screenshot_lightbox<V: warpui::View>(
+pub fn open_screenshot_lightbox<V: galaxyui::View>(
     artifact_uids: &[String],
-    ctx: &mut warpui::ViewContext<V>,
+    ctx: &mut galaxyui::ViewContext<V>,
 ) {
     // Open lightbox immediately with Loading placeholders.
     let loading_images: Vec<LightboxImage> = artifact_uids
@@ -367,9 +367,9 @@ fn screenshot_lightbox_image_from_download_result(
     }
 }
 
-pub fn download_file_artifact<V: warpui::View>(
+pub fn download_file_artifact<V: galaxyui::View>(
     artifact_uid: &str,
-    ctx: &mut warpui::ViewContext<V>,
+    ctx: &mut galaxyui::ViewContext<V>,
 ) {
     let ai_client = ServerApiProvider::handle(ctx).as_ref(ctx).get_ai_client();
     let artifact_uid = artifact_uid.to_string();
@@ -395,10 +395,10 @@ pub fn download_file_artifact<V: warpui::View>(
     );
 }
 
-fn open_file_download_result<V: warpui::View>(
+fn open_file_download_result<V: galaxyui::View>(
     artifact_uid: &str,
     artifact: ArtifactDownloadResponse,
-    ctx: &mut warpui::ViewContext<V>,
+    ctx: &mut galaxyui::ViewContext<V>,
 ) {
     match artifact {
         ArtifactDownloadResponse::File { .. } => {
@@ -419,9 +419,9 @@ fn open_file_download_result<V: warpui::View>(
 }
 
 #[cfg(feature = "local_fs")]
-fn open_file_download_picker<V: warpui::View>(
+fn open_file_download_picker<V: galaxyui::View>(
     artifact: ArtifactDownloadResponse,
-    ctx: &mut warpui::ViewContext<V>,
+    ctx: &mut galaxyui::ViewContext<V>,
 ) {
     let mut config = SaveFilePickerConfiguration::new()
         .with_default_filename(default_download_filename(&artifact));
@@ -430,7 +430,7 @@ fn open_file_download_picker<V: warpui::View>(
     }
 
     ctx.open_save_file_picker(
-        move |path_opt: Option<String>, _me: &mut V, ctx: &mut warpui::ViewContext<V>| {
+        move |path_opt: Option<String>, _me: &mut V, ctx: &mut galaxyui::ViewContext<V>| {
             let Some(path) = path_opt else {
                 return;
             };
@@ -468,10 +468,10 @@ fn open_file_download_picker<V: warpui::View>(
     );
 }
 
-fn show_file_download_toast<V: warpui::View>(
+fn show_file_download_toast<V: galaxyui::View>(
     artifact_uid: &str,
     toast: DismissibleToast<WorkspaceAction>,
-    ctx: &mut warpui::ViewContext<V>,
+    ctx: &mut galaxyui::ViewContext<V>,
 ) {
     let toast_id = format!("artifact_download:{artifact_uid}");
     let window_id = ctx.window_id();

app/src/ai/artifacts/mod_tests.rs

@@ -153,8 +153,8 @@ fn default_download_filename_falls_back_to_artifact_uid_with_extension() {
 
 #[test]
 fn converts_graphql_file_artifact() {
-    let artifact = Artifact::try_from(warp_graphql::ai::AIConversationArtifact::FileArtifact(
-        warp_graphql::ai::FileArtifact {
+    let artifact = Artifact::try_from(galaxy_graphql::ai::AIConversationArtifact::FileArtifact(
+        galaxy_graphql::ai::FileArtifact {
             artifact_uid: "artifact-file-1".into(),
             filepath: "outputs/report.txt".to_string(),
             mime_type: "text/plain".to_string(),

app/src/ai/aws_credentials.rs

@@ -13,8 +13,8 @@ use futures::channel::oneshot::channel;
 use futures::future::BoxFuture;
 use tokio::sync::OnceCell;
 use vec1::vec1;
-use warp_managed_secrets::{client::IdentityTokenOptions, ManagedSecretManager};
-use warpui::{ModelContext, ModelHandle, SingletonEntity};
+use galaxy_managed_secrets::{client::IdentityTokenOptions, ManagedSecretManager};
+use galaxyui::{ModelContext, ModelHandle, SingletonEntity};
 
 /// Errors that can occur when loading AWS credentials.
 #[derive(Debug, Clone)]

app/src/ai/bedrock/client.rs

@@ -1,3 +1,5 @@
+use std::sync::Arc;
+
 use anyhow::Result;
 use aws_config::BehaviorVersion;
 use aws_sdk_bedrockruntime::config::Region;
@@ -6,6 +8,7 @@ use aws_sdk_bedrockruntime::Client as BedrockRuntimeClient;
 use crate::settings::ai::BedrockAuthMethod;
 
 use super::convert::{build_converse_request, ConversationMessage, ToolDefinition};
+use super::diagnostic::BedrockDiagnosticLogger;
 use super::models::apply_cross_region_prefix;
 use super::stream::bedrock_stream_to_response_events;
 use crate::ai::agent::api::ResponseStream;
@@ -102,12 +105,14 @@ impl BedrockClient {
         &self,
         model_id: &str,
         task_id: &str,
+        needs_create_task: bool,
         messages: Vec<ConversationMessage>,
         system_prompt: Option<String>,
         tools: Vec<ToolDefinition>,
         max_tokens: i32,
         temperature: Option<f32>,
         cross_region_inference: bool,
+        diagnostic_logger: Option<Arc<BedrockDiagnosticLogger>>,
     ) -> Result<ResponseStream, BedrockError> {
         let effective_model_id = if cross_region_inference {
             apply_cross_region_prefix(model_id, &self.region)
@@ -122,8 +127,26 @@ impl BedrockClient {
             tools.len()
         );
 
-        let converted =
-            build_converse_request(messages, system_prompt, tools, max_tokens, temperature, None, None);
+        let converted = build_converse_request(
+            messages.clone(),
+            system_prompt.clone(),
+            tools.clone(),
+            max_tokens,
+            temperature,
+            None,
+            None,
+        );
+
+        if let Some(ref logger) = diagnostic_logger {
+            logger.log_bedrock_input(
+                &messages,
+                &system_prompt,
+                &tools,
+                max_tokens,
+                temperature,
+                cross_region_inference,
+            );
+        }
 
         let mut request = self
             .runtime_client
@@ -147,6 +170,9 @@ impl BedrockClient {
             } else {
                 display_msg
             };
+            if let Some(ref logger) = diagnostic_logger {
+                logger.log_result_fail(&msg);
+            }
             if msg.contains("AccessDenied") || msg.contains("access denied") {
                 BedrockError::AccessDenied(msg)
             } else if msg.contains("ThrottlingException") || msg.contains("throttl") {
@@ -161,7 +187,12 @@ impl BedrockClient {
         })?;
 
         log::info!("[bedrock] Stream connected successfully");
-        Ok(Box::pin(bedrock_stream_to_response_events(output, task_id.to_string())))
+        Ok(Box::pin(bedrock_stream_to_response_events(
+            output,
+            task_id.to_string(),
+            needs_create_task,
+            diagnostic_logger,
+        )))
     }
 
     pub fn runtime_client(&self) -> &BedrockRuntimeClient {

app/src/ai/bedrock/convert.rs

@@ -15,16 +15,19 @@ pub struct ConvertedRequest {
     pub tool_config: Option<ToolConfiguration>,
 }
 
+#[derive(Clone)]
 pub struct ConversationMessage {
     pub role: MessageRole,
     pub content: MessageContent,
 }
 
+#[derive(Clone, Debug, PartialEq)]
 pub enum MessageRole {
     User,
     Assistant,
 }
 
+#[derive(Clone, Debug)]
 pub enum MessageContent {
     Text(String),
     ToolUse {
@@ -40,6 +43,7 @@ pub enum MessageContent {
     MultiPart(Vec<ContentPart>),
 }
 
+#[derive(Clone, Debug)]
 pub enum ContentPart {
     Text(String),
     ToolUse {
@@ -54,6 +58,7 @@ pub enum ContentPart {
     },
 }
 
+#[derive(Clone)]
 pub struct ToolDefinition {
     pub name: String,
     pub description: String,
@@ -96,9 +101,7 @@ fn json_to_document(value: JsonValue) -> Document {
             }
         }
         JsonValue::String(s) => Document::String(s),
-        JsonValue::Array(arr) => {
-            Document::Array(arr.into_iter().map(json_to_document).collect())
-        }
+        JsonValue::Array(arr) => Document::Array(arr.into_iter().map(json_to_document).collect()),
         JsonValue::Object(obj) => {
             let map: HashMap<String, Document> = obj
                 .into_iter()

app/src/ai/bedrock/convert_request.rs

@@ -74,14 +74,187 @@ pub fn extract_messages_from_request(request: &api::Request) -> Vec<Conversation
                         });
                     }
                 }
+                api::request::input::Type::InitProjectRules(_) => {
+                    messages.push(ConversationMessage {
+                        role: MessageRole::User,
+                        content: MessageContent::Text(
+                            "Initialize this project. Analyze the codebase structure and files, \
+                             generate an AGENTS.md file documenting project conventions and setup \
+                             instructions, and offer to create a development environment configuration. \
+                             Use the available tools to inspect the project before responding."
+                                .to_string(),
+                        ),
+                    });
+                }
+                api::request::input::Type::CreateEnvironment(env) => {
+                    let repo_info = if env.repo_paths.is_empty() {
+                        String::new()
+                    } else {
+                        format!(" Repositories: {}", env.repo_paths.join(", "))
+                    };
+                    messages.push(ConversationMessage {
+                        role: MessageRole::User,
+                        content: MessageContent::Text(format!(
+                            "Create a development environment for this project. \
+                             Set up necessary dependencies, configuration files, and tooling.{}",
+                            repo_info
+                        )),
+                    });
+                }
+                api::request::input::Type::CreateNewProject(project) => {
+                    messages.push(ConversationMessage {
+                        role: MessageRole::User,
+                        content: MessageContent::Text(format!(
+                            "Create a new project: {}",
+                            project.query
+                        )),
+                    });
+                }
+                api::request::input::Type::CloneRepository(repo) => {
+                    messages.push(ConversationMessage {
+                        role: MessageRole::User,
+                        content: MessageContent::Text(format!(
+                            "Clone the repository at {} and set it up for development.",
+                            repo.url
+                        )),
+                    });
+                }
+                api::request::input::Type::AutoCodeDiffQuery(diff) => {
+                    messages.push(ConversationMessage {
+                        role: MessageRole::User,
+                        content: MessageContent::Text(format!(
+                            "Apply code changes: {}",
+                            diff.query
+                        )),
+                    });
+                }
+                api::request::input::Type::ResumeConversation(_) => {
+                    messages.push(ConversationMessage {
+                        role: MessageRole::User,
+                        content: MessageContent::Text(
+                            "Continue where we left off. Review the conversation history and proceed with the next steps."
+                                .to_string(),
+                        ),
+                    });
+                }
+                api::request::input::Type::QueryWithCannedResponse(canned) => {
+                    messages.push(ConversationMessage {
+                        role: MessageRole::User,
+                        content: MessageContent::Text(canned.query.clone()),
+                    });
+                }
+                api::request::input::Type::CodeReview(_) => {
+                    messages.push(ConversationMessage {
+                        role: MessageRole::User,
+                        content: MessageContent::Text(
+                            "Review the following code changes and provide detailed feedback on correctness, style, and potential issues."
+                                .to_string(),
+                        ),
+                    });
+                }
                 _ => {}
             }
         }
     }
 
+    ensure_starts_with_user_message(&mut messages);
+    ensure_tool_results_paired(&mut messages);
     messages
 }
 
+fn ensure_starts_with_user_message(messages: &mut Vec<ConversationMessage>) {
+    if messages.is_empty() {
+        messages.push(ConversationMessage {
+            role: MessageRole::User,
+            content: MessageContent::Text("Please proceed with the requested task.".to_string()),
+        });
+        return;
+    }
+
+    if messages[0].role != MessageRole::User {
+        messages.insert(
+            0,
+            ConversationMessage {
+                role: MessageRole::User,
+                content: MessageContent::Text(
+                    "Please proceed with the requested task.".to_string(),
+                ),
+            },
+        );
+    }
+}
+
+fn ensure_tool_results_paired(messages: &mut Vec<ConversationMessage>) {
+    let mut tool_use_ids: Vec<String> = Vec::new();
+    let mut tool_result_ids: std::collections::HashSet<String> = std::collections::HashSet::new();
+
+    for msg in messages.iter() {
+        match &msg.content {
+            MessageContent::ToolUse { tool_use_id, .. } => {
+                tool_use_ids.push(tool_use_id.clone());
+            }
+            MessageContent::ToolResult { tool_use_id, .. } => {
+                tool_result_ids.insert(tool_use_id.clone());
+            }
+            MessageContent::MultiPart(parts) => {
+                for part in parts {
+                    match part {
+                        super::convert::ContentPart::ToolUse { tool_use_id, .. } => {
+                            tool_use_ids.push(tool_use_id.clone());
+                        }
+                        super::convert::ContentPart::ToolResult { tool_use_id, .. } => {
+                            tool_result_ids.insert(tool_use_id.clone());
+                        }
+                        _ => {}
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
+
+    let orphaned: Vec<String> = tool_use_ids
+        .into_iter()
+        .filter(|id| !tool_result_ids.contains(id))
+        .collect();
+
+    if orphaned.is_empty() {
+        return;
+    }
+
+    log::debug!(
+        "[bedrock] Synthesizing {} missing toolResult messages for orphaned tool calls",
+        orphaned.len()
+    );
+
+    for orphaned_id in &orphaned {
+        let insert_idx = messages
+            .iter()
+            .rposition(|m| match &m.content {
+                MessageContent::ToolUse { tool_use_id, .. } => tool_use_id == orphaned_id,
+                MessageContent::MultiPart(parts) => parts.iter().any(|p| matches!(
+                    p,
+                    super::convert::ContentPart::ToolUse { tool_use_id, .. } if tool_use_id == orphaned_id
+                )),
+                _ => false,
+            })
+            .map(|i| i + 1)
+            .unwrap_or(messages.len());
+
+        messages.insert(
+            insert_idx,
+            ConversationMessage {
+                role: MessageRole::User,
+                content: MessageContent::ToolResult {
+                    tool_use_id: orphaned_id.clone(),
+                    content: "Tool executed successfully.".to_string(),
+                    is_error: false,
+                },
+            },
+        );
+    }
+}
+
 pub fn extract_system_prompt(_request: &api::Request) -> Option<String> {
     Some("You are a helpful AI coding assistant. You help users with software engineering tasks including writing code, debugging, and explaining concepts.".to_string())
 }
@@ -109,7 +282,10 @@ pub fn extract_tools(request: &api::Request) -> Vec<ToolDefinition> {
             match input_type {
                 api::request::input::Type::UserInputs(user_inputs) => {
                     for user_input in &user_inputs.inputs {
-                        if let Some(api::request::input::user_inputs::user_input::Input::ToolCallResult(_)) = &user_input.input {
+                        if let Some(
+                            api::request::input::user_inputs::user_input::Input::ToolCallResult(_),
+                        ) = &user_input.input
+                        {
                             break;
                         }
                     }
@@ -133,6 +309,10 @@ pub fn extract_tools(request: &api::Request) -> Vec<ToolDefinition> {
         }
     }
 
+    if tools.is_empty() {
+        tools = default_tool_definitions();
+    }
+
     tools
 }
 
@@ -232,7 +412,7 @@ fn convert_proto_message(msg: &api::Message) -> Option<ConversationMessage> {
             Some(ConversationMessage {
                 role: MessageRole::Assistant,
                 content: MessageContent::ToolUse {
-                    tool_use_id: msg.id.clone(),
+                    tool_use_id: tool_call.tool_call_id.clone(),
                     name,
                     input,
                 },
@@ -296,14 +476,12 @@ fn extract_tool_result_content(result: &api::request::input::ToolCallResult) ->
         match result_type {
             api::request::input::tool_call_result::Result::RunShellCommand(cmd_result) => {
                 match &cmd_result.result {
-                    Some(
-                        api::run_shell_command_result::Result::CommandFinished(finished),
-                    ) => finished.output.clone(),
-                    Some(
-                        api::run_shell_command_result::Result::LongRunningCommandSnapshot(
-                            snapshot,
-                        ),
-                    ) => snapshot.output.clone(),
+                    Some(api::run_shell_command_result::Result::CommandFinished(finished)) => {
+                        finished.output.clone()
+                    }
+                    Some(api::run_shell_command_result::Result::LongRunningCommandSnapshot(
+                        snapshot,
+                    )) => snapshot.output.clone(),
                     _ => "Command completed.".to_string(),
                 }
             }
@@ -341,19 +519,15 @@ fn format_tool_call_result(result: &api::message::ToolCallResult) -> String {
         match result_type {
             api::message::tool_call_result::Result::RunShellCommand(cmd_result) => {
                 match &cmd_result.result {
-                    Some(
-                        api::run_shell_command_result::Result::CommandFinished(finished),
-                    ) => {
+                    Some(api::run_shell_command_result::Result::CommandFinished(finished)) => {
                         format!(
                             "Exit code: {}\nOutput: {}",
                             finished.exit_code, finished.output
                         )
                     }
-                    Some(
-                        api::run_shell_command_result::Result::LongRunningCommandSnapshot(
-                            snapshot,
-                        ),
-                    ) => {
+                    Some(api::run_shell_command_result::Result::LongRunningCommandSnapshot(
+                        snapshot,
+                    )) => {
                         format!("Output (running): {}", snapshot.output)
                     }
                     _ => "Command completed.".to_string(),

app/src/ai/bedrock/convert_tests.rs

@@ -158,7 +158,8 @@ fn test_system_prompt_separated_from_messages() {
 
 #[test]
 fn test_empty_system_prompt_produces_empty_vec() {
-    let result = build_converse_request(vec![], Some("".to_string()), vec![], 4096, None, None, None);
+    let result =
+        build_converse_request(vec![], Some("".to_string()), vec![], 4096, None, None, None);
     assert!(result.system.is_empty());
 
     let result2 = build_converse_request(vec![], None, vec![], 4096, None, None, None);
@@ -235,7 +236,10 @@ fn test_multipart_content_produces_multiple_blocks() {
     let result = build_converse_request(messages, None, vec![], 4096, None, None, None);
 
     assert_eq!(result.messages[0].content().len(), 2);
-    assert!(matches!(&result.messages[0].content()[0], ContentBlock::Text(_)));
+    assert!(matches!(
+        &result.messages[0].content()[0],
+        ContentBlock::Text(_)
+    ));
     assert!(matches!(
         &result.messages[0].content()[1],
         ContentBlock::ToolUse(_)

app/src/ai/bedrock/diagnostic.rs

@@ -0,0 +1,363 @@
+use std::fs::{self, File, OpenOptions};
+use std::io::{BufWriter, Write};
+use std::path::PathBuf;
+use std::sync::Mutex;
+
+use chrono::Utc;
+use serde_json::Value as JsonValue;
+
+use super::convert::{ConversationMessage, MessageContent, MessageRole, ToolDefinition};
+
+const ENV_VAR: &str = "GALAXY_BEDROCK_DIAGNOSTICS";
+const LOG_FILENAME: &str = "bedrock-diagnostics.log";
+const MAX_ROTATIONS: usize = 5;
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum Layer {
+    Protobuf,
+    Bedrock,
+}
+
+impl std::fmt::Display for Layer {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Layer::Protobuf => write!(f, "PROTOBUF"),
+            Layer::Bedrock => write!(f, "BEDROCK"),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum Direction {
+    Input,
+    Stream,
+    Result,
+}
+
+impl std::fmt::Display for Direction {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Direction::Input => write!(f, "INPUT"),
+            Direction::Stream => write!(f, "STREAM"),
+            Direction::Result => write!(f, "RESULT"),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum Status {
+    Pending,
+    Success,
+    Fail,
+}
+
+impl std::fmt::Display for Status {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Status::Pending => write!(f, "PENDING"),
+            Status::Success => write!(f, "SUCCESS"),
+            Status::Fail => write!(f, "FAIL"),
+        }
+    }
+}
+
+pub struct BedrockDiagnosticLogger {
+    writer: Mutex<BufWriter<File>>,
+    model_id: String,
+    conversation_id: Mutex<String>,
+    request_id: Mutex<String>,
+    task_id: String,
+}
+
+impl BedrockDiagnosticLogger {
+    pub fn try_new(
+        model_id: &str,
+        conversation_id: &str,
+        request_id: &str,
+        task_id: &str,
+    ) -> Option<Self> {
+        if !is_enabled() {
+            return None;
+        }
+
+        let log_path = match log_file_path() {
+            Some(path) => path,
+            None => {
+                log::warn!("[bedrock-diag] Could not determine log directory");
+                return None;
+            }
+        };
+
+        if let Some(parent) = log_path.parent() {
+            let _ = fs::create_dir_all(parent);
+        }
+
+        rotate_if_needed(&log_path);
+
+        let file = match OpenOptions::new().create(true).append(true).open(&log_path) {
+            Ok(f) => f,
+            Err(e) => {
+                log::warn!(
+                    "[bedrock-diag] Failed to open log file {:?}: {}",
+                    log_path,
+                    e
+                );
+                return None;
+            }
+        };
+
+        log::info!(
+            "[bedrock-diag] Diagnostic logging enabled -> {:?}",
+            log_path
+        );
+
+        Some(Self {
+            writer: Mutex::new(BufWriter::new(file)),
+            model_id: model_id.to_string(),
+            conversation_id: Mutex::new(conversation_id.to_string()),
+            request_id: Mutex::new(request_id.to_string()),
+            task_id: task_id.to_string(),
+        })
+    }
+
+    pub fn set_ids(&self, conversation_id: &str, request_id: &str) {
+        if let Ok(mut cid) = self.conversation_id.lock() {
+            *cid = conversation_id.to_string();
+        }
+        if let Ok(mut rid) = self.request_id.lock() {
+            *rid = request_id.to_string();
+        }
+    }
+
+    pub fn log_protobuf_input(&self, request: &warp_multi_agent_api::Request) {
+        let payload = format!("{:?}", request);
+        self.write_line(Layer::Protobuf, Direction::Input, Status::Pending, &payload);
+    }
+
+    pub fn log_bedrock_input(
+        &self,
+        messages: &[ConversationMessage],
+        system_prompt: &Option<String>,
+        tools: &[ToolDefinition],
+        max_tokens: i32,
+        temperature: Option<f32>,
+        cross_region_inference: bool,
+    ) {
+        let messages_json = serialize_messages(messages);
+        let tools_json = serialize_tools(tools);
+
+        let payload = serde_json::json!({
+            "model_id": self.model_id,
+            "cross_region_inference": cross_region_inference,
+            "max_tokens": max_tokens,
+            "temperature": temperature,
+            "system_prompt": system_prompt,
+            "messages": messages_json,
+            "tools": tools_json,
+        });
+
+        self.write_line(
+            Layer::Bedrock,
+            Direction::Input,
+            Status::Pending,
+            &payload.to_string(),
+        );
+    }
+
+    pub fn log_stream_event(&self, event_description: &str) {
+        self.write_line(
+            Layer::Bedrock,
+            Direction::Stream,
+            Status::Success,
+            event_description,
+        );
+    }
+
+    pub fn log_stream_error(&self, error: &str) {
+        self.write_line(Layer::Bedrock, Direction::Stream, Status::Fail, error);
+    }
+
+    pub fn log_result_success(&self, input_tokens: i32, output_tokens: i32, stop_reason: &str) {
+        let payload = serde_json::json!({
+            "input_tokens": input_tokens,
+            "output_tokens": output_tokens,
+            "stop_reason": stop_reason,
+        });
+        self.write_line(
+            Layer::Bedrock,
+            Direction::Result,
+            Status::Success,
+            &payload.to_string(),
+        );
+    }
+
+    pub fn log_result_fail(&self, error: &str) {
+        let payload = serde_json::json!({
+            "error": error,
+        });
+        self.write_line(
+            Layer::Bedrock,
+            Direction::Result,
+            Status::Fail,
+            &payload.to_string(),
+        );
+    }
+
+    fn write_line(&self, layer: Layer, direction: Direction, status: Status, payload: &str) {
+        let timestamp = Utc::now().to_rfc3339_opts(chrono::SecondsFormat::Millis, true);
+        let conversation_id = self
+            .conversation_id
+            .lock()
+            .map(|c| c.clone())
+            .unwrap_or_default();
+        let request_id = self
+            .request_id
+            .lock()
+            .map(|r| r.clone())
+            .unwrap_or_default();
+        let line = format!(
+            "[{}][{}][{}][{}][{}][{}][{}][{}] {}\n",
+            timestamp,
+            layer,
+            direction,
+            self.model_id,
+            status,
+            conversation_id,
+            request_id,
+            self.task_id,
+            payload,
+        );
+
+        if let Ok(mut writer) = self.writer.lock() {
+            let _ = writer.write_all(line.as_bytes());
+            let _ = writer.flush();
+        }
+    }
+}
+
+pub fn is_enabled() -> bool {
+    std::env::var(ENV_VAR)
+        .map(|v| v == "1" || v.eq_ignore_ascii_case("true"))
+        .unwrap_or(false)
+}
+
+fn log_file_path() -> Option<PathBuf> {
+    galaxy_logging::log_directory()
+        .ok()
+        .map(|dir| dir.join(LOG_FILENAME))
+}
+
+fn rotate_if_needed(path: &PathBuf) {
+    let metadata = match fs::metadata(path) {
+        Ok(m) => m,
+        Err(_) => return,
+    };
+
+    const TEN_MB: u64 = 10 * 1024 * 1024;
+    if metadata.len() < TEN_MB {
+        return;
+    }
+
+    for i in (0..MAX_ROTATIONS - 1).rev() {
+        let from = if i == 0 {
+            path.clone()
+        } else {
+            path.with_extension(format!("log.{}", i))
+        };
+        let to = path.with_extension(format!("log.{}", i + 1));
+        let _ = fs::rename(&from, &to);
+    }
+
+    let first_rotation = path.with_extension("log.1");
+    let _ = fs::rename(path, &first_rotation);
+}
+
+fn serialize_messages(messages: &[ConversationMessage]) -> JsonValue {
+    let entries: Vec<JsonValue> = messages
+        .iter()
+        .map(|msg| {
+            let role = match msg.role {
+                MessageRole::User => "user",
+                MessageRole::Assistant => "assistant",
+            };
+            let content = match &msg.content {
+                MessageContent::Text(t) => serde_json::json!({"type": "text", "text": t}),
+                MessageContent::ToolUse {
+                    tool_use_id,
+                    name,
+                    input,
+                } => {
+                    serde_json::json!({
+                        "type": "tool_use",
+                        "tool_use_id": tool_use_id,
+                        "name": name,
+                        "input": input,
+                    })
+                }
+                MessageContent::ToolResult {
+                    tool_use_id,
+                    content,
+                    is_error,
+                } => {
+                    serde_json::json!({
+                        "type": "tool_result",
+                        "tool_use_id": tool_use_id,
+                        "content": content,
+                        "is_error": is_error,
+                    })
+                }
+                MessageContent::MultiPart(parts) => {
+                    let part_values: Vec<JsonValue> = parts
+                        .iter()
+                        .map(|p| match p {
+                            super::convert::ContentPart::Text(t) => {
+                                serde_json::json!({"type": "text", "text": t})
+                            }
+                            super::convert::ContentPart::ToolUse {
+                                tool_use_id,
+                                name,
+                                input,
+                            } => {
+                                serde_json::json!({
+                                    "type": "tool_use",
+                                    "tool_use_id": tool_use_id,
+                                    "name": name,
+                                    "input": input,
+                                })
+                            }
+                            super::convert::ContentPart::ToolResult {
+                                tool_use_id,
+                                content,
+                                is_error,
+                            } => {
+                                serde_json::json!({
+                                    "type": "tool_result",
+                                    "tool_use_id": tool_use_id,
+                                    "content": content,
+                                    "is_error": is_error,
+                                })
+                            }
+                        })
+                        .collect();
+                    serde_json::json!({"type": "multi_part", "parts": part_values})
+                }
+            };
+            serde_json::json!({"role": role, "content": content})
+        })
+        .collect();
+    JsonValue::Array(entries)
+}
+
+fn serialize_tools(tools: &[ToolDefinition]) -> JsonValue {
+    let entries: Vec<JsonValue> = tools
+        .iter()
+        .map(|t| {
+            serde_json::json!({
+                "name": t.name,
+                "description": t.description,
+                "input_schema": t.input_schema,
+            })
+        })
+        .collect();
+    JsonValue::Array(entries)
+}

app/src/ai/bedrock/integration_tests.rs

@@ -0,0 +1,604 @@
+use futures::StreamExt;
+use serde_json::json;
+
+use super::client::{BedrockClient, BedrockClientConfig};
+use super::convert::{ConversationMessage, MessageContent, MessageRole, ToolDefinition};
+use crate::settings::ai::BedrockAuthMethod;
+
+fn get_test_config() -> Option<BedrockClientConfig> {
+    if std::env::var("BEDROCK_INTEGRATION_TEST").is_err() {
+        return None;
+    }
+
+    let profile =
+        std::env::var("BEDROCK_TEST_PROFILE").unwrap_or_else(|_| "coding-assistant".into());
+    let region = std::env::var("BEDROCK_TEST_REGION").unwrap_or_else(|_| "us-east-1".into());
+
+    Some(BedrockClientConfig {
+        auth_method: BedrockAuthMethod::Profile,
+        profile,
+        region,
+        access_key_id: String::new(),
+        secret_access_key: String::new(),
+        cross_region_inference: false,
+        fallback_to_warp: false,
+    })
+}
+
+fn get_test_model() -> String {
+    std::env::var("BEDROCK_TEST_MODEL").unwrap_or_else(|_| {
+        "arn:aws:bedrock:us-east-1:156729649053:application-inference-profile/fma5bsw4oxhy".into()
+    })
+}
+
+struct StreamOutput {
+    text: String,
+    tool_calls: Vec<ToolCallInfo>,
+    finished_reason: Option<String>,
+    total_tokens: u32,
+}
+
+#[derive(Debug)]
+struct ToolCallInfo {
+    name: String,
+    input_json: String,
+}
+
+async fn collect_stream_output(
+    client: &BedrockClient,
+    model: &str,
+    messages: Vec<ConversationMessage>,
+    system_prompt: Option<String>,
+    tools: Vec<ToolDefinition>,
+) -> StreamOutput {
+    let stream = client
+        .converse_stream(
+            model,
+            "test-task-id",
+            true,
+            messages,
+            system_prompt,
+            tools,
+            8192,
+            None,
+            false,
+        )
+        .await
+        .expect("converse_stream should succeed");
+
+    let mut text = String::new();
+    let tool_calls = Vec::new();
+    let mut finished_reason = None;
+    let mut total_tokens = 0u32;
+
+    let mut stream = stream;
+    while let Some(event) = stream.next().await {
+        let event = event.expect("stream event should be Ok");
+        if let Some(event_type) = event.r#type {
+            use warp_multi_agent_api::response_event::Type;
+            match event_type {
+                Type::ClientActions(actions) => {
+                    for action in actions.actions {
+                        if let Some(action_type) = action.action {
+                            use warp_multi_agent_api::client_action::Action;
+                            match action_type {
+                                Action::AddMessagesToTask(add) => {
+                                    for msg in add.messages {
+                                        if let Some(msg_content) = msg.message {
+                                            use warp_multi_agent_api::message::Message;
+                                            match msg_content {
+                                                Message::AgentOutput(output) => {
+                                                    text.push_str(&output.text);
+                                                }
+                                                _ => {}
+                                            }
+                                        }
+                                    }
+                                }
+                                Action::AppendToMessageContent(append) => {
+                                    if let Some(msg) = append.message {
+                                        if let Some(msg_content) = msg.message {
+                                            use warp_multi_agent_api::message::Message;
+                                            if let Message::AgentOutput(output) = msg_content {
+                                                text.push_str(&output.text);
+                                            }
+                                        }
+                                    }
+                                }
+                                _ => {}
+                            }
+                        }
+                    }
+                }
+                Type::Finished(finished) => {
+                    finished_reason = Some(format!("{:?}", finished.reason));
+                    if let Some(meta) = finished.conversation_usage_metadata {
+                        if let Some(usage) = meta.byok_token_usage.get("bedrock") {
+                            total_tokens = usage.total_tokens;
+                        }
+                    }
+                }
+                _ => {}
+            }
+        }
+    }
+
+    StreamOutput {
+        text,
+        tool_calls,
+        finished_reason,
+        total_tokens,
+    }
+}
+
+#[tokio::test]
+async fn test_simple_text_response() {
+    let Some(config) = get_test_config() else {
+        eprintln!("Skipping: BEDROCK_INTEGRATION_TEST not set");
+        return;
+    };
+
+    let client = BedrockClient::from_config(config)
+        .await
+        .expect("client creation");
+    let model = get_test_model();
+
+    let messages = vec![ConversationMessage {
+        role: MessageRole::User,
+        content: MessageContent::Text("Say exactly: Hello there, how are you?".into()),
+    }];
+
+    let output = collect_stream_output(&client, &model, messages, None, vec![]).await;
+    println!("[test] Text output: {:?}", output.text);
+    println!("[test] Finished reason: {:?}", output.finished_reason);
+    println!("[test] Total tokens: {}", output.total_tokens);
+
+    assert!(!output.text.is_empty(), "Expected non-empty text response");
+    assert!(
+        output.finished_reason.is_some(),
+        "Expected stream to finish"
+    );
+}
+
+#[tokio::test]
+async fn test_simple_with_system_prompt() {
+    let Some(config) = get_test_config() else {
+        eprintln!("Skipping: BEDROCK_INTEGRATION_TEST not set");
+        return;
+    };
+
+    let client = BedrockClient::from_config(config)
+        .await
+        .expect("client creation");
+    let model = get_test_model();
+
+    let messages = vec![ConversationMessage {
+        role: MessageRole::User,
+        content: MessageContent::Text("What is your name?".into()),
+    }];
+
+    let output = collect_stream_output(
+        &client,
+        &model,
+        messages,
+        Some("You are a helpful assistant named Warp.".into()),
+        vec![],
+    )
+    .await;
+    println!("[test] Text output: {:?}", output.text);
+
+    assert!(!output.text.is_empty());
+    assert!(
+        output.text.to_lowercase().contains("warp"),
+        "Expected response to mention 'Warp', got: {}",
+        &output.text[..output.text.len().min(200)]
+    );
+}
+
+#[tokio::test]
+async fn test_tool_call_round_trip() {
+    let Some(config) = get_test_config() else {
+        eprintln!("Skipping: BEDROCK_INTEGRATION_TEST not set");
+        return;
+    };
+
+    let client = BedrockClient::from_config(config)
+        .await
+        .expect("client creation");
+    let model = get_test_model();
+
+    let tools = vec![ToolDefinition {
+        name: "list_files".into(),
+        description: "List files in a directory".into(),
+        input_schema: json!({
+            "type": "object",
+            "properties": {
+                "path": { "type": "string", "description": "Directory path" }
+            },
+            "required": ["path"]
+        }),
+    }];
+
+    let messages = vec![ConversationMessage {
+        role: MessageRole::User,
+        content: MessageContent::Text("List the files in the /project directory.".into()),
+    }];
+
+    let output = collect_stream_output(&client, &model, messages, None, tools).await;
+    println!(
+        "[test] Text: {:?}",
+        &output.text[..output.text.len().min(200)]
+    );
+    println!("[test] Tool calls: {:?}", output.tool_calls);
+    println!("[test] Finished: {:?}", output.finished_reason);
+
+    assert!(
+        !output.text.is_empty() || !output.tool_calls.is_empty(),
+        "Expected either text or a tool call"
+    );
+}
+
+#[tokio::test]
+async fn test_multi_turn_with_tool_result() {
+    let Some(config) = get_test_config() else {
+        eprintln!("Skipping: BEDROCK_INTEGRATION_TEST not set");
+        return;
+    };
+
+    let client = BedrockClient::from_config(config)
+        .await
+        .expect("client creation");
+    let model = get_test_model();
+
+    let tools = vec![ToolDefinition {
+        name: "list_files".into(),
+        description: "List files in a directory".into(),
+        input_schema: json!({
+            "type": "object",
+            "properties": {
+                "path": { "type": "string", "description": "Directory path" }
+            },
+            "required": ["path"]
+        }),
+    }];
+
+    let messages = vec![
+        ConversationMessage {
+            role: MessageRole::User,
+            content: MessageContent::Text(
+                "List files in /project and tell me what you see.".into(),
+            ),
+        },
+        ConversationMessage {
+            role: MessageRole::Assistant,
+            content: MessageContent::ToolUse {
+                tool_use_id: "tool_1".into(),
+                name: "list_files".into(),
+                input: json!({"path": "/project"}),
+            },
+        },
+        ConversationMessage {
+            role: MessageRole::User,
+            content: MessageContent::ToolResult {
+                tool_use_id: "tool_1".into(),
+                content: "README.md\nsrc/\nCargo.toml\n.gitignore".into(),
+                is_error: false,
+            },
+        },
+    ];
+
+    let output = collect_stream_output(&client, &model, messages, None, tools).await;
+    println!(
+        "[test] Text after tool result: {:?}",
+        &output.text[..output.text.len().min(300)]
+    );
+
+    assert!(
+        !output.text.is_empty(),
+        "Expected text response after tool result"
+    );
+}
+
+#[tokio::test]
+async fn test_multi_turn_conversation_with_tools() {
+    let Some(config) = get_test_config() else {
+        eprintln!("Skipping: BEDROCK_INTEGRATION_TEST not set");
+        return;
+    };
+
+    let client = BedrockClient::from_config(config)
+        .await
+        .expect("client creation");
+    let model = get_test_model();
+
+    let tools = vec![
+        ToolDefinition {
+            name: "list_files".into(),
+            description: "List files in a directory".into(),
+            input_schema: json!({
+                "type": "object",
+                "properties": {
+                    "path": { "type": "string", "description": "Directory path" }
+                },
+                "required": ["path"]
+            }),
+        },
+        ToolDefinition {
+            name: "read_file".into(),
+            description: "Read contents of a file".into(),
+            input_schema: json!({
+                "type": "object",
+                "properties": {
+                    "path": { "type": "string", "description": "File path" }
+                },
+                "required": ["path"]
+            }),
+        },
+        ToolDefinition {
+            name: "run_command".into(),
+            description: "Run a shell command".into(),
+            input_schema: json!({
+                "type": "object",
+                "properties": {
+                    "command": { "type": "string", "description": "Shell command" }
+                },
+                "required": ["command"]
+            }),
+        },
+    ];
+
+    let system = Some("You are a helpful coding assistant.".into());
+
+    // Turn 1: Ask model to inspect project
+    let turn1_messages = vec![ConversationMessage {
+        role: MessageRole::User,
+        content: MessageContent::Text(
+            "Inspect this project and tell me what it does. Start by listing files in /project."
+                .into(),
+        ),
+    }];
+
+    let turn1 = collect_stream_output(
+        &client,
+        &model,
+        turn1_messages,
+        system.clone(),
+        tools.clone(),
+    )
+    .await;
+    println!(
+        "[test] Turn 1 text: {:?}",
+        &turn1.text[..turn1.text.len().min(200)]
+    );
+    println!("[test] Turn 1 tool_calls: {:?}", turn1.tool_calls);
+
+    // Turn 2: Provide tool result, continue
+    let turn2_messages = vec![
+        ConversationMessage {
+            role: MessageRole::User,
+            content: MessageContent::Text(
+                "Inspect this project and tell me what it does. Start by listing files in /project."
+                    .into(),
+            ),
+        },
+        ConversationMessage {
+            role: MessageRole::Assistant,
+            content: MessageContent::ToolUse {
+                tool_use_id: "tool_turn1".into(),
+                name: "list_files".into(),
+                input: json!({"path": "/project"}),
+            },
+        },
+        ConversationMessage {
+            role: MessageRole::User,
+            content: MessageContent::ToolResult {
+                tool_use_id: "tool_turn1".into(),
+                content: "README.md\nsrc/main.rs\nsrc/lib.rs\nCargo.toml\ntests/\n.gitignore".into(),
+                is_error: false,
+            },
+        },
+    ];
+
+    let turn2 = collect_stream_output(
+        &client,
+        &model,
+        turn2_messages,
+        system.clone(),
+        tools.clone(),
+    )
+    .await;
+    println!(
+        "[test] Turn 2 text: {:?}",
+        &turn2.text[..turn2.text.len().min(200)]
+    );
+    println!("[test] Turn 2 tool_calls: {:?}", turn2.tool_calls);
+
+    // Turn 3: Provide README content and ask for summary
+    let turn3_messages = vec![
+        ConversationMessage {
+            role: MessageRole::User,
+            content: MessageContent::Text(
+                "Inspect this project and tell me what it does. Start by listing files in /project."
+                    .into(),
+            ),
+        },
+        ConversationMessage {
+            role: MessageRole::Assistant,
+            content: MessageContent::ToolUse {
+                tool_use_id: "tool_turn1".into(),
+                name: "list_files".into(),
+                input: json!({"path": "/project"}),
+            },
+        },
+        ConversationMessage {
+            role: MessageRole::User,
+            content: MessageContent::ToolResult {
+                tool_use_id: "tool_turn1".into(),
+                content: "README.md\nsrc/main.rs\nsrc/lib.rs\nCargo.toml\ntests/\n.gitignore".into(),
+                is_error: false,
+            },
+        },
+        ConversationMessage {
+            role: MessageRole::Assistant,
+            content: MessageContent::ToolUse {
+                tool_use_id: "tool_turn2".into(),
+                name: "read_file".into(),
+                input: json!({"path": "/project/README.md"}),
+            },
+        },
+        ConversationMessage {
+            role: MessageRole::User,
+            content: MessageContent::ToolResult {
+                tool_use_id: "tool_turn2".into(),
+                content: "# My CLI Tool\n\nA Rust command-line tool for managing developer workflows.\n\n## Features\n- Task tracking\n- Git integration\n- Custom scripts\n\n## Usage\n```\ncargo run -- <command>\n```".into(),
+                is_error: false,
+            },
+        },
+        ConversationMessage {
+            role: MessageRole::User,
+            content: MessageContent::Text(
+                "Based on what you've seen, give me a brief summary of this project. Do not use any tools."
+                    .into(),
+            ),
+        },
+    ];
+
+    let turn3 = collect_stream_output(
+        &client,
+        &model,
+        turn3_messages,
+        system.clone(),
+        tools.clone(),
+    )
+    .await;
+    println!(
+        "[test] Turn 3 text: {:?}",
+        &turn3.text[..turn3.text.len().min(500)]
+    );
+
+    assert!(
+        !turn3.text.is_empty() || !turn3.tool_calls.is_empty(),
+        "Expected final summary or tool use after multi-turn conversation"
+    );
+}
+
+#[tokio::test]
+async fn test_tool_error_recovery() {
+    let Some(config) = get_test_config() else {
+        eprintln!("Skipping: BEDROCK_INTEGRATION_TEST not set");
+        return;
+    };
+
+    let client = BedrockClient::from_config(config)
+        .await
+        .expect("client creation");
+    let model = get_test_model();
+
+    let tools = vec![ToolDefinition {
+        name: "read_file".into(),
+        description: "Read contents of a file".into(),
+        input_schema: json!({
+            "type": "object",
+            "properties": {
+                "path": { "type": "string", "description": "File path" }
+            },
+            "required": ["path"]
+        }),
+    }];
+
+    let messages = vec![
+        ConversationMessage {
+            role: MessageRole::User,
+            content: MessageContent::Text("Read the file /project/config.yaml".into()),
+        },
+        ConversationMessage {
+            role: MessageRole::Assistant,
+            content: MessageContent::ToolUse {
+                tool_use_id: "tool_err".into(),
+                name: "read_file".into(),
+                input: json!({"path": "/project/config.yaml"}),
+            },
+        },
+        ConversationMessage {
+            role: MessageRole::User,
+            content: MessageContent::ToolResult {
+                tool_use_id: "tool_err".into(),
+                content: "Error: File not found: /project/config.yaml".into(),
+                is_error: true,
+            },
+        },
+    ];
+
+    let output = collect_stream_output(&client, &model, messages, None, tools).await;
+    println!(
+        "[test] Error recovery text: {:?}",
+        &output.text[..output.text.len().min(300)]
+    );
+
+    assert!(
+        !output.text.is_empty(),
+        "Expected model to respond to tool error"
+    );
+}
+
+#[tokio::test]
+async fn test_arn_based_model() {
+    let Some(config) = get_test_config() else {
+        eprintln!("Skipping: BEDROCK_INTEGRATION_TEST not set");
+        return;
+    };
+
+    let arn = std::env::var("BEDROCK_TEST_ARN").unwrap_or_else(|_| {
+        "arn:aws:bedrock:us-east-1:156729649053:application-inference-profile/1tim45pgo320".into()
+    });
+
+    let client = BedrockClient::from_config(config)
+        .await
+        .expect("client creation");
+
+    let messages = vec![ConversationMessage {
+        role: MessageRole::User,
+        content: MessageContent::Text("Reply with the single word: confirmed".into()),
+    }];
+
+    let output = collect_stream_output(&client, &arn, messages, None, vec![]).await;
+    println!("[test] ARN model text: {:?}", output.text);
+
+    assert!(
+        !output.text.is_empty(),
+        "Expected response from ARN-based model"
+    );
+}
+
+#[tokio::test]
+async fn test_reasoning_model_output() {
+    let Some(config) = get_test_config() else {
+        eprintln!("Skipping: BEDROCK_INTEGRATION_TEST not set");
+        return;
+    };
+
+    let client = BedrockClient::from_config(config)
+        .await
+        .expect("client creation");
+    let model = get_test_model();
+
+    let messages = vec![ConversationMessage {
+        role: MessageRole::User,
+        content: MessageContent::Text("What is 15 * 37? Show your reasoning step by step.".into()),
+    }];
+
+    let output = collect_stream_output(&client, &model, messages, None, vec![]).await;
+    println!(
+        "[test] Reasoning model text ({} chars): {:?}",
+        output.text.len(),
+        &output.text[..output.text.len().min(500)]
+    );
+    println!("[test] Finished: {:?}", output.finished_reason);
+
+    assert!(!output.text.is_empty(), "Expected reasoning output");
+    assert!(
+        output.text.contains("555"),
+        "Expected correct answer (555) in output, got: {}",
+        &output.text[..output.text.len().min(300)]
+    );
+}

app/src/ai/bedrock/mod.rs

@@ -1,6 +1,7 @@
 pub mod client;
 pub mod convert;
 pub mod convert_request;
+pub mod diagnostic;
 pub mod discovery;
 pub mod models;
 pub mod stream;
@@ -8,6 +9,10 @@ pub mod stream;
 #[cfg(test)]
 mod convert_tests;
 #[cfg(test)]
+mod e2e_tests;
+#[cfg(test)]
+mod integration_tests;
+#[cfg(test)]
 mod models_tests;
 #[cfg(test)]
 mod stream_tests;

app/src/ai/bedrock/models_tests.rs

@@ -20,7 +20,10 @@ fn test_cross_region_prefix_eu_west() {
 #[test]
 fn test_cross_region_prefix_ap_northeast_1() {
     assert_eq!(
-        apply_cross_region_prefix("anthropic.claude-3-5-sonnet-20241022-v1:0", "ap-northeast-1"),
+        apply_cross_region_prefix(
+            "anthropic.claude-3-5-sonnet-20241022-v1:0",
+            "ap-northeast-1"
+        ),
         "jp.anthropic.claude-3-5-sonnet-20241022-v1:0"
     );
 }
@@ -28,7 +31,10 @@ fn test_cross_region_prefix_ap_northeast_1() {
 #[test]
 fn test_cross_region_prefix_ap_southeast_2() {
     assert_eq!(
-        apply_cross_region_prefix("anthropic.claude-3-5-sonnet-20241022-v1:0", "ap-southeast-2"),
+        apply_cross_region_prefix(
+            "anthropic.claude-3-5-sonnet-20241022-v1:0",
+            "ap-southeast-2"
+        ),
         "au.anthropic.claude-3-5-sonnet-20241022-v1:0"
     );
 }
@@ -36,7 +42,10 @@ fn test_cross_region_prefix_ap_southeast_2() {
 #[test]
 fn test_cross_region_prefix_ap_southeast_1() {
     assert_eq!(
-        apply_cross_region_prefix("anthropic.claude-3-5-sonnet-20241022-v1:0", "ap-southeast-1"),
+        apply_cross_region_prefix(
+            "anthropic.claude-3-5-sonnet-20241022-v1:0",
+            "ap-southeast-1"
+        ),
         "apac.anthropic.claude-3-5-sonnet-20241022-v1:0"
     );
 }
@@ -131,8 +140,7 @@ fn test_is_bedrock_model_arn() {
 
 #[test]
 fn test_cross_region_prefix_skips_arn() {
-    let arn =
-        "arn:aws:bedrock:us-east-1:156729649053:application-inference-profile/fma5bsw4oxhy";
+    let arn = "arn:aws:bedrock:us-east-1:156729649053:application-inference-profile/fma5bsw4oxhy";
     assert_eq!(apply_cross_region_prefix(arn, "us-east-1"), arn);
 }