Initial public release of Warp.
Repo-Sync-Origin: warpdotdev/warp-internal@12af1d983b
This commit is contained in:
David Stern
@@ -0,0 +1,734 @@
|
||||
use std::{path::PathBuf, time::Duration};
|
||||
|
||||
use itertools::Itertools as _;
|
||||
use uuid::Uuid;
|
||||
use warp_core::features::FeatureFlag;
|
||||
use warp_multi_agent_api as api;
|
||||
|
||||
use crate::{
|
||||
agent::{
|
||||
action::{
|
||||
AIAgentActionType, AIAgentPtyWriteMode, CommentSide, FileEdit, InsertReviewComment,
|
||||
InsertedCommentLine, InsertedCommentLocation, ReadFilesRequest, ReadSkillRequest,
|
||||
SearchCodebaseRequest, ShellCommandDelay, SuggestPromptRequest, UploadArtifactRequest,
|
||||
UseComputerRequest,
|
||||
},
|
||||
action_result::{AnyFileContent, FileContext},
|
||||
convert::ToolToAIAgentActionError,
|
||||
FileLocations,
|
||||
},
|
||||
diff_validation::{ParsedDiff, V4AHunk},
|
||||
document::AIDocumentId,
|
||||
skills::SkillReference,
|
||||
};
|
||||
|
||||
impl From<api::message::tool_call::RunShellCommand> for AIAgentActionType {
|
||||
fn from(value: api::message::tool_call::RunShellCommand) -> Self {
|
||||
AIAgentActionType::RequestCommandOutput {
|
||||
command: value.command,
|
||||
is_read_only: Some(value.is_read_only),
|
||||
rationale: None,
|
||||
uses_pager: Some(value.uses_pager),
|
||||
is_risky: Some(value.is_risky),
|
||||
wait_until_completion: value.wait_until_complete_value.is_none_or(
|
||||
|api::message::tool_call::run_shell_command::WaitUntilCompleteValue::WaitUntilComplete(
|
||||
should_wait,
|
||||
)| should_wait,
|
||||
),
|
||||
citations: value
|
||||
.citations
|
||||
.iter()
|
||||
.filter_map(|citation| citation.clone().try_into().ok())
|
||||
.collect(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<api::message::tool_call::WriteToLongRunningShellCommand> for AIAgentActionType {
|
||||
fn from(value: api::message::tool_call::WriteToLongRunningShellCommand) -> Self {
|
||||
AIAgentActionType::WriteToLongRunningShellCommand {
|
||||
block_id: value.command_id.into(),
|
||||
input: value.input.into(),
|
||||
mode: value.mode.map(Into::into).unwrap_or_default(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<api::message::tool_call::write_to_long_running_shell_command::Mode>
|
||||
for AIAgentPtyWriteMode
|
||||
{
|
||||
fn from(value: api::message::tool_call::write_to_long_running_shell_command::Mode) -> Self {
|
||||
match value.mode {
|
||||
Some(mode) => {
|
||||
use warp_multi_agent_api::message::tool_call::write_to_long_running_shell_command::mode::Mode;
|
||||
match mode {
|
||||
Mode::Raw(_) => AIAgentPtyWriteMode::Raw,
|
||||
Mode::Line(_) => AIAgentPtyWriteMode::Line,
|
||||
Mode::Block(_) => AIAgentPtyWriteMode::Block,
|
||||
}
|
||||
}
|
||||
None => AIAgentPtyWriteMode::Raw,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<api::message::tool_call::SuggestNewConversation> for AIAgentActionType {
|
||||
fn from(value: api::message::tool_call::SuggestNewConversation) -> Self {
|
||||
AIAgentActionType::SuggestNewConversation {
|
||||
message_id: value.message_id,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<api::message::tool_call::ApplyFileDiffs> for AIAgentActionType {
|
||||
fn from(value: api::message::tool_call::ApplyFileDiffs) -> Self {
|
||||
let diff_edits = value.diffs.into_iter().map(|file_diff| {
|
||||
FileEdit::Edit(ParsedDiff::StrReplaceEdit {
|
||||
search: file_diff.search.none_if_default(),
|
||||
replace: file_diff.replace.none_if_default(),
|
||||
file: file_diff.file_path.none_if_default(),
|
||||
})
|
||||
});
|
||||
let v4a_updates = value.v4a_updates.into_iter().map(|v4a_update| {
|
||||
FileEdit::Edit(ParsedDiff::V4AEdit {
|
||||
file: v4a_update.file_path.none_if_default(),
|
||||
move_to: v4a_update.move_to.clone().none_if_default(),
|
||||
hunks: v4a_update
|
||||
.hunks
|
||||
.into_iter()
|
||||
.map(|hunk| V4AHunk {
|
||||
change_context: hunk.change_context,
|
||||
pre_context: hunk.pre_context,
|
||||
old: hunk.old,
|
||||
new: hunk.new,
|
||||
post_context: hunk.post_context,
|
||||
})
|
||||
.collect(),
|
||||
})
|
||||
});
|
||||
let file_deletes = value
|
||||
.deleted_files
|
||||
.into_iter()
|
||||
.map(|file_delete| FileEdit::Delete {
|
||||
file: file_delete.file_path.none_if_default(),
|
||||
});
|
||||
let new_file_edits = value
|
||||
.new_files
|
||||
.into_iter()
|
||||
.map(|new_file| FileEdit::Create {
|
||||
file: new_file.file_path.none_if_default(),
|
||||
content: new_file.content.none_if_default(),
|
||||
});
|
||||
|
||||
AIAgentActionType::RequestFileEdits {
|
||||
file_edits: diff_edits
|
||||
.chain(v4a_updates)
|
||||
.chain(new_file_edits)
|
||||
.chain(file_deletes)
|
||||
.collect(),
|
||||
title: Some(value.summary),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<api::message::tool_call::ReadFiles> for AIAgentActionType {
|
||||
fn from(value: api::message::tool_call::ReadFiles) -> Self {
|
||||
AIAgentActionType::ReadFiles(ReadFilesRequest {
|
||||
locations: value.files.into_iter().map(Into::into).collect(),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl TryFrom<api::UploadFileArtifact> for AIAgentActionType {
|
||||
type Error = ToolToAIAgentActionError;
|
||||
|
||||
fn try_from(value: api::UploadFileArtifact) -> Result<Self, Self::Error> {
|
||||
let file = value
|
||||
.file
|
||||
.filter(|file| !file.file_path.is_empty())
|
||||
.ok_or(ToolToAIAgentActionError::MissingUploadArtifactFileReference)?;
|
||||
|
||||
Ok(AIAgentActionType::UploadArtifact(UploadArtifactRequest {
|
||||
file_path: file.file_path,
|
||||
description: value.description.none_if_default(),
|
||||
}))
|
||||
}
|
||||
}
|
||||
|
||||
impl From<api::message::tool_call::SearchCodebase> for AIAgentActionType {
|
||||
fn from(value: api::message::tool_call::SearchCodebase) -> Self {
|
||||
AIAgentActionType::SearchCodebase(SearchCodebaseRequest {
|
||||
query: value.query,
|
||||
partial_paths: if !value.path_filters.is_empty() {
|
||||
Some(value.path_filters)
|
||||
} else {
|
||||
None
|
||||
},
|
||||
codebase_path: if !value.codebase_path.is_empty() {
|
||||
Some(value.codebase_path)
|
||||
} else {
|
||||
None
|
||||
},
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl From<api::message::tool_call::Grep> for AIAgentActionType {
|
||||
fn from(value: api::message::tool_call::Grep) -> Self {
|
||||
AIAgentActionType::Grep {
|
||||
queries: value.queries,
|
||||
path: value.path,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<api::message::tool_call::FileGlob> for AIAgentActionType {
|
||||
fn from(value: api::message::tool_call::FileGlob) -> Self {
|
||||
AIAgentActionType::FileGlob {
|
||||
patterns: value.patterns,
|
||||
path: if value.path.is_empty() {
|
||||
None
|
||||
} else {
|
||||
Some(value.path)
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<api::message::tool_call::FileGlobV2> for AIAgentActionType {
|
||||
fn from(value: api::message::tool_call::FileGlobV2) -> Self {
|
||||
AIAgentActionType::FileGlobV2 {
|
||||
patterns: value.patterns,
|
||||
search_dir: if value.search_dir.is_empty() {
|
||||
None
|
||||
} else {
|
||||
Some(value.search_dir)
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<api::message::tool_call::read_files::File> for FileLocations {
|
||||
fn from(value: api::message::tool_call::read_files::File) -> Self {
|
||||
Self {
|
||||
name: value.name,
|
||||
lines: value
|
||||
.line_ranges
|
||||
.into_iter()
|
||||
.map(|line_range| line_range.start as usize..line_range.end as usize)
|
||||
.collect(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<api::message::tool_call::ReadMcpResource> for AIAgentActionType {
|
||||
fn from(value: api::message::tool_call::ReadMcpResource) -> Self {
|
||||
let server_id = if FeatureFlag::MCPGroupedServerContext.is_enabled() {
|
||||
Uuid::parse_str(&value.server_id).ok()
|
||||
} else {
|
||||
None
|
||||
};
|
||||
|
||||
AIAgentActionType::ReadMCPResource {
|
||||
server_id,
|
||||
uri: Some(value.uri),
|
||||
name: Default::default(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl TryFrom<api::message::tool_call::CallMcpTool> for AIAgentActionType {
|
||||
type Error = ToolToAIAgentActionError;
|
||||
|
||||
fn try_from(value: api::message::tool_call::CallMcpTool) -> Result<Self, Self::Error> {
|
||||
let Some(args) = value.args else {
|
||||
return Err(ToolToAIAgentActionError::CallMCPToolArgsError(
|
||||
String::from("missing args"),
|
||||
));
|
||||
};
|
||||
|
||||
let input = prost_to_serde_json(prost_types::Value {
|
||||
kind: Some(prost_types::value::Kind::StructValue(args)),
|
||||
})
|
||||
.map_err(ToolToAIAgentActionError::CallMCPToolArgsError)?;
|
||||
|
||||
let server_id = if FeatureFlag::MCPGroupedServerContext.is_enabled() {
|
||||
Uuid::parse_str(&value.server_id).ok()
|
||||
} else {
|
||||
None
|
||||
};
|
||||
|
||||
Ok(AIAgentActionType::CallMCPTool {
|
||||
server_id,
|
||||
name: value.name,
|
||||
input,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl TryFrom<api::message::tool_call::SuggestPrompt> for AIAgentActionType {
|
||||
type Error = ToolToAIAgentActionError;
|
||||
|
||||
fn try_from(value: api::message::tool_call::SuggestPrompt) -> Result<Self, Self::Error> {
|
||||
let request = match value.display_mode {
|
||||
Some(api::message::tool_call::suggest_prompt::DisplayMode::InlineQueryBanner(
|
||||
inline_query_banner,
|
||||
)) => SuggestPromptRequest::UnitTestsSuggestion {
|
||||
title: inline_query_banner.title,
|
||||
description: inline_query_banner.description,
|
||||
query: inline_query_banner.query,
|
||||
},
|
||||
Some(api::message::tool_call::suggest_prompt::DisplayMode::PromptChip(chip)) => {
|
||||
let label = chip.label.none_if_default();
|
||||
SuggestPromptRequest::PromptSuggestion {
|
||||
prompt: chip.prompt,
|
||||
label,
|
||||
}
|
||||
}
|
||||
_ => {
|
||||
return Err(ToolToAIAgentActionError::SuggestPromptError(String::from(
|
||||
"unsupported display mode",
|
||||
)));
|
||||
}
|
||||
};
|
||||
Ok(AIAgentActionType::SuggestPrompt(request))
|
||||
}
|
||||
}
|
||||
|
||||
impl From<warp_multi_agent_api::FileContent> for FileContext {
|
||||
fn from(content: warp_multi_agent_api::FileContent) -> Self {
|
||||
let line_range = content.line_range.map(|r| r.start as usize..r.end as usize);
|
||||
|
||||
FileContext::new(
|
||||
content.file_path,
|
||||
AnyFileContent::StringContent(content.content),
|
||||
line_range,
|
||||
None,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
impl From<warp_multi_agent_api::AnyFileContent> for FileContext {
|
||||
fn from(content: warp_multi_agent_api::AnyFileContent) -> Self {
|
||||
match content.content {
|
||||
Some(api::any_file_content::Content::BinaryContent(binary_content)) => {
|
||||
FileContext::new(
|
||||
binary_content.file_path,
|
||||
AnyFileContent::BinaryContent(binary_content.data),
|
||||
None,
|
||||
None,
|
||||
)
|
||||
}
|
||||
Some(api::any_file_content::Content::TextContent(text_content)) => {
|
||||
let line_range = text_content
|
||||
.line_range
|
||||
.map(|r| r.start as usize..r.end as usize);
|
||||
|
||||
FileContext::new(
|
||||
text_content.file_path,
|
||||
AnyFileContent::StringContent(text_content.content),
|
||||
line_range,
|
||||
None,
|
||||
)
|
||||
}
|
||||
None => unreachable!("AnyFileContent should always have a content"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<api::message::tool_call::ReadDocuments> for AIAgentActionType {
|
||||
fn from(value: api::message::tool_call::ReadDocuments) -> Self {
|
||||
use crate::agent::action::ReadDocumentsRequest;
|
||||
AIAgentActionType::ReadDocuments(ReadDocumentsRequest {
|
||||
document_ids: value
|
||||
.documents
|
||||
.into_iter()
|
||||
.filter_map(|doc| AIDocumentId::try_from(doc.document_id).ok())
|
||||
.collect(),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl From<api::message::tool_call::EditDocuments> for AIAgentActionType {
|
||||
fn from(value: api::message::tool_call::EditDocuments) -> Self {
|
||||
use crate::agent::action::{DocumentDiff, EditDocumentsRequest};
|
||||
AIAgentActionType::EditDocuments(EditDocumentsRequest {
|
||||
diffs: value
|
||||
.diffs
|
||||
.into_iter()
|
||||
.filter_map(|diff| {
|
||||
AIDocumentId::try_from(diff.document_id)
|
||||
.map(|document_id| DocumentDiff {
|
||||
document_id,
|
||||
search: diff.search,
|
||||
replace: diff.replace,
|
||||
})
|
||||
.ok()
|
||||
})
|
||||
.collect(),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl From<api::message::tool_call::CreateDocuments> for AIAgentActionType {
|
||||
fn from(value: api::message::tool_call::CreateDocuments) -> Self {
|
||||
use crate::agent::action::{CreateDocumentsRequest, DocumentToCreate};
|
||||
AIAgentActionType::CreateDocuments(CreateDocumentsRequest {
|
||||
documents: value
|
||||
.new_documents
|
||||
.into_iter()
|
||||
.map(|doc| DocumentToCreate {
|
||||
content: doc.content,
|
||||
title: if doc.title.is_empty() {
|
||||
// DO NOT SUBMIT
|
||||
// crate::ai::ai_document_view::DEFAULT_PLANNING_DOCUMENT_TITLE.to_string()
|
||||
"".to_string()
|
||||
} else {
|
||||
doc.title
|
||||
},
|
||||
})
|
||||
.collect(),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl From<api::message::tool_call::ReadShellCommandOutput> for AIAgentActionType {
|
||||
fn from(value: api::message::tool_call::ReadShellCommandOutput) -> Self {
|
||||
let delay = match value.delay {
|
||||
Some(api::message::tool_call::read_shell_command_output::Delay::Duration(duration)) => {
|
||||
Some(ShellCommandDelay::Duration(Duration::from_secs(
|
||||
duration.seconds as u64,
|
||||
)))
|
||||
}
|
||||
Some(api::message::tool_call::read_shell_command_output::Delay::OnCompletion(_)) => {
|
||||
Some(ShellCommandDelay::OnCompletion)
|
||||
}
|
||||
None => None,
|
||||
};
|
||||
AIAgentActionType::ReadShellCommandOutput {
|
||||
block_id: value.command_id.into(),
|
||||
delay,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<api::message::tool_call::TransferShellCommandControlToUser> for AIAgentActionType {
|
||||
fn from(value: api::message::tool_call::TransferShellCommandControlToUser) -> Self {
|
||||
AIAgentActionType::TransferShellCommandControlToUser {
|
||||
reason: value.reason,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl TryFrom<api::message::tool_call::UseComputer> for AIAgentActionType {
|
||||
type Error = ToolToAIAgentActionError;
|
||||
|
||||
fn try_from(value: api::message::tool_call::UseComputer) -> Result<Self, Self::Error> {
|
||||
use api::message::tool_call::use_computer;
|
||||
|
||||
let actions = value
|
||||
.actions
|
||||
.into_iter()
|
||||
.map(|action| {
|
||||
let Some(action_type) = action.r#type else {
|
||||
return Err(ToolToAIAgentActionError::MissingComputerUseActionType);
|
||||
};
|
||||
match action_type {
|
||||
use_computer::action::Type::MouseMove(mouse_move) => {
|
||||
Ok(computer_use::Action::MouseMove {
|
||||
to: coordinates_to_vec(mouse_move.to.as_ref())?,
|
||||
})
|
||||
}
|
||||
use_computer::action::Type::MouseDown(mouse_down) => {
|
||||
Ok(computer_use::Action::MouseDown {
|
||||
button: to_computer_use_button(mouse_down.button()),
|
||||
at: coordinates_to_vec(mouse_down.at.as_ref())?,
|
||||
})
|
||||
}
|
||||
use_computer::action::Type::MouseUp(mouse_up) => {
|
||||
Ok(computer_use::Action::MouseUp {
|
||||
button: to_computer_use_button(mouse_up.button()),
|
||||
})
|
||||
}
|
||||
use_computer::action::Type::MouseWheel(mouse_wheel) => {
|
||||
let direction = to_scroll_direction(mouse_wheel.direction());
|
||||
let distance = to_scroll_distance(mouse_wheel.distance)?;
|
||||
Ok(computer_use::Action::MouseWheel {
|
||||
at: coordinates_to_vec(mouse_wheel.at.as_ref())?,
|
||||
direction,
|
||||
distance,
|
||||
})
|
||||
}
|
||||
use_computer::action::Type::Wait(wait) => {
|
||||
let duration = wait.duration.unwrap_or_default();
|
||||
if duration.seconds < 0 || duration.nanos < 0 {
|
||||
return Err(ToolToAIAgentActionError::InvalidComputerUseWaitDuration);
|
||||
}
|
||||
let duration = Duration::from_secs(duration.seconds as u64)
|
||||
+ Duration::from_nanos(duration.nanos as u64);
|
||||
Ok(computer_use::Action::Wait(duration))
|
||||
}
|
||||
use_computer::action::Type::TypeText(type_text) => {
|
||||
Ok(computer_use::Action::TypeText {
|
||||
text: type_text.text,
|
||||
})
|
||||
}
|
||||
use_computer::action::Type::KeyDown(key_down) => {
|
||||
let key = convert_key(key_down.key)?;
|
||||
Ok(computer_use::Action::KeyDown { key })
|
||||
}
|
||||
use_computer::action::Type::KeyUp(key_up) => {
|
||||
let key = convert_key(key_up.key)?;
|
||||
Ok(computer_use::Action::KeyUp { key })
|
||||
}
|
||||
}
|
||||
})
|
||||
.try_collect()?;
|
||||
let screenshot_params = value
|
||||
.post_actions_screenshot_params
|
||||
.map(convert_screenshot_params);
|
||||
Ok(AIAgentActionType::UseComputer(UseComputerRequest {
|
||||
action_summary: value.action_summary,
|
||||
actions,
|
||||
screenshot_params,
|
||||
}))
|
||||
}
|
||||
}
|
||||
|
||||
impl From<api::message::tool_call::RequestComputerUse> for AIAgentActionType {
|
||||
fn from(value: api::message::tool_call::RequestComputerUse) -> Self {
|
||||
use crate::agent::action::RequestComputerUseRequest;
|
||||
AIAgentActionType::RequestComputerUse(RequestComputerUseRequest {
|
||||
task_summary: value.task_summary,
|
||||
screenshot_params: value.screenshot_params.map(convert_screenshot_params),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl TryFrom<api::message::tool_call::ReadSkill> for AIAgentActionType {
|
||||
type Error = ToolToAIAgentActionError;
|
||||
|
||||
fn try_from(value: api::message::tool_call::ReadSkill) -> Result<Self, Self::Error> {
|
||||
match value.skill_reference {
|
||||
Some(reference) => Ok(AIAgentActionType::ReadSkill(ReadSkillRequest {
|
||||
skill: SkillReference::from(reference),
|
||||
})),
|
||||
None => Err(ToolToAIAgentActionError::MissingSkillReference),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<api::message::tool_call::FetchConversation> for AIAgentActionType {
|
||||
fn from(value: api::message::tool_call::FetchConversation) -> Self {
|
||||
AIAgentActionType::FetchConversation {
|
||||
conversation_id: value.conversation_id,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<api::message::tool_call::read_skill::SkillReference> for SkillReference {
|
||||
fn from(value: api::message::tool_call::read_skill::SkillReference) -> Self {
|
||||
use warp_multi_agent_api::message::tool_call::read_skill::SkillReference as ApiSkillReference;
|
||||
match value {
|
||||
ApiSkillReference::SkillPath(skill_path) => {
|
||||
SkillReference::Path(PathBuf::from(skill_path))
|
||||
}
|
||||
ApiSkillReference::BundledSkillId(id) => SkillReference::BundledSkillId(id),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Converts API ScreenshotParams to the internal computer_use type.
|
||||
fn convert_screenshot_params(
|
||||
params: api::message::tool_call::ScreenshotParams,
|
||||
) -> computer_use::ScreenshotParams {
|
||||
let region = params
|
||||
.region
|
||||
.and_then(|r| match (r.top_left.as_ref(), r.bottom_right.as_ref()) {
|
||||
(Some(tl), Some(br)) => Some(computer_use::ScreenshotRegion {
|
||||
top_left: computer_use::Vector2I::new(tl.x, tl.y),
|
||||
bottom_right: computer_use::Vector2I::new(br.x, br.y),
|
||||
}),
|
||||
_ => None,
|
||||
});
|
||||
|
||||
computer_use::ScreenshotParams {
|
||||
max_long_edge_px: (params.max_long_edge_px > 0).then_some(params.max_long_edge_px as usize),
|
||||
max_total_px: (params.max_total_px > 0).then_some(params.max_total_px as usize),
|
||||
region,
|
||||
}
|
||||
}
|
||||
|
||||
fn coordinates_to_vec(
|
||||
coords: Option<&api::Coordinates>,
|
||||
) -> Result<computer_use::Vector2I, ToolToAIAgentActionError> {
|
||||
match coords {
|
||||
Some(coords) => Ok(computer_use::Vector2I::new(coords.x, coords.y)),
|
||||
None => Err(ToolToAIAgentActionError::MissingComputerUseCoordinates),
|
||||
}
|
||||
}
|
||||
|
||||
fn to_computer_use_button(
|
||||
api_button: api::message::tool_call::use_computer::action::MouseButton,
|
||||
) -> computer_use::MouseButton {
|
||||
use api::message::tool_call::use_computer::action::MouseButton;
|
||||
match api_button {
|
||||
MouseButton::Left => computer_use::MouseButton::Left,
|
||||
MouseButton::Right => computer_use::MouseButton::Right,
|
||||
MouseButton::Middle => computer_use::MouseButton::Middle,
|
||||
MouseButton::Back => computer_use::MouseButton::Back,
|
||||
MouseButton::Forward => computer_use::MouseButton::Forward,
|
||||
}
|
||||
}
|
||||
|
||||
fn to_scroll_direction(
|
||||
api_direction: api::message::tool_call::use_computer::action::mouse_wheel::Direction,
|
||||
) -> computer_use::ScrollDirection {
|
||||
use api::message::tool_call::use_computer::action::mouse_wheel::Direction;
|
||||
match api_direction {
|
||||
Direction::Up => computer_use::ScrollDirection::Up,
|
||||
Direction::Down => computer_use::ScrollDirection::Down,
|
||||
Direction::Left => computer_use::ScrollDirection::Left,
|
||||
Direction::Right => computer_use::ScrollDirection::Right,
|
||||
}
|
||||
}
|
||||
|
||||
fn to_scroll_distance(
|
||||
api_distance: Option<api::message::tool_call::use_computer::action::mouse_wheel::Distance>,
|
||||
) -> Result<computer_use::ScrollDistance, ToolToAIAgentActionError> {
|
||||
use api::message::tool_call::use_computer::action::mouse_wheel::Distance;
|
||||
match api_distance {
|
||||
Some(Distance::Pixels(pixels)) => Ok(computer_use::ScrollDistance::Pixels(pixels)),
|
||||
Some(Distance::Clicks(clicks)) => Ok(computer_use::ScrollDistance::Clicks(clicks)),
|
||||
None => Err(ToolToAIAgentActionError::MissingComputerUseScrollDistance),
|
||||
}
|
||||
}
|
||||
|
||||
fn convert_key(
|
||||
api_key: Option<api::message::tool_call::use_computer::action::Key>,
|
||||
) -> Result<computer_use::Key, ToolToAIAgentActionError> {
|
||||
use api::message::tool_call::use_computer::action::key::Data;
|
||||
let key = api_key.ok_or(ToolToAIAgentActionError::MissingComputerUseKey)?;
|
||||
match key.data {
|
||||
Some(Data::Keycode(keycode)) => Ok(computer_use::Key::Keycode(keycode)),
|
||||
Some(Data::Char(char_str)) => {
|
||||
let mut chars = char_str.chars();
|
||||
let ch = chars
|
||||
.next()
|
||||
.ok_or(ToolToAIAgentActionError::InvalidComputerUseCharKey)?;
|
||||
if chars.next().is_some() {
|
||||
return Err(ToolToAIAgentActionError::InvalidComputerUseCharKey);
|
||||
}
|
||||
Ok(computer_use::Key::Char(ch))
|
||||
}
|
||||
None => Err(ToolToAIAgentActionError::MissingComputerUseKey),
|
||||
}
|
||||
}
|
||||
|
||||
fn prost_to_serde_json(x: prost_types::Value) -> Result<serde_json::Value, String> {
|
||||
use prost_types::value::Kind::*;
|
||||
use serde_json::Value::*;
|
||||
|
||||
let Some(kind) = x.kind else {
|
||||
return Err("google.protobuf.Value kind was None".to_string());
|
||||
};
|
||||
|
||||
Ok(match kind {
|
||||
NullValue(_) => Null,
|
||||
BoolValue(v) => Bool(v),
|
||||
NumberValue(n) => Number(
|
||||
serde_json::Number::from_f64(n)
|
||||
.ok_or_else(|| format!("float {n} is not valid JSON number"))?,
|
||||
),
|
||||
StringValue(s) => String(s),
|
||||
ListValue(l) => Array(
|
||||
l.values
|
||||
.into_iter()
|
||||
.map(prost_to_serde_json)
|
||||
.collect::<Result<Vec<_>, std::string::String>>()?,
|
||||
),
|
||||
StructValue(v) => Object(
|
||||
v.fields
|
||||
.into_iter()
|
||||
.map(|(k, v)| prost_to_serde_json(v).map(|v| (k, v)))
|
||||
.collect::<Result<serde_json::Map<_, _>, std::string::String>>()?,
|
||||
),
|
||||
})
|
||||
}
|
||||
|
||||
/// Helper trait to easily convert default values to `None`.
|
||||
/// With `prost`, scalar types are converted to their default values instead
|
||||
/// of `None` if the type is unset. This trait allows a more natural
|
||||
/// conversion to better denote if a value should be `Some` (indicating it was set)
|
||||
/// or `None` (indicating it was unset).
|
||||
///
|
||||
///
|
||||
/// NOTE: Consumers should use this with caution as it only makes sense where the default
|
||||
/// value of the type isn't a reasonable value and `None` makes more sense instead.
|
||||
trait NoneIfDefault
|
||||
where
|
||||
Self: Sized + Default,
|
||||
{
|
||||
fn none_if_default(self) -> Option<Self>;
|
||||
}
|
||||
|
||||
impl NoneIfDefault for String {
|
||||
fn none_if_default(self) -> Option<Self> {
|
||||
if self == Self::default() {
|
||||
None
|
||||
} else {
|
||||
Some(self)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<api::message::tool_call::InsertReviewComments> for AIAgentActionType {
|
||||
fn from(value: api::message::tool_call::InsertReviewComments) -> Self {
|
||||
AIAgentActionType::InsertCodeReviewComments {
|
||||
repo_path: PathBuf::from(value.repo_path),
|
||||
comments: value.comments.into_iter().map(Into::into).collect(),
|
||||
base_branch: value.base_branch.none_if_default(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<api::message::tool_call::insert_review_comments::CommentSide> for CommentSide {
|
||||
fn from(value: api::message::tool_call::insert_review_comments::CommentSide) -> Self {
|
||||
match value {
|
||||
api::message::tool_call::insert_review_comments::CommentSide::New => CommentSide::Right,
|
||||
api::message::tool_call::insert_review_comments::CommentSide::Old => CommentSide::Left,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<api::message::tool_call::insert_review_comments::Comment> for InsertReviewComment {
|
||||
fn from(value: api::message::tool_call::insert_review_comments::Comment) -> Self {
|
||||
let location = value.location.map(|loc| InsertedCommentLocation {
|
||||
relative_file_path: loc.file_path,
|
||||
line: loc.line.and_then(|comment_line_range| {
|
||||
let side = comment_line_range.side().into();
|
||||
let diff_hunk = comment_line_range.diff_hunk;
|
||||
comment_line_range.range.map(|r| InsertedCommentLine {
|
||||
comment_line_range: r.start as usize..r.end as usize,
|
||||
diff_hunk_line_range: r.start as usize..r.end as usize,
|
||||
diff_hunk_text: diff_hunk,
|
||||
side: Some(side),
|
||||
})
|
||||
}),
|
||||
});
|
||||
|
||||
InsertReviewComment {
|
||||
comment_id: value.comment_id,
|
||||
author: value.author,
|
||||
last_modified_timestamp: value.last_modified_timestamp,
|
||||
comment_body: value.comment_body,
|
||||
parent_comment_id: if value.parent_comment_id.is_empty() {
|
||||
None
|
||||
} else {
|
||||
Some(value.parent_comment_id)
|
||||
},
|
||||
comment_location: location,
|
||||
html_url: value.html_url.none_if_default(),
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user