first pass of merging in warp (doesn't build)
This commit is contained in:
Ryan Ward
@@ -1,11 +1,10 @@
|
||||
use galaxyui::{Entity, EntityId, ModelContext, SingletonEntity, WindowId};
|
||||
use std::collections::HashMap;
|
||||
|
||||
use crate::{
|
||||
ai::execution_profiles::profiles::ClientProfileId,
|
||||
pane_group::{ExecutionProfileEditorPane, PaneContent},
|
||||
PaneViewLocator,
|
||||
};
|
||||
|
||||
use crate::ai::execution_profiles::profiles::ClientProfileId;
|
||||
use crate::pane_group::{ExecutionProfileEditorPane, PaneContent};
|
||||
use crate::PaneViewLocator;
|
||||
|
||||
/// Manages execution profile editor panes across different windows and profiles.
|
||||
///
|
||||
|
||||
@@ -1,46 +1,53 @@
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
use ai::api_keys::{ApiKeyManager, ApiKeyManagerEvent};
|
||||
use itertools::Itertools;
|
||||
use regex::Regex;
|
||||
use thousands::Separable;
|
||||
use galaxy_core::ui::theme::color::internal_colors;
|
||||
use warpui::elements::{
|
||||
Align, Border, ChildView, ClippedScrollStateHandle, ClippedScrollable, ConstrainedBox,
|
||||
Container, CrossAxisAlignment, Expanded, Flex, Highlight, MouseStateHandle, ParentElement,
|
||||
PartialClickableElement, ScrollbarWidth, Text,
|
||||
};
|
||||
use warpui::fonts::Properties;
|
||||
use warpui::platform::Cursor;
|
||||
use warpui::ui_components::slider::SliderStateHandle;
|
||||
use warpui::ui_components::switch::SwitchStateHandle;
|
||||
use warpui::{
|
||||
AppContext, Element, Entity, ModelHandle, SingletonEntity, TypedActionView, View, ViewContext,
|
||||
ViewHandle,
|
||||
};
|
||||
|
||||
use crate::ai::blocklist::BlocklistAIPermissions;
|
||||
use crate::ai::execution_profiles::model_menu_items::available_model_menu_items;
|
||||
use crate::ai::execution_profiles::profiles::{
|
||||
AIExecutionProfilesModel, AIExecutionProfilesModelEvent, ClientProfileId,
|
||||
};
|
||||
use crate::ai::execution_profiles::{
|
||||
profiles::{AIExecutionProfilesModel, AIExecutionProfilesModelEvent, ClientProfileId},
|
||||
AIExecutionProfile, ActionPermission, WriteToPtyPermission,
|
||||
AIExecutionProfile, AIExecutionProfileAppExt as _, ActionPermission, RunAgentsPermission,
|
||||
WriteToPtyPermission,
|
||||
};
|
||||
use crate::ai::llms::{
|
||||
DisableReason, LLMContextWindow, LLMId, LLMInfo, LLMPreferences, LLMPreferencesEvent,
|
||||
};
|
||||
use crate::ai::llms::{DisableReason, LLMId, LLMInfo, LLMPreferences, LLMPreferencesEvent};
|
||||
use crate::ai::paths::host_native_absolute_path;
|
||||
use crate::editor::InteractionState;
|
||||
use crate::editor::{EditorView, Event as EditorEvent, SingleLineEditorOptions};
|
||||
use crate::editor::{
|
||||
EditorView, Event as EditorEvent, InteractionState, SingleLineEditorOptions, TextOptions,
|
||||
};
|
||||
use crate::pane_group::focus_state::PaneFocusHandle;
|
||||
use crate::settings::{AISettings, AgentModeCommandExecutionPredicate};
|
||||
use crate::pane_group::pane::view;
|
||||
use crate::pane_group::{BackingView, PaneConfiguration, PaneEvent};
|
||||
use crate::settings::{AISettings, AISettingsChangedEvent, AgentModeCommandExecutionPredicate};
|
||||
use crate::ui_components::icons::Icon;
|
||||
use crate::view_components::action_button::{ActionButton, DangerSecondaryTheme};
|
||||
use crate::view_components::dropdown::DropdownAction;
|
||||
use crate::view_components::{
|
||||
action_button::{ActionButton, DangerSecondaryTheme},
|
||||
Dropdown, DropdownItem, FilterableDropdown, SubmittableTextInput, SubmittableTextInputEvent,
|
||||
};
|
||||
use crate::workspace::WorkspaceAction;
|
||||
use crate::workspaces::user_workspaces::UserWorkspacesEvent;
|
||||
use crate::TemplatableMCPServerManager;
|
||||
use crate::UserWorkspaces;
|
||||
use crate::{
|
||||
pane_group::{pane::view, BackingView, PaneConfiguration, PaneEvent},
|
||||
Appearance,
|
||||
};
|
||||
use ai::api_keys::{ApiKeyManager, ApiKeyManagerEvent};
|
||||
use galaxy_core::ui::theme::color::internal_colors;
|
||||
use galaxyui::fonts::Properties;
|
||||
use galaxyui::platform::Cursor;
|
||||
use galaxyui::ui_components::switch::SwitchStateHandle;
|
||||
use itertools::Itertools;
|
||||
use regex::Regex;
|
||||
|
||||
use galaxyui::{
|
||||
elements::{
|
||||
Align, Border, ChildView, ClippedScrollStateHandle, ClippedScrollable, ConstrainedBox,
|
||||
Container, CrossAxisAlignment, Expanded, Flex, Highlight, MouseStateHandle, ParentElement,
|
||||
PartialClickableElement, ScrollbarWidth, Text,
|
||||
},
|
||||
AppContext, Element, Entity, ModelHandle, SingletonEntity, TypedActionView, View, ViewContext,
|
||||
ViewHandle,
|
||||
};
|
||||
use std::path::{Path, PathBuf};
|
||||
use crate::{Appearance, TemplatableMCPServerManager, UserWorkspaces};
|
||||
|
||||
const MODEL_MENU_WIDTH: f32 = 480.;
|
||||
|
||||
@@ -119,10 +126,10 @@ struct TooltipMouseStateHandles {
|
||||
write_to_pty_tooltip_mouse_state: MouseStateHandle,
|
||||
computer_use_tooltip_mouse_state: MouseStateHandle,
|
||||
ask_user_question_tooltip_mouse_state: MouseStateHandle,
|
||||
run_agents_tooltip_mouse_state: MouseStateHandle,
|
||||
call_mcp_servers_tooltip_mouse_state: MouseStateHandle,
|
||||
// Separate mouse state handles for text input editors (for workspace override tooltips)
|
||||
command_allowlist_editor_tooltip_mouse_state: MouseStateHandle,
|
||||
command_denylist_editor_tooltip_mouse_state: MouseStateHandle,
|
||||
directory_allowlist_editor_tooltip_mouse_state: MouseStateHandle,
|
||||
mcp_allowlist_editor_tooltip_mouse_state: MouseStateHandle,
|
||||
mcp_denylist_editor_tooltip_mouse_state: MouseStateHandle,
|
||||
@@ -145,6 +152,15 @@ pub enum ExecutionProfileEditorViewAction {
|
||||
SetBaseModel {
|
||||
id: LLMId,
|
||||
},
|
||||
/// Fired continuously while the user drags the context window slider.
|
||||
ContextWindowSliderDragged {
|
||||
value: u32,
|
||||
},
|
||||
/// Fired when the user commits a new context window value (slider drop,
|
||||
/// track click, or input box commit).
|
||||
SetContextWindowSize {
|
||||
value: u32,
|
||||
},
|
||||
SetCodingModel {
|
||||
id: LLMId,
|
||||
},
|
||||
@@ -177,6 +193,9 @@ pub enum ExecutionProfileEditorViewAction {
|
||||
SetAskUserQuestion {
|
||||
permission: super::AskUserQuestionPermission,
|
||||
},
|
||||
SetRunAgents {
|
||||
permission: RunAgentsPermission,
|
||||
},
|
||||
AddToCommandAllowlist {
|
||||
predicate: AgentModeCommandExecutionPredicate,
|
||||
},
|
||||
@@ -222,6 +241,10 @@ pub struct ExecutionProfileEditorView {
|
||||
focus_handle: Option<PaneFocusHandle>,
|
||||
clipped_scroll_state: ClippedScrollStateHandle,
|
||||
base_model_dropdown: ViewHandle<FilterableDropdown<ExecutionProfileEditorViewAction>>,
|
||||
context_window_slider_state: SliderStateHandle,
|
||||
context_window_editor: ViewHandle<EditorView>,
|
||||
last_synced_context_window_editor_value: Option<u32>,
|
||||
dragged_context_window_value: Option<u32>,
|
||||
coding_model_dropdown: ViewHandle<Dropdown<ExecutionProfileEditorViewAction>>,
|
||||
full_terminal_use_model_dropdown:
|
||||
ViewHandle<FilterableDropdown<ExecutionProfileEditorViewAction>>,
|
||||
@@ -233,11 +256,13 @@ pub struct ExecutionProfileEditorView {
|
||||
call_mcp_servers_dropdown: ViewHandle<Dropdown<ExecutionProfileEditorViewAction>>,
|
||||
computer_use_dropdown: ViewHandle<Dropdown<ExecutionProfileEditorViewAction>>,
|
||||
ask_user_question_dropdown: ViewHandle<Dropdown<ExecutionProfileEditorViewAction>>,
|
||||
run_agents_dropdown: ViewHandle<Dropdown<ExecutionProfileEditorViewAction>>,
|
||||
command_allowlist_editor: ViewHandle<SubmittableTextInput>,
|
||||
command_denylist_editor: ViewHandle<SubmittableTextInput>,
|
||||
directory_allowlist_editor: ViewHandle<SubmittableTextInput>,
|
||||
command_allowlist_mouse_state_handles: Vec<MouseStateHandle>,
|
||||
command_denylist_mouse_state_handles: Vec<MouseStateHandle>,
|
||||
command_denylist_tooltip_mouse_state_handles: Vec<MouseStateHandle>,
|
||||
directory_allowlist_mouse_state_handles: Vec<MouseStateHandle>,
|
||||
mcp_allowlist_dropdown: ViewHandle<FilterableDropdown<ExecutionProfileEditorViewAction>>,
|
||||
mcp_allowlist_mouse_state_handles: Vec<MouseStateHandle>,
|
||||
@@ -451,6 +476,34 @@ impl ExecutionProfileEditorView {
|
||||
dropdown
|
||||
});
|
||||
|
||||
let run_agents_dropdown = ctx.add_typed_action_view(|ctx| {
|
||||
let mut dropdown = Dropdown::new(ctx);
|
||||
dropdown.set_items(
|
||||
vec![
|
||||
DropdownItem::new(
|
||||
"Never",
|
||||
ExecutionProfileEditorViewAction::SetRunAgents {
|
||||
permission: RunAgentsPermission::NeverAllow,
|
||||
},
|
||||
),
|
||||
DropdownItem::new(
|
||||
"Always allow",
|
||||
ExecutionProfileEditorViewAction::SetRunAgents {
|
||||
permission: RunAgentsPermission::AlwaysAllow,
|
||||
},
|
||||
),
|
||||
DropdownItem::new(
|
||||
"Always ask",
|
||||
ExecutionProfileEditorViewAction::SetRunAgents {
|
||||
permission: RunAgentsPermission::AlwaysAsk,
|
||||
},
|
||||
),
|
||||
],
|
||||
ctx,
|
||||
);
|
||||
dropdown
|
||||
});
|
||||
|
||||
let mcp_allowlist_dropdown = ctx.add_typed_action_view(|ctx| {
|
||||
let mut dropdown = FilterableDropdown::new(ctx);
|
||||
dropdown.set_menu_header_to_static("Select MCP servers");
|
||||
@@ -484,6 +537,27 @@ impl ExecutionProfileEditorView {
|
||||
dropdown.set_menu_width(MODEL_MENU_WIDTH, ctx);
|
||||
dropdown
|
||||
});
|
||||
|
||||
// Initialize the context window editor buffer with the profile's
|
||||
// persisted limit (or the active model's max as a sensible default).
|
||||
// The slider's current position is derived from the profile on each
|
||||
// render, so no local Cell is needed.
|
||||
let initial_context_window_value = initial_context_window_display_value(&profile_data, ctx);
|
||||
let context_window_slider_state = SliderStateHandle::default();
|
||||
let context_window_editor = ctx.add_typed_action_view(|ctx| {
|
||||
let options = SingleLineEditorOptions {
|
||||
text: TextOptions {
|
||||
font_size_override: Some(Appearance::as_ref(ctx).ui_font_size()),
|
||||
..Default::default()
|
||||
},
|
||||
..Default::default()
|
||||
};
|
||||
let mut editor = EditorView::single_line(options, ctx);
|
||||
editor.set_buffer_text(&initial_context_window_value.separate_with_commas(), ctx);
|
||||
editor
|
||||
});
|
||||
let last_synced_context_window_editor_value = Some(initial_context_window_value);
|
||||
|
||||
let coding_model_dropdown = ctx.add_typed_action_view(|ctx| {
|
||||
let mut dropdown = Dropdown::new(ctx);
|
||||
dropdown.set_top_bar_max_width(MODEL_MENU_WIDTH);
|
||||
@@ -578,6 +652,10 @@ impl ExecutionProfileEditorView {
|
||||
focus_handle: None,
|
||||
clipped_scroll_state: Default::default(),
|
||||
base_model_dropdown,
|
||||
context_window_slider_state,
|
||||
context_window_editor,
|
||||
last_synced_context_window_editor_value,
|
||||
dragged_context_window_value: None,
|
||||
coding_model_dropdown,
|
||||
full_terminal_use_model_dropdown,
|
||||
computer_use_model_dropdown,
|
||||
@@ -588,11 +666,17 @@ impl ExecutionProfileEditorView {
|
||||
call_mcp_servers_dropdown,
|
||||
computer_use_dropdown,
|
||||
ask_user_question_dropdown,
|
||||
run_agents_dropdown,
|
||||
command_allowlist_editor,
|
||||
command_denylist_editor,
|
||||
directory_allowlist_editor,
|
||||
command_allowlist_mouse_state_handles,
|
||||
command_denylist_mouse_state_handles,
|
||||
command_denylist_tooltip_mouse_state_handles: profile_data
|
||||
.command_denylist
|
||||
.iter()
|
||||
.map(|_| Default::default())
|
||||
.collect(),
|
||||
directory_allowlist_mouse_state_handles,
|
||||
mcp_allowlist_dropdown,
|
||||
mcp_allowlist_mouse_state_handles,
|
||||
@@ -612,6 +696,10 @@ impl ExecutionProfileEditorView {
|
||||
}
|
||||
});
|
||||
|
||||
ctx.subscribe_to_view(&view.context_window_editor, |view, _, event, ctx| {
|
||||
view.handle_context_window_editor_event(event, ctx);
|
||||
});
|
||||
|
||||
ctx.subscribe_to_view(&view.command_allowlist_editor, |view, _, event, ctx| {
|
||||
if let SubmittableTextInputEvent::Submit(s) = event {
|
||||
let predicate = match AgentModeCommandExecutionPredicate::new_regex(s) {
|
||||
@@ -671,7 +759,7 @@ impl ExecutionProfileEditorView {
|
||||
Self::refresh_filterable_model_dropdown(
|
||||
&me.base_model_dropdown,
|
||||
current_permissions.base_model.clone(),
|
||||
|prefs| prefs.get_base_llm_choices_for_agent_mode().collect_vec(),
|
||||
|prefs, app| prefs.get_base_llm_choices_for_agent_mode(app).collect_vec(),
|
||||
|id| ExecutionProfileEditorViewAction::SetBaseModel { id },
|
||||
|prefs| prefs.get_default_base_model().id.clone(),
|
||||
&me.upgrade_footer_mouse_state,
|
||||
@@ -685,7 +773,7 @@ impl ExecutionProfileEditorView {
|
||||
Self::refresh_filterable_model_dropdown(
|
||||
&me.full_terminal_use_model_dropdown,
|
||||
current_permissions.cli_agent_model.clone(),
|
||||
|prefs| prefs.get_cli_agent_llm_choices().collect_vec(),
|
||||
|prefs, app| prefs.get_cli_agent_llm_choices(app).collect_vec(),
|
||||
|id| ExecutionProfileEditorViewAction::SetFullTerminalUseModel { id },
|
||||
|prefs| prefs.get_default_cli_agent_model().id.clone(),
|
||||
&me.upgrade_footer_mouse_state,
|
||||
@@ -694,23 +782,25 @@ impl ExecutionProfileEditorView {
|
||||
Self::refresh_filterable_model_dropdown(
|
||||
&me.computer_use_model_dropdown,
|
||||
current_permissions.computer_use_model.clone(),
|
||||
|prefs| prefs.get_computer_use_llm_choices().collect_vec(),
|
||||
|prefs, _| prefs.get_computer_use_llm_choices().collect_vec(),
|
||||
|id| ExecutionProfileEditorViewAction::SetComputerUseModel { id },
|
||||
|prefs| prefs.get_default_computer_use_model().id.clone(),
|
||||
&me.upgrade_footer_mouse_state,
|
||||
ctx,
|
||||
);
|
||||
me.sync_context_window_editor(ctx, false);
|
||||
}
|
||||
LLMPreferencesEvent::UpdatedActiveAgentModeLLM => {
|
||||
Self::refresh_filterable_model_dropdown(
|
||||
&me.base_model_dropdown,
|
||||
current_permissions.base_model.clone(),
|
||||
|prefs| prefs.get_base_llm_choices_for_agent_mode().collect_vec(),
|
||||
|prefs, app| prefs.get_base_llm_choices_for_agent_mode(app).collect_vec(),
|
||||
|id| ExecutionProfileEditorViewAction::SetBaseModel { id },
|
||||
|prefs| prefs.get_default_base_model().id.clone(),
|
||||
&me.upgrade_footer_mouse_state,
|
||||
ctx,
|
||||
);
|
||||
me.sync_context_window_editor(ctx, false);
|
||||
}
|
||||
LLMPreferencesEvent::UpdatedActiveCodingLLM => {
|
||||
Self::refresh_coding_model_dropdown(
|
||||
@@ -732,7 +822,7 @@ impl ExecutionProfileEditorView {
|
||||
Self::refresh_filterable_model_dropdown(
|
||||
&me.base_model_dropdown,
|
||||
current_permissions.base_model.clone(),
|
||||
|prefs| prefs.get_base_llm_choices_for_agent_mode().collect_vec(),
|
||||
|prefs, app| prefs.get_base_llm_choices_for_agent_mode(app).collect_vec(),
|
||||
|id| ExecutionProfileEditorViewAction::SetBaseModel { id },
|
||||
|prefs| prefs.get_default_base_model().id.clone(),
|
||||
&me.upgrade_footer_mouse_state,
|
||||
@@ -743,6 +833,7 @@ impl ExecutionProfileEditorView {
|
||||
current_permissions.coding_model.clone(),
|
||||
ctx,
|
||||
);
|
||||
me.sync_context_window_editor(ctx, false);
|
||||
ctx.notify();
|
||||
},
|
||||
);
|
||||
@@ -761,6 +852,15 @@ impl ExecutionProfileEditorView {
|
||||
ctx.subscribe_to_model(&workspace, |me, workspace, event, ctx| {
|
||||
if let UserWorkspacesEvent::TeamsChanged = event {
|
||||
Self::update_all_editor_interaction_states(me, workspace, ctx);
|
||||
me.update_mouse_state_handles(ctx);
|
||||
ctx.notify();
|
||||
}
|
||||
});
|
||||
ctx.subscribe_to_model(&AISettings::handle(ctx), |me, _, event, ctx| {
|
||||
if let AISettingsChangedEvent::IsAnyAIEnabled { .. } = event {
|
||||
let workspace = UserWorkspaces::handle(ctx);
|
||||
Self::update_all_editor_interaction_states(me, workspace, ctx);
|
||||
me.sync_context_window_editor(ctx, true);
|
||||
ctx.notify();
|
||||
}
|
||||
});
|
||||
@@ -795,6 +895,12 @@ impl ExecutionProfileEditorView {
|
||||
.map(|_| Default::default())
|
||||
.collect();
|
||||
|
||||
self.command_denylist_tooltip_mouse_state_handles = current_permissions
|
||||
.command_denylist
|
||||
.iter()
|
||||
.map(|_| Default::default())
|
||||
.collect();
|
||||
|
||||
self.directory_allowlist_mouse_state_handles = current_permissions
|
||||
.directory_allowlist
|
||||
.iter()
|
||||
@@ -826,12 +932,13 @@ impl ExecutionProfileEditorView {
|
||||
let computer_use_disabled = !ai_settings.is_computer_use_permissions_editable(ctx);
|
||||
let ask_user_question_disabled =
|
||||
!ai_settings.is_ask_user_question_permissions_editable(ctx);
|
||||
let run_agents_disabled = !ai_settings.is_run_agents_permissions_editable(ctx);
|
||||
let mcp_disabled = !ai_settings.is_mcp_permission_editable(ctx);
|
||||
|
||||
Self::refresh_filterable_model_dropdown(
|
||||
&self.base_model_dropdown,
|
||||
current_permissions.base_model.clone(),
|
||||
|prefs| prefs.get_base_llm_choices_for_agent_mode().collect_vec(),
|
||||
|prefs, app| prefs.get_base_llm_choices_for_agent_mode(app).collect_vec(),
|
||||
|id| ExecutionProfileEditorViewAction::SetBaseModel { id },
|
||||
|prefs| prefs.get_default_base_model().id.clone(),
|
||||
&self.upgrade_footer_mouse_state,
|
||||
@@ -845,7 +952,7 @@ impl ExecutionProfileEditorView {
|
||||
Self::refresh_filterable_model_dropdown(
|
||||
&self.full_terminal_use_model_dropdown,
|
||||
current_permissions.cli_agent_model.clone(),
|
||||
|prefs| prefs.get_cli_agent_llm_choices().collect_vec(),
|
||||
|prefs, app| prefs.get_cli_agent_llm_choices(app).collect_vec(),
|
||||
|id| ExecutionProfileEditorViewAction::SetFullTerminalUseModel { id },
|
||||
|prefs| prefs.get_default_cli_agent_model().id.clone(),
|
||||
&self.upgrade_footer_mouse_state,
|
||||
@@ -854,7 +961,7 @@ impl ExecutionProfileEditorView {
|
||||
Self::refresh_filterable_model_dropdown(
|
||||
&self.computer_use_model_dropdown,
|
||||
current_permissions.computer_use_model.clone(),
|
||||
|prefs| prefs.get_computer_use_llm_choices().collect_vec(),
|
||||
|prefs, _| prefs.get_computer_use_llm_choices().collect_vec(),
|
||||
|id| ExecutionProfileEditorViewAction::SetComputerUseModel { id },
|
||||
|prefs| prefs.get_default_computer_use_model().id.clone(),
|
||||
&self.upgrade_footer_mouse_state,
|
||||
@@ -903,6 +1010,12 @@ impl ExecutionProfileEditorView {
|
||||
ask_user_question_disabled,
|
||||
ctx,
|
||||
);
|
||||
Self::refresh_run_agents_dropdown_menu(
|
||||
&self.run_agents_dropdown,
|
||||
current_permissions.run_agents,
|
||||
run_agents_disabled,
|
||||
ctx,
|
||||
);
|
||||
Self::refresh_mcp_dropdown(
|
||||
&self.mcp_allowlist_dropdown,
|
||||
|uuid| ExecutionProfileEditorViewAction::AddToMCPAllowlist { id: uuid },
|
||||
@@ -919,6 +1032,7 @@ impl ExecutionProfileEditorView {
|
||||
);
|
||||
|
||||
Self::update_profile_name_editor(&self.profile_name_editor, ¤t_permissions, ctx);
|
||||
self.sync_context_window_editor(ctx, false);
|
||||
}
|
||||
|
||||
fn refresh_execution_profile_dropdown_menu(
|
||||
@@ -1022,6 +1136,31 @@ impl ExecutionProfileEditorView {
|
||||
ctx.notify();
|
||||
}
|
||||
|
||||
fn refresh_run_agents_dropdown_menu(
|
||||
menu: &ViewHandle<Dropdown<ExecutionProfileEditorViewAction>>,
|
||||
current_permission: RunAgentsPermission,
|
||||
disabled: bool,
|
||||
ctx: &mut ViewContext<Self>,
|
||||
) {
|
||||
menu.update(ctx, |menu, ctx| {
|
||||
if !disabled {
|
||||
menu.set_enabled(ctx);
|
||||
} else {
|
||||
menu.set_disabled(ctx);
|
||||
}
|
||||
|
||||
let active = match current_permission {
|
||||
RunAgentsPermission::NeverAllow | RunAgentsPermission::Unknown => 0,
|
||||
RunAgentsPermission::AlwaysAllow => 1,
|
||||
RunAgentsPermission::AlwaysAsk => 2,
|
||||
};
|
||||
|
||||
menu.set_selected_by_index(active, ctx);
|
||||
ctx.notify();
|
||||
});
|
||||
ctx.notify();
|
||||
}
|
||||
|
||||
fn refresh_filterable_model_dropdown<G, A, D>(
|
||||
menu: &ViewHandle<FilterableDropdown<ExecutionProfileEditorViewAction>>,
|
||||
profile_model: Option<LLMId>,
|
||||
@@ -1031,7 +1170,7 @@ impl ExecutionProfileEditorView {
|
||||
upgrade_mouse_state: &MouseStateHandle,
|
||||
ctx: &mut ViewContext<Self>,
|
||||
) where
|
||||
G: FnOnce(&LLMPreferences) -> Vec<&LLMInfo>,
|
||||
G: for<'a> FnOnce(&'a LLMPreferences, &AppContext) -> Vec<&'a LLMInfo>,
|
||||
A: Fn(LLMId) -> ExecutionProfileEditorViewAction,
|
||||
D: FnOnce(&LLMPreferences) -> LLMId,
|
||||
{
|
||||
@@ -1046,7 +1185,7 @@ impl ExecutionProfileEditorView {
|
||||
|
||||
let llm_prefs = LLMPreferences::handle(ctx);
|
||||
let llm_prefs = llm_prefs.as_ref(ctx);
|
||||
let choices = get_choices(llm_prefs);
|
||||
let choices = get_choices(llm_prefs, ctx);
|
||||
|
||||
let has_upgrade_gated_models = choices
|
||||
.iter()
|
||||
@@ -1054,7 +1193,7 @@ impl ExecutionProfileEditorView {
|
||||
|
||||
let items = available_model_menu_items(
|
||||
choices,
|
||||
|llm| create_action(llm.id.clone()).into(),
|
||||
|llm| DropdownAction::select_action_and_close(create_action(llm.id.clone())),
|
||||
None,
|
||||
None,
|
||||
false,
|
||||
@@ -1097,13 +1236,15 @@ impl ExecutionProfileEditorView {
|
||||
}
|
||||
|
||||
let choices = LLMPreferences::as_ref(ctx)
|
||||
.get_coding_llm_choices()
|
||||
.get_coding_llm_choices(ctx)
|
||||
.collect_vec();
|
||||
|
||||
let items = available_model_menu_items(
|
||||
choices,
|
||||
|llm| {
|
||||
ExecutionProfileEditorViewAction::SetCodingModel { id: llm.id.clone() }.into()
|
||||
DropdownAction::select_action_and_close(
|
||||
ExecutionProfileEditorViewAction::SetCodingModel { id: llm.id.clone() },
|
||||
)
|
||||
},
|
||||
None,
|
||||
None,
|
||||
@@ -1225,7 +1366,7 @@ impl ExecutionProfileEditorView {
|
||||
|
||||
Self::update_editor_interaction_state(
|
||||
view.command_denylist_editor.as_ref(ctx).editor().clone(),
|
||||
is_any_ai_enabled && !ai_autonomy_settings.has_override_for_execute_commands_denylist(),
|
||||
is_any_ai_enabled,
|
||||
ctx,
|
||||
);
|
||||
|
||||
@@ -1256,10 +1397,112 @@ impl ExecutionProfileEditorView {
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
fn configurable_context_window(&self, app: &AppContext) -> Option<LLMContextWindow> {
|
||||
let profile =
|
||||
BlocklistAIPermissions::as_ref(app).permissions_profile_for_id(app, self.profile_id);
|
||||
profile.configurable_context_window(app)
|
||||
}
|
||||
|
||||
fn current_context_window_display_value(&self, app: &AppContext) -> Option<u32> {
|
||||
let profile =
|
||||
BlocklistAIPermissions::as_ref(app).permissions_profile_for_id(app, self.profile_id);
|
||||
profile.context_window_display_value(app)
|
||||
}
|
||||
|
||||
fn handle_context_window_editor_event(
|
||||
&mut self,
|
||||
event: &EditorEvent,
|
||||
ctx: &mut ViewContext<Self>,
|
||||
) {
|
||||
match event {
|
||||
EditorEvent::Blurred | EditorEvent::Enter => {
|
||||
if !AISettings::as_ref(ctx).is_any_ai_enabled(ctx) {
|
||||
self.sync_context_window_editor(ctx, true);
|
||||
return;
|
||||
}
|
||||
let Some(cw) = self.configurable_context_window(ctx) else {
|
||||
return;
|
||||
};
|
||||
let buffer_text = self.context_window_editor.as_ref(ctx).buffer_text(ctx);
|
||||
let cleaned: String = buffer_text
|
||||
.chars()
|
||||
.filter(|c| !c.is_whitespace() && *c != ',')
|
||||
.collect();
|
||||
if let Ok(parsed) = cleaned.parse::<u32>() {
|
||||
let clamped = parsed.clamp(cw.min, cw.max);
|
||||
if Some(clamped) != self.current_context_window_display_value(ctx) {
|
||||
AIExecutionProfilesModel::handle(ctx).update(ctx, |profiles_model, ctx| {
|
||||
profiles_model.set_context_window_limit(
|
||||
self.profile_id,
|
||||
Some(clamped),
|
||||
ctx,
|
||||
);
|
||||
});
|
||||
}
|
||||
}
|
||||
self.sync_context_window_editor(ctx, true);
|
||||
ctx.notify();
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
|
||||
fn sync_context_window_editor(&mut self, ctx: &mut ViewContext<Self>, force: bool) {
|
||||
self.dragged_context_window_value = None;
|
||||
let Some(value) = self.current_context_window_display_value(ctx) else {
|
||||
self.last_synced_context_window_editor_value = None;
|
||||
self.context_window_slider_state.reset_offset();
|
||||
ctx.notify();
|
||||
return;
|
||||
};
|
||||
|
||||
let formatted = value.separate_with_commas();
|
||||
let should_update = if force {
|
||||
true
|
||||
} else {
|
||||
match self.last_synced_context_window_editor_value {
|
||||
Some(last_value) => {
|
||||
self.context_window_editor.as_ref(ctx).buffer_text(ctx)
|
||||
== last_value.separate_with_commas()
|
||||
}
|
||||
None => true,
|
||||
}
|
||||
};
|
||||
|
||||
if should_update {
|
||||
self.context_window_editor.update(ctx, |editor, ctx| {
|
||||
if editor.buffer_text(ctx) != formatted {
|
||||
editor.system_reset_buffer_text(&formatted, ctx);
|
||||
}
|
||||
});
|
||||
self.last_synced_context_window_editor_value = Some(value);
|
||||
self.context_window_slider_state.reset_offset();
|
||||
ctx.notify();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn initial_context_window_display_value(
|
||||
profile_data: &AIExecutionProfile,
|
||||
app: &AppContext,
|
||||
) -> u32 {
|
||||
profile_data
|
||||
.context_window_display_value(app)
|
||||
.unwrap_or_else(|| {
|
||||
LLMPreferences::as_ref(app)
|
||||
.get_default_base_model()
|
||||
.context_window
|
||||
.default_max
|
||||
})
|
||||
}
|
||||
|
||||
mod ui_helpers;
|
||||
|
||||
#[cfg(test)]
|
||||
#[path = "mod_tests.rs"]
|
||||
mod tests;
|
||||
|
||||
impl View for ExecutionProfileEditorView {
|
||||
fn ui_name() -> &'static str {
|
||||
"ExecutionProfileEditorView"
|
||||
@@ -1278,7 +1521,7 @@ impl View for ExecutionProfileEditorView {
|
||||
&self.profile_name_editor,
|
||||
profile_data.is_default_profile,
|
||||
))
|
||||
.with_child(render_models_section(appearance, self))
|
||||
.with_child(render_models_section(appearance, self, app))
|
||||
.with_child(render_permissions_section(
|
||||
appearance,
|
||||
self,
|
||||
@@ -1323,9 +1566,48 @@ impl TypedActionView for ExecutionProfileEditorView {
|
||||
ctx.emit(ExecutionProfileEditorViewEvent::Pane(PaneEvent::Close));
|
||||
}
|
||||
ExecutionProfileEditorViewAction::SetBaseModel { id } => {
|
||||
// Changing the base model resets any persisted context window
|
||||
// override — the new model may have a different range (or not
|
||||
// be configurable at all). The user can pick a new value for
|
||||
// the new model if they want one.
|
||||
AIExecutionProfilesModel::handle(ctx).update(ctx, |profiles_model, ctx| {
|
||||
profiles_model.set_base_model(self.profile_id, Some(id.clone()), ctx);
|
||||
profiles_model.set_context_window_limit(self.profile_id, None, ctx);
|
||||
});
|
||||
self.sync_context_window_editor(ctx, true);
|
||||
ctx.notify();
|
||||
}
|
||||
ExecutionProfileEditorViewAction::ContextWindowSliderDragged { value } => {
|
||||
if !AISettings::as_ref(ctx).is_any_ai_enabled(ctx) {
|
||||
self.sync_context_window_editor(ctx, true);
|
||||
return;
|
||||
}
|
||||
// Transient drag update: reflect the current slider position
|
||||
// in the input box without persisting to the profile yet.
|
||||
// Persistence happens on SetContextWindowSize (drop / commit).
|
||||
if self.configurable_context_window(ctx).is_some() {
|
||||
self.dragged_context_window_value = Some(*value);
|
||||
let formatted = value.separate_with_commas();
|
||||
self.context_window_editor.update(ctx, |editor, ctx| {
|
||||
editor.system_reset_buffer_text(&formatted, ctx);
|
||||
});
|
||||
ctx.notify();
|
||||
}
|
||||
}
|
||||
ExecutionProfileEditorViewAction::SetContextWindowSize { value } => {
|
||||
self.dragged_context_window_value = None;
|
||||
if !AISettings::as_ref(ctx).is_any_ai_enabled(ctx) {
|
||||
self.sync_context_window_editor(ctx, true);
|
||||
return;
|
||||
}
|
||||
let Some(cw) = self.configurable_context_window(ctx) else {
|
||||
return;
|
||||
};
|
||||
let clamped = (*value).clamp(cw.min, cw.max);
|
||||
AIExecutionProfilesModel::handle(ctx).update(ctx, |profiles_model, ctx| {
|
||||
profiles_model.set_context_window_limit(self.profile_id, Some(clamped), ctx);
|
||||
});
|
||||
self.sync_context_window_editor(ctx, true);
|
||||
ctx.notify();
|
||||
}
|
||||
ExecutionProfileEditorViewAction::SetCodingModel { id } => {
|
||||
@@ -1388,6 +1670,12 @@ impl TypedActionView for ExecutionProfileEditorView {
|
||||
});
|
||||
ctx.notify();
|
||||
}
|
||||
ExecutionProfileEditorViewAction::SetRunAgents { permission } => {
|
||||
AIExecutionProfilesModel::handle(ctx).update(ctx, |profiles_model, ctx| {
|
||||
profiles_model.set_run_agents(self.profile_id, *permission, ctx);
|
||||
});
|
||||
ctx.notify();
|
||||
}
|
||||
ExecutionProfileEditorViewAction::AddToCommandAllowlist { predicate } => {
|
||||
AIExecutionProfilesModel::handle(ctx).update(ctx, |profiles_model, ctx| {
|
||||
profiles_model.add_to_command_allowlist(self.profile_id, predicate, ctx);
|
||||
|
||||
@@ -0,0 +1,315 @@
|
||||
use std::collections::HashMap;
|
||||
|
||||
use galaxy_core::features::FeatureFlag;
|
||||
use warpui::App;
|
||||
|
||||
use super::ui_helpers::context_window_snap_values;
|
||||
use crate::ai::execution_profiles::profiles::AIExecutionProfilesModel;
|
||||
use crate::ai::execution_profiles::{
|
||||
has_configurable_context_window, should_show_long_context_pricing_warning, AIExecutionProfile,
|
||||
AIExecutionProfileAppExt as _,
|
||||
};
|
||||
use crate::ai::llms::{
|
||||
AvailableLLMs, LLMContextWindow, LLMInfo, LLMPreferences, LLMProvider, LLMUsageMetadata,
|
||||
ModelsByFeature,
|
||||
};
|
||||
use crate::ai::mcp::TemplatableMCPServerManager;
|
||||
use crate::auth::auth_manager::AuthManager;
|
||||
use crate::auth::AuthStateProvider;
|
||||
use crate::cloud_object::model::persistence::CloudModel;
|
||||
use crate::network::NetworkStatus;
|
||||
use crate::server::cloud_objects::update_manager::UpdateManager;
|
||||
use crate::server::server_api::ServerApiProvider;
|
||||
use crate::server::sync_queue::SyncQueue;
|
||||
use crate::test_util::settings::initialize_settings_for_tests;
|
||||
use crate::workspaces::team_tester::TeamTesterStatus;
|
||||
use crate::workspaces::user_workspaces::UserWorkspaces;
|
||||
use crate::LaunchMode;
|
||||
fn configurable_model(provider: LLMProvider) -> LLMInfo {
|
||||
LLMInfo {
|
||||
display_name: "test model".to_string(),
|
||||
base_model_name: "test model".to_string(),
|
||||
id: "test-model".into(),
|
||||
reasoning_level: None,
|
||||
usage_metadata: LLMUsageMetadata {
|
||||
request_multiplier: 1,
|
||||
credit_multiplier: None,
|
||||
},
|
||||
description: None,
|
||||
disable_reason: None,
|
||||
vision_supported: false,
|
||||
spec: None,
|
||||
provider,
|
||||
host_configs: HashMap::new(),
|
||||
discount_percentage: None,
|
||||
context_window: LLMContextWindow {
|
||||
is_configurable: true,
|
||||
min: 200_000,
|
||||
max: 1_000_000,
|
||||
default_max: 272_000,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
fn assert_context_window_limit_for_request(
|
||||
model: &LLMInfo,
|
||||
selected_limit: Option<u32>,
|
||||
gpt_configurable_context_window_enabled: bool,
|
||||
expected: Option<u32>,
|
||||
) {
|
||||
let model = model.clone();
|
||||
App::test((), move |mut app| async move {
|
||||
let _flag = FeatureFlag::GPTConfigurableContextWindow
|
||||
.override_enabled(gpt_configurable_context_window_enabled);
|
||||
|
||||
initialize_settings_for_tests(&mut app);
|
||||
app.add_singleton_model(|_| ServerApiProvider::new_for_test());
|
||||
app.add_singleton_model(|_| AuthStateProvider::new_for_test());
|
||||
app.add_singleton_model(AuthManager::new_for_test);
|
||||
app.add_singleton_model(|_| NetworkStatus::new());
|
||||
app.add_singleton_model(UserWorkspaces::default_mock);
|
||||
app.add_singleton_model(CloudModel::mock);
|
||||
app.add_singleton_model(TeamTesterStatus::mock);
|
||||
app.add_singleton_model(SyncQueue::mock);
|
||||
app.add_singleton_model(UpdateManager::mock);
|
||||
app.add_singleton_model(|_| TemplatableMCPServerManager::default());
|
||||
app.add_singleton_model(|ctx| {
|
||||
AIExecutionProfilesModel::new(&LaunchMode::new_for_unit_test(), ctx)
|
||||
});
|
||||
let llm_preferences = app.add_singleton_model(LLMPreferences::new);
|
||||
|
||||
let profile_model_id = model.id.clone();
|
||||
let available_model_id = profile_model_id.clone();
|
||||
llm_preferences.update(&mut app, move |preferences, ctx| {
|
||||
preferences.update_feature_model_choices(
|
||||
Ok(ModelsByFeature {
|
||||
agent_mode: AvailableLLMs::new(available_model_id, [model], None)
|
||||
.expect("test model should create available LLMs"),
|
||||
..Default::default()
|
||||
}),
|
||||
ctx,
|
||||
);
|
||||
});
|
||||
|
||||
let profile = AIExecutionProfile {
|
||||
base_model: Some(profile_model_id),
|
||||
context_window_limit: selected_limit,
|
||||
..Default::default()
|
||||
};
|
||||
app.read(|ctx| {
|
||||
assert_eq!(profile.context_window_limit_for_request(ctx), expected);
|
||||
});
|
||||
});
|
||||
}
|
||||
/// Helper: round-trip f32 → u32 for readable assertions and absorb the
|
||||
/// negligible f64→f32 drift the snap helper picks up on large ranges.
|
||||
fn rounded(values: &[f32]) -> Vec<u32> {
|
||||
values.iter().map(|v| v.round() as u32).collect()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn snap_values_for_min_eq_max_returns_single_point() {
|
||||
assert_eq!(
|
||||
rounded(&context_window_snap_values(50_000, 50_000)),
|
||||
vec![50_000]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn snap_values_for_min_gt_max_collapses_to_min() {
|
||||
// Defensive: invalid bounds shouldn't panic, just degrade gracefully.
|
||||
assert_eq!(rounded(&context_window_snap_values(100, 50)), vec![100]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn snap_values_always_include_endpoints() {
|
||||
let values = rounded(&context_window_snap_values(1_000, 200_000));
|
||||
assert_eq!(values.first(), Some(&1_000));
|
||||
assert_eq!(values.last(), Some(&200_000));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn snap_values_for_classic_200k_range_match_legacy_layout() {
|
||||
// Mirrors the old hardcoded list, except `1_000` replaces the missing
|
||||
// round multiple at the start.
|
||||
let values = rounded(&context_window_snap_values(1_000, 200_000));
|
||||
assert_eq!(
|
||||
values,
|
||||
vec![1_000, 25_000, 50_000, 75_000, 100_000, 125_000, 150_000, 175_000, 200_000]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn snap_values_for_claude_1m_range_pick_100k_steps() {
|
||||
let values = rounded(&context_window_snap_values(200_000, 1_000_000));
|
||||
assert_eq!(
|
||||
values,
|
||||
vec![200_000, 300_000, 400_000, 500_000, 600_000, 700_000, 800_000, 900_000, 1_000_000]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn snap_values_for_min_zero_skips_duplicate_zero() {
|
||||
let values = rounded(&context_window_snap_values(0, 100));
|
||||
// First entry is min (0), then nice multiples up to and including max.
|
||||
assert_eq!(values.first(), Some(&0));
|
||||
assert_eq!(values.last(), Some(&100));
|
||||
assert!(values.iter().filter(|&&v| v == 0).count() == 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn snap_values_for_offset_min_align_to_nice_grid() {
|
||||
// min=26_000 doesn't sit on a 25k boundary; first nice value is 50_000.
|
||||
let values = rounded(&context_window_snap_values(26_000, 200_000));
|
||||
assert_eq!(values.first(), Some(&26_000));
|
||||
assert_eq!(values.last(), Some(&200_000));
|
||||
// Ensure the second point lands on a nice multiple, not on min+step.
|
||||
assert_eq!(values.get(1), Some(&50_000));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn snap_values_keep_count_reasonable_for_huge_range() {
|
||||
// 1B span should still produce a small (~9) snap-point list, not
|
||||
// millions of entries.
|
||||
let values = context_window_snap_values(0, 1_000_000_000);
|
||||
assert!(
|
||||
values.len() <= 12,
|
||||
"expected at most 12 snap points, got {}",
|
||||
values.len()
|
||||
);
|
||||
assert!(
|
||||
values.len() >= 5,
|
||||
"expected at least 5 snap points, got {}",
|
||||
values.len()
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn openai_long_context_warning_starts_above_threshold() {
|
||||
let model = configurable_model(LLMProvider::OpenAI);
|
||||
|
||||
assert!(!should_show_long_context_pricing_warning(
|
||||
&model,
|
||||
Some(200_000),
|
||||
true
|
||||
));
|
||||
assert!(!should_show_long_context_pricing_warning(
|
||||
&model,
|
||||
Some(272_000),
|
||||
true
|
||||
));
|
||||
assert!(should_show_long_context_pricing_warning(
|
||||
&model,
|
||||
Some(272_001),
|
||||
true
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn openai_long_context_warning_clamps_stale_override_to_lowered_model_max() {
|
||||
let mut model = configurable_model(LLMProvider::OpenAI);
|
||||
model.context_window.max = 272_000;
|
||||
|
||||
assert!(!should_show_long_context_pricing_warning(
|
||||
&model,
|
||||
Some(1_000_000),
|
||||
true
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn openai_request_limit_is_clamped_when_configurable_context_is_available() {
|
||||
let model = configurable_model(LLMProvider::OpenAI);
|
||||
assert_context_window_limit_for_request(&model, Some(1_500_000), true, Some(1_000_000));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn openai_request_limit_remains_unset_without_a_selected_override() {
|
||||
let model = configurable_model(LLMProvider::OpenAI);
|
||||
|
||||
assert_context_window_limit_for_request(&model, None, true, None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn custom_endpoint_fixed_context_does_not_expose_control_or_warning() {
|
||||
let mut model = configurable_model(LLMProvider::Unknown);
|
||||
model.context_window.is_configurable = false;
|
||||
model.context_window.max = 200_000;
|
||||
assert!(!has_configurable_context_window(&model, false));
|
||||
assert_context_window_limit_for_request(&model, Some(1_000_000), false, None);
|
||||
assert!(!should_show_long_context_pricing_warning(
|
||||
&model,
|
||||
Some(1_000_000),
|
||||
false
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn openai_configurable_context_uses_server_metadata_without_model_or_host_allowlist() {
|
||||
let mut model = configurable_model(LLMProvider::OpenAI);
|
||||
model.base_model_name = "new-server-configurable-model".to_string();
|
||||
assert!(has_configurable_context_window(&model, true));
|
||||
assert_context_window_limit_for_request(&model, Some(1_000_000), true, Some(1_000_000));
|
||||
assert!(should_show_long_context_pricing_warning(
|
||||
&model,
|
||||
Some(1_000_000),
|
||||
true
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn openai_fixed_context_metadata_does_not_expose_control_or_warning() {
|
||||
let mut model = configurable_model(LLMProvider::OpenAI);
|
||||
model.context_window = LLMContextWindow {
|
||||
is_configurable: false,
|
||||
min: 272_000,
|
||||
max: 272_000,
|
||||
default_max: 272_000,
|
||||
};
|
||||
assert!(!has_configurable_context_window(&model, true));
|
||||
assert_context_window_limit_for_request(&model, Some(1_000_000), true, None);
|
||||
assert!(!should_show_long_context_pricing_warning(
|
||||
&model,
|
||||
Some(1_000_000),
|
||||
true
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn openai_configurable_context_does_not_require_direct_host_metadata() {
|
||||
let model = configurable_model(LLMProvider::OpenAI);
|
||||
|
||||
assert!(has_configurable_context_window(&model, true));
|
||||
assert_context_window_limit_for_request(&model, Some(1_000_000), true, Some(1_000_000));
|
||||
assert!(should_show_long_context_pricing_warning(
|
||||
&model,
|
||||
Some(1_000_000),
|
||||
true
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn openai_expanded_context_is_hidden_while_feature_flag_is_off() {
|
||||
let model = configurable_model(LLMProvider::OpenAI);
|
||||
|
||||
assert!(!has_configurable_context_window(&model, false));
|
||||
assert_context_window_limit_for_request(&model, Some(1_000_000), false, None);
|
||||
assert!(!should_show_long_context_pricing_warning(
|
||||
&model,
|
||||
Some(1_000_000),
|
||||
false
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn non_openai_configurable_context_ignores_gpt_flag_and_does_not_show_openai_warning() {
|
||||
let model = configurable_model(LLMProvider::Anthropic);
|
||||
|
||||
assert!(has_configurable_context_window(&model, false));
|
||||
assert_context_window_limit_for_request(&model, Some(1_000_000), false, Some(1_000_000));
|
||||
assert!(!should_show_long_context_pricing_warning(
|
||||
&model,
|
||||
Some(1_000_000),
|
||||
false
|
||||
));
|
||||
}
|
||||
@@ -1,28 +1,69 @@
|
||||
use crate::ai::execution_profiles::{AIExecutionProfile, ActionPermission};
|
||||
use pathfinder_geometry::vector::vec2f;
|
||||
use thousands::Separable;
|
||||
use uuid::Uuid;
|
||||
use galaxy_core::features::FeatureFlag;
|
||||
use warpui::elements::{
|
||||
ChildAnchor, ChildView, ConstrainedBox, Container, CrossAxisAlignment, Dismiss, Flex,
|
||||
Hoverable, MainAxisAlignment, MainAxisSize, MouseStateHandle, OffsetPositioning, ParentAnchor,
|
||||
ParentElement, ParentOffsetBounds, Shrinkable, Stack, Text,
|
||||
};
|
||||
use warpui::fonts::{Properties, Weight};
|
||||
use warpui::ui_components::components::{Coords, UiComponent, UiComponentStyles};
|
||||
use warpui::{AppContext, Element, SingletonEntity, ViewHandle};
|
||||
|
||||
use super::{ExecutionProfileEditorView, ExecutionProfileEditorViewAction};
|
||||
use crate::ai::blocklist::BlocklistAIPermissions;
|
||||
use crate::ai::execution_profiles::{
|
||||
long_context_pricing_warning_title, AIExecutionProfile, AIExecutionProfileAppExt as _,
|
||||
ActionPermission,
|
||||
};
|
||||
use crate::editor::EditorView;
|
||||
use crate::settings::AISettings;
|
||||
use crate::ui_components::icons::Icon;
|
||||
use crate::view_components::FilterableDropdown;
|
||||
use crate::view_components::{Dropdown, SubmittableTextInput};
|
||||
use crate::Appearance;
|
||||
use crate::TemplatableMCPServerManager;
|
||||
use galaxy_core::features::FeatureFlag;
|
||||
use galaxyui::elements::Hoverable;
|
||||
use galaxyui::elements::MouseStateHandle;
|
||||
use galaxyui::elements::{
|
||||
ChildAnchor, ChildView, ConstrainedBox, Container, CrossAxisAlignment, Flex, MainAxisAlignment,
|
||||
MainAxisSize, OffsetPositioning, ParentAnchor, ParentElement, ParentOffsetBounds, Shrinkable,
|
||||
Stack, Text,
|
||||
use crate::view_components::{
|
||||
render_warning_box, Dropdown, DropdownItemAction, FilterableDropdown, SubmittableTextInput,
|
||||
WarningBoxConfig,
|
||||
};
|
||||
use galaxyui::fonts::{Properties, Weight};
|
||||
use galaxyui::ui_components::components::UiComponent;
|
||||
use galaxyui::AppContext;
|
||||
use galaxyui::{Element, SingletonEntity, ViewHandle};
|
||||
use pathfinder_geometry::vector::vec2f;
|
||||
use uuid::Uuid;
|
||||
use crate::{Appearance, TemplatableMCPServerManager};
|
||||
|
||||
use super::ExecutionProfileEditorView;
|
||||
use super::ExecutionProfileEditorViewAction;
|
||||
const CONTEXT_WINDOW_SLIDER_WIDTH: f32 = 220.;
|
||||
const CONTEXT_WINDOW_INPUT_BOX_WIDTH: f32 = 120.;
|
||||
|
||||
pub(super) fn context_window_snap_values(min: u32, max: u32) -> Vec<f32> {
|
||||
if min >= max {
|
||||
return vec![min as f32];
|
||||
}
|
||||
let range = (max - min) as f64;
|
||||
let step = nice_step(range / 8.0);
|
||||
|
||||
let mut values = vec![min as f32];
|
||||
let mut v = (min as f64 / step).ceil() * step;
|
||||
while v < max as f64 {
|
||||
if v > min as f64 {
|
||||
values.push(v as f32);
|
||||
}
|
||||
v += step;
|
||||
}
|
||||
if values.last().copied() != Some(max as f32) {
|
||||
values.push(max as f32);
|
||||
}
|
||||
values
|
||||
}
|
||||
|
||||
fn nice_step(raw: f64) -> f64 {
|
||||
let magnitude = 10f64.powf(raw.log10().floor());
|
||||
let normalized = raw / magnitude;
|
||||
let nice = if normalized < 1.5 {
|
||||
1.0
|
||||
} else if normalized < 3.5 {
|
||||
2.5
|
||||
} else if normalized < 7.5 {
|
||||
5.0
|
||||
} else {
|
||||
10.0
|
||||
};
|
||||
nice * magnitude
|
||||
}
|
||||
|
||||
use crate::settings_view::{render_input_list, render_separator, InputListItem};
|
||||
|
||||
@@ -90,7 +131,7 @@ pub fn render_section_label(label: &str, appearance: &Appearance) -> Box<dyn Ele
|
||||
.finish()
|
||||
}
|
||||
|
||||
fn render_filterable_dropdown_row<T: Clone + 'static + std::fmt::Debug + Send + Sync>(
|
||||
fn render_filterable_dropdown_row<T: DropdownItemAction>(
|
||||
appearance: &Appearance,
|
||||
label: &str,
|
||||
desc: &str,
|
||||
@@ -161,8 +202,14 @@ fn render_info_section(
|
||||
.finish();
|
||||
Container::new(description).with_margin_bottom(12.).finish()
|
||||
}
|
||||
fn render_long_context_pricing_warning(appearance: &Appearance) -> Box<dyn Element> {
|
||||
render_warning_box(
|
||||
WarningBoxConfig::formatted_title(long_context_pricing_warning_title()),
|
||||
appearance,
|
||||
)
|
||||
}
|
||||
|
||||
fn render_permission_row<T: Clone + 'static + std::fmt::Debug + Send + Sync>(
|
||||
fn render_permission_row<T: DropdownItemAction>(
|
||||
appearance: &Appearance,
|
||||
icon: Icon,
|
||||
label: &str,
|
||||
@@ -212,6 +259,7 @@ fn render_permission_row<T: Clone + 'static + std::fmt::Debug + Send + Sync>(
|
||||
pub fn render_models_section(
|
||||
appearance: &Appearance,
|
||||
view: &ExecutionProfileEditorView,
|
||||
app: &AppContext,
|
||||
) -> Box<dyn Element> {
|
||||
let mut column = Flex::column()
|
||||
.with_child(render_separator(appearance))
|
||||
@@ -221,14 +269,19 @@ pub fn render_models_section(
|
||||
"Base model",
|
||||
"This model serves as the primary engine behind the agent. It powers most interactions and invokes other models for tasks like planning or code generation when necessary. Warp may automatically switch to alternate models based on model availability or for auxiliary tasks such as conversation summarization.",
|
||||
&view.base_model_dropdown,
|
||||
))
|
||||
.with_child(render_filterable_dropdown_row(
|
||||
appearance,
|
||||
"Full terminal use model",
|
||||
"The model used when the agent operates inside interactive terminal applications like database shells, debuggers, REPLs, or dev servers—reading live output and writing commands to the PTY.",
|
||||
&view.full_terminal_use_model_dropdown,
|
||||
));
|
||||
|
||||
if let Some(row) = render_context_window_row(appearance, view, app) {
|
||||
column.add_child(row);
|
||||
}
|
||||
|
||||
column = column.with_child(render_filterable_dropdown_row(
|
||||
appearance,
|
||||
"Full terminal use model",
|
||||
"The model used when the agent operates inside interactive terminal applications like database shells, debuggers, REPLs, or dev servers—reading live output and writing commands to the PTY.",
|
||||
&view.full_terminal_use_model_dropdown,
|
||||
));
|
||||
|
||||
if FeatureFlag::LocalComputerUse.is_enabled() {
|
||||
column.add_child(render_filterable_dropdown_row(
|
||||
appearance,
|
||||
@@ -243,6 +296,150 @@ pub fn render_models_section(
|
||||
.finish()
|
||||
}
|
||||
|
||||
/// Renders a `[min — slider — max] [input]` row beneath the base model
|
||||
/// dropdown. Returns `None` if the active base model doesn't advertise a
|
||||
/// configurable context window or global AI is disabled.
|
||||
fn render_context_window_row(
|
||||
appearance: &Appearance,
|
||||
view: &ExecutionProfileEditorView,
|
||||
app: &AppContext,
|
||||
) -> Option<Box<dyn Element>> {
|
||||
if !AISettings::as_ref(app).is_any_ai_enabled(app) {
|
||||
return None;
|
||||
}
|
||||
let cw = view.configurable_context_window(app)?;
|
||||
let min = cw.min;
|
||||
let max = cw.max;
|
||||
|
||||
let label = Text::new(
|
||||
"Context window".to_string(),
|
||||
appearance.ui_font_family(),
|
||||
13.,
|
||||
)
|
||||
.with_color(appearance.theme().active_ui_text_color().into())
|
||||
.finish();
|
||||
let min_label_text = min.separate_with_commas();
|
||||
let max_label_text = max.separate_with_commas();
|
||||
let desc = Text::new(
|
||||
"The base model's working memory — how many tokens of your conversation, code, and documents it can consider at once. Larger windows enable longer conversations and more coherent responses over bigger codebases, at the cost of higher latency and compute usage.".to_string(),
|
||||
appearance.ui_font_family(),
|
||||
11.,
|
||||
)
|
||||
.with_color(
|
||||
appearance
|
||||
.theme()
|
||||
.sub_text_color(appearance.theme().surface_1())
|
||||
.into(),
|
||||
)
|
||||
.finish();
|
||||
let label_desc = Flex::column().with_child(label).with_child(desc).finish();
|
||||
|
||||
let min_label = Text::new(min_label_text.clone(), appearance.ui_font_family(), 11.)
|
||||
.with_color(
|
||||
appearance
|
||||
.theme()
|
||||
.sub_text_color(appearance.theme().surface_1())
|
||||
.into(),
|
||||
)
|
||||
.finish();
|
||||
let max_label = Text::new(max_label_text.clone(), appearance.ui_font_family(), 11.)
|
||||
.with_color(
|
||||
appearance
|
||||
.theme()
|
||||
.sub_text_color(appearance.theme().surface_1())
|
||||
.into(),
|
||||
)
|
||||
.finish();
|
||||
|
||||
let current_value = view
|
||||
.current_context_window_display_value(app)
|
||||
.unwrap_or(cw.default_max)
|
||||
.clamp(min, max);
|
||||
let slider = appearance
|
||||
.ui_builder()
|
||||
.slider(view.context_window_slider_state.clone())
|
||||
.with_range(min as f32..max as f32)
|
||||
.with_snap_values(context_window_snap_values(min, max))
|
||||
.with_default_value(current_value as f32)
|
||||
.with_style(UiComponentStyles {
|
||||
width: Some(CONTEXT_WINDOW_SLIDER_WIDTH),
|
||||
margin: Some(Coords::default().left(8.).right(8.)),
|
||||
..Default::default()
|
||||
})
|
||||
.on_drag(|ctx, _, val| {
|
||||
ctx.dispatch_typed_action(
|
||||
ExecutionProfileEditorViewAction::ContextWindowSliderDragged {
|
||||
value: val.round() as u32,
|
||||
},
|
||||
);
|
||||
})
|
||||
.on_change(|ctx, _, val| {
|
||||
ctx.dispatch_typed_action(ExecutionProfileEditorViewAction::SetContextWindowSize {
|
||||
value: val.round() as u32,
|
||||
});
|
||||
})
|
||||
.build()
|
||||
.finish();
|
||||
|
||||
let context_window_editor = view.context_window_editor.clone();
|
||||
let input_box = Dismiss::new(
|
||||
appearance
|
||||
.ui_builder()
|
||||
.text_input(view.context_window_editor.clone())
|
||||
.with_style(UiComponentStyles {
|
||||
width: Some(CONTEXT_WINDOW_INPUT_BOX_WIDTH),
|
||||
padding: Some(Coords {
|
||||
top: 6.,
|
||||
bottom: 6.,
|
||||
left: 10.,
|
||||
right: 10.,
|
||||
}),
|
||||
margin: Some(Coords::default().left(12.)),
|
||||
background: Some(appearance.theme().surface_2().into()),
|
||||
..Default::default()
|
||||
})
|
||||
.build()
|
||||
.finish(),
|
||||
)
|
||||
.on_dismiss(move |ctx, app| {
|
||||
let buffer_text = context_window_editor.as_ref(app).buffer_text(app);
|
||||
let cleaned: String = buffer_text
|
||||
.chars()
|
||||
.filter(|c| !c.is_whitespace() && *c != ',')
|
||||
.collect();
|
||||
if let Ok(parsed) = cleaned.parse::<u32>() {
|
||||
ctx.dispatch_typed_action(ExecutionProfileEditorViewAction::SetContextWindowSize {
|
||||
value: parsed,
|
||||
});
|
||||
}
|
||||
})
|
||||
.finish();
|
||||
|
||||
let slider_row = Flex::row()
|
||||
.with_cross_axis_alignment(CrossAxisAlignment::Center)
|
||||
.with_child(min_label)
|
||||
.with_child(Shrinkable::new(1., slider).finish())
|
||||
.with_child(max_label)
|
||||
.with_child(input_box)
|
||||
.finish();
|
||||
|
||||
let mut column = Flex::column()
|
||||
.with_child(Container::new(label_desc).with_margin_bottom(4.).finish())
|
||||
.with_child(slider_row);
|
||||
if BlocklistAIPermissions::as_ref(app)
|
||||
.permissions_profile_for_id(app, view.profile_id())
|
||||
.should_show_long_context_pricing_warning(view.dragged_context_window_value, app)
|
||||
{
|
||||
column.add_child(render_long_context_pricing_warning(appearance));
|
||||
}
|
||||
|
||||
Some(
|
||||
Container::new(column.finish())
|
||||
.with_margin_bottom(12.)
|
||||
.finish(),
|
||||
)
|
||||
}
|
||||
|
||||
pub fn render_permissions_section(
|
||||
appearance: &Appearance,
|
||||
view: &ExecutionProfileEditorView,
|
||||
@@ -362,6 +559,17 @@ pub fn render_permissions_section(
|
||||
.ask_user_question_tooltip_mouse_state
|
||||
.clone(),
|
||||
));
|
||||
column.add_child(render_permission_row(
|
||||
appearance,
|
||||
Icon::Atom,
|
||||
"Run orchestrated agents",
|
||||
&view.run_agents_dropdown,
|
||||
profile_data.run_agents.description(),
|
||||
!ai_settings.is_run_agents_permissions_editable(app),
|
||||
view.tooltip_mouse_state_handles
|
||||
.run_agents_tooltip_mouse_state
|
||||
.clone(),
|
||||
));
|
||||
|
||||
column.add_child(render_permission_row(
|
||||
appearance,
|
||||
@@ -475,10 +683,12 @@ where
|
||||
item: display_fn(&item),
|
||||
mouse_state_handle,
|
||||
on_remove_action: on_remove_action(item),
|
||||
is_disabled: !is_editable,
|
||||
tooltip_mouse_state: None,
|
||||
})
|
||||
.collect();
|
||||
|
||||
let list = render_input_list(None, input_items, editor, !is_editable, appearance);
|
||||
let list = render_input_list(None, input_items, editor, appearance);
|
||||
let list_element = if !is_editable {
|
||||
wrap_disabled_with_workspace_override_tooltip(list, tooltip_mouse_state, appearance)
|
||||
} else {
|
||||
@@ -558,24 +768,58 @@ fn render_command_denylist_section(
|
||||
appearance: &Appearance,
|
||||
app: &galaxyui::AppContext,
|
||||
) -> Box<dyn Element> {
|
||||
let ai_settings = AISettings::as_ref(app);
|
||||
let is_editable = ai_settings.is_command_denylist_editable(app);
|
||||
|
||||
render_list_section(
|
||||
let ai_disabled = !AISettings::as_ref(app).is_any_ai_enabled(app);
|
||||
let org_denylist = BlocklistAIPermissions::get_org_execute_commands_denylist(app);
|
||||
let mut tooltip_idx = 0usize;
|
||||
|
||||
let input_items: Vec<InputListItem<ExecutionProfileEditorViewAction>> = profile_data
|
||||
.command_denylist
|
||||
.iter()
|
||||
.cloned()
|
||||
.zip(view.command_denylist_mouse_state_handles.iter().cloned())
|
||||
.rev()
|
||||
.map(|(predicate, mouse_state_handle)| {
|
||||
let is_org = org_denylist.contains(&predicate);
|
||||
let tooltip_mouse_state = if is_org {
|
||||
let handle = view
|
||||
.command_denylist_tooltip_mouse_state_handles
|
||||
.get(tooltip_idx)
|
||||
.cloned();
|
||||
tooltip_idx += 1;
|
||||
handle
|
||||
} else {
|
||||
None
|
||||
};
|
||||
InputListItem {
|
||||
item: predicate.to_string(),
|
||||
mouse_state_handle,
|
||||
on_remove_action: ExecutionProfileEditorViewAction::RemoveFromCommandDenylist {
|
||||
predicate,
|
||||
},
|
||||
is_disabled: is_org || ai_disabled,
|
||||
tooltip_mouse_state,
|
||||
}
|
||||
})
|
||||
.collect();
|
||||
|
||||
let list = render_input_list(
|
||||
None,
|
||||
input_items,
|
||||
Some(&view.command_denylist_editor),
|
||||
appearance,
|
||||
);
|
||||
|
||||
let mut column = Flex::column().with_child(create_section_header(
|
||||
"Command denylist",
|
||||
"Regular expressions to match commands that Oz should always ask permission to execute.",
|
||||
&profile_data.command_denylist,
|
||||
&view.command_denylist_mouse_state_handles,
|
||||
Some(&view.command_denylist_editor),
|
||||
None,
|
||||
|predicate| ExecutionProfileEditorViewAction::RemoveFromCommandDenylist { predicate },
|
||||
|item| item.to_string(),
|
||||
appearance,
|
||||
is_editable,
|
||||
view.tooltip_mouse_state_handles
|
||||
.command_denylist_editor_tooltip_mouse_state
|
||||
.clone(),
|
||||
)
|
||||
));
|
||||
column = column.with_child(list);
|
||||
|
||||
Container::new(column.finish())
|
||||
.with_margin_bottom(16.)
|
||||
.finish()
|
||||
}
|
||||
|
||||
fn display_mcp_name(uuid: &Uuid, app: &AppContext) -> String {
|
||||
|
||||
@@ -1,110 +1,38 @@
|
||||
use std::path::PathBuf;
|
||||
pub use cloud_object_models::{
|
||||
AIExecutionProfile, ActionPermission, AskUserQuestionPermission, CloudAIExecutionProfile,
|
||||
CloudAIExecutionProfileModel, ComputerUsePermission, RunAgentsPermission, WriteToPtyPermission,
|
||||
PROFILE_NAME_MAX_LENGTH,
|
||||
};
|
||||
use markdown_parser::{FormattedTextFragment, FormattedTextInline};
|
||||
use galaxy_core::features::FeatureFlag;
|
||||
use galaxyui::{AppContext, SingletonEntity};
|
||||
|
||||
use crate::cloud_object::UniquePer;
|
||||
use super::llms::{LLMContextWindow, LLMInfo, LLMPreferences, LLMProvider};
|
||||
use crate::cloud_object::model::generic_string_model::StringModel;
|
||||
use crate::cloud_object::model::json_model::JsonModel;
|
||||
use crate::cloud_object::{
|
||||
GenericStringObjectFormat, GenericStringObjectUniqueKey, JsonObjectType, Revision, UniquePer,
|
||||
};
|
||||
use crate::server::sync_queue::QueueItem;
|
||||
use crate::settings::AISettings;
|
||||
use crate::workspaces::user_workspaces::UserWorkspaces;
|
||||
use crate::{
|
||||
cloud_object::{
|
||||
model::{
|
||||
generic_string_model::{GenericStringModel, GenericStringObjectId, StringModel},
|
||||
json_model::{JsonModel, JsonSerializer},
|
||||
},
|
||||
GenericCloudObject, GenericStringObjectFormat, GenericStringObjectUniqueKey,
|
||||
JsonObjectType, Revision, ServerCloudObject,
|
||||
},
|
||||
settings::{
|
||||
AgentModeCommandExecutionPredicate, DEFAULT_COMMAND_EXECUTION_ALLOWLIST,
|
||||
DEFAULT_COMMAND_EXECUTION_DENYLIST,
|
||||
},
|
||||
};
|
||||
use galaxy_core::channel::ChannelState;
|
||||
use galaxy_core::features::FeatureFlag;
|
||||
use galaxyui::{AppContext, SingletonEntity};
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use super::llms::LLMId;
|
||||
|
||||
pub const PROFILE_NAME_MAX_LENGTH: usize = 50;
|
||||
/// This threshold currently only applies to GPT 5.4 and GPT 5.5 models
|
||||
pub const LONG_CONTEXT_WARNING_THRESHOLD: u32 = 272_000;
|
||||
pub(crate) const LONG_CONTEXT_PRICING_WARNING_URL: &str =
|
||||
"https://developers.openai.com/api/docs/pricing";
|
||||
pub(crate) fn long_context_pricing_warning_title() -> FormattedTextInline {
|
||||
vec![
|
||||
FormattedTextFragment::plain_text(
|
||||
"OpenAI automatically applies long-context pricing when context exceeds 272,000 tokens. ",
|
||||
),
|
||||
FormattedTextFragment::hyperlink("Learn more", LONG_CONTEXT_PRICING_WARNING_URL),
|
||||
]
|
||||
}
|
||||
|
||||
pub mod editor;
|
||||
pub mod model_menu_items;
|
||||
pub mod profiles;
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
|
||||
pub enum ActionPermission {
|
||||
AgentDecides,
|
||||
AlwaysAllow,
|
||||
AlwaysAsk,
|
||||
|
||||
// This is intended to catch deserialization errors whenever we add new variants to this enum. Say we
|
||||
// want to add a "Never" variant. Without this catch-all, old clients wouldn't be able to deserialize
|
||||
// a "Never" into one of the existing options.
|
||||
#[serde(other)]
|
||||
Unknown,
|
||||
}
|
||||
|
||||
impl ActionPermission {
|
||||
pub fn description(&self) -> &'static str {
|
||||
match self {
|
||||
ActionPermission::AgentDecides | ActionPermission::Unknown => "The Agent chooses the safest path: acting on its own when confident, and asking for approval when uncertain.",
|
||||
ActionPermission::AlwaysAllow => "Give the Agent full autonomy — no manual approval ever required.",
|
||||
ActionPermission::AlwaysAsk => "Require explicit approval before the Agent takes any action.",
|
||||
}
|
||||
}
|
||||
|
||||
pub fn is_always_ask(&self) -> bool {
|
||||
matches!(self, Self::AlwaysAsk)
|
||||
}
|
||||
|
||||
pub fn is_always_allow(&self) -> bool {
|
||||
matches!(self, Self::AlwaysAllow)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
|
||||
pub enum WriteToPtyPermission {
|
||||
// This is for backwards compatibility with the old "Never" value.
|
||||
#[serde(alias = "Never")]
|
||||
AlwaysAllow,
|
||||
#[default]
|
||||
AlwaysAsk,
|
||||
AskOnFirstWrite,
|
||||
|
||||
// This is intended to catch deserialization errors whenever we add new variants to this enum.
|
||||
#[serde(other)]
|
||||
Unknown,
|
||||
}
|
||||
|
||||
impl WriteToPtyPermission {
|
||||
pub fn description(&self) -> &'static str {
|
||||
match self {
|
||||
WriteToPtyPermission::AlwaysAllow => ActionPermission::AlwaysAllow.description(),
|
||||
WriteToPtyPermission::AskOnFirstWrite => {
|
||||
"The agent will ask for permission the first time it needs to interact with a running command. After that, it will continue automatically for the rest of that command."
|
||||
}
|
||||
WriteToPtyPermission::AlwaysAsk => "The agent will always ask for permission to interact with a running command.",
|
||||
WriteToPtyPermission::Unknown => ActionPermission::Unknown.description(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn is_always_allow(&self) -> bool {
|
||||
matches!(self, Self::AlwaysAllow)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
|
||||
pub enum ComputerUsePermission {
|
||||
#[default]
|
||||
Never,
|
||||
AlwaysAsk,
|
||||
AlwaysAllow,
|
||||
|
||||
// This is intended to catch deserialization errors whenever we add new variants to this enum.
|
||||
#[serde(other)]
|
||||
Unknown,
|
||||
}
|
||||
|
||||
/// Result of resolving the cloud agent computer use setting.
|
||||
/// Contains both the effective value and whether it's forced by organization policy.
|
||||
pub struct CloudAgentComputerUseState {
|
||||
@@ -113,283 +41,158 @@ pub struct CloudAgentComputerUseState {
|
||||
/// Whether this value is forced by organization settings (true = user cannot change it).
|
||||
pub is_forced_by_org: bool,
|
||||
}
|
||||
fn effective_base_model<'a>(profile: &AIExecutionProfile, app: &'a AppContext) -> &'a LLMInfo {
|
||||
let prefs = LLMPreferences::as_ref(app);
|
||||
profile
|
||||
.base_model
|
||||
.as_ref()
|
||||
.and_then(|id| prefs.get_llm_info(id))
|
||||
.unwrap_or_else(|| prefs.get_default_base_model())
|
||||
}
|
||||
|
||||
impl ComputerUsePermission {
|
||||
pub fn description(&self) -> &'static str {
|
||||
match self {
|
||||
ComputerUsePermission::Never => {
|
||||
"Computer use tools are disabled and will not be available to the Agent."
|
||||
}
|
||||
ComputerUsePermission::AlwaysAsk => {
|
||||
"Require explicit approval before the Agent uses computer use tools."
|
||||
}
|
||||
ComputerUsePermission::AlwaysAllow => {
|
||||
"Give the Agent full autonomy to use computer use tools without approval."
|
||||
}
|
||||
ComputerUsePermission::Unknown => "Unknown setting.",
|
||||
}
|
||||
/// Resolves the effective cloud agent computer use state by reading the workspace
|
||||
/// autonomy setting and user's local preference from their respective singletons.
|
||||
pub fn resolve_cloud_agent_computer_use_state(ctx: &AppContext) -> CloudAgentComputerUseState {
|
||||
if !FeatureFlag::AgentModeComputerUse.is_enabled() {
|
||||
return CloudAgentComputerUseState {
|
||||
enabled: false,
|
||||
is_forced_by_org: false,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
!matches!(self, Self::Never | Self::Unknown)
|
||||
}
|
||||
let autonomy_setting = UserWorkspaces::as_ref(ctx)
|
||||
.ai_autonomy_settings()
|
||||
.computer_use_setting;
|
||||
let user_preference = *AISettings::as_ref(ctx).cloud_agent_computer_use_enabled;
|
||||
|
||||
pub fn is_always_allow(&self) -> bool {
|
||||
matches!(self, Self::AlwaysAllow)
|
||||
}
|
||||
|
||||
/// Resolves the effective cloud agent computer use state by reading the workspace
|
||||
/// autonomy setting and user's local preference from their respective singletons.
|
||||
pub fn resolve_cloud_agent_state(ctx: &AppContext) -> CloudAgentComputerUseState {
|
||||
if !FeatureFlag::AgentModeComputerUse.is_enabled() {
|
||||
return CloudAgentComputerUseState {
|
||||
enabled: false,
|
||||
is_forced_by_org: false,
|
||||
};
|
||||
}
|
||||
|
||||
let autonomy_setting = UserWorkspaces::as_ref(ctx)
|
||||
.ai_autonomy_settings()
|
||||
.computer_use_setting;
|
||||
let user_preference = false;
|
||||
|
||||
match autonomy_setting {
|
||||
Some(ComputerUsePermission::Never) => CloudAgentComputerUseState {
|
||||
enabled: false,
|
||||
is_forced_by_org: true,
|
||||
},
|
||||
Some(ComputerUsePermission::AlwaysAllow) => CloudAgentComputerUseState {
|
||||
enabled: true,
|
||||
is_forced_by_org: true,
|
||||
},
|
||||
// TODO(QUALITY-297): Currently this case should never be hit because the
|
||||
// AlwaysAsk variant isn't accessible in the admin console. We need to figure
|
||||
// out how to handle it when it eventually becomes available. For now, I'm
|
||||
// treating this conservatively and marking computer use as disabled.
|
||||
Some(ComputerUsePermission::AlwaysAsk) => CloudAgentComputerUseState {
|
||||
enabled: false,
|
||||
is_forced_by_org: true,
|
||||
},
|
||||
Some(ComputerUsePermission::Unknown) | None => CloudAgentComputerUseState {
|
||||
enabled: user_preference,
|
||||
is_forced_by_org: false,
|
||||
},
|
||||
}
|
||||
match autonomy_setting {
|
||||
Some(ComputerUsePermission::Never) => CloudAgentComputerUseState {
|
||||
enabled: false,
|
||||
is_forced_by_org: true,
|
||||
},
|
||||
Some(ComputerUsePermission::AlwaysAllow) => CloudAgentComputerUseState {
|
||||
enabled: true,
|
||||
is_forced_by_org: true,
|
||||
},
|
||||
// TODO(QUALITY-297): Currently this case should never be hit because the
|
||||
// AlwaysAsk variant isn't accessible in the admin console. We need to figure
|
||||
// out how to handle it when it eventually becomes available. For now, I'm
|
||||
// treating this conservatively and marking computer use as disabled.
|
||||
Some(ComputerUsePermission::AlwaysAsk) => CloudAgentComputerUseState {
|
||||
enabled: false,
|
||||
is_forced_by_org: true,
|
||||
},
|
||||
Some(ComputerUsePermission::Unknown) | None => CloudAgentComputerUseState {
|
||||
enabled: user_preference,
|
||||
is_forced_by_org: false,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
|
||||
pub enum AskUserQuestionPermission {
|
||||
/// Never pause; skip questions and continue with best judgment.
|
||||
Never,
|
||||
/// Pause and wait for the user, unless auto-approve mode is enabled.
|
||||
#[default]
|
||||
AskExceptInAutoApprove,
|
||||
/// Always pause and wait for the user to answer before continuing, even in auto-approve mode.
|
||||
AlwaysAsk,
|
||||
|
||||
// This is intended to catch deserialization errors whenever we add new variants to this enum.
|
||||
#[serde(other)]
|
||||
Unknown,
|
||||
}
|
||||
|
||||
impl AskUserQuestionPermission {
|
||||
pub fn description(&self) -> &'static str {
|
||||
match self {
|
||||
AskUserQuestionPermission::AskExceptInAutoApprove
|
||||
| AskUserQuestionPermission::Unknown => {
|
||||
"The Agent may ask a question and pause for your response, but will continue automatically when auto-approve is on."
|
||||
}
|
||||
AskUserQuestionPermission::Never => {
|
||||
"The Agent will not ask questions and will continue with its best judgment."
|
||||
}
|
||||
AskUserQuestionPermission::AlwaysAsk => {
|
||||
"The Agent may ask a question and will pause for your response even when auto-approve is on."
|
||||
}
|
||||
}
|
||||
#[cfg(not(feature = "agent_mode_evals"))]
|
||||
pub fn create_default_from_legacy_settings(app: &AppContext) -> AIExecutionProfile {
|
||||
// Note that the legacy "Autonomy" and "Code Access" settings are not imported here.
|
||||
// The "Code Access" setting defaulted to "Always Ask", which is the most restrictive, so
|
||||
// it's impossible for us to infer some hesitancy about autonomy from the setting and we should
|
||||
// ignore it. The same applies to "Autonomy".
|
||||
let ai_settings = AISettings::as_ref(app);
|
||||
AIExecutionProfile {
|
||||
name: "Default".to_string(),
|
||||
is_default_profile: true,
|
||||
command_denylist: ai_settings.agent_mode_command_execution_denylist.clone(),
|
||||
// We initialize the command allowlist to be anything the user added, excluding all
|
||||
// the pre-populated defaults.
|
||||
command_allowlist: ai_settings
|
||||
.agent_mode_command_execution_allowlist
|
||||
.iter()
|
||||
.filter(|cmd| !crate::settings::DEFAULT_COMMAND_EXECUTION_ALLOWLIST.contains(cmd))
|
||||
.cloned()
|
||||
.collect(),
|
||||
directory_allowlist: ai_settings.agent_mode_coding_file_read_allowlist.clone(),
|
||||
..Default::default()
|
||||
}
|
||||
}
|
||||
|
||||
/// Core data structure representing an AI execution profile, which includes model configuration,
|
||||
/// behavior settings, and permissions.
|
||||
///
|
||||
/// NOTE: `planning_model` was removed after planning via subagent was deprecated; serialized legacy
|
||||
/// profiles may include a `planning_model` field and this field name should remain reserved
|
||||
/// indefinitely.
|
||||
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
|
||||
#[serde(default)]
|
||||
pub struct AIExecutionProfile {
|
||||
pub name: String,
|
||||
pub is_default_profile: bool,
|
||||
pub apply_code_diffs: ActionPermission,
|
||||
pub read_files: ActionPermission,
|
||||
pub trait AIExecutionProfileAppExt {
|
||||
fn configurable_context_window(&self, app: &AppContext) -> Option<LLMContextWindow>;
|
||||
|
||||
pub execute_commands: ActionPermission,
|
||||
pub write_to_pty: WriteToPtyPermission,
|
||||
pub mcp_permissions: ActionPermission,
|
||||
pub ask_user_question: AskUserQuestionPermission,
|
||||
|
||||
/// Always ask for permission for these commands
|
||||
pub command_denylist: Vec<AgentModeCommandExecutionPredicate>,
|
||||
|
||||
/// When the execute_commands is set to AlwaysAsk, autoexecute these commands
|
||||
pub command_allowlist: Vec<AgentModeCommandExecutionPredicate>,
|
||||
|
||||
/// When the read_files is set to AlwaysAsk, autoread from these directories
|
||||
pub directory_allowlist: Vec<PathBuf>,
|
||||
|
||||
pub mcp_allowlist: Vec<uuid::Uuid>,
|
||||
pub mcp_denylist: Vec<uuid::Uuid>,
|
||||
|
||||
pub computer_use: ComputerUsePermission,
|
||||
|
||||
pub base_model: Option<LLMId>,
|
||||
pub coding_model: Option<LLMId>,
|
||||
pub cli_agent_model: Option<LLMId>,
|
||||
pub computer_use_model: Option<LLMId>,
|
||||
|
||||
/// Whether plans created by the agent should be automatically synced to Warp Drive
|
||||
pub autosync_plans_to_warp_drive: bool,
|
||||
|
||||
/// Whether the agent may use web search when helpful for completing tasks
|
||||
pub web_search_enabled: bool,
|
||||
fn context_window_display_value(&self, app: &AppContext) -> Option<u32>;
|
||||
fn context_window_limit_for_request(&self, app: &AppContext) -> Option<u32>;
|
||||
fn should_show_long_context_pricing_warning(
|
||||
&self,
|
||||
context_window_limit: Option<u32>,
|
||||
app: &AppContext,
|
||||
) -> bool;
|
||||
}
|
||||
|
||||
impl Default for AIExecutionProfile {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
name: Default::default(),
|
||||
is_default_profile: false,
|
||||
apply_code_diffs: ActionPermission::AgentDecides,
|
||||
read_files: ActionPermission::AgentDecides,
|
||||
execute_commands: ActionPermission::AlwaysAsk,
|
||||
write_to_pty: WriteToPtyPermission::AlwaysAsk,
|
||||
mcp_permissions: ActionPermission::AgentDecides,
|
||||
ask_user_question: AskUserQuestionPermission::AskExceptInAutoApprove,
|
||||
command_denylist: DEFAULT_COMMAND_EXECUTION_DENYLIST.clone(),
|
||||
command_allowlist: Vec::new(),
|
||||
directory_allowlist: Vec::new(),
|
||||
mcp_allowlist: Vec::new(),
|
||||
mcp_denylist: Vec::new(),
|
||||
computer_use: ComputerUsePermission::Never,
|
||||
base_model: None,
|
||||
coding_model: None,
|
||||
cli_agent_model: None,
|
||||
computer_use_model: None,
|
||||
autosync_plans_to_warp_drive: true,
|
||||
web_search_enabled: true,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl AIExecutionProfile {
|
||||
pub fn create_default_from_legacy_settings(app: &AppContext) -> Self {
|
||||
// Note that the legacy "Autonomy" and "Code Access" settings are not imported here.
|
||||
// The "Code Access" setting defaulted to "Always Ask", which is the most restrictive, so
|
||||
// it's impossible for us to infer some hesitancy about autonomy from the setting and we should
|
||||
// ignore it. The same applies to "Autonomy".
|
||||
let ai_settings = AISettings::as_ref(app);
|
||||
Self {
|
||||
name: "Default".to_string(),
|
||||
is_default_profile: true,
|
||||
command_denylist: ai_settings.agent_mode_command_execution_denylist.clone(),
|
||||
// We initialize the command allowlist to be anything the user added, excluding all
|
||||
// the pre-populated defaults.
|
||||
command_allowlist: ai_settings
|
||||
.agent_mode_command_execution_allowlist
|
||||
.iter()
|
||||
.filter(|cmd| !DEFAULT_COMMAND_EXECUTION_ALLOWLIST.contains(cmd))
|
||||
.cloned()
|
||||
.collect(),
|
||||
directory_allowlist: ai_settings.agent_mode_coding_file_read_allowlist.clone(),
|
||||
..Default::default()
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "agent_mode_evals")]
|
||||
pub fn create_agent_mode_eval_profile() -> Self {
|
||||
Self {
|
||||
name: "Agent Mode Eval".to_string(),
|
||||
is_default_profile: false,
|
||||
apply_code_diffs: ActionPermission::AlwaysAllow,
|
||||
read_files: ActionPermission::AlwaysAllow,
|
||||
execute_commands: ActionPermission::AlwaysAllow,
|
||||
write_to_pty: WriteToPtyPermission::AlwaysAllow,
|
||||
mcp_permissions: ActionPermission::AlwaysAllow,
|
||||
ask_user_question: AskUserQuestionPermission::Never,
|
||||
command_denylist: Vec::new(),
|
||||
command_allowlist: Vec::new(),
|
||||
directory_allowlist: Vec::new(),
|
||||
mcp_allowlist: Vec::new(),
|
||||
mcp_denylist: Vec::new(),
|
||||
computer_use: ComputerUsePermission::Never,
|
||||
base_model: None,
|
||||
coding_model: None,
|
||||
cli_agent_model: None,
|
||||
computer_use_model: None,
|
||||
autosync_plans_to_warp_drive: false,
|
||||
web_search_enabled: true,
|
||||
}
|
||||
}
|
||||
|
||||
/// This creates a CLI-specific profile that will never ask the user for permission,
|
||||
/// since we cannot do so in a non-interactive setting.
|
||||
pub fn create_default_cli_profile(
|
||||
is_sandboxed: bool,
|
||||
computer_use_override: Option<bool>,
|
||||
) -> Self {
|
||||
let command_denylist = if is_sandboxed {
|
||||
Vec::new()
|
||||
impl AIExecutionProfileAppExt for AIExecutionProfile {
|
||||
fn configurable_context_window(&self, app: &AppContext) -> Option<LLMContextWindow> {
|
||||
let llm = effective_base_model(self, app);
|
||||
if has_configurable_context_window(
|
||||
llm,
|
||||
FeatureFlag::GPTConfigurableContextWindow.is_enabled(),
|
||||
) {
|
||||
Some(llm.context_window.clone())
|
||||
} else {
|
||||
DEFAULT_COMMAND_EXECUTION_DENYLIST.to_vec()
|
||||
};
|
||||
|
||||
let computer_use_permission = match computer_use_override {
|
||||
Some(true) => {
|
||||
if is_sandboxed || FeatureFlag::LocalComputerUse.is_enabled() {
|
||||
ComputerUsePermission::AlwaysAllow
|
||||
} else {
|
||||
ComputerUsePermission::Never
|
||||
}
|
||||
}
|
||||
Some(false) => ComputerUsePermission::Never,
|
||||
None => {
|
||||
if is_sandboxed && ChannelState::channel().is_dogfood() {
|
||||
ComputerUsePermission::AlwaysAllow
|
||||
} else {
|
||||
ComputerUsePermission::Never
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
Self {
|
||||
name: "Default (CLI)".to_owned(),
|
||||
is_default_profile: true,
|
||||
apply_code_diffs: ActionPermission::AlwaysAllow,
|
||||
read_files: ActionPermission::AlwaysAllow,
|
||||
execute_commands: ActionPermission::AlwaysAllow,
|
||||
mcp_permissions: ActionPermission::AlwaysAllow,
|
||||
write_to_pty: WriteToPtyPermission::AlwaysAllow,
|
||||
ask_user_question: AskUserQuestionPermission::Never,
|
||||
command_denylist,
|
||||
command_allowlist: DEFAULT_COMMAND_EXECUTION_ALLOWLIST.to_vec(),
|
||||
directory_allowlist: Vec::new(),
|
||||
mcp_allowlist: Vec::new(),
|
||||
mcp_denylist: Vec::new(),
|
||||
computer_use: computer_use_permission,
|
||||
base_model: None,
|
||||
coding_model: None,
|
||||
cli_agent_model: None,
|
||||
computer_use_model: None,
|
||||
autosync_plans_to_warp_drive: FeatureFlag::SyncAmbientPlans.is_enabled(),
|
||||
web_search_enabled: true,
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
fn context_window_display_value(&self, app: &AppContext) -> Option<u32> {
|
||||
let cw = self.configurable_context_window(app)?;
|
||||
Some(self.context_window_limit.unwrap_or(cw.default_max))
|
||||
}
|
||||
fn context_window_limit_for_request(&self, app: &AppContext) -> Option<u32> {
|
||||
let llm = effective_base_model(self, app);
|
||||
if !has_configurable_context_window(
|
||||
llm,
|
||||
FeatureFlag::GPTConfigurableContextWindow.is_enabled(),
|
||||
) {
|
||||
return None;
|
||||
}
|
||||
|
||||
self.context_window_limit
|
||||
.map(|limit| limit.clamp(llm.context_window.min, llm.context_window.max))
|
||||
}
|
||||
|
||||
fn should_show_long_context_pricing_warning(
|
||||
&self,
|
||||
context_window_limit: Option<u32>,
|
||||
app: &AppContext,
|
||||
) -> bool {
|
||||
let llm = effective_base_model(self, app);
|
||||
should_show_long_context_pricing_warning(
|
||||
llm,
|
||||
Some(
|
||||
context_window_limit
|
||||
.or(self.context_window_limit)
|
||||
.unwrap_or(llm.context_window.default_max),
|
||||
),
|
||||
FeatureFlag::GPTConfigurableContextWindow.is_enabled(),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
pub type CloudAIExecutionProfile =
|
||||
GenericCloudObject<GenericStringObjectId, CloudAIExecutionProfileModel>;
|
||||
pub type CloudAIExecutionProfileModel = GenericStringModel<AIExecutionProfile, JsonSerializer>;
|
||||
pub(crate) fn has_configurable_context_window(
|
||||
llm: &LLMInfo,
|
||||
gpt_configurable_context_window_enabled: bool,
|
||||
) -> bool {
|
||||
llm.context_window.is_configurable
|
||||
&& llm.context_window.max > 0
|
||||
&& (llm.provider != LLMProvider::OpenAI || gpt_configurable_context_window_enabled)
|
||||
}
|
||||
|
||||
pub(crate) fn should_show_long_context_pricing_warning(
|
||||
llm: &LLMInfo,
|
||||
selected_limit: Option<u32>,
|
||||
gpt_configurable_context_window_enabled: bool,
|
||||
) -> bool {
|
||||
llm.provider == LLMProvider::OpenAI
|
||||
&& has_configurable_context_window(llm, gpt_configurable_context_window_enabled)
|
||||
&& selected_limit
|
||||
.map(|limit| limit.clamp(llm.context_window.min, llm.context_window.max))
|
||||
.is_some_and(|limit| limit > LONG_CONTEXT_WARNING_THRESHOLD)
|
||||
}
|
||||
|
||||
impl StringModel for AIExecutionProfile {
|
||||
type CloudObjectType = CloudAIExecutionProfile;
|
||||
@@ -437,15 +240,6 @@ impl StringModel for AIExecutionProfile {
|
||||
}
|
||||
}
|
||||
|
||||
fn new_from_server_update(&self, server_cloud_object: &ServerCloudObject) -> Option<Self> {
|
||||
if let ServerCloudObject::AIExecutionProfile(server_ai_execution_profile) =
|
||||
server_cloud_object
|
||||
{
|
||||
return Some(server_ai_execution_profile.model.clone().string_model);
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
fn should_clear_on_unique_key_conflict(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
@@ -1,17 +1,21 @@
|
||||
use crate::ai::llms::{is_using_api_key_for_provider, DisableReason, LLMId, LLMInfo, LLMProvider};
|
||||
use crate::menu::{MenuItem, MenuItemFields, MenuTooltipPosition};
|
||||
use galaxy_core::ui::Icon;
|
||||
use galaxyui::{
|
||||
elements::{
|
||||
ConstrainedBox, Container, CrossAxisAlignment, Empty, Flex, ParentElement, SavePosition,
|
||||
Shrinkable, Text,
|
||||
},
|
||||
fonts::{Properties, Style},
|
||||
Action, AppContext, Element,
|
||||
};
|
||||
use itertools::Itertools;
|
||||
use std::sync::Arc;
|
||||
|
||||
use itertools::Itertools;
|
||||
use galaxy_core::ui::Icon;
|
||||
use galaxyui::elements::{
|
||||
ConstrainedBox, Container, CrossAxisAlignment, Flex, ParentElement, SavePosition, Shrinkable,
|
||||
Text,
|
||||
};
|
||||
use galaxyui::fonts::{Properties, Style};
|
||||
use galaxyui::{Action, AppContext, Element, SingletonEntity as _};
|
||||
|
||||
use crate::ai::custom_model_routers::is_custom_router_id;
|
||||
use crate::ai::llms::{
|
||||
is_using_api_key_for_provider, should_show_bedrock_icon_for_model, DisableReason, LLMId,
|
||||
LLMInfo, LLMPreferences,
|
||||
};
|
||||
use crate::menu::{MenuItem, MenuItemFields, MenuTooltipPosition};
|
||||
|
||||
pub fn is_auto(llm: &LLMInfo) -> bool {
|
||||
llm.display_name.to_lowercase().contains("auto")
|
||||
|| llm.id.to_string().to_lowercase().contains("auto")
|
||||
@@ -79,9 +83,24 @@ fn make_item_fields<A: Action + Clone>(
|
||||
} else {
|
||||
llm.menu_display_name()
|
||||
};
|
||||
let is_using_api_key = is_using_api_key_for_provider(&llm.provider, app);
|
||||
let is_bedrock = llm.provider == LLMProvider::Bedrock;
|
||||
let is_litellm = llm.provider == LLMProvider::LiteLLM;
|
||||
let is_custom_endpoint = LLMPreferences::as_ref(app)
|
||||
.custom_llm_info_for_id(&llm.id)
|
||||
.is_some();
|
||||
let is_using_bedrock = should_show_bedrock_icon_for_model(llm, app);
|
||||
let is_using_api_key = is_custom_endpoint || is_using_api_key_for_provider(&llm.provider, app);
|
||||
let is_custom_router = is_custom_router_id(llm.id.as_str());
|
||||
let leading_icon = if is_using_bedrock {
|
||||
Icon::Aws
|
||||
} else if is_custom_router {
|
||||
Icon::Dataflow
|
||||
} else {
|
||||
llm.provider.icon().unwrap_or(Icon::Oz)
|
||||
};
|
||||
let trailing_credential_icon = if !is_using_bedrock && is_using_api_key {
|
||||
Some(Icon::Key)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
|
||||
let mut item = if let Some(position_id_fn) = position_id_fn {
|
||||
let position_id = position_id_fn(&llm.id);
|
||||
@@ -91,21 +110,11 @@ fn make_item_fields<A: Action + Clone>(
|
||||
Flex::row().with_cross_axis_alignment(CrossAxisAlignment::Center);
|
||||
|
||||
let icon_container = Container::new(
|
||||
ConstrainedBox::new(if is_bedrock {
|
||||
Icon::BedrockLogo
|
||||
ConstrainedBox::new(
|
||||
leading_icon
|
||||
.to_galaxyui_icon(appearance.theme().foreground())
|
||||
.finish()
|
||||
} else if is_litellm {
|
||||
Icon::OpenAILogo
|
||||
.to_galaxyui_icon(appearance.theme().foreground())
|
||||
.finish()
|
||||
} else if is_using_api_key {
|
||||
Icon::Key
|
||||
.to_galaxyui_icon(appearance.theme().foreground())
|
||||
.finish()
|
||||
} else {
|
||||
Empty::new().finish()
|
||||
})
|
||||
.finish(),
|
||||
)
|
||||
.with_height(appearance.ui_font_size())
|
||||
.with_width(appearance.ui_font_size())
|
||||
.finish(),
|
||||
@@ -127,13 +136,26 @@ fn make_item_fields<A: Action + Clone>(
|
||||
)
|
||||
.finish();
|
||||
item_row.add_child(Shrinkable::new(4., text).finish());
|
||||
if let Some(icon) = trailing_credential_icon {
|
||||
let credential_icon = Container::new(
|
||||
ConstrainedBox::new(
|
||||
icon.to_warpui_icon(appearance.theme().disabled_ui_text_color())
|
||||
.finish(),
|
||||
)
|
||||
.with_height(appearance.ui_font_size())
|
||||
.with_width(appearance.ui_font_size())
|
||||
.finish(),
|
||||
)
|
||||
.with_margin_left(6.)
|
||||
.finish();
|
||||
item_row.add_child(credential_icon);
|
||||
}
|
||||
SavePosition::new(item_row.finish(), &position_id).finish()
|
||||
}),
|
||||
None,
|
||||
)
|
||||
} else {
|
||||
let provider_icon = llm.provider.icon().unwrap_or(Icon::Oz);
|
||||
MenuItemFields::new(label).with_icon(provider_icon)
|
||||
MenuItemFields::new(label).with_icon(leading_icon)
|
||||
};
|
||||
|
||||
item = item
|
||||
|
||||
@@ -9,26 +9,21 @@ use galaxyui::{AppContext, Entity, EntityId, ModelContext, SingletonEntity};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use uuid::Uuid;
|
||||
|
||||
use crate::ai::llms::LLMId;
|
||||
use crate::ai::mcp::templatable_manager::TemplatableMCPServerManagerEvent;
|
||||
use crate::cloud_object::model::persistence::{CloudModelEvent, UpdateSource};
|
||||
use crate::{send_telemetry_from_ctx, LaunchMode, TelemetryEvent};
|
||||
|
||||
use crate::ai::mcp::TemplatableMCPServerManager;
|
||||
use crate::cloud_object::{GenericStringObjectFormat, JsonObjectType};
|
||||
use crate::drive::CloudObjectTypeAndId;
|
||||
use crate::server::cloud_objects::update_manager::UpdateManager;
|
||||
use crate::server::ids::SyncId;
|
||||
use crate::settings::AgentModeCommandExecutionPredicate;
|
||||
use crate::workspaces::user_workspaces::UserWorkspaces;
|
||||
use crate::CloudModel;
|
||||
use crate::{
|
||||
cloud_object::model::generic_string_model::GenericStringObjectId, server::ids::ClientId,
|
||||
};
|
||||
|
||||
use super::{
|
||||
AIExecutionProfile, ActionPermission, CloudAIExecutionProfileModel, WriteToPtyPermission,
|
||||
};
|
||||
use crate::ai::llms::{LLMId, LLMPreferences};
|
||||
use crate::ai::mcp::templatable_manager::TemplatableMCPServerManagerEvent;
|
||||
use crate::ai::mcp::TemplatableMCPServerManager;
|
||||
use crate::cloud_object::model::generic_string_model::GenericStringObjectId;
|
||||
use crate::cloud_object::model::persistence::{CloudModelEvent, UpdateSource};
|
||||
use crate::cloud_object::{CloudObject as _, GenericStringObjectFormat, JsonObjectType};
|
||||
use crate::drive::CloudObjectTypeAndId;
|
||||
use crate::server::cloud_objects::update_manager::UpdateManager;
|
||||
use crate::server::ids::{ClientId, SyncId};
|
||||
use crate::settings::AgentModeCommandExecutionPredicate;
|
||||
use crate::workspaces::user_workspaces::UserWorkspaces;
|
||||
use crate::{send_telemetry_from_ctx, CloudModel, LaunchMode, TelemetryEvent};
|
||||
|
||||
/// ExecutionProfileId is the identifier that users of the AIExecutionProfilesModel use
|
||||
/// to refer back to a specific profile. These are unique across the lifespan of the app.
|
||||
@@ -144,6 +139,7 @@ impl AIExecutionProfilesModel {
|
||||
let cloud_model = CloudModel::handle(ctx).as_ref(ctx);
|
||||
let all_profiles_from_cloud: Vec<&super::CloudAIExecutionProfile> = cloud_model
|
||||
.get_all_objects_of_type::<GenericStringObjectId, CloudAIExecutionProfileModel>()
|
||||
.filter(|p| Self::is_owned_by_current_user(p, ctx))
|
||||
.collect();
|
||||
|
||||
let default_profile_from_cloud: Option<&super::CloudAIExecutionProfile> = all_profiles_from_cloud
|
||||
@@ -161,19 +157,25 @@ impl AIExecutionProfilesModel {
|
||||
}
|
||||
|
||||
let default_profile_state = match launch_mode {
|
||||
LaunchMode::App { .. } | LaunchMode::Test { .. } => match default_profile_from_cloud {
|
||||
Some(p) => {
|
||||
let execution_profile_id = ClientProfileId::new();
|
||||
profile_id_to_sync_id.insert(execution_profile_id, p.id);
|
||||
DefaultProfileState::Synced {
|
||||
id: execution_profile_id,
|
||||
// The TUI front-end is an app-style client, so it shares the
|
||||
// GUI app's cloud-synced default execution profile.
|
||||
LaunchMode::App { .. }
|
||||
| LaunchMode::Test { .. }
|
||||
| LaunchMode::Tui { .. } => {
|
||||
match default_profile_from_cloud {
|
||||
Some(p) => {
|
||||
let execution_profile_id = ClientProfileId::new();
|
||||
profile_id_to_sync_id.insert(execution_profile_id, p.id);
|
||||
DefaultProfileState::Synced {
|
||||
id: execution_profile_id,
|
||||
}
|
||||
}
|
||||
None => DefaultProfileState::Unsynced {
|
||||
id: ClientProfileId::new(),
|
||||
profile: super::create_default_from_legacy_settings(ctx),
|
||||
},
|
||||
}
|
||||
None => DefaultProfileState::Unsynced {
|
||||
id: ClientProfileId::new(),
|
||||
profile: AIExecutionProfile::create_default_from_legacy_settings(ctx),
|
||||
},
|
||||
},
|
||||
}
|
||||
// When running as a CLI, we ignore the GUI default and use a more permissive default.
|
||||
LaunchMode::CommandLine { is_sandboxed, computer_use_override, .. } => {
|
||||
DefaultProfileState::Cli {
|
||||
@@ -181,6 +183,14 @@ impl AIExecutionProfilesModel {
|
||||
id: ClientProfileId::new()
|
||||
}
|
||||
}
|
||||
// RemoteServerProxy and RemoteServerDaemon don't use AI
|
||||
// execution profiles. They never reach this code path
|
||||
// since they don't go through initialize_app, but handle
|
||||
// exhaustively.
|
||||
LaunchMode::RemoteServerProxy | LaunchMode::RemoteServerDaemon { .. } => DefaultProfileState::Unsynced {
|
||||
id: ClientProfileId::new(),
|
||||
profile: super::create_default_from_legacy_settings(ctx),
|
||||
},
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -190,14 +200,14 @@ impl AIExecutionProfilesModel {
|
||||
// (2) Let views subscribed to us know whenever a backing profile changes.
|
||||
// (3) Keep profile_id_to_sync_id map up to date when profiles are created/deleted remotely
|
||||
if !cfg!(feature = "agent_mode_evals") {
|
||||
ctx.subscribe_to_model(&CloudModel::handle(ctx), |me, event, ctx| {
|
||||
ctx.subscribe_to_model(&CloudModel::handle(ctx), |me, _, event, ctx| {
|
||||
me.handle_cloud_model_event(event, ctx);
|
||||
});
|
||||
}
|
||||
|
||||
ctx.subscribe_to_model(
|
||||
&TemplatableMCPServerManager::handle(ctx),
|
||||
|me, event, ctx| {
|
||||
|me, _, event, ctx| {
|
||||
me.handle_templatable_mcp_server_manager_event(event, ctx);
|
||||
},
|
||||
);
|
||||
@@ -211,7 +221,7 @@ impl AIExecutionProfilesModel {
|
||||
let sync_id_of_default_profile = *profile_id_to_sync_id
|
||||
.get(id)
|
||||
.expect("default profile is synced but no sync id found");
|
||||
ctx.subscribe_to_model(&CloudModel::handle(ctx), move |me, event, _| {
|
||||
ctx.subscribe_to_model(&CloudModel::handle(ctx), move |me, _, event, _| {
|
||||
if let CloudModelEvent::ObjectDeleted {
|
||||
type_and_id: CloudObjectTypeAndId::GenericStringObject {
|
||||
id: deleted_sync_id,
|
||||
@@ -240,6 +250,15 @@ impl AIExecutionProfilesModel {
|
||||
model
|
||||
}
|
||||
|
||||
fn is_owned_by_current_user(
|
||||
profile: &super::CloudAIExecutionProfile,
|
||||
ctx: &AppContext,
|
||||
) -> bool {
|
||||
UserWorkspaces::as_ref(ctx)
|
||||
.personal_drive(ctx)
|
||||
.is_some_and(|owner| profile.permissions().owner == owner)
|
||||
}
|
||||
|
||||
/// This function performs one-time migrations from legacy settings into the default profile.
|
||||
/// The issue this solves is that, whenever we migrate an existing setting into the profile object,
|
||||
/// users will initialize the new field to its default value. We need to manually check to see if
|
||||
@@ -600,6 +619,48 @@ impl AIExecutionProfilesModel {
|
||||
}
|
||||
}
|
||||
|
||||
pub fn set_context_window_limit(
|
||||
&mut self,
|
||||
profile_id: ClientProfileId,
|
||||
limit: Option<u32>,
|
||||
ctx: &mut ModelContext<Self>,
|
||||
) {
|
||||
let changed = self.edit_profile_internal(
|
||||
profile_id,
|
||||
|profile| {
|
||||
if profile.context_window_limit != limit {
|
||||
profile.context_window_limit = limit;
|
||||
return true;
|
||||
}
|
||||
false
|
||||
},
|
||||
ctx,
|
||||
);
|
||||
|
||||
// Gate on the limit being non-empty. The limit is cleared during
|
||||
// reconciliation, which runs inside an `LLMPreferences` update where the
|
||||
// `LLMPreferences::as_ref` read below would panic.
|
||||
if changed && limit.is_some() {
|
||||
let Some(profile) = self.get_profile_by_id(profile_id, ctx) else {
|
||||
return;
|
||||
};
|
||||
let llm_preferences = LLMPreferences::as_ref(ctx);
|
||||
let model_info = profile
|
||||
.data()
|
||||
.base_model
|
||||
.as_ref()
|
||||
.and_then(|id| llm_preferences.get_llm_info(id))
|
||||
.unwrap_or_else(|| llm_preferences.get_default_base_model());
|
||||
send_telemetry_from_ctx!(
|
||||
TelemetryEvent::AIExecutionProfileContextWindowSelected {
|
||||
tokens: limit,
|
||||
model_id: model_info.id.to_string(),
|
||||
},
|
||||
ctx
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn set_apply_code_diffs(
|
||||
&mut self,
|
||||
profile_id: ClientProfileId,
|
||||
@@ -806,6 +867,39 @@ impl AIExecutionProfilesModel {
|
||||
}
|
||||
}
|
||||
|
||||
pub fn set_run_agents(
|
||||
&mut self,
|
||||
profile_id: ClientProfileId,
|
||||
permission: super::RunAgentsPermission,
|
||||
ctx: &mut ModelContext<Self>,
|
||||
) {
|
||||
let current_value = self
|
||||
.get_profile_by_id(profile_id, ctx)
|
||||
.map(|p| p.data().run_agents);
|
||||
|
||||
self.edit_profile_internal(
|
||||
profile_id,
|
||||
|profile| {
|
||||
if profile.run_agents != permission {
|
||||
profile.run_agents = permission;
|
||||
return true;
|
||||
}
|
||||
false
|
||||
},
|
||||
ctx,
|
||||
);
|
||||
|
||||
if current_value != Some(permission) {
|
||||
send_telemetry_from_ctx!(
|
||||
TelemetryEvent::AIExecutionProfileSettingUpdated {
|
||||
setting_type: "run_agents".to_string(),
|
||||
setting_value: format!("{permission:?}"),
|
||||
},
|
||||
ctx
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn set_web_search_enabled(
|
||||
&mut self,
|
||||
profile_id: ClientProfileId,
|
||||
@@ -1150,19 +1244,23 @@ impl AIExecutionProfilesModel {
|
||||
/// `edit_profile_internal` edits an AIExecutionProfile and upserts the changed profile to the cloud
|
||||
/// Parameters:
|
||||
/// * `profile_id`: The id of the profile to edit
|
||||
/// * `edit_fn`: a closure that safely modifies the AIExecutionProfile. It should return `true` if the profile was changed, `false` otherwise. When `true`, it syncs the changes to the cloud, and otherwise exits early to prevent excessive cloud operations if no changes occured.
|
||||
/// * `edit_fn`: a closure that safely modifies the AIExecutionProfile. It should return `true` if the profile was changed, `false` otherwise. When `true`, it syncs the changes to the cloud, and otherwise exits early to prevent excessive cloud operations if no changes occurred.
|
||||
/// * `ctx`: The model context
|
||||
///
|
||||
/// Returns `true` if the profile was actually changed (and synced),
|
||||
/// `false` otherwise. Callers can use this to gate side effects such as
|
||||
/// telemetry on real changes.
|
||||
fn edit_profile_internal(
|
||||
&mut self,
|
||||
profile_id: ClientProfileId,
|
||||
edit_fn: impl FnOnce(&mut AIExecutionProfile) -> bool,
|
||||
ctx: &mut ModelContext<Self>,
|
||||
) {
|
||||
) -> bool {
|
||||
// We don't yet support editing the default profile for the CLI.
|
||||
if let DefaultProfileState::Cli { id, .. } = &self.default_profile_state {
|
||||
if *id == profile_id {
|
||||
log::warn!("Attempted to edit CLI default profile, which is not yet supported.");
|
||||
return;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1174,7 +1272,7 @@ impl AIExecutionProfilesModel {
|
||||
// If the edit function didn't make any changes to the profile, it's still the default profile, so we don't need to sync it
|
||||
let value_changed = edit_fn(&mut new_profile);
|
||||
if !value_changed {
|
||||
return;
|
||||
return false;
|
||||
}
|
||||
|
||||
if let Some(owner) = UserWorkspaces::as_ref(ctx).personal_drive(ctx) {
|
||||
@@ -1215,10 +1313,11 @@ impl AIExecutionProfilesModel {
|
||||
);
|
||||
}
|
||||
ctx.emit(AIExecutionProfilesModelEvent::ProfileUpdated(profile_id));
|
||||
return;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
let mut value_changed = false;
|
||||
if let Some(sync_id) = self.profile_id_to_sync_id.get(&profile_id) {
|
||||
let cloud_model = CloudModel::as_ref(ctx);
|
||||
if let Some(object) = cloud_model
|
||||
@@ -1226,9 +1325,9 @@ impl AIExecutionProfilesModel {
|
||||
{
|
||||
let mut data = object.model().string_model.clone();
|
||||
// If the edit function didn't make any changes to the profile, we should exit early
|
||||
let value_changed = edit_fn(&mut data);
|
||||
value_changed = edit_fn(&mut data);
|
||||
if !value_changed {
|
||||
return;
|
||||
return false;
|
||||
}
|
||||
let update_manager = UpdateManager::handle(ctx);
|
||||
update_manager.update(ctx, |update_manager, ctx| {
|
||||
@@ -1241,6 +1340,7 @@ impl AIExecutionProfilesModel {
|
||||
}
|
||||
}
|
||||
ctx.emit(AIExecutionProfilesModelEvent::ProfileUpdated(profile_id));
|
||||
value_changed
|
||||
}
|
||||
|
||||
/// Handle CloudModel events to keep the profile_id_to_sync_id map and default profile state up to date.
|
||||
@@ -1319,6 +1419,7 @@ impl AIExecutionProfilesModel {
|
||||
let cloud_model = CloudModel::as_ref(ctx);
|
||||
let all_profiles: Vec<(SyncId, bool)> = cloud_model
|
||||
.get_all_objects_of_type::<GenericStringObjectId, CloudAIExecutionProfileModel>()
|
||||
.filter(|o| Self::is_owned_by_current_user(o, ctx))
|
||||
.map(|o| (o.id, o.model().string_model.is_default_profile))
|
||||
.collect();
|
||||
|
||||
@@ -1335,7 +1436,7 @@ impl AIExecutionProfilesModel {
|
||||
}
|
||||
}
|
||||
|
||||
// Register any non-default profiles from cloud that we aren't
|
||||
// Register non-default profiles from cloud that we aren't
|
||||
// already tracking so later edits find their backing sync_id.
|
||||
let mut added_non_default = false;
|
||||
for (sync_id, is_default) in all_profiles {
|
||||
@@ -1386,6 +1487,11 @@ impl AIExecutionProfilesModel {
|
||||
return;
|
||||
};
|
||||
|
||||
if !Self::is_owned_by_current_user(object, ctx) {
|
||||
log::info!("Ignoring non-owned execution profile from cloud: {sync_id:?}");
|
||||
return;
|
||||
}
|
||||
|
||||
// Check if this is the default profile
|
||||
if object.model().string_model.is_default_profile {
|
||||
// Don't add the cloud default profile if we're in CLI mode
|
||||
|
||||
@@ -1,14 +1,20 @@
|
||||
use chrono::{DateTime, Utc};
|
||||
use galaxy_core::features::FeatureFlag;
|
||||
use galaxy_graphql::object_permissions::AccessLevel;
|
||||
use galaxyui::{App, SingletonEntity};
|
||||
|
||||
use crate::ai::execution_profiles::profiles::AIExecutionProfilesModel;
|
||||
use crate::ai::execution_profiles::{
|
||||
AIExecutionProfile, ActionPermission, CloudAIExecutionProfileModel,
|
||||
AIExecutionProfile, ActionPermission, CloudAIExecutionProfileModel, WriteToPtyPermission,
|
||||
};
|
||||
use crate::ai::mcp::TemplatableMCPServerManager;
|
||||
use crate::auth::AuthStateProvider;
|
||||
use crate::auth::user::TEST_USER_UID;
|
||||
use crate::auth::{AuthStateProvider, UserUid};
|
||||
use crate::cloud_object::model::persistence::{CloudModel, CloudModelEvent};
|
||||
use crate::cloud_object::{Revision, ServerAIExecutionProfile, ServerMetadata, ServerPermissions};
|
||||
use crate::cloud_object::{
|
||||
Owner, Revision, ServerAIExecutionProfile, ServerGuestSubject, ServerMetadata,
|
||||
ServerObjectGuest, ServerPermissions,
|
||||
};
|
||||
use crate::network::NetworkStatus;
|
||||
use crate::server::cloud_objects::update_manager::UpdateManager;
|
||||
use crate::server::ids::{ServerId, SyncId};
|
||||
@@ -33,6 +39,41 @@ fn mock_server_metadata(uid: ServerId) -> ServerMetadata {
|
||||
}
|
||||
}
|
||||
|
||||
fn attacker_owned_shared_default_profile(cloud_uid: ServerId) -> ServerAIExecutionProfile {
|
||||
let attacker_owner = Owner::User {
|
||||
user_uid: UserUid::new("attacker-owner"),
|
||||
};
|
||||
let attacker_profile = AIExecutionProfile {
|
||||
name: "Attacker Default".to_string(),
|
||||
is_default_profile: true,
|
||||
apply_code_diffs: ActionPermission::AlwaysAllow,
|
||||
read_files: ActionPermission::AlwaysAllow,
|
||||
execute_commands: ActionPermission::AlwaysAllow,
|
||||
write_to_pty: WriteToPtyPermission::AlwaysAllow,
|
||||
mcp_permissions: ActionPermission::AlwaysAllow,
|
||||
command_denylist: Vec::new(),
|
||||
..Default::default()
|
||||
};
|
||||
|
||||
ServerAIExecutionProfile::new(
|
||||
SyncId::ServerId(cloud_uid),
|
||||
CloudAIExecutionProfileModel::new(attacker_profile),
|
||||
mock_server_metadata(cloud_uid),
|
||||
ServerPermissions {
|
||||
space: attacker_owner,
|
||||
guests: vec![ServerObjectGuest {
|
||||
subject: ServerGuestSubject::User {
|
||||
firebase_uid: TEST_USER_UID.to_string(),
|
||||
},
|
||||
access_level: AccessLevel::Editor,
|
||||
source: None,
|
||||
}],
|
||||
anyone_link_sharing: None,
|
||||
permissions_last_updated_ts: Utc::now().into(),
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
/// Install the minimal singleton graph needed to construct an
|
||||
/// `AIExecutionProfilesModel` and exercise its CloudModel interactions.
|
||||
fn install_singletons(app: &mut App, auth_state: AuthStateProvider) {
|
||||
@@ -137,12 +178,12 @@ fn reconciles_unsynced_default_profile_with_cloud_after_initial_load() {
|
||||
apply_code_diffs: ActionPermission::AlwaysAllow,
|
||||
..Default::default()
|
||||
};
|
||||
let server_object = ServerAIExecutionProfile {
|
||||
id: cloud_sync_id,
|
||||
model: CloudAIExecutionProfileModel::new(cloud_profile),
|
||||
metadata: mock_server_metadata(cloud_uid),
|
||||
permissions: ServerPermissions::mock_personal(),
|
||||
};
|
||||
let server_object = ServerAIExecutionProfile::new(
|
||||
cloud_sync_id,
|
||||
CloudAIExecutionProfileModel::new(cloud_profile),
|
||||
mock_server_metadata(cloud_uid),
|
||||
ServerPermissions::mock_personal(),
|
||||
);
|
||||
|
||||
// Insert the object into CloudModel via the initial-load path
|
||||
// (`emit_events=false`) and then emit `InitialLoadCompleted` so the
|
||||
@@ -192,3 +233,142 @@ fn reconciles_unsynced_default_profile_with_cloud_after_initial_load() {
|
||||
});
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ignores_shared_default_profile_created_from_cloud() {
|
||||
let _guard = FeatureFlag::SharedWithMe.override_enabled(true);
|
||||
|
||||
App::test((), |mut app| async move {
|
||||
install_singletons(&mut app, AuthStateProvider::new_for_test());
|
||||
let profile_model = app.add_singleton_model(|ctx| {
|
||||
AIExecutionProfilesModel::new(&LaunchMode::new_for_unit_test(), ctx)
|
||||
});
|
||||
|
||||
profile_model.read(&app, |model, ctx| {
|
||||
let default_profile = model.default_profile(ctx);
|
||||
assert_eq!(default_profile.sync_id(), None);
|
||||
assert_eq!(
|
||||
default_profile.data().execute_commands,
|
||||
ActionPermission::AlwaysAsk
|
||||
);
|
||||
});
|
||||
|
||||
let attacker_sync_id = SyncId::ServerId(ServerId::from(31337));
|
||||
let attacker_profile = attacker_owned_shared_default_profile(ServerId::from(31337));
|
||||
CloudModel::handle(&app).update(&mut app, move |cloud_model, ctx| {
|
||||
cloud_model.upsert_from_server_object(attacker_profile, ctx);
|
||||
});
|
||||
|
||||
profile_model.read(&app, |model, ctx| {
|
||||
let default_profile = model.default_profile(ctx);
|
||||
assert_eq!(
|
||||
default_profile.sync_id(),
|
||||
None,
|
||||
"shared attacker-owned default profile should not be adopted"
|
||||
);
|
||||
assert_eq!(
|
||||
default_profile.data().execute_commands,
|
||||
ActionPermission::AlwaysAsk,
|
||||
"shared attacker-owned profile should not control command approvals"
|
||||
);
|
||||
assert_ne!(default_profile.sync_id(), Some(attacker_sync_id));
|
||||
});
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ignores_shared_default_profile_after_initial_load() {
|
||||
let _guard = FeatureFlag::SharedWithMe.override_enabled(true);
|
||||
|
||||
App::test((), |mut app| async move {
|
||||
install_singletons(&mut app, AuthStateProvider::new_for_test());
|
||||
let profile_model = app.add_singleton_model(|ctx| {
|
||||
AIExecutionProfilesModel::new(&LaunchMode::new_for_unit_test(), ctx)
|
||||
});
|
||||
|
||||
let attacker_sync_id = SyncId::ServerId(ServerId::from(31338));
|
||||
let attacker_profile = attacker_owned_shared_default_profile(ServerId::from(31338));
|
||||
CloudModel::handle(&app).update(&mut app, move |cloud_model, ctx| {
|
||||
let server_objects: Vec<ServerAIExecutionProfile> = vec![attacker_profile];
|
||||
cloud_model.update_objects_from_initial_load(server_objects, false, false, ctx);
|
||||
ctx.emit(CloudModelEvent::InitialLoadCompleted);
|
||||
});
|
||||
|
||||
profile_model.read(&app, |model, ctx| {
|
||||
let default_profile = model.default_profile(ctx);
|
||||
assert_eq!(
|
||||
default_profile.sync_id(),
|
||||
None,
|
||||
"shared attacker-owned default profile should not be reconciled as default"
|
||||
);
|
||||
assert_eq!(
|
||||
default_profile.data().execute_commands,
|
||||
ActionPermission::AlwaysAsk,
|
||||
"shared attacker-owned profile should not control command approvals"
|
||||
);
|
||||
assert_ne!(default_profile.sync_id(), Some(attacker_sync_id));
|
||||
});
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn filters_non_owned_non_default_profile_from_list() {
|
||||
let _guard = FeatureFlag::SharedWithMe.override_enabled(true);
|
||||
|
||||
App::test((), |mut app| async move {
|
||||
install_singletons(&mut app, AuthStateProvider::new_for_test());
|
||||
let profile_model = app.add_singleton_model(|ctx| {
|
||||
AIExecutionProfilesModel::new(&LaunchMode::new_for_unit_test(), ctx)
|
||||
});
|
||||
|
||||
// Create a non-default profile owned by an attacker, shared with victim
|
||||
let attacker_owner = Owner::User {
|
||||
user_uid: UserUid::new("attacker-owner"),
|
||||
};
|
||||
let attacker_profile = AIExecutionProfile {
|
||||
name: "Attacker Custom".to_string(),
|
||||
is_default_profile: false,
|
||||
..Default::default()
|
||||
};
|
||||
let attacker_server_obj = ServerAIExecutionProfile::new(
|
||||
SyncId::ServerId(ServerId::from(99999)),
|
||||
CloudAIExecutionProfileModel::new(attacker_profile),
|
||||
mock_server_metadata(ServerId::from(99999)),
|
||||
ServerPermissions {
|
||||
space: attacker_owner,
|
||||
guests: vec![ServerObjectGuest {
|
||||
subject: ServerGuestSubject::User {
|
||||
firebase_uid: TEST_USER_UID.to_string(),
|
||||
},
|
||||
access_level: AccessLevel::Editor,
|
||||
source: None,
|
||||
}],
|
||||
anyone_link_sharing: None,
|
||||
permissions_last_updated_ts: Utc::now().into(),
|
||||
},
|
||||
);
|
||||
|
||||
CloudModel::handle(&app).update(&mut app, move |cloud_model, ctx| {
|
||||
cloud_model.upsert_from_server_object(attacker_server_obj, ctx);
|
||||
});
|
||||
|
||||
profile_model.read(&app, |model, ctx| {
|
||||
assert!(
|
||||
!model.has_multiple_profiles(),
|
||||
"non-owned profile should not appear in profile list"
|
||||
);
|
||||
let all_ids = model.get_all_profile_ids();
|
||||
assert_eq!(
|
||||
all_ids.len(),
|
||||
1,
|
||||
"only the default profile should be in the list"
|
||||
);
|
||||
assert_eq!(all_ids[0], model.default_profile_id());
|
||||
assert_eq!(
|
||||
model.default_profile(ctx).data().name,
|
||||
"Default",
|
||||
"surviving profile should be the user's default, not the attacker's"
|
||||
);
|
||||
});
|
||||
})
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user