1241 lines
52 KiB
Rust
1241 lines
52 KiB
Rust
pub(super) mod ask_user_question;
|
|
pub(super) mod call_mcp_tool;
|
|
pub(super) mod create_documents;
|
|
pub(super) mod edit_documents;
|
|
pub(super) mod fetch_conversation;
|
|
pub(super) mod file_glob;
|
|
pub(super) mod grep;
|
|
pub(super) mod read_documents;
|
|
pub(super) mod read_files;
|
|
pub(super) mod read_mcp_resource;
|
|
pub(super) mod read_skill;
|
|
pub(super) mod request_computer_use;
|
|
pub(super) mod request_file_edits;
|
|
pub(super) mod search_codebase;
|
|
pub(super) mod send_message;
|
|
pub(super) mod shell_command;
|
|
pub(super) mod start_agent;
|
|
pub(super) mod suggest_new_conversation;
|
|
pub(super) mod suggest_prompt;
|
|
pub(super) mod upload_artifact;
|
|
pub(super) mod use_computer;
|
|
|
|
use ai::agent::action_result::{InsertReviewCommentsResult, RequestCommandOutputResult};
|
|
pub use ask_user_question::AskUserQuestionExecutor;
|
|
pub(crate) use call_mcp_tool::coerce_integer_args;
|
|
use call_mcp_tool::CallMCPToolExecutor;
|
|
use create_documents::CreateDocumentsExecutor;
|
|
use edit_documents::EditDocumentsExecutor;
|
|
use fetch_conversation::FetchConversationExecutor;
|
|
use file_glob::FileGlobExecutor;
|
|
use futures::{future::BoxFuture, FutureExt};
|
|
use galaxy_core::{execution_mode::AppExecutionMode, features::FeatureFlag};
|
|
use grep::GrepExecutor;
|
|
use parking_lot::FairMutex;
|
|
use read_documents::ReadDocumentsExecutor;
|
|
pub(super) use read_files::ReadFilesExecutor;
|
|
use read_mcp_resource::ReadMCPResourceExecutor;
|
|
use read_skill::ReadSkillExecutor;
|
|
use request_computer_use::RequestComputerUseExecutor;
|
|
pub(crate) use request_file_edits::apply_edits;
|
|
pub(crate) use request_file_edits::FileReadResult;
|
|
pub(crate) use request_file_edits::MalformedFinalLineProxyEvent;
|
|
pub use request_file_edits::{
|
|
EditAcceptAndContinueClickedEvent, EditAcceptClickedEvent, EditResolvedEvent, EditStats,
|
|
RequestFileEditsExecutor, RequestFileEditsFormatKind, RequestFileEditsTelemetryEvent,
|
|
};
|
|
pub use send_message::SendMessageToAgentExecutor;
|
|
use serde::{Deserialize, Serialize};
|
|
pub use shell_command::{ShellCommandExecutor, ShellCommandExecutorEvent};
|
|
pub use start_agent::{StartAgentExecutor, StartAgentExecutorEvent, StartAgentRequest};
|
|
pub use suggest_new_conversation::NewConversationDecision;
|
|
use suggest_new_conversation::SuggestNewConversationExecutor;
|
|
pub use suggest_prompt::PromptSuggestionExecutor;
|
|
use upload_artifact::UploadArtifactExecutor;
|
|
use use_computer::UseComputerExecutor;
|
|
|
|
#[cfg(feature = "local_fs")]
|
|
use crate::util::openable_file_type::is_binary_file;
|
|
#[cfg(feature = "local_fs")]
|
|
use futures::AsyncReadExt;
|
|
#[cfg(feature = "local_fs")]
|
|
use galaxy_files::{FileModel, TextFileReadResult};
|
|
#[cfg(feature = "local_fs")]
|
|
use galaxy_util::file::FileLoadError;
|
|
#[cfg(feature = "local_fs")]
|
|
use galaxy_util::file_type::is_buffer_binary;
|
|
use galaxyui::{
|
|
r#async::{Spawnable, SpawnableOutput},
|
|
AppContext, Entity, EntityId, ModelContext, ModelHandle, SingletonEntity,
|
|
};
|
|
use std::{any::Any, path::PathBuf, pin::Pin, sync::Arc};
|
|
|
|
#[cfg(feature = "local_fs")]
|
|
use crate::util::image::{
|
|
is_supported_image_mime_type, process_image_for_agent, ProcessImageResult,
|
|
};
|
|
#[cfg(feature = "local_fs")]
|
|
use mime_guess::from_path;
|
|
|
|
use self::search_codebase::SearchCodebaseExecutor;
|
|
#[cfg(feature = "local_fs")]
|
|
use crate::ai::{agent::AnyFileContent, paths::host_native_absolute_path};
|
|
use crate::{
|
|
ai::{
|
|
agent::{
|
|
conversation::AIConversationId, AIAgentAction, AIAgentActionId, AIAgentActionResult,
|
|
AIAgentActionResultType, AIAgentActionType, CancellationReason, FileContext,
|
|
FileLocations, ServerOutputId,
|
|
},
|
|
ambient_agents::AmbientAgentTaskId,
|
|
get_relevant_files::controller::GetRelevantFilesController,
|
|
},
|
|
terminal::{
|
|
model::session::{active_session::ActiveSession, ExecuteCommandOptions, Session},
|
|
model_events::ModelEventDispatcher,
|
|
shell::ShellType,
|
|
ShellLaunchData, TerminalModel,
|
|
},
|
|
BlocklistAIHistoryModel,
|
|
};
|
|
|
|
/// Types of actions that can be executed in parallel.
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
pub(super) enum ParallelExecutionPolicy {
|
|
/// Read-only actions that only inspect local context and may be safely coalesced into the
|
|
/// same execution phase when the underlying runtime supports it.
|
|
ReadOnlyLocalContext,
|
|
}
|
|
|
|
/// Whether an action is running serially or in parallel with other actions.
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
pub(super) enum RunningActionPhase {
|
|
/// A barrier action that must run by itself.
|
|
Serial,
|
|
/// A phase where several actions from the same compatibility group may be in flight together.
|
|
Parallel(ParallelExecutionPolicy),
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy)]
|
|
struct ExecuteActionInput<'a> {
|
|
action: &'a AIAgentAction,
|
|
conversation_id: AIConversationId,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy)]
|
|
struct PreprocessActionInput<'a> {
|
|
action: &'a AIAgentAction,
|
|
conversation_id: AIConversationId,
|
|
}
|
|
|
|
type AsyncExecuteActionFn<T> = Pin<Box<dyn Spawnable<Output = T>>>;
|
|
type OnCompleteFn<T> = Box<dyn FnOnce(T, &mut AppContext) -> AIAgentActionResultType>;
|
|
|
|
enum ActionExecution<T: SpawnableOutput> {
|
|
Async {
|
|
execute_future: AsyncExecuteActionFn<T>,
|
|
on_complete: OnCompleteFn<T>,
|
|
},
|
|
Sync(AIAgentActionResultType),
|
|
NotReady,
|
|
InvalidAction,
|
|
}
|
|
|
|
impl<T: SpawnableOutput> ActionExecution<T> {
|
|
fn new_async(
|
|
execute_future: impl Spawnable<Output = T>,
|
|
on_complete: impl FnOnce(T, &mut AppContext) -> AIAgentActionResultType + 'static,
|
|
) -> Self {
|
|
Self::Async {
|
|
execute_future: Box::pin(execute_future),
|
|
on_complete: Box::new(on_complete),
|
|
}
|
|
}
|
|
}
|
|
|
|
/// A trait implemented by all types that implement [`Any`] and [`SpawnableOutput`].
|
|
trait AnySpawnableOutput: Any + SpawnableOutput {}
|
|
impl<T> AnySpawnableOutput for T where T: Any + SpawnableOutput {}
|
|
|
|
type AnyAsyncExecuteActionFn = Pin<Box<dyn Spawnable<Output = Box<dyn AnySpawnableOutput>>>>;
|
|
type AnyOnCompleteFn = Box<dyn FnOnce(Box<dyn Any>, &mut AppContext) -> AIAgentActionResultType>;
|
|
|
|
enum AnyActionExecution {
|
|
Async {
|
|
execute_future: AnyAsyncExecuteActionFn,
|
|
on_complete: AnyOnCompleteFn,
|
|
},
|
|
Sync(AIAgentActionResultType),
|
|
NotReady,
|
|
InvalidAction,
|
|
}
|
|
|
|
impl<T> From<ActionExecution<T>> for AnyActionExecution
|
|
where
|
|
T: Send + 'static,
|
|
{
|
|
fn from(value: ActionExecution<T>) -> Self {
|
|
match value {
|
|
ActionExecution::Async {
|
|
execute_future,
|
|
on_complete,
|
|
} => AnyActionExecution::Async {
|
|
execute_future: Box::pin(async move {
|
|
let result = execute_future.await;
|
|
Box::new(result) as Box<dyn AnySpawnableOutput>
|
|
}),
|
|
on_complete: Box::new(move |result, app| {
|
|
on_complete(*result.downcast::<T>().expect("Type is correct."), app)
|
|
}),
|
|
},
|
|
ActionExecution::Sync(result) => AnyActionExecution::Sync(result),
|
|
ActionExecution::NotReady => AnyActionExecution::NotReady,
|
|
ActionExecution::InvalidAction => AnyActionExecution::InvalidAction,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub enum NotExecutedReason {
|
|
NotReady,
|
|
NeedsConfirmation,
|
|
WaitingOnSharer,
|
|
}
|
|
|
|
impl NotExecutedReason {
|
|
pub fn needs_confirmation(&self) -> bool {
|
|
matches!(self, Self::NeedsConfirmation)
|
|
}
|
|
}
|
|
|
|
/// Result type for `BlocklistAIActionExecutor::try_to_execute_action`.
|
|
#[derive(Debug)]
|
|
pub(super) enum TryExecuteResult {
|
|
ExecutedSync,
|
|
ExecutedAsync,
|
|
NotExecuted {
|
|
reason: NotExecutedReason,
|
|
action: Box<AIAgentAction>,
|
|
},
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
struct AsyncExecutingAction {
|
|
action: AIAgentAction,
|
|
/// The conversation this action belongs to so cancellation and follow-up scheduling remain
|
|
/// scoped even when several conversations have async actions in flight.
|
|
conversation_id: AIConversationId,
|
|
}
|
|
|
|
impl AsyncExecutingAction {
|
|
fn is_shell_command_action(&self) -> bool {
|
|
matches!(
|
|
self.action.action,
|
|
AIAgentActionType::RequestCommandOutput { .. }
|
|
| AIAgentActionType::WriteToLongRunningShellCommand { .. }
|
|
| AIAgentActionType::ReadShellCommandOutput { .. }
|
|
)
|
|
}
|
|
}
|
|
|
|
pub struct BlocklistAIActionExecutor {
|
|
shell_command_executor: ModelHandle<ShellCommandExecutor>,
|
|
read_files_executor: ModelHandle<ReadFilesExecutor>,
|
|
upload_artifact_executor: ModelHandle<UploadArtifactExecutor>,
|
|
search_codebase_executor: ModelHandle<SearchCodebaseExecutor>,
|
|
request_file_edits_executor: ModelHandle<RequestFileEditsExecutor>,
|
|
grep_executor: ModelHandle<GrepExecutor>,
|
|
file_glob_executor: ModelHandle<FileGlobExecutor>,
|
|
read_mcp_resource_executor: ModelHandle<ReadMCPResourceExecutor>,
|
|
call_mcp_tool_executor: ModelHandle<CallMCPToolExecutor>,
|
|
suggest_new_conversation_executor: ModelHandle<SuggestNewConversationExecutor>,
|
|
suggest_prompt_executor: ModelHandle<PromptSuggestionExecutor>,
|
|
read_documents_executor: ModelHandle<ReadDocumentsExecutor>,
|
|
edit_documents_executor: ModelHandle<EditDocumentsExecutor>,
|
|
create_documents_executor: ModelHandle<CreateDocumentsExecutor>,
|
|
use_computer_executor: ModelHandle<UseComputerExecutor>,
|
|
request_computer_use_executor: ModelHandle<RequestComputerUseExecutor>,
|
|
read_skill_executor: ModelHandle<ReadSkillExecutor>,
|
|
fetch_conversation_executor: ModelHandle<FetchConversationExecutor>,
|
|
start_agent_executor: ModelHandle<StartAgentExecutor>,
|
|
send_message_executor: ModelHandle<SendMessageToAgentExecutor>,
|
|
ask_user_question_executor: ModelHandle<AskUserQuestionExecutor>,
|
|
/// The actions currently executing asynchronously, keyed by action ID.
|
|
/// We track them per action rather than as a single slot so multiple actions from the same
|
|
/// parallel phase can complete independently.
|
|
async_executing_actions: std::collections::HashMap<AIAgentActionId, AsyncExecutingAction>,
|
|
|
|
/// Reference to the terminal model for checking session sharing state.
|
|
terminal_model: Arc<FairMutex<TerminalModel>>,
|
|
}
|
|
|
|
impl BlocklistAIActionExecutor {
|
|
pub fn new(
|
|
terminal_model: Arc<FairMutex<TerminalModel>>,
|
|
active_session: ModelHandle<ActiveSession>,
|
|
model_event_dispatcher: &ModelHandle<ModelEventDispatcher>,
|
|
get_relevant_files_controller: ModelHandle<GetRelevantFilesController>,
|
|
terminal_view_id: EntityId,
|
|
ctx: &mut ModelContext<Self>,
|
|
) -> Self {
|
|
let read_files_executor =
|
|
ctx.add_model(|_| ReadFilesExecutor::new(active_session.clone(), terminal_view_id));
|
|
let upload_artifact_executor = ctx
|
|
.add_model(|_| UploadArtifactExecutor::new(active_session.clone(), terminal_view_id));
|
|
let search_codebase_executor = ctx.add_model(|ctx| {
|
|
SearchCodebaseExecutor::new(
|
|
active_session.clone(),
|
|
get_relevant_files_controller,
|
|
terminal_view_id,
|
|
ctx,
|
|
)
|
|
});
|
|
let shell_command_executor = ctx.add_model(|ctx| {
|
|
ShellCommandExecutor::new(
|
|
active_session.clone(),
|
|
terminal_model.clone(),
|
|
model_event_dispatcher,
|
|
terminal_view_id,
|
|
ctx,
|
|
)
|
|
});
|
|
let request_file_edits_executor = ctx.add_model(|ctx| {
|
|
RequestFileEditsExecutor::new(active_session.clone(), terminal_view_id, ctx)
|
|
});
|
|
let grep_executor =
|
|
ctx.add_model(|_| GrepExecutor::new(active_session.clone(), terminal_view_id));
|
|
let file_glob_executor =
|
|
ctx.add_model(|_| FileGlobExecutor::new(active_session.clone(), terminal_view_id));
|
|
let read_mcp_resource_executor = ctx
|
|
.add_model(|_| ReadMCPResourceExecutor::new(active_session.clone(), terminal_view_id));
|
|
let call_mcp_tool_executor =
|
|
ctx.add_model(|_| CallMCPToolExecutor::new(active_session.clone(), terminal_view_id));
|
|
let suggest_new_conversation_executor =
|
|
ctx.add_model(|_| SuggestNewConversationExecutor::new());
|
|
let suggest_prompt_executor = ctx.add_model(|_| PromptSuggestionExecutor::new());
|
|
let read_documents_executor = ctx.add_model(|_| ReadDocumentsExecutor::new());
|
|
let edit_documents_executor = ctx.add_model(|_| EditDocumentsExecutor::new());
|
|
let create_documents_executor = ctx
|
|
.add_model(|_| CreateDocumentsExecutor::new(active_session.clone(), terminal_view_id));
|
|
let use_computer_executor = ctx.add_model(|_| UseComputerExecutor::new());
|
|
let request_computer_use_executor =
|
|
ctx.add_model(|_| RequestComputerUseExecutor::new(terminal_view_id));
|
|
let read_skill_executor = ctx.add_model(|_| ReadSkillExecutor::new());
|
|
let fetch_conversation_executor = ctx.add_model(|_| FetchConversationExecutor::new());
|
|
let start_agent_executor = ctx.add_model(StartAgentExecutor::new);
|
|
let send_message_executor = ctx.add_model(|_| SendMessageToAgentExecutor::new());
|
|
let ask_user_question_executor =
|
|
ctx.add_model(|_| AskUserQuestionExecutor::new(terminal_view_id));
|
|
Self {
|
|
shell_command_executor,
|
|
read_files_executor,
|
|
upload_artifact_executor,
|
|
search_codebase_executor,
|
|
request_file_edits_executor,
|
|
grep_executor,
|
|
file_glob_executor,
|
|
read_mcp_resource_executor,
|
|
call_mcp_tool_executor,
|
|
suggest_new_conversation_executor,
|
|
suggest_prompt_executor,
|
|
read_documents_executor,
|
|
edit_documents_executor,
|
|
create_documents_executor,
|
|
use_computer_executor,
|
|
request_computer_use_executor,
|
|
async_executing_actions: Default::default(),
|
|
terminal_model,
|
|
read_skill_executor,
|
|
fetch_conversation_executor,
|
|
start_agent_executor,
|
|
send_message_executor,
|
|
ask_user_question_executor,
|
|
}
|
|
}
|
|
|
|
pub fn async_executing_action(&self, action_id: &AIAgentActionId) -> Option<&AIAgentAction> {
|
|
self.async_executing_actions
|
|
.get(action_id)
|
|
.map(|running| &running.action)
|
|
}
|
|
|
|
pub fn shell_command_executor(&self) -> &ModelHandle<ShellCommandExecutor> {
|
|
&self.shell_command_executor
|
|
}
|
|
|
|
pub fn request_file_edits_executor(&self) -> &ModelHandle<RequestFileEditsExecutor> {
|
|
&self.request_file_edits_executor
|
|
}
|
|
|
|
pub fn search_codebase_executor(&self) -> &ModelHandle<SearchCodebaseExecutor> {
|
|
&self.search_codebase_executor
|
|
}
|
|
|
|
pub fn suggest_new_conversation_executor(
|
|
&self,
|
|
) -> &ModelHandle<SuggestNewConversationExecutor> {
|
|
&self.suggest_new_conversation_executor
|
|
}
|
|
|
|
pub fn suggest_prompt_executor(&self) -> &ModelHandle<PromptSuggestionExecutor> {
|
|
&self.suggest_prompt_executor
|
|
}
|
|
|
|
pub fn start_agent_executor(&self) -> &ModelHandle<StartAgentExecutor> {
|
|
&self.start_agent_executor
|
|
}
|
|
|
|
pub fn action_phase(&self, action: &AIAgentAction, ctx: &AppContext) -> RunningActionPhase {
|
|
match &action.action {
|
|
AIAgentActionType::ReadFiles(..)
|
|
| AIAgentActionType::SearchCodebase(..)
|
|
| AIAgentActionType::ReadSkill(_) => {
|
|
RunningActionPhase::Parallel(ParallelExecutionPolicy::ReadOnlyLocalContext)
|
|
}
|
|
AIAgentActionType::Grep { .. }
|
|
if self.grep_executor.as_ref(ctx).can_execute_in_parallel(ctx) =>
|
|
{
|
|
RunningActionPhase::Parallel(ParallelExecutionPolicy::ReadOnlyLocalContext)
|
|
}
|
|
AIAgentActionType::FileGlob { .. } | AIAgentActionType::FileGlobV2 { .. }
|
|
if self
|
|
.file_glob_executor
|
|
.as_ref(ctx)
|
|
.can_execute_in_parallel(ctx) =>
|
|
{
|
|
RunningActionPhase::Parallel(ParallelExecutionPolicy::ReadOnlyLocalContext)
|
|
}
|
|
_ => RunningActionPhase::Serial,
|
|
}
|
|
}
|
|
|
|
pub fn ask_user_question_executor(&self) -> &ModelHandle<AskUserQuestionExecutor> {
|
|
&self.ask_user_question_executor
|
|
}
|
|
|
|
pub fn set_ambient_agent_task_id(
|
|
&self,
|
|
id: Option<AmbientAgentTaskId>,
|
|
ctx: &mut ModelContext<Self>,
|
|
) {
|
|
self.request_computer_use_executor
|
|
.update(ctx, |executor, _| {
|
|
executor.set_ambient_agent_task_id(id);
|
|
});
|
|
}
|
|
|
|
pub fn preprocess_action(
|
|
&self,
|
|
action: &AIAgentAction,
|
|
conversation_id: AIConversationId,
|
|
ctx: &mut ModelContext<Self>,
|
|
) -> BoxFuture<'static, ()> {
|
|
// In view-only mode, we do not need to perform any preprocessing work.
|
|
if self.is_shared_session_viewer() {
|
|
return futures::future::ready(()).boxed();
|
|
}
|
|
|
|
let input = PreprocessActionInput {
|
|
action,
|
|
conversation_id,
|
|
};
|
|
|
|
match &action.action {
|
|
AIAgentActionType::RequestCommandOutput { .. }
|
|
| AIAgentActionType::WriteToLongRunningShellCommand { .. }
|
|
| AIAgentActionType::ReadShellCommandOutput { .. }
|
|
| AIAgentActionType::TransferShellCommandControlToUser { .. } => self
|
|
.shell_command_executor
|
|
.update(ctx, |executor, ctx| executor.preprocess_action(input, ctx)),
|
|
AIAgentActionType::ReadFiles(..) => self
|
|
.read_files_executor
|
|
.update(ctx, |executor, ctx| executor.preprocess_action(input, ctx)),
|
|
AIAgentActionType::UploadArtifact(..) => self
|
|
.upload_artifact_executor
|
|
.update(ctx, |executor, ctx| executor.preprocess_action(input, ctx)),
|
|
AIAgentActionType::SearchCodebase(..) => self
|
|
.search_codebase_executor
|
|
.update(ctx, |executor, ctx| executor.preprocess_action(input, ctx)),
|
|
AIAgentActionType::Grep { .. } => self
|
|
.grep_executor
|
|
.update(ctx, |executor, ctx| executor.preprocess_action(input, ctx)),
|
|
AIAgentActionType::FileGlob { .. } | AIAgentActionType::FileGlobV2 { .. } => self
|
|
.file_glob_executor
|
|
.update(ctx, |executor, ctx| executor.preprocess_action(input, ctx)),
|
|
AIAgentActionType::CallMCPTool { .. } => self
|
|
.call_mcp_tool_executor
|
|
.update(ctx, |executor, ctx| executor.preprocess_action(input, ctx)),
|
|
AIAgentActionType::ReadMCPResource { .. } => self
|
|
.read_mcp_resource_executor
|
|
.update(ctx, |executor, ctx| executor.preprocess_action(input, ctx)),
|
|
// Normally, requested file edits are not handled by the executor. However, when performing a task autonomously,
|
|
// the executor is responsible for auto-approving diffs.
|
|
AIAgentActionType::RequestFileEdits { .. } => self
|
|
.request_file_edits_executor
|
|
.update(ctx, |executor, ctx| executor.preprocess_action(input, ctx)),
|
|
AIAgentActionType::InitProject => futures::future::ready(()).boxed(),
|
|
AIAgentActionType::OpenCodeReview => futures::future::ready(()).boxed(),
|
|
AIAgentActionType::InsertCodeReviewComments { .. } => {
|
|
futures::future::ready(()).boxed()
|
|
}
|
|
AIAgentActionType::SuggestNewConversation { .. } => self
|
|
.suggest_new_conversation_executor
|
|
.update(ctx, |executor, ctx| executor.preprocess_action(input, ctx)),
|
|
AIAgentActionType::SuggestPrompt { .. } => self
|
|
.suggest_prompt_executor
|
|
.update(ctx, |executor, ctx| executor.preprocess_action(input, ctx)),
|
|
AIAgentActionType::ReadDocuments(_) => self
|
|
.read_documents_executor
|
|
.update(ctx, |executor, ctx| executor.preprocess_action(input, ctx)),
|
|
AIAgentActionType::EditDocuments(_) => self
|
|
.edit_documents_executor
|
|
.update(ctx, |executor, ctx| executor.preprocess_action(input, ctx)),
|
|
AIAgentActionType::CreateDocuments(_) => self
|
|
.create_documents_executor
|
|
.update(ctx, |executor, ctx| executor.preprocess_action(input, ctx)),
|
|
AIAgentActionType::UseComputer(_) => self
|
|
.use_computer_executor
|
|
.update(ctx, |executor, ctx| executor.preprocess_action(input, ctx)),
|
|
AIAgentActionType::RequestComputerUse(_) => self
|
|
.request_computer_use_executor
|
|
.update(ctx, |executor, ctx| executor.preprocess_action(input, ctx)),
|
|
AIAgentActionType::ReadSkill(_) => self
|
|
.read_skill_executor
|
|
.update(ctx, |executor, ctx| executor.preprocess_action(input, ctx)),
|
|
AIAgentActionType::FetchConversation { .. } => self
|
|
.fetch_conversation_executor
|
|
.update(ctx, |executor, ctx| executor.preprocess_action(input, ctx)),
|
|
AIAgentActionType::StartAgent { .. } => self
|
|
.start_agent_executor
|
|
.update(ctx, |executor, ctx| executor.preprocess_action(input, ctx)),
|
|
AIAgentActionType::SendMessageToAgent { .. } => self
|
|
.send_message_executor
|
|
.update(ctx, |executor, ctx| executor.preprocess_action(input, ctx)),
|
|
AIAgentActionType::AskUserQuestion { .. } => self
|
|
.ask_user_question_executor
|
|
.update(ctx, |executor, ctx| executor.preprocess_action(input, ctx)),
|
|
}
|
|
}
|
|
|
|
/// Returns `None` if the action was executed (and thereby consumed).
|
|
///
|
|
/// If the executor cannot execute the action at this time, returns a result indicating why.
|
|
pub fn try_to_execute_action(
|
|
&mut self,
|
|
action: AIAgentAction,
|
|
conversation_id: AIConversationId,
|
|
is_user_initiated: bool,
|
|
ctx: &mut ModelContext<Self>,
|
|
) -> TryExecuteResult {
|
|
// We should never actually execute actions in view-only mode.
|
|
if self.is_shared_session_viewer() {
|
|
return TryExecuteResult::NotExecuted {
|
|
reason: NotExecutedReason::WaitingOnSharer,
|
|
action: Box::new(action),
|
|
};
|
|
}
|
|
|
|
let input = ExecuteActionInput {
|
|
action: &action,
|
|
conversation_id,
|
|
};
|
|
let can_auto_execute = self.should_autoexecute(input, ctx);
|
|
let is_agent_autonomous = AppExecutionMode::as_ref(ctx).is_autonomous();
|
|
|
|
// The agent cannot auto execute and either:
|
|
// - the agent is interactive, OR
|
|
// - the agent is autonomous and the action was not requesting command output
|
|
let needs_confirmation = !(is_user_initiated
|
|
|| can_auto_execute
|
|
|| (is_agent_autonomous && action.action.is_request_command_output()));
|
|
if needs_confirmation {
|
|
return TryExecuteResult::NotExecuted {
|
|
action: Box::new(action),
|
|
reason: NotExecutedReason::NeedsConfirmation,
|
|
};
|
|
} else if !is_user_initiated && !can_auto_execute && is_agent_autonomous {
|
|
// It must be the case that the autonomous agent is requesting a denylisted command.
|
|
if let AIAgentActionType::RequestCommandOutput { command, .. } = &action.action {
|
|
let action_id = action.id.clone();
|
|
let result = AIAgentActionResultType::RequestCommandOutput(
|
|
RequestCommandOutputResult::Denylisted {
|
|
command: command.clone(),
|
|
},
|
|
);
|
|
|
|
ctx.emit(BlocklistAIActionExecutorEvent::ExecutingAction {
|
|
action_id: action_id.clone(),
|
|
});
|
|
ctx.emit(BlocklistAIActionExecutorEvent::FinishedAction {
|
|
result: Arc::new(AIAgentActionResult {
|
|
id: action_id,
|
|
task_id: action.task_id.clone(),
|
|
result,
|
|
}),
|
|
conversation_id,
|
|
cancellation_reason: None,
|
|
});
|
|
|
|
return TryExecuteResult::ExecutedSync;
|
|
}
|
|
}
|
|
|
|
let action_clone = action.clone();
|
|
let execution = match &action.action {
|
|
AIAgentActionType::RequestCommandOutput { .. }
|
|
| AIAgentActionType::WriteToLongRunningShellCommand { .. }
|
|
| AIAgentActionType::ReadShellCommandOutput { .. }
|
|
| AIAgentActionType::TransferShellCommandControlToUser { .. } => self
|
|
.shell_command_executor
|
|
.update(ctx, |executor, ctx| executor.execute(input, ctx))
|
|
.into(),
|
|
AIAgentActionType::InitProject => {
|
|
ctx.emit(BlocklistAIActionExecutorEvent::InitProject(action.id));
|
|
ActionExecution::<()>::Sync(AIAgentActionResultType::InitProject).into()
|
|
}
|
|
AIAgentActionType::OpenCodeReview => {
|
|
ctx.emit(BlocklistAIActionExecutorEvent::OpenCodeReview(action.id));
|
|
ActionExecution::<()>::Sync(AIAgentActionResultType::OpenCodeReview).into()
|
|
}
|
|
AIAgentActionType::InsertCodeReviewComments {
|
|
repo_path,
|
|
comments,
|
|
base_branch,
|
|
} => {
|
|
if FeatureFlag::PRCommentsSlashCommand.is_enabled() {
|
|
ctx.emit(BlocklistAIActionExecutorEvent::InsertCodeReviewComments {
|
|
action_id: action.id,
|
|
repo_path: repo_path.clone(),
|
|
comments: comments.clone(),
|
|
base_branch: base_branch.clone(),
|
|
});
|
|
}
|
|
ActionExecution::<()>::Sync(AIAgentActionResultType::InsertReviewComments(
|
|
InsertReviewCommentsResult::Success {
|
|
repo_path: repo_path.to_string_lossy().to_string(),
|
|
},
|
|
))
|
|
.into()
|
|
}
|
|
AIAgentActionType::ReadFiles(..) => self
|
|
.read_files_executor
|
|
.update(ctx, |executor, ctx| executor.execute(input, ctx))
|
|
.into(),
|
|
AIAgentActionType::UploadArtifact(..) => self
|
|
.upload_artifact_executor
|
|
.update(ctx, |executor, ctx| executor.execute(input, ctx)),
|
|
AIAgentActionType::SearchCodebase(..) => self
|
|
.search_codebase_executor
|
|
.update(ctx, |executor, ctx| executor.execute(input, ctx))
|
|
.into(),
|
|
AIAgentActionType::Grep { .. } => self
|
|
.grep_executor
|
|
.update(ctx, |executor, ctx| executor.execute(input, ctx))
|
|
.into(),
|
|
AIAgentActionType::FileGlob { .. } | AIAgentActionType::FileGlobV2 { .. } => self
|
|
.file_glob_executor
|
|
.update(ctx, |executor, ctx| executor.execute(input, ctx))
|
|
.into(),
|
|
AIAgentActionType::CallMCPTool { .. } => self
|
|
.call_mcp_tool_executor
|
|
.update(ctx, |executor, ctx| executor.execute(input, ctx))
|
|
.into(),
|
|
AIAgentActionType::ReadMCPResource { .. } => self
|
|
.read_mcp_resource_executor
|
|
.update(ctx, |executor, ctx| executor.execute(input, ctx))
|
|
.into(),
|
|
// Normally, requested file edits are not handled by the executor. However, when performing a task autonomously,
|
|
// the executor is responsible for auto-approving diffs.
|
|
AIAgentActionType::RequestFileEdits { .. } => self
|
|
.request_file_edits_executor
|
|
.update(ctx, |executor, ctx| executor.execute(input, ctx))
|
|
.into(),
|
|
AIAgentActionType::SuggestNewConversation { .. } => self
|
|
.suggest_new_conversation_executor
|
|
.update(ctx, |executor, ctx| executor.execute(input, ctx))
|
|
.into(),
|
|
AIAgentActionType::SuggestPrompt { .. } => self
|
|
.suggest_prompt_executor
|
|
.update(ctx, |executor, ctx| executor.execute(input, ctx))
|
|
.into(),
|
|
AIAgentActionType::ReadDocuments(_) => self
|
|
.read_documents_executor
|
|
.update(ctx, |executor, ctx| executor.execute(input, ctx))
|
|
.into(),
|
|
AIAgentActionType::EditDocuments(_) => self
|
|
.edit_documents_executor
|
|
.update(ctx, |executor, ctx| executor.execute(input, ctx))
|
|
.into(),
|
|
AIAgentActionType::CreateDocuments(_) => self
|
|
.create_documents_executor
|
|
.update(ctx, |executor, ctx| {
|
|
executor.execute(input, conversation_id, ctx)
|
|
})
|
|
.into(),
|
|
AIAgentActionType::UseComputer(_) => self
|
|
.use_computer_executor
|
|
.update(ctx, |executor, ctx| executor.execute(input, ctx))
|
|
.into(),
|
|
AIAgentActionType::RequestComputerUse(_) => self
|
|
.request_computer_use_executor
|
|
.update(ctx, |executor, ctx| executor.execute(input, ctx))
|
|
.into(),
|
|
AIAgentActionType::ReadSkill(_) => self
|
|
.read_skill_executor
|
|
.update(ctx, |executor, ctx| executor.execute(input, ctx))
|
|
.into(),
|
|
AIAgentActionType::FetchConversation { .. } => self
|
|
.fetch_conversation_executor
|
|
.update(ctx, |executor, ctx| executor.execute(input, ctx))
|
|
.into(),
|
|
AIAgentActionType::StartAgent { .. } => self
|
|
.start_agent_executor
|
|
.update(ctx, |executor, ctx| executor.execute(input, ctx))
|
|
.into(),
|
|
AIAgentActionType::SendMessageToAgent { .. } => self
|
|
.send_message_executor
|
|
.update(ctx, |executor, ctx| executor.execute(input, ctx)),
|
|
AIAgentActionType::AskUserQuestion { .. } => self
|
|
.ask_user_question_executor
|
|
.update(ctx, |executor, ctx| executor.execute(input, ctx))
|
|
.into(),
|
|
};
|
|
|
|
let action_id = action_clone.id.clone();
|
|
match execution {
|
|
AnyActionExecution::NotReady => TryExecuteResult::NotExecuted {
|
|
reason: NotExecutedReason::NotReady,
|
|
action: Box::new(action_clone),
|
|
},
|
|
AnyActionExecution::InvalidAction => {
|
|
debug_assert!(false, "Tried to execute AIAgentAction with wrong executor.");
|
|
TryExecuteResult::NotExecuted {
|
|
reason: NotExecutedReason::NotReady,
|
|
action: Box::new(action_clone),
|
|
}
|
|
}
|
|
AnyActionExecution::Async {
|
|
execute_future,
|
|
on_complete,
|
|
} => {
|
|
self.async_executing_actions.insert(
|
|
action_id.clone(),
|
|
AsyncExecutingAction {
|
|
action: action_clone,
|
|
conversation_id,
|
|
},
|
|
);
|
|
ctx.emit(BlocklistAIActionExecutorEvent::ExecutingAction {
|
|
action_id: action_id.clone(),
|
|
});
|
|
ctx.spawn(execute_future, move |me, result, ctx| {
|
|
let Some(running) = me.async_executing_actions.remove(&action_id) else {
|
|
return;
|
|
};
|
|
let result = on_complete(result, ctx);
|
|
ctx.emit(BlocklistAIActionExecutorEvent::FinishedAction {
|
|
result: Arc::new(AIAgentActionResult {
|
|
id: action_id,
|
|
task_id: running.action.task_id,
|
|
result,
|
|
}),
|
|
conversation_id: running.conversation_id,
|
|
cancellation_reason: None,
|
|
});
|
|
});
|
|
TryExecuteResult::ExecutedAsync
|
|
}
|
|
AnyActionExecution::Sync(action_result) => {
|
|
ctx.emit(BlocklistAIActionExecutorEvent::ExecutingAction {
|
|
action_id: action_id.clone(),
|
|
});
|
|
ctx.emit(BlocklistAIActionExecutorEvent::FinishedAction {
|
|
result: Arc::new(AIAgentActionResult {
|
|
id: action_id,
|
|
task_id: action.task_id,
|
|
result: action_result,
|
|
}),
|
|
conversation_id,
|
|
cancellation_reason: None,
|
|
});
|
|
TryExecuteResult::ExecutedSync
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn can_autoexecute_action(
|
|
&self,
|
|
action: &AIAgentAction,
|
|
conversation_id: AIConversationId,
|
|
ctx: &mut ModelContext<Self>,
|
|
) -> bool {
|
|
self.should_autoexecute(
|
|
ExecuteActionInput {
|
|
action,
|
|
conversation_id,
|
|
},
|
|
ctx,
|
|
)
|
|
}
|
|
|
|
pub fn cancel_running_async_action(
|
|
&mut self,
|
|
action_id: &AIAgentActionId,
|
|
reason: Option<CancellationReason>,
|
|
ctx: &mut ModelContext<Self>,
|
|
) {
|
|
// A viewer should not be able to cancel an action.
|
|
if self.is_shared_session_viewer() {
|
|
return;
|
|
}
|
|
if let Some(running) = self.async_executing_actions.remove(action_id) {
|
|
if running.is_shell_command_action() {
|
|
self.shell_command_executor.update(ctx, |executor, ctx| {
|
|
executor.cancel_execution(&running.action.id, ctx);
|
|
});
|
|
} else if matches!(running.action.action, AIAgentActionType::SearchCodebase(..)) {
|
|
self.search_codebase_executor.update(ctx, |executor, ctx| {
|
|
executor.cancel_execution(&running.action.id, ctx);
|
|
});
|
|
}
|
|
ctx.emit(BlocklistAIActionExecutorEvent::FinishedAction {
|
|
result: Arc::new(AIAgentActionResult {
|
|
id: running.action.id.clone(),
|
|
task_id: running.action.task_id,
|
|
result: running.action.action.cancelled_result(),
|
|
}),
|
|
conversation_id: running.conversation_id,
|
|
cancellation_reason: reason,
|
|
});
|
|
}
|
|
}
|
|
|
|
pub fn cancel_all_running_async_actions_for_conversation(
|
|
&mut self,
|
|
conversation_id: AIConversationId,
|
|
reason: Option<CancellationReason>,
|
|
ctx: &mut ModelContext<Self>,
|
|
) {
|
|
let action_ids = self
|
|
.async_executing_actions
|
|
.iter()
|
|
.filter_map(|(action_id, running)| {
|
|
(running.conversation_id == conversation_id).then_some(action_id.clone())
|
|
})
|
|
.collect::<Vec<_>>();
|
|
for action_id in action_ids {
|
|
self.cancel_running_async_action(&action_id, reason, ctx);
|
|
}
|
|
}
|
|
|
|
fn should_autoexecute(&self, input: ExecuteActionInput, ctx: &mut ModelContext<Self>) -> bool {
|
|
if cfg!(feature = "bedrock_smoke_test") {
|
|
return true;
|
|
}
|
|
match input.action.action {
|
|
AIAgentActionType::RequestCommandOutput { .. }
|
|
| AIAgentActionType::WriteToLongRunningShellCommand { .. }
|
|
| AIAgentActionType::ReadShellCommandOutput { .. }
|
|
| AIAgentActionType::TransferShellCommandControlToUser { .. } => self
|
|
.shell_command_executor
|
|
.update(ctx, |executor, ctx| executor.should_autoexecute(input, ctx)),
|
|
AIAgentActionType::ReadFiles(_) => self
|
|
.read_files_executor
|
|
.update(ctx, |executor, ctx| executor.should_autoexecute(input, ctx)),
|
|
AIAgentActionType::UploadArtifact(_) => self
|
|
.upload_artifact_executor
|
|
.update(ctx, |executor, ctx| executor.should_autoexecute(input, ctx)),
|
|
AIAgentActionType::SearchCodebase(_) => self
|
|
.search_codebase_executor
|
|
.update(ctx, |executor, ctx| executor.should_autoexecute(input, ctx)),
|
|
AIAgentActionType::RequestFileEdits { .. } => self
|
|
.request_file_edits_executor
|
|
.update(ctx, |executor, ctx| executor.should_autoexecute(input, ctx)),
|
|
AIAgentActionType::Grep { .. } => self
|
|
.grep_executor
|
|
.update(ctx, |executor, ctx| executor.should_autoexecute(input, ctx)),
|
|
AIAgentActionType::FileGlob { .. } | AIAgentActionType::FileGlobV2 { .. } => self
|
|
.file_glob_executor
|
|
.update(ctx, |executor, ctx| executor.should_autoexecute(input, ctx)),
|
|
AIAgentActionType::CallMCPTool { .. } => self
|
|
.call_mcp_tool_executor
|
|
.update(ctx, |executor, ctx| executor.should_autoexecute(input, ctx)),
|
|
AIAgentActionType::ReadMCPResource { .. } => self
|
|
.read_mcp_resource_executor
|
|
.update(ctx, |executor, ctx| executor.should_autoexecute(input, ctx)),
|
|
AIAgentActionType::InitProject => true,
|
|
AIAgentActionType::OpenCodeReview => true,
|
|
AIAgentActionType::InsertCodeReviewComments { .. } => true,
|
|
AIAgentActionType::SuggestNewConversation { .. } => self
|
|
.suggest_new_conversation_executor
|
|
.update(ctx, |executor, ctx| executor.should_autoexecute(input, ctx)),
|
|
AIAgentActionType::SuggestPrompt { .. } => self
|
|
.suggest_prompt_executor
|
|
.update(ctx, |executor, ctx| executor.should_autoexecute(input, ctx)),
|
|
AIAgentActionType::ReadDocuments(_) => self
|
|
.read_documents_executor
|
|
.update(ctx, |executor, ctx| executor.should_autoexecute(input, ctx)),
|
|
AIAgentActionType::EditDocuments(_) => self
|
|
.edit_documents_executor
|
|
.update(ctx, |executor, ctx| executor.should_autoexecute(input, ctx)),
|
|
AIAgentActionType::CreateDocuments(_) => self
|
|
.create_documents_executor
|
|
.update(ctx, |executor, ctx| executor.should_autoexecute(input, ctx)),
|
|
AIAgentActionType::UseComputer(_) => self
|
|
.use_computer_executor
|
|
.update(ctx, |executor, ctx| executor.should_autoexecute(input, ctx)),
|
|
AIAgentActionType::RequestComputerUse(_) => self
|
|
.request_computer_use_executor
|
|
.update(ctx, |executor, ctx| executor.should_autoexecute(input, ctx)),
|
|
AIAgentActionType::ReadSkill(_) => self
|
|
.read_skill_executor
|
|
.update(ctx, |executor, ctx| executor.should_autoexecute(input, ctx)),
|
|
AIAgentActionType::FetchConversation { .. } => self
|
|
.fetch_conversation_executor
|
|
.update(ctx, |executor, ctx| executor.should_autoexecute(input, ctx)),
|
|
AIAgentActionType::StartAgent { .. } => self
|
|
.start_agent_executor
|
|
.update(ctx, |executor, ctx| executor.should_autoexecute(input, ctx)),
|
|
AIAgentActionType::SendMessageToAgent { .. } => self
|
|
.send_message_executor
|
|
.update(ctx, |executor, ctx| executor.should_autoexecute(input, ctx)),
|
|
AIAgentActionType::AskUserQuestion { .. } => self
|
|
.ask_user_question_executor
|
|
.update(ctx, |executor, ctx| executor.should_autoexecute(input, ctx)),
|
|
}
|
|
}
|
|
|
|
fn is_shared_session_viewer(&self) -> bool {
|
|
self.terminal_model.lock().is_shared_session_viewer()
|
|
}
|
|
}
|
|
impl Entity for BlocklistAIActionExecutor {
|
|
type Event = BlocklistAIActionExecutorEvent;
|
|
}
|
|
|
|
pub enum BlocklistAIActionExecutorEvent {
|
|
/// Emitted when an action is execution starts.
|
|
ExecutingAction {
|
|
action_id: AIAgentActionId,
|
|
},
|
|
|
|
/// Emitted when an action has finished.
|
|
FinishedAction {
|
|
result: Arc<AIAgentActionResult>,
|
|
conversation_id: AIConversationId,
|
|
/// The reason for cancellation, if this action was cancelled.
|
|
cancellation_reason: Option<CancellationReason>,
|
|
},
|
|
|
|
InitProject(AIAgentActionId),
|
|
OpenCodeReview(AIAgentActionId),
|
|
InsertCodeReviewComments {
|
|
action_id: AIAgentActionId,
|
|
repo_path: PathBuf,
|
|
comments: Vec<ai::agent::action::InsertReviewComment>,
|
|
base_branch: Option<String>,
|
|
},
|
|
}
|
|
|
|
/// Per-file byte limit for [`read_local_file_context`]. Binary files larger
|
|
/// than this are skipped; text files are truncated at this limit.
|
|
#[cfg(feature = "local_fs")]
|
|
const MAX_FILE_READ_BYTES: usize = 1_000_000;
|
|
|
|
/// The results of a [`read_local_file_context`] call.
|
|
#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)]
|
|
pub struct ReadFileContextResult {
|
|
/// [`FileContext`] data for all files that could be read.
|
|
pub file_contexts: Vec<FileContext>,
|
|
|
|
/// Expected absolute paths of requested files that did not exist or could
|
|
/// not be read (e.g. binary files that exceed the size limit).
|
|
pub missing_files: Vec<String>,
|
|
}
|
|
|
|
/// Reads the content of the given files at the given `FileLocations`.
|
|
///
|
|
/// If any files do not exist, they are included in the `missing_files` field of the result.
|
|
///
|
|
/// Binary files larger than the per-file byte limit are skipped and reported as oversized.
|
|
/// Text files are truncated at the per-file limit via line streaming.
|
|
/// If `max_file_bytes` is provided, it overrides the default per-file limit
|
|
/// ([`MAX_FILE_READ_BYTES`]). Pass `None` to use the default.
|
|
/// If `max_batch_bytes` is provided, the cumulative content of all files is capped at that
|
|
/// budget; once exceeded, remaining files are reported as oversized.
|
|
#[cfg_attr(not(feature = "local_fs"), allow(unused_variables))]
|
|
pub async fn read_local_file_context(
|
|
file_names: &[FileLocations],
|
|
current_working_directory: Option<String>,
|
|
shell: Option<ShellLaunchData>,
|
|
max_file_bytes: Option<usize>,
|
|
max_batch_bytes: Option<usize>,
|
|
) -> anyhow::Result<ReadFileContextResult> {
|
|
#[cfg(not(feature = "local_fs"))]
|
|
return Err(anyhow::anyhow!(
|
|
"Can't read files when not on a local filesystem"
|
|
));
|
|
|
|
#[cfg(feature = "local_fs")]
|
|
{
|
|
let mut result = ReadFileContextResult {
|
|
file_contexts: Vec::new(),
|
|
missing_files: Vec::new(),
|
|
};
|
|
|
|
let mut batch_bytes_remaining = max_batch_bytes;
|
|
|
|
for file in file_names {
|
|
let absolute_file_path = PathBuf::from(host_native_absolute_path(
|
|
&file.name,
|
|
&shell,
|
|
¤t_working_directory,
|
|
));
|
|
|
|
let metadata = match async_fs::metadata(&absolute_file_path).await {
|
|
Ok(m) => m,
|
|
Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
|
|
result
|
|
.missing_files
|
|
.push(absolute_file_path.to_string_lossy().to_string());
|
|
continue;
|
|
}
|
|
Err(e) => return Err(anyhow::anyhow!(e)),
|
|
};
|
|
let last_modified = metadata.modified().ok();
|
|
let file_size = metadata.len() as usize;
|
|
let path_str = absolute_file_path.to_string_lossy().to_string();
|
|
|
|
// Effective byte budget: the tighter of per-file and remaining batch.
|
|
let per_file_limit = max_file_bytes.unwrap_or(MAX_FILE_READ_BYTES);
|
|
let effective_max = match batch_bytes_remaining {
|
|
Some(remaining) => per_file_limit.min(remaining),
|
|
None => per_file_limit,
|
|
};
|
|
|
|
// Decide text vs binary before opening the file. Extension-based
|
|
// detection alone is wrong for extensionless text files (e.g. shell
|
|
// scripts named `bundle`, `run`), so for the ambiguous case we fall
|
|
// back to content-based inspection of the first chunk. The binary
|
|
// path below still acts as a safety net via
|
|
// `TextFileReadResult::NotText` if the text reader trips on invalid
|
|
// UTF-8.
|
|
if !should_read_as_binary(&absolute_file_path).await {
|
|
match FileModel::read_text_file(
|
|
&absolute_file_path,
|
|
effective_max,
|
|
&file.lines,
|
|
last_modified,
|
|
)
|
|
.await?
|
|
{
|
|
TextFileReadResult::Segments {
|
|
segments,
|
|
bytes_read,
|
|
} => {
|
|
if let Some(remaining) = &mut batch_bytes_remaining {
|
|
*remaining = remaining.saturating_sub(bytes_read);
|
|
}
|
|
result
|
|
.file_contexts
|
|
.extend(segments.into_iter().map(|seg| FileContext {
|
|
file_name: seg.file_name,
|
|
content: AnyFileContent::StringContent(seg.content),
|
|
line_range: seg.line_range,
|
|
last_modified: seg.last_modified,
|
|
line_count: seg.line_count,
|
|
}));
|
|
continue;
|
|
}
|
|
TextFileReadResult::NotText => {
|
|
// Fall through to binary path below.
|
|
}
|
|
}
|
|
}
|
|
|
|
// Binary path (either detected as binary, or text reading failed).
|
|
match read_binary_file_context(
|
|
&absolute_file_path,
|
|
effective_max,
|
|
file_size,
|
|
last_modified,
|
|
)
|
|
.await?
|
|
{
|
|
BinaryFileReadResult::Context {
|
|
file_context,
|
|
bytes_read,
|
|
} => {
|
|
if let Some(remaining) = &mut batch_bytes_remaining {
|
|
*remaining = remaining.saturating_sub(bytes_read);
|
|
}
|
|
result.file_contexts.push(file_context);
|
|
}
|
|
BinaryFileReadResult::Missing => result.missing_files.push(path_str),
|
|
}
|
|
}
|
|
|
|
Ok(result)
|
|
}
|
|
}
|
|
|
|
/// Returns `true` if the file at `path` should be read via the binary code
|
|
/// path in [`read_local_file_context`], `false` if it should be read as text.
|
|
///
|
|
/// Uses extension-based detection as a fast path and falls back to content
|
|
/// inspection (reading the first 1 KiB) for extensionless files whose names
|
|
/// don't match any known text or binary pattern. Without the content-based
|
|
/// fallback, extensionless text files (e.g. shell scripts named `bundle`)
|
|
/// would be incorrectly classified as binary and returned to the agent as
|
|
/// raw bytes instead of UTF-8 text.
|
|
#[cfg(feature = "local_fs")]
|
|
async fn should_read_as_binary(path: &std::path::Path) -> bool {
|
|
// Fast path: extension/filename clearly indicates text.
|
|
if !is_binary_file(path) {
|
|
return false;
|
|
}
|
|
// Fast path: file has a known binary extension (e.g. `.png`, `.exe`).
|
|
if path.extension().is_some() {
|
|
return true;
|
|
}
|
|
// Extensionless file with an unknown basename. Inspect the first chunk of
|
|
// the file to decide. Treat open/read errors as binary so the binary path
|
|
// takes over and reports a consistent error.
|
|
is_file_content_binary_async(path).await
|
|
}
|
|
|
|
/// Async sibling of [`galaxy_util::file_type::is_file_content_binary`]. Reads
|
|
/// the first 1 KiB of `path` asynchronously and returns `true` if the content
|
|
/// looks binary according to [`is_buffer_binary`]. Returns `true` on any I/O
|
|
/// error so callers default to the binary code path. Kept local to this
|
|
/// module so `galaxy_util` doesn't need to grow an `async_fs` dependency.
|
|
#[cfg(feature = "local_fs")]
|
|
async fn is_file_content_binary_async(path: &std::path::Path) -> bool {
|
|
const CHUNK_SIZE: usize = 1024;
|
|
|
|
let Ok(mut file) = async_fs::File::open(path).await else {
|
|
return true;
|
|
};
|
|
let mut buffer = [0u8; CHUNK_SIZE];
|
|
let Ok(n) = file.read(&mut buffer).await else {
|
|
return true;
|
|
};
|
|
is_buffer_binary(&buffer[..n])
|
|
}
|
|
|
|
#[cfg(feature = "local_fs")]
|
|
enum BinaryFileReadResult {
|
|
/// Successfully read as binary.
|
|
Context {
|
|
file_context: FileContext,
|
|
bytes_read: usize,
|
|
},
|
|
/// File doesn't exist, exceeds the size limit, or couldn't be processed.
|
|
Missing,
|
|
}
|
|
|
|
/// Reads a binary file, applying image processing when applicable.
|
|
#[cfg(feature = "local_fs")]
|
|
async fn read_binary_file_context(
|
|
path: &std::path::Path,
|
|
max_bytes: usize,
|
|
file_size: usize,
|
|
last_modified: Option<std::time::SystemTime>,
|
|
) -> anyhow::Result<BinaryFileReadResult> {
|
|
if file_size > max_bytes {
|
|
return Ok(BinaryFileReadResult::Missing);
|
|
}
|
|
|
|
let content = match read_file_as_binary(path).await {
|
|
Ok(content) => content,
|
|
Err(FileLoadError::DoesNotExist) => return Ok(BinaryFileReadResult::Missing),
|
|
Err(FileLoadError::IOError(e)) => return Err(anyhow::anyhow!(e)),
|
|
};
|
|
|
|
let mime_type = from_path(path).first_or_octet_stream().to_string();
|
|
let processed_content = if is_supported_image_mime_type(&mime_type) {
|
|
match process_image_for_agent(&content) {
|
|
ProcessImageResult::Success { data } => Some(data),
|
|
ProcessImageResult::TooLarge => {
|
|
log::warn!("Image file too large after processing: {}", path.display());
|
|
return Ok(BinaryFileReadResult::Missing);
|
|
}
|
|
ProcessImageResult::Error(err) => {
|
|
log::warn!("Error processing image file {}: {err:?}", path.display());
|
|
return Ok(BinaryFileReadResult::Missing);
|
|
}
|
|
}
|
|
} else {
|
|
None
|
|
};
|
|
|
|
let final_content = processed_content.unwrap_or(content);
|
|
if final_content.len() > max_bytes {
|
|
return Ok(BinaryFileReadResult::Missing);
|
|
}
|
|
|
|
let bytes_read = final_content.len();
|
|
Ok(BinaryFileReadResult::Context {
|
|
file_context: FileContext::new(
|
|
path.to_string_lossy().to_string(),
|
|
AnyFileContent::BinaryContent(final_content),
|
|
None,
|
|
last_modified,
|
|
),
|
|
bytes_read,
|
|
})
|
|
}
|
|
|
|
/// Returns true if the given path is a regular file on the session's filesystem.
|
|
/// Runs a shell command on the session so it works for both local and remote sessions.
|
|
async fn is_file_path(path: &str, session: &Session) -> bool {
|
|
let command = if session.shell().shell_type() == ShellType::PowerShell {
|
|
format!("if (Test-Path -PathType Leaf \"{path}\") {{ exit 0 }} else {{ exit 1 }}")
|
|
} else {
|
|
format!("test -f \"{path}\"")
|
|
};
|
|
session
|
|
.execute_command(&command, None, None, ExecuteCommandOptions::default())
|
|
.await
|
|
.map(|output| output.success())
|
|
.unwrap_or(false)
|
|
}
|
|
|
|
/// Returns true if git is installed and the given path is in a git repository.
|
|
async fn is_git_repository(absolute_path: &str, session: &Session) -> anyhow::Result<bool> {
|
|
let git_command = format!("git -C \"{absolute_path}\" rev-parse");
|
|
let command_output = session
|
|
.execute_command(
|
|
git_command.as_str(),
|
|
None,
|
|
None,
|
|
ExecuteCommandOptions::default(),
|
|
)
|
|
.await?;
|
|
Ok(command_output.success())
|
|
}
|
|
|
|
fn get_server_output_id(
|
|
conversation_id: AIConversationId,
|
|
ctx: &mut AppContext,
|
|
) -> Option<ServerOutputId> {
|
|
BlocklistAIHistoryModel::as_ref(ctx)
|
|
.conversation(&conversation_id)?
|
|
.latest_exchange()?
|
|
.output_status
|
|
.server_output_id()
|
|
}
|
|
|
|
#[cfg(feature = "local_fs")]
|
|
async fn read_file_as_binary(file_path: &std::path::Path) -> Result<Vec<u8>, FileLoadError> {
|
|
if !FileModel::file_exists(file_path).await {
|
|
return Err(FileLoadError::DoesNotExist);
|
|
}
|
|
|
|
async_fs::read(file_path).await.map_err(FileLoadError::from)
|
|
}
|
|
|
|
#[cfg(all(test, feature = "local_fs"))]
|
|
#[path = "execute_tests.rs"]
|
|
mod tests;
|