From d7a883b281ce0d4f3bf490601e163c29ac4fb688 Mon Sep 17 00:00:00 2001 From: Humberto Yusta Date: Tue, 13 May 2025 19:33:37 +0200 Subject: [PATCH 01/17] fix: add message when deleting a binary file Tell which file was deleted, and if possible, its size --- refact-agent/engine/src/nicer_logs.rs | 16 +++++++ refact-agent/engine/src/tools/tool_rm.rs | 54 ++++++++++++++++-------- 2 files changed, 52 insertions(+), 18 deletions(-) diff --git a/refact-agent/engine/src/nicer_logs.rs b/refact-agent/engine/src/nicer_logs.rs index e58004eb7..0f4802e9b 100644 --- a/refact-agent/engine/src/nicer_logs.rs +++ b/refact-agent/engine/src/nicer_logs.rs @@ -104,3 +104,19 @@ pub fn last_n_chars(msg: &String, n: usize) -> String { } return last_n_chars.replace("\n", "\\n"); } + +pub fn human_readable_bytes(bytes: u64) -> String { + const KB: u64 = 1024; + const MB: u64 = KB * 1024; + const GB: u64 = MB * 1024; + + if bytes < KB { + format!("{}B", bytes) + } else if bytes < MB { + format!("{:.1}KB", bytes as f64 / KB as f64) + } else if bytes < GB { + format!("{:.1}MB", bytes as f64 / MB as f64) + } else { + format!("{:.1}GB", bytes as f64 / GB as f64) + } +} \ No newline at end of file diff --git a/refact-agent/engine/src/tools/tool_rm.rs b/refact-agent/engine/src/tools/tool_rm.rs index 2b3e4fa0e..ae8afffd1 100644 --- a/refact-agent/engine/src/tools/tool_rm.rs +++ b/refact-agent/engine/src/tools/tool_rm.rs @@ -166,6 +166,7 @@ impl Tool for ToolRm { } let mut file_content = String::new(); + let mut file_size = None; let is_dir = true_path.is_dir(); if !is_dir { file_content = match get_file_text_from_memory_or_disk(gcx.clone(), &true_path).await { @@ -175,6 +176,9 @@ impl Tool for ToolRm { String::new() }, }; + if let Ok(meta) = fs::metadata(&true_path).await { + file_size = Some(meta.len()); + } } let mut messages: Vec = Vec::new(); let corrections = path_str != corrected_path; @@ -216,24 +220,38 @@ impl Tool for ToolRm { fs::remove_file(&true_path).await.map_err(|e| { format!("Failed to remove file '{}': {}", corrected_path, e) })?; - let diff_chunk = DiffChunk { - file_name: corrected_path.clone(), - file_action: "remove".to_string(), - line1: 1, - line2: file_content.lines().count(), - lines_remove: file_content.clone(), - lines_add: "".to_string(), - file_name_rename: None, - is_file: true, - application_details: format!("File `{}` removed", corrected_path), - }; - messages.push(ContextEnum::ChatMessage(ChatMessage { - role: "diff".to_string(), - content: ChatContent::SimpleText(json!([diff_chunk]).to_string()), - tool_calls: None, - tool_call_id: tool_call_id.clone(), - ..Default::default() - })); + if !file_content.is_empty() { + let diff_chunk = DiffChunk { + file_name: corrected_path.clone(), + file_action: "remove".to_string(), + line1: 1, + line2: file_content.lines().count(), + lines_remove: file_content.clone(), + lines_add: "".to_string(), + file_name_rename: None, + is_file: true, + application_details: format!("File `{}` removed", corrected_path), + }; + messages.push(ContextEnum::ChatMessage(ChatMessage { + role: "diff".to_string(), + content: ChatContent::SimpleText(json!([diff_chunk]).to_string()), + tool_calls: None, + tool_call_id: tool_call_id.clone(), + ..Default::default() + })); + } else { + let mut message = format!("Removed file '{}'", corrected_path); + if let Some(file_size) = file_size { + message = format!("{} ({})", message, crate::nicer_logs::human_readable_bytes(file_size)); + } + messages.push(ContextEnum::ChatMessage(ChatMessage { + role: "tool".to_string(), + content: ChatContent::SimpleText(message), + tool_calls: None, + tool_call_id: tool_call_id.clone(), + ..Default::default() + })); + } } Ok((corrections, messages)) From d1cb876bdd1c5853acac5eb3cee0c79fd3d6a2bd Mon Sep 17 00:00:00 2001 From: Humberto Yusta Date: Tue, 13 May 2025 22:15:18 +0200 Subject: [PATCH 02/17] fix: if parent is empty, complain to ask for abs path --- .../engine/src/tools/file_edit/tool_create_textdoc.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/refact-agent/engine/src/tools/file_edit/tool_create_textdoc.rs b/refact-agent/engine/src/tools/file_edit/tool_create_textdoc.rs index b2940ceaf..9b57fcb57 100644 --- a/refact-agent/engine/src/tools/file_edit/tool_create_textdoc.rs +++ b/refact-agent/engine/src/tools/file_edit/tool_create_textdoc.rs @@ -41,7 +41,7 @@ async fn parse_args( )); }; let path = if !raw_path.is_absolute() { - if let Some(parent) = raw_path.parent() { + if let Some(parent) = raw_path.parent().filter(|p| !p.as_os_str().is_empty()) { let parent_str = parent.to_string_lossy().to_string(); let candidates_dir = correct_to_nearest_dir_path(gcx.clone(), &parent_str, false, 3).await; let candidate_parent_dir = match return_one_candidate_or_a_good_error(gcx.clone(), &parent_str, &candidates_dir, &get_project_dirs(gcx.clone()).await, true).await { @@ -139,7 +139,7 @@ impl Tool for ToolCreateTextDoc { ) -> Result { let gcx = ccx.lock().await.global_context.clone(); let privacy_settings = load_privacy_if_needed(gcx.clone()).await; - + async fn can_execute_tool_edit(gcx: Arc>, args: &HashMap, privacy_settings: Arc) -> Result<(), String> { let _ = parse_args(gcx.clone(), args, privacy_settings).await?; Ok(()) From ff61011b0711dd84e2a7ac6d47b0e981ebcc3249 Mon Sep 17 00:00:00 2001 From: Humberto Yusta Date: Wed, 14 May 2025 15:40:59 +0200 Subject: [PATCH 03/17] fix: add tool failed flag, so UI can know when tool call failed --- refact-agent/engine/src/call_validation.rs | 6 ++- .../engine/src/tools/tools_execute.rs | 44 ++++++++++--------- 2 files changed, 28 insertions(+), 22 deletions(-) diff --git a/refact-agent/engine/src/call_validation.rs b/refact-agent/engine/src/call_validation.rs index 67262783b..2ba2e2cf8 100644 --- a/refact-agent/engine/src/call_validation.rs +++ b/refact-agent/engine/src/call_validation.rs @@ -175,6 +175,8 @@ pub struct ChatMessage { #[serde(default, skip_serializing_if = "String::is_empty")] pub tool_call_id: String, #[serde(default, skip_serializing_if = "Option::is_none")] + pub tool_failed: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] pub usage: Option, #[serde(default, skip_serializing_if = "Vec::is_empty")] pub checkpoints: Vec, @@ -187,7 +189,7 @@ pub struct ChatMessage { pub enum ModelType { Chat, Completion, - Embedding, + Embedding, } #[derive(Debug, Serialize, Deserialize, Clone, Copy, PartialEq)] @@ -289,7 +291,7 @@ impl ChatMode { pub fn is_agentic(self) -> bool { match self { ChatMode::AGENT => true, - ChatMode::NO_TOOLS | ChatMode::EXPLORE | ChatMode::CONFIGURE | + ChatMode::NO_TOOLS | ChatMode::EXPLORE | ChatMode::CONFIGURE | ChatMode::PROJECT_SUMMARY => false, } } diff --git a/refact-agent/engine/src/tools/tools_execute.rs b/refact-agent/engine/src/tools/tools_execute.rs index 08d34d1b7..5652f24ab 100644 --- a/refact-agent/engine/src/tools/tools_execute.rs +++ b/refact-agent/engine/src/tools/tools_execute.rs @@ -73,7 +73,7 @@ pub async fn unwrap_subchat_params(ccx: Arc>, tool_nam } }, Err(e) => { - tracing::warn!("{:?} model is not available: {}. Using {} model as a fallback.", + tracing::warn!("{:?} model is not available: {}. Using {} model as a fallback.", params.subchat_model_type, e, current_model); current_model } @@ -161,7 +161,7 @@ pub async fn run_tools( style: &Option, ) -> Result<(Vec, bool), String> { let n_ctx = ccx.lock().await.n_ctx; - // Default tokens limit for tools that perform internal compression (`tree()`, ...) + // Default tokens limit for tools that perform internal compression (`tree()`, ...) ccx.lock().await.tokens_for_rag = 4096; let last_msg_tool_calls = match original_messages.last().filter(|m|m.role=="assistant") { @@ -171,7 +171,7 @@ pub async fn run_tools( if last_msg_tool_calls.is_empty() { return Ok((vec![], false)); } - + let mut context_files_for_pp = vec![]; let mut generated_tool = vec![]; // tool results must go first let mut generated_other = vec![]; @@ -181,7 +181,7 @@ pub async fn run_tools( let cmd = match tools.get_mut(&t_call.function.name) { Some(cmd) => cmd, None => { - let tool_failed_message = tool_answer( + let tool_failed_message = tool_answer_err( format!("tool use: function {:?} not found", &t_call.function.name), t_call.id.to_string() ); warn!("{}", tool_failed_message.content.content_text_only()); @@ -193,7 +193,7 @@ pub async fn run_tools( let args = match serde_json::from_str::>(&t_call.function.arguments) { Ok(args) => args, Err(e) => { - let tool_failed_message = tool_answer( + let tool_failed_message = tool_answer_err( format!("Tool use: couldn't parse arguments: {}. Error:\n{}", t_call.function.arguments, e), t_call.id.to_string() ); generated_tool.push(tool_failed_message); @@ -209,31 +209,34 @@ pub async fn run_tools( let command_to_match = cmd .command_to_match_against_confirm_deny(&args) .unwrap_or("".to_string()); - generated_tool.push(tool_answer(format!("tool use: command '{command_to_match}' is denied"), t_call.id.to_string())); + generated_tool.push(tool_answer_err(format!("tool use: command '{command_to_match}' is denied"), t_call.id.to_string())); continue; } _ => {} } } Err(err) => { - generated_tool.push(tool_answer(format!("tool use: {}", err), t_call.id.to_string())); + generated_tool.push(tool_answer_err(format!("tool use: {}", err), t_call.id.to_string())); continue; } }; - let (corrections, tool_execute_results) = { - match cmd.tool_execute(ccx.clone(), &t_call.id.to_string(), &args).await { - Ok(msg_and_maybe_more) => msg_and_maybe_more, - Err(e) => { - warn!("tool use {}({:?}) FAILED: {}", &t_call.function.name, &args, e); - let mut tool_failed_message = tool_answer(e, t_call.id.to_string()); - - tool_failed_message.usage = cmd.usage().clone(); - *cmd.usage() = None; - - generated_tool.push(tool_failed_message.clone()); - continue; + let (corrections, tool_execute_results) = match cmd.tool_execute(ccx.clone(), &t_call.id.to_string(), &args).await { + Ok((corrections, mut tool_execute_results)) => { + for tool_execute_result in &mut tool_execute_results { + if let ContextEnum::ChatMessage(m) = tool_execute_result { + m.tool_failed = Some(false); + } } + (corrections, tool_execute_results) + } + Err(e) => { + warn!("tool use {}({:?}) FAILED: {}", &t_call.function.name, &args, e); + let mut tool_failed_message = tool_answer_err(e, t_call.id.to_string()); + tool_failed_message.usage = cmd.usage().clone(); + *cmd.usage() = None; + generated_tool.push(tool_failed_message.clone()); + continue; } }; @@ -392,12 +395,13 @@ async fn pp_run_tools( } -fn tool_answer(content: String, tool_call_id: String) -> ChatMessage { +fn tool_answer_err(content: String, tool_call_id: String) -> ChatMessage { ChatMessage { role: "tool".to_string(), content: ChatContent::SimpleText(content), tool_calls: None, tool_call_id, + tool_failed: Some(true), ..Default::default() } } From 753972473715495b6f68c7a31df303369ea9b032 Mon Sep 17 00:00:00 2001 From: alashchev17 Date: Wed, 14 May 2025 17:02:08 +0200 Subject: [PATCH 04/17] feat: getting fullpath of the file and then opening it in IDE & hiding textdoc tools if tools_failed: true --- .../components/ChatContent/ContextFiles.tsx | 9 ++++++-- .../components/ChatContent/DiffContent.tsx | 10 ++++----- .../components/ChatContent/ToolsContent.tsx | 1 + .../IntegrationForm/ErrorState.tsx | 2 +- .../IntegrationForm/FormSmartlinks.tsx | 2 +- .../gui/src/components/Tools/Textdoc.tsx | 22 +++++++++++-------- .../gui/src/features/Chat/Thread/utils.ts | 11 ++++++++-- .../src/features/Checkpoints/Checkpoints.tsx | 2 +- .../gui/src/hooks/useEventBusForIDE.ts | 10 ++++----- refact-agent/gui/src/hooks/useGoToLink.ts | 2 +- refact-agent/gui/src/services/refact/types.ts | 3 +++ 11 files changed, 47 insertions(+), 27 deletions(-) diff --git a/refact-agent/gui/src/components/ChatContent/ContextFiles.tsx b/refact-agent/gui/src/components/ChatContent/ContextFiles.tsx index e37192f09..79fb09c7c 100644 --- a/refact-agent/gui/src/components/ChatContent/ContextFiles.tsx +++ b/refact-agent/gui/src/components/ChatContent/ContextFiles.tsx @@ -102,7 +102,7 @@ export const ContextFile: React.FC<{ const ContextFilesContent: React.FC<{ files: ChatContextFile[]; - onOpenFile: (file: { file_name: string; line?: number }) => Promise; + onOpenFile: (file: { file_path: string; line?: number }) => Promise; }> = ({ files, onOpenFile }) => { if (files.length === 0) return null; @@ -120,7 +120,12 @@ const ContextFilesContent: React.FC<{ { event.preventDefault(); - void onOpenFile(file); + // TODO: not optimal to do like this :/ + // maybe we can safely rename file_name -> file_path in ChatContextFile type + void onOpenFile({ + ...file, + file_path: file.file_name, + }); }} key={key} name={file.file_name + lineText} diff --git a/refact-agent/gui/src/components/ChatContent/DiffContent.tsx b/refact-agent/gui/src/components/ChatContent/DiffContent.tsx index 122d8e173..e456009c3 100644 --- a/refact-agent/gui/src/components/ChatContent/DiffContent.tsx +++ b/refact-agent/gui/src/components/ChatContent/DiffContent.tsx @@ -282,8 +282,8 @@ export const DiffForm: React.FC<{ const { openFile } = useEventsBusForIDE(); return ( - {Object.entries(diffs).map(([fullFileName, diffsForFile], index) => { - const key = fullFileName + "-" + index; + {Object.entries(diffs).map(([fullFilePath, diffsForFile], index) => { + const key = fullFilePath + "-" + index; // Check if this is a rename action const renameAction = diffsForFile.find( @@ -303,7 +303,7 @@ export const DiffForm: React.FC<{ ...diffsForFile.map((diff) => diff.line1), ); openFile({ - file_name: fullFileName, + file_path: fullFilePath, line: startLine, }); }} @@ -316,7 +316,7 @@ export const DiffForm: React.FC<{ > {renameAction?.file_name_rename ? renameAction.file_name_rename - : fullFileName} + : fullFilePath} @@ -330,7 +330,7 @@ export const DiffForm: React.FC<{ }} > {diffsForFile.map((diff, i) => ( - + ))} diff --git a/refact-agent/gui/src/components/ChatContent/ToolsContent.tsx b/refact-agent/gui/src/components/ChatContent/ToolsContent.tsx index 08e303549..b6c3fad92 100644 --- a/refact-agent/gui/src/components/ChatContent/ToolsContent.tsx +++ b/refact-agent/gui/src/components/ChatContent/ToolsContent.tsx @@ -269,6 +269,7 @@ function processToolCalls( ); return processToolCalls(tail, toolResults, features, [...processed, elem]); diff --git a/refact-agent/gui/src/components/IntegrationsView/IntegrationForm/ErrorState.tsx b/refact-agent/gui/src/components/IntegrationsView/IntegrationForm/ErrorState.tsx index 909355bc2..1ef3fd1a5 100644 --- a/refact-agent/gui/src/components/IntegrationsView/IntegrationForm/ErrorState.tsx +++ b/refact-agent/gui/src/components/IntegrationsView/IntegrationForm/ErrorState.tsx @@ -43,7 +43,7 @@ export const ErrorState: FC = ({ title={`Open ${integr_name}.yaml configuration file in your IDE`} onClick={() => openFile({ - file_name: integr_config_path, + file_path: integr_config_path, line: error_line === 0 ? 1 : error_line, }) } diff --git a/refact-agent/gui/src/components/IntegrationsView/IntegrationForm/FormSmartlinks.tsx b/refact-agent/gui/src/components/IntegrationsView/IntegrationForm/FormSmartlinks.tsx index f37fcf89c..b7c9492ba 100644 --- a/refact-agent/gui/src/components/IntegrationsView/IntegrationForm/FormSmartlinks.tsx +++ b/refact-agent/gui/src/components/IntegrationsView/IntegrationForm/FormSmartlinks.tsx @@ -60,7 +60,7 @@ export const FormSmartlinks: FC = ({ title={`Open ${integr_name}.yaml configuration file in your IDE`} onClick={() => openFile({ - file_name: integr_config_path, + file_path: integr_config_path, line: 1, }) } diff --git a/refact-agent/gui/src/components/Tools/Textdoc.tsx b/refact-agent/gui/src/components/Tools/Textdoc.tsx index 885ffea02..4c8c250e4 100644 --- a/refact-agent/gui/src/components/Tools/Textdoc.tsx +++ b/refact-agent/gui/src/components/Tools/Textdoc.tsx @@ -34,11 +34,12 @@ import { isRTKResponseErrorWithDetailMessage } from "../../utils"; import { MarkdownCodeBlock } from "../Markdown/CodeBlock"; import classNames from "classnames"; -export const TextDocTool: React.FC<{ toolCall: RawTextDocTool }> = ({ - toolCall, -}) => { +export const TextDocTool: React.FC<{ + toolCall: RawTextDocTool; + toolFailed?: boolean; +}> = ({ toolCall, toolFailed = false }) => { + if (toolFailed) return false; const maybeTextDocToolCall = parseRawTextDocToolCall(toolCall); - if (!maybeTextDocToolCall) return false; if (isCreateTextDocToolCall(maybeTextDocToolCall)) { @@ -63,7 +64,8 @@ export const TextDocTool: React.FC<{ toolCall: RawTextDocTool }> = ({ type TextDocHeaderProps = { toolCall: TextDocToolCall }; const TextDocHeader = forwardRef( ({ toolCall }, ref) => { - const { openFile, diffPasteBack, sendToolCallToIde } = useEventsBusForIDE(); + const { queryPathThenOpenFile, diffPasteBack, sendToolCallToIde } = + useEventsBusForIDE(); const [requestDryRun, dryRunResult] = toolsApi.useDryRunForEditToolMutation(); const [errorMessage, setErrorMessage] = useState(""); @@ -73,10 +75,12 @@ const TextDocHeader = forwardRef( const clearErrorMessage = useCallback(() => setErrorMessage(""), []); // move this - const handleOpenFile = useCallback(() => { + const handleOpenFile = useCallback(async () => { if (!toolCall.function.arguments.path) return; - openFile({ file_name: toolCall.function.arguments.path }); - }, [openFile, toolCall.function.arguments.path]); + await queryPathThenOpenFile({ + file_path: toolCall.function.arguments.path, + }); + }, [toolCall.function.arguments.path, queryPathThenOpenFile]); const handleReplace = useCallback( (content: string) => { @@ -133,7 +137,7 @@ const TextDocHeader = forwardRef( title="Open file" onClick={(event) => { event.preventDefault(); - handleOpenFile(); + void handleOpenFile(); }} > {toolCall.function.arguments.path} diff --git a/refact-agent/gui/src/features/Chat/Thread/utils.ts b/refact-agent/gui/src/features/Chat/Thread/utils.ts index 0da37e668..0d7c67e82 100644 --- a/refact-agent/gui/src/features/Chat/Thread/utils.ts +++ b/refact-agent/gui/src/features/Chat/Thread/utils.ts @@ -256,8 +256,13 @@ export function formatChatResponse( } if (isToolResponse(response)) { - const { tool_call_id, content, finish_reason, compression_strength } = - response; + const { + tool_call_id, + content, + tool_failed, + finish_reason, + compression_strength, + } = response; const filteredMessages = finishToolCallInMessages(messages, tool_call_id); const toolResult: ToolResult = typeof content === "string" @@ -266,12 +271,14 @@ export function formatChatResponse( content, finish_reason, compression_strength, + tool_failed, } : { tool_call_id, content, finish_reason, compression_strength, + tool_failed, }; return [...filteredMessages, { role: response.role, content: toolResult }]; diff --git a/refact-agent/gui/src/features/Checkpoints/Checkpoints.tsx b/refact-agent/gui/src/features/Checkpoints/Checkpoints.tsx index 33c74199c..0626b5135 100644 --- a/refact-agent/gui/src/features/Checkpoints/Checkpoints.tsx +++ b/refact-agent/gui/src/features/Checkpoints/Checkpoints.tsx @@ -81,7 +81,7 @@ export const Checkpoints = () => { title="Open file" onClick={(event) => { event.preventDefault(); - openFile({ file_name: file.absolute_path }); + openFile({ file_path: file.absolute_path }); }} style={{ textDecoration: diff --git a/refact-agent/gui/src/hooks/useEventBusForIDE.ts b/refact-agent/gui/src/hooks/useEventBusForIDE.ts index 43bbe3638..5d95cfab1 100644 --- a/refact-agent/gui/src/hooks/useEventBusForIDE.ts +++ b/refact-agent/gui/src/hooks/useEventBusForIDE.ts @@ -26,7 +26,7 @@ export const ideNewFileAction = createAction("ide/newFile"); export const ideOpenHotKeys = createAction("ide/openHotKeys"); export type OpenFilePayload = { - file_name: string; + file_path: string; line?: number; }; export const ideOpenFile = createAction("ide/openFile"); @@ -154,9 +154,9 @@ export const useEventsBusForIDE = () => { const queryPathThenOpenFile = useCallback( async (file: OpenFilePayload) => { - const res = await getFullPath(file.file_name).unwrap(); - const file_name = res ?? file.file_name; - const action = ideOpenFile({ file_name, line: file.line }); + const res = await getFullPath(file.file_path).unwrap(); + const file_name = res ?? file.file_path; + const action = ideOpenFile({ file_path: file_name, line: file.line }); postMessage(action); }, [getFullPath, postMessage], @@ -240,7 +240,7 @@ export const useEventsBusForIDE = () => { const res = await getPathQuery(undefined).unwrap(); if (res) { - const action = ideOpenFile({ file_name: res }); + const action = ideOpenFile({ file_path: res }); postMessage(action); const res_split = res.split("/"); void sendTelemetryEvent({ diff --git a/refact-agent/gui/src/hooks/useGoToLink.ts b/refact-agent/gui/src/hooks/useGoToLink.ts index 143a2c639..d633f4550 100644 --- a/refact-agent/gui/src/hooks/useGoToLink.ts +++ b/refact-agent/gui/src/hooks/useGoToLink.ts @@ -22,7 +22,7 @@ export function useGoToLink() { const payload = payloadParts.join(":"); switch (action.toLowerCase()) { case "editor": { - void queryPathThenOpenFile({ file_name: payload }); + void queryPathThenOpenFile({ file_path: payload }); return; } case "settings": { diff --git a/refact-agent/gui/src/services/refact/types.ts b/refact-agent/gui/src/services/refact/types.ts index f17fbe9ae..d48a44f56 100644 --- a/refact-agent/gui/src/services/refact/types.ts +++ b/refact-agent/gui/src/services/refact/types.ts @@ -71,6 +71,7 @@ export interface BaseToolResult { finish_reason?: string; // "call_failed" | "call_worked"; content: ToolContent; compression_strength?: CompressionStrength; + tool_failed: boolean; } export interface SingleModelToolResult extends BaseToolResult { @@ -438,6 +439,7 @@ export type ChatUserMessageResponse = export type ToolResponse = { id: string; role: "tool"; + tool_failed: boolean; } & ToolResult; export function isChatUserMessageResponse( @@ -538,6 +540,7 @@ export function isToolResponse(json: unknown): json is ToolResponse { if (!("content" in json)) return false; if (!("role" in json)) return false; if (!("tool_call_id" in json)) return false; + if (!("tool_failed" in json)) return false; return json.role === "tool"; } From 4f233704f21f70a55c3784c9ab9b6c37d40615d7 Mon Sep 17 00:00:00 2001 From: alashchev17 Date: Wed, 14 May 2025 18:50:05 +0200 Subject: [PATCH 05/17] fix: updated fixtures & combobox tests --- refact-agent/gui/src/__fixtures__/chat.ts | 34 +++++++++++++++++++ .../src/__fixtures__/chat_config_thread.ts | 20 +++++++++++ .../gui/src/__fixtures__/chat_textdoc.ts | 5 +++ refact-agent/gui/src/__fixtures__/history.ts | 1 + .../gui/src/__fixtures__/markdown-issue.ts | 8 +++++ .../__fixtures__/some_chrome_screenshots.ts | 6 ++++ .../components/ChatContent/ContextFiles.tsx | 4 +-- .../src/components/ComboBox/ComboBox.test.tsx | 12 ++++--- .../gui/src/features/Chat/Thread/reducer.ts | 2 ++ .../src/features/Chat/Thread/utils.test.ts | 1 + 10 files changed, 87 insertions(+), 6 deletions(-) diff --git a/refact-agent/gui/src/__fixtures__/chat.ts b/refact-agent/gui/src/__fixtures__/chat.ts index e279614a2..523352ec1 100644 --- a/refact-agent/gui/src/__fixtures__/chat.ts +++ b/refact-agent/gui/src/__fixtures__/chat.ts @@ -115,6 +115,7 @@ export const CHAT_FUNCTIONS_MESSAGES: ChatMessages = [ content: "Listing directory .\n 2260 file Cargo.toml\n 1530 file LICENSE\n 224 dir target\n 1198 file mycaps_te3.json\n 416 dir tests\n 152298 file Cargo.lock\n 757 file mycaps_openai.json\n 61 file build.rs\n 1264 file mycaps_gte.json\n 1598 file _video\n 3548 file README.md\n 768 dir examples\n 219 file _backtrace\n 1665 file _video2\n 141 file a.sh\n 139 file _help\n 992 dir src\n", finish_reason: "call_worked", + tool_failed: false, }, }, { @@ -124,6 +125,7 @@ export const CHAT_FUNCTIONS_MESSAGES: ChatMessages = [ content: 'File README.md:50-99\n``` "temperature": 0.1,\n "max_new_tokens": 20\n }\n}\'\n```\n\nOutput is `[{"code_completion": "\\n return \\"Hello World!\\"\\n"}]`.\n\n[LSP example](examples/lsp_completion.py)\n\n\n## Telemetry\n\nThe flags `--basic-telemetry` and `--snippet-telemetry` control what telemetry is sent. To be clear: without\nthese flags, no telemetry is sent. Those flags are typically controlled from IDE plugin settings.\n\nBasic telemetry means counters and error messages without information about you or your code. It is "compressed"\ninto `.cache/refact/telemetry/compressed` folder, then from time to time it\'s sent and moved\nto `.cache/refact/telemetry/sent` folder.\n\n"Compressed" means similar records are joined together, increasing the counter. "Sent" means the rust binary\ncommunicates with a HTTP endpoint specified in caps (see Caps section below) and sends .json file exactly how\nyou see it in `.cache/refact/telemetry`. The files are human-readable.\n\nWhen using Refact self-hosted server, telemetry goes to the self-hosted server, not to the cloud.\n\n\n## Caps File\n\nThe `--address-url` parameter controls the behavior of this program by a lot. The address is first used\nto construct `$URL/coding_assistant_caps.json` address to fetch the caps file. Furthermore, there are\ncompiled-in caps you can use by magic addresses "Refact" and "HF".\n\nThe caps file describes which models are running, default models for completion and chat,\nwhere to send the telemetry, how to download a\ntokenizer, where is the endpoint to access actual language models. To read more, check out\ncompiled-in caps in [caps.rs](src/caps.rs).\n\n\n## Tests\n\nThe one to run often is [test_edge_cases.py](tests/test_edge_cases.py).\n\nYou can also run [measure_humaneval_fim.py](tests/measure_humaneval_fim.py) for your favorite model.\n\n\n## Credits\n\nThe initial version of this project was written by looking at llm-ls by [@McPatate](https://github.com/McPatate). He\'s a Rust fan who inspired this project!\n```', finish_reason: "call_worked", + tool_failed: false, }, }, { @@ -133,6 +135,7 @@ export const CHAT_FUNCTIONS_MESSAGES: ChatMessages = [ content: 'File Cargo.toml:39-88\n```futures-util = "0.3"\nasync-stream = "0.3.5"\nchrono = "0.4.31"\nregex = "1.9.5"\nasync-trait = "0.1.73"\nsimilar = "2.3.0"\naxum = "0.6.20"\nuuid = { version = "1", features = ["v4"] }\nlazy_static = "1.4.0"\n\nregex-automata = { version = "0.1.10", features = ["transducer"] }\nsorted-vec = "0.8.3"\ntree-sitter = "0.20"\ntree-sitter-cpp = "0.20"\n#tree-sitter-c-sharp = "0.20"\ntree-sitter-java = "0.20"\ntree-sitter-javascript = "0.20"\n#tree-sitter-kotlin = "0.3.1"\ntree-sitter-python = "0.20"\ntree-sitter-rust = "0.20"\ntree-sitter-typescript = "0.20"\n\narrow = "47.0.0"\narrow-array = "47.0.0"\narrow-schema= "47.0.0"\nasync_once= "0.2.6"\nasync-process = "2.0.1"\nitertools = "0.11.0"\nlance = "=0.9.0"\nlance-linalg = "=0.9.0"\nlance-index = "=0.9.0"\nlog = "0.4.20"\nmd5 = "0.7"\nmockito = "0.28.0"\nnotify = { version = "6.1.1", features = ["serde"] }\nparking_lot = { version = "0.12.1", features = ["serde"] }\nrusqlite = { version = "0.30.0", features = ["bundled"] }\ntempfile = "3.8.1"\ntime = "0.3.30"\ntokio-rusqlite = "0.5.0"\nvectordb = "=0.4.0"\nwalkdir = "2.3"\nwhich = "5.0.0"\nstrsim = "0.8.0"\ntypetag = "0.2"\ndyn_partial_eq = "=0.1.2"\nrayon = "1.8.0"\nbacktrace = "0.3.71"\nrand = "0.8.5"\n```', finish_reason: "call_worked", + tool_failed: false, }, }, { @@ -142,6 +145,7 @@ export const CHAT_FUNCTIONS_MESSAGES: ChatMessages = [ content: 'File Cargo.lock:6265-6314\n```]\n\n[[package]]\nname = "zstd"\nversion = "0.11.2+zstd.1.5.2"\nsource = "registry+https://github.com/rust-lang/crates.io-index"\nchecksum = "20cc960326ece64f010d2d2107537f26dc589a6573a316bd5b1dba685fa5fde4"\ndependencies = [\n "zstd-safe 5.0.2+zstd.1.5.2",\n]\n\n[[package]]\nname = "zstd"\nversion = "0.12.4"\nsource = "registry+https://github.com/rust-lang/crates.io-index"\nchecksum = "1a27595e173641171fc74a1232b7b1c7a7cb6e18222c11e9dfb9888fa424c53c"\ndependencies = [\n "zstd-safe 6.0.6",\n]\n\n[[package]]\nname = "zstd-safe"\nversion = "5.0.2+zstd.1.5.2"\nsource = "registry+https://github.com/rust-lang/crates.io-index"\nchecksum = "1d2a5585e04f9eea4b2a3d1eca508c4dee9592a89ef6f450c11719da0726f4db"\ndependencies = [\n "libc",\n "zstd-sys",\n]\n\n[[package]]\nname = "zstd-safe"\nversion = "6.0.6"\nsource = "registry+https://github.com/rust-lang/crates.io-index"\nchecksum = "ee98ffd0b48ee95e6c5168188e44a54550b1564d9d530ee21d5f0eaed1069581"\ndependencies = [\n "libc",\n "zstd-sys",\n]\n\n[[package]]\nname = "zstd-sys"\nversion = "2.0.9+zstd.1.5.5"\nsource = "registry+https://github.com/rust-lang/crates.io-index"\nchecksum = "9e16efa8a874a0481a574084d34cc26fdb3b99627480f785888deb6386506656"\ndependencies = [\n "cc",\n "pkg-config",\n]\n```', finish_reason: "call_worked", + tool_failed: false, }, }, { @@ -160,6 +164,7 @@ export const CHAT_FUNCTIONS_MESSAGES: ChatMessages = [ content: "Listing directory tests\n 2438 file test_hf_endpoint.py\n 3021 file lsp_connect.py\n 678 file lsp_completion.py\n 0 file __init__.py\n 96 dir __pycache__/\n 1340 file test_at_completion.py\n 3926 file post_doc_info.py\n 224 dir emergency_frog_situation/\n 4107 file test_edge_cases.py\n 2081 file code_completion_with_rag.py\n 2866 file measure_humaneval_fim.py\n", finish_reason: "call_worked", + tool_failed: false, }, }, { @@ -169,6 +174,7 @@ export const CHAT_FUNCTIONS_MESSAGES: ChatMessages = [ content: "ERROR: [Errno 21] Is a directory: './tests/emergency_frog_situation'", finish_reason: "call_failed", + tool_failed: false, }, }, { @@ -178,6 +184,7 @@ export const CHAT_FUNCTIONS_MESSAGES: ChatMessages = [ content: "ERROR: [Errno 21] Is a directory: './tests/emergency_frog_situation'", finish_reason: "call_failed", + tool_failed: false, }, }, { @@ -187,6 +194,7 @@ export const CHAT_FUNCTIONS_MESSAGES: ChatMessages = [ content: "ERROR: [Errno 21] Is a directory: './tests/emergency_frog_situation'", finish_reason: "call_failed", + tool_failed: false, }, }, { @@ -196,6 +204,7 @@ export const CHAT_FUNCTIONS_MESSAGES: ChatMessages = [ content: "ERROR: [Errno 21] Is a directory: './tests/emergency_frog_situation'", finish_reason: "call_failed", + tool_failed: false, }, }, { @@ -211,6 +220,7 @@ export const CHAT_FUNCTIONS_MESSAGES: ChatMessages = [ content: "Listing directory tests/emergency_frog_situation\n 1516 file jump_to_conclusions.py\n 695 file set_as_avatar.py\n 96 dir __pycache__/\n 777 file frog.py\n 249 file work_day.py\n", finish_reason: "call_worked", + tool_failed: false, }, }, { @@ -241,6 +251,7 @@ export const CHAT_FUNCTIONS_MESSAGES: ChatMessages = [ content: "File tests/emergency_frog_situation/frog.py:1-29\n```import numpy as np\n\nDT = 0.01\n\nclass Frog:\n def __init__(self, x, y, vx, vy):\n self.x = x\n self.y = y\n self.vx = vx\n self.vy = vy\n\n def bounce_off_banks(self, pond_width, pond_height):\n if self.x < 0:\n self.vx = np.abs(self.vx)\n elif self.x > pond_width:\n self.vx = -np.abs(self.vx)\n if self.y < 0:\n self.vy = np.abs(self.vy)\n elif self.y > pond_height:\n self.vy = -np.abs(self.vy)\n\n def jump(self, pond_width, pond_height):\n self.x += self.vx * DT\n self.y += self.vy * DT\n self.bounce_off_banks(pond_width, pond_height)\n self.x = np.clip(self.x, 0, pond_width)\n self.y = np.clip(self.y, 0, pond_height)\n\n```", finish_reason: "call_worked", + tool_failed: false, }, }, { @@ -288,6 +299,7 @@ export const FROG_CHAT: ChatThread = { tool_call_id: "call_NSSpdvLovaH50zZUug463YRI", content: "attached file: /Users/marc/Projects/refact-lsp/tests/emergency_frog_situation/frog.py", + tool_failed: false, }, }, { @@ -296,6 +308,8 @@ export const FROG_CHAT: ChatThread = { tool_call_id: "call_cmTkaNJ0roopnMcNfG4raxny", content: "attached file: /Users/marc/Projects/refact-lsp/tests/emergency_frog_situation/frog.py", + + tool_failed: false, }, }, { @@ -334,6 +348,8 @@ export const FROG_CHAT: ChatThread = { tool_call_id: "call_8ER9PVREdkt37h84LZyc97c9", content: "attached file: /Users/marc/Projects/refact-lsp/tests/emergency_frog_situation/frog.py", + + tool_failed: false, }, }, { @@ -373,6 +389,8 @@ export const FROG_CHAT: ChatThread = { tool_call_id: "call_1bHhD3bVIzvOueSDq1otYX4i", content: "attached file: /Users/marc/Projects/refact-lsp/tests/emergency_frog_situation/frog.py", + + tool_failed: false, }, }, { @@ -498,6 +516,7 @@ export const CHAT_WITH_DIFF_ACTIONS: ChatThread = { content: { tool_call_id: "call_n5qeQaFZNAoaP3qJzRiGO6Js", content: "performed vecdb search, results below", + tool_failed: false, }, }, { @@ -619,6 +638,8 @@ export const LARGE_DIFF: ChatThread = { tool_call_id: "call_b0ZalvpaQCZLGIHS0t4O3tH3", content: " \n Users\n marc\n Projects\n refact-lsp\n tests\n emergency_frog_situation\n frog.py\n holiday.py\n jump_to_conclusions.py\n set_as_avatar.py\n work_day.py\n", + + tool_failed: false, }, }, { @@ -641,6 +662,8 @@ export const LARGE_DIFF: ChatThread = { content: { tool_call_id: "call_YozL4pz5zNwdEaNWhdVQdcIF", content: "performed vecdb search, results below", + + tool_failed: false, }, }, { @@ -884,6 +907,8 @@ export const TOOL_IMAGE_STUB: ChatMessages = [ tool_call_id: "a", content: "Opened new tab new\n\nChrome tab navigated to https://www.wikipedia.org/", + + tool_failed: false, }, }, { @@ -920,6 +945,7 @@ export const TOOL_IMAGE_STUB: ChatMessages = [ "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", }, ], + tool_failed: false, }, }, ]; @@ -959,6 +985,8 @@ export const CHAT_WITH_KNOWLEDGE_TOOL: ChatThread = { tool_call_id: "toolu_01QjezACFfkEe4Yfid2AgdPh", content: '🗃️110c57fd71\nYou have a specialization today: web development.\n\nYou only need to receive instructions from the user once, and then you can autonomously fill in the details of\nthe task, make the necessary changes, verify results and make adjustments and fixes.\n\nHere\'s your approximate web development plan:\n1. Investigate project to understand the task given by the user, start with calling tree() and looking into relevant files. If you see reference designs and sketches, read them using cat().\n2. Run the server. You don\'t have direct access to the command line. Look if there\'s a tool for that purpose. If there is not, you cannot run a web server.\n3. Make relevant screenshots of existing website using chrome(), open both desktop and mobile tabs if the task requires it.\n4. Form a complete interpretation of the task, and write a plan.\n5. Make changes in files using 📍-notation, after that call patch(). Really, first you need to write the updates using 📍-notation, only after that you can apply it using patch().\n6. Check if screenshots got better, or any errors appeared.\n7. Goto 5, unless you see the task is complete.\n\nAs a web developer agent, you need to pay attention to detail. The task is complete if all the elements\nare at the right place. You really need to cat() designs and sketches if they are present in the task.\n\nIf you don\'t see a way to run a real server for the website, then just use chrome() to look\nat .html pages using file:// addresses.\n\nHere is a compressed example of successful trajectory from another project:\n\nDON\'T DO STUPID THINGS:\n* DON\'T SKIP MAKING SCREENSHOTS\n* DON\'T CALL patch() UNTIL YOU FINIHSHED WRITING CODE IN 📍-NOTATION\n* DON\'T ASK USER ANYTHING, YOU HAVE AUTONOMOUS WORK TO DO\n* MAKE SURE IF HAVE A TOOL CALL IN THE END OF EACH RESPONSE, UNLESS YOU COMPLETED AND TESTED THE TASK\n\n\n🗃️019957b6ff\nAdditional instructions for django web development.\n\nYou only need to receive instructions from the user once, and then you can autonomously fill in the details of\nthe task, make the necessary changes, verify results and make adjustments and fixes.\n\nHere\'s your approximate web development plan:\n1. Investigate project to understand the task given by the user, start with calling tree() and locate(), looking into relevant files using cat(). If you see reference designs and sketches, read them using cat()\n2. Start django server\n3. Navigate to the place on the website that user wants to change, make a screenshot to make sure you understand what exactly needs to change\n4. Form a complete interpretation of the task, and write a plan.\n5. Make changes in files using 📍-notation, after that call patch(). Really, first you need to write the updates using 📍-notation, only after that you can apply it.\n6. Check if screenshots got better, or any errors appeared.\n7. Goto 5, unless you see the task is complete.\n\nAs a web developer agent, you need to pay attention to detail. The task is complete if all the elements\nare at the right place.\n\nDON\'T DO STUPID THINGS:\n* DON\'T SKIP MAKING SCREENSHOTS\n* DON\'T CALL patch() UNTIL YOU FINIHSHED WRITING CODE IN 📍-NOTATION\n* DON\'T ASK USER ANYTHING, YOU HAVE AUTONOMOUS WORK TO DO\n* MAKE SURE YOU HAVE A TOOL CALL IN THE END OF EACH RESPONSE, UNLESS YOU COMPLETED AND TESTED THE TASK\n\n🗃️36338b63b3\n[\n["goal", "Discuss whether birds are real, their software, programming, and Python usage"],\n["thinking", "User is asking about birds and software. Evidence: birds are biological creatures, but there\'s research into bird-inspired algorithms and robotics."],\n["thinking", "When asked about bird programming, focused on research projects like BirdBrain, Flocking, and RoboBird that simulate or interact with birds."],\n["thinking", "When asked about Python-using birds, clarified that birds don\'t use programming languages, but Python is used by researchers to study birds."],\n["coding", "Provided example of Boid algorithm simulation in Python showing flocking behavior"],\n["coding", "Provided finite state machine simulation of bird behavior states (perched, flying, eating)"],\n["coding", "Provided bird population growth simulation using simple mathematical model"],\n["coding", "Provided example of bird song classification using RandomForestClassifier"],\n["outcome", "SUCCESS"]\n]\n\n🗃️81e825a188\n[\n["goal", "Add swim method to Frog class in frog.py"],\n["thinking", "Can add swim method directly using REWRITE_ONE_SYMBOL since the file is small and class structure is clear"],\n["coding", "📍REWRITE_ONE_SYMBOL 000 added swim(dx, dy, pond_width, pond_height) method with position updates and boundary checks"],\n["outcome", "SUCCESS"]\n]\n\n🗃️6f3566503d\nLooks like proj2 is written in fact in Rust.\n', + + tool_failed: false, }, }, { @@ -982,6 +1010,8 @@ export const CHAT_WITH_KNOWLEDGE_TOOL: ChatThread = { tool_call_id: "toolu_01P9sbpcJDR7tDBFPDVbRuYK", content: '{\n "FOUND": {\n "frog.py": "Frog",\n "holiday.py": "frog.Frog",\n "work_day.py": "bring_your_own_frog"\n },\n "MORE_TOCHANGE": {\n "set_as_avatar.py": "Toad, EuropeanCommonToad",\n "jump_to_conclusions.py": "creatures",\n "holiday.py": "frog1,frog2"\n },\n "USAGE": {\n "jump_to_conclusions.py": "creatures",\n "work_day.py": "bring_your_own_frog",\n "set_as_avatar.py": "Toad, EuropeanCommonToad"\n }\n}', + + tool_failed: false, }, }, { @@ -1392,6 +1422,8 @@ export const CHAT_WITH_KNOWLEDGE_TOOL: ChatThread = { tool_call_id: "toolu_01XrmGSBgvr3BNHw8VrNM2M5", content: 'AST assessment has failed: the generated diff had introduced errors into the file `"/Users/marc/Projects/refact-lsp/tests/emergency_frog_situation/jump_to_conclusions.py"`: 0 before errs < 46 after errs', + + tool_failed: false, }, }, { @@ -1476,6 +1508,8 @@ export const CHAT_WITH_KNOWLEDGE_TOOL: ChatThread = { tool_call_id: "toolu_01EkpiymGNGZPdzevMeTpRS9", content: "Nothing in STDOUT/STDERR\n\nThe command was running 0.010s, finished with exit code 0", + + tool_failed: false, }, }, { diff --git a/refact-agent/gui/src/__fixtures__/chat_config_thread.ts b/refact-agent/gui/src/__fixtures__/chat_config_thread.ts index 9bd824400..f5adbf6fc 100644 --- a/refact-agent/gui/src/__fixtures__/chat_config_thread.ts +++ b/refact-agent/gui/src/__fixtures__/chat_config_thread.ts @@ -33,6 +33,8 @@ export const CHAT_CONFIG_THREAD: Chat = { tool_call_id: "call_IkNfXpwhNVR6D1Sr2CDA5Cfi", content: "🧩 for configuration go to SETTINGS:postgres, psql failed:\nNo such file or directory (os error 2)", + + tool_failed: false, }, }, { @@ -56,6 +58,7 @@ export const CHAT_CONFIG_THREAD: Chat = { tool_call_id: "call_kw6TJChemYjXEGL9mLL3T0mN", content: "/\n Users/\n marc/\n Projects/\n refact-lsp/\n .dockerignore\n .gitattributes\n .gitignore\n CODE_OF_CONDUCT.md\n CONTRIBUTING.md\n Cargo.lock\n Cargo.toml\n Cross.toml\n INTEGRATIONS.md\n LICENSE\n README.md\n build.rs\n tests/\n __init__.py\n lsp_connect.py\n test01_completion_edge_cases.py\n test02_completion_with_rag.py\n test03_at_commands_completion.py\n test04_completion_lsp.py\n test05_is_openai_compatible.py\n test06_tool_not_tool.py\n test07_memories.py\n test08_post_processing.py\n test09_ast_pick_up_changes.py\n test10_locate.py\n test11_patch.py\n test11_patch_partial_edit.py\n test12_tools_authorize_calls.py\n test13_vision.py\n test_diff_handlers.py\n test13_data/\n 200.jpg\n 530.jpg\n test11_data/\n already_applied_rewrite_symbol_01.py\n already_applied_rewrite_symbol_02.py\n toad_orig.py\n toad_partial_edit_01.py\n toad_partial_edit_02.py\n toad_rewrite_symbol_01.py\n toad_rewrite_symbol_02.py\n toad_rewrite_symbol_03.py\n toad_rewrite_symbol_04_orig.rs\n toad_rewrite_symbol_04_patched.rs\n emergency_frog_situation/\n frog.py\n holiday.py\n jump_to_conclusions.py\n set_as_avatar.py\n work_day.py\n src/\n background_tasks.rs\n cached_tokenizers.rs\n call_validation.rs\n caps.rs\n completion_cache.rs\n custom_error.rs\n diffs.rs\n fetch_embedding.rs\n file_filter.rs\n files_correction.rs\n files_in_jsonl.rs\n files_in_workspace.rs\n forward_to_hf_endpoint.rs\n forward_to_openai_endpoint.rs\n fuzzy_search.rs\n git.rs\n global_context.rs\n http.rs\n knowledge.rs\n known_models.rs\n lsp.rs\n main.rs\n nicer_logs.rs\n privacy.rs\n privacy_compiled_in.rs\n restream.rs\n scratchpad_abstract.rs\n subchat.rs\n version.rs\n yaml_configs/\n create_configs.rs\n customization_compiled_in.rs\n customization_loader.rs\n mod.rs\n vecdb/\n mod.rs\n vdb_cache.rs\n vdb_file_splitter.rs\n vdb_highlev.rs\n vdb_lance.rs\n vdb_remote.rs\n vdb_structs.rs\n vdb_thread.rs\n tools/\n mod.rs\n tool_ast_definition.rs\n tool_ast_reference.rs\n tool_cat.rs\n tool_cmdline.rs\n tool_deep_thinking.rs\n tool_knowledge.rs\n tool_locate_search.rs\n tool_patch.rs\n tool_relevant_files.rs\n tool_search.rs\n tool_tree.rs\n tool_web.rs\n tools_description.rs\n tools_execute.rs\n tool_patch_aux/\n ast_lint.rs\n diff_apply.rs\n diff_structs.rs\n fs_utils.rs\n mod.rs\n no_model_edit.rs\n postprocessing_utils.rs\n tickets_parsing.rs\n model_based_edit/\n blocks_of_code_parser.rs\n mod.rs\n model_execution.rs\n partial_edit.rs\n whole_file_parser.rs\n telemetry/\n basic_comp_counters.rs\n basic_network.rs\n basic_robot_human.rs\n basic_transmit.rs\n mod.rs\n snippets_collection.rs\n snippets_transmit.rs\n telemetry_structs.rs\n utils.rs\n scratchpads/\n chat_generic.rs\n chat_llama2.rs\n chat_passthrough.rs\n chat_utils_deltadelta.rs\n chat_utils_limit_history.rs\n chat_utils_prompts.rs\n code_completion_fim.rs\n code_completion_replace.rs\n comments_parser.rs\n mod.rs\n multimodality.rs\n passthrough_convert_messages.rs\n scratchpad_utils.rs\n postprocessing/\n mod.rs\n pp_command_output.rs\n pp_context_files.rs\n pp_plain_text.rs\n pp_utils.rs\n integrations/\n config_chat.rs\n integr_abstract.rs\n integr_chrome.rs\n integr_github.rs\n integr_gitlab.rs\n integr_pdb.rs\n integr_postgres.rs\n mod.rs\n process_io_utils.rs\n running_integrations.rs\n sessions.rs\n setting_up_integrations.rs\n yaml_schema.rs\n docker/\n docker_container_manager.rs\n docker_ssh_tunnel_utils.rs\n integr_docker.rs\n mod.rs\n http/\n routers.rs\n utils.rs\n routers/\n info.rs\n v1.rs\n v1/\n ast.rs\n at_commands.rs\n at_tools.rs\n caps.rs\n chat.rs\n code_completion.rs\n code_lens.rs\n customization.rs\n dashboard.rs\n docker.rs\n git.rs\n graceful_shutdown.rs\n gui_help_handlers.rs\n handlers_memdb.rs\n links.rs\n lsp_like_handlers.rs\n patch.rs\n snippet_accepted.rs\n status.rs\n subchat.rs\n sync_files.rs\n system_prompt.rs\n telemetry_network.rs\n v1_integrations.rs\n vecdb.rs\n dashboard/\n dashboard.rs\n mod.rs\n structs.rs\n utils.rs\n at_commands/\n at_ast_definition.rs\n at_ast_reference.rs\n at_commands.rs\n at_file.rs\n at_search.rs\n at_tree.rs\n at_web.rs\n execute_at.rs\n mod.rs\n ast/\n ast_db.rs\n ast_indexer_thread.rs\n ast_parse_anything.rs\n ast_structs.rs\n chunk_utils.rs\n dummy_tokenizer.json\n file_splitter.rs\n linters.rs\n mod.rs\n parse_common.rs\n parse_python.rs\n treesitter/\n ast_instance_structs.rs\n file_ast_markup.rs\n language_id.rs\n mod.rs\n parsers.rs\n skeletonizer.rs\n structs.rs\n parsers/\n cpp.rs\n java.rs\n js.rs\n python.rs\n rust.rs\n tests.rs\n ts.rs\n utils.rs\n tests/\n cpp.rs\n java.rs\n js.rs\n python.rs\n rust.rs\n ts.rs\n cases/\n ts/\n main.ts\n main.ts.json\n person.ts\n person.ts.decl_json\n person.ts.skeleton\n rust/\n main.rs\n main.rs.json\n point.rs\n point.rs.decl_json\n point.rs.skeleton\n python/\n calculator.py\n calculator.py.decl_json\n calculator.py.skeleton\n main.py\n main.py.json\n js/\n car.js\n car.js.decl_json\n car.js.skeleton\n main.js\n main.js.json\n java/\n main.java\n main.java.json\n person.java\n person.java.decl_json\n person.java.skeleton\n cpp/\n circle.cpp\n circle.cpp.decl_json\n circle.cpp.skeleton\n main.cpp\n main.cpp.json\n alt_testsuite/\n cpp_goat_library.correct\n cpp_goat_library.h\n cpp_goat_main.correct\n cpp_goat_main.cpp\n jump_to_conclusions_annotated.py\n py_goat_library.correct\n py_goat_library.py\n py_goat_library_annotated.py\n py_goat_main.py\n py_goat_main_annotated.py\n py_torture1_attr.py\n py_torture1_attr_annotated.py\n py_torture2_resolving.py\n py_torture2_resolving_annotated.py\n python_binding_and_cmdline/\n setup.py\n refact/\n __init__.py\n chat_client.py\n cli_app_switcher.py\n cli_export.py\n cli_inspect.py\n cli_main.py\n cli_markdown.py\n cli_printing.py\n cli_settings.py\n cli_statusbar.py\n cli_streaming.py\n lsp_runner.py\n traj_compressor.py\n examples/\n ast_definition.sh\n ast_references.sh\n chat_with_at_command.py\n http_caps.sh\n http_chat.sh\n http_chat_passthrough.sh\n http_completion.sh\n http_rag_status.sh\n http_subchat.sh\n http_vecdb_search.sh\n lsp_runner.py\n note3.py\n rag_skeletonize_video.py\n docker/\n lsp-debug.Dockerfile\n chrome/\n mac_arm-130.0.6723.69/\n chrome-mac-arm64/\n Google Chrome for Testing.app/\n Contents/\n Resources/\n com.google.chrome.for.testing.manifest/\n Contents/\n Resources/\n com.google.chrome.for.testing.manifest\n en.lproj/\n Localizable.strings\n Frameworks/\n Google Chrome for Testing Framework.framework/\n Versions/\n 130.0.6723.69/\n Libraries/\n WidevineCdm/\n _platform_specific/\n mac_arm64/\n libwidevinecdm.dylib\n bring_your_own_key/\n hf.yaml\n mixed.yaml\n openai.yaml\n openrouter.yaml", + tool_failed: false, }, }, { @@ -98,6 +101,7 @@ export const CHAT_CONFIG_THREAD: Chat = { tool_call_id: "call_QD1oyHwPOvvFdYUfV3ijiKzB", content: "Paths found:\n/Users/marc/Projects/refact-lsp/tests/emergency_frog_situation/frog.py\n", + tool_failed: false, }, }, { @@ -106,6 +110,7 @@ export const CHAT_CONFIG_THREAD: Chat = { tool_call_id: "call_vmIGl31ytfpLWPkc138HJnxz", content: 'Path problems:\n\nThe path "README.md" does not exist. There are no similar names either.\n', + tool_failed: false, }, }, { @@ -114,6 +119,7 @@ export const CHAT_CONFIG_THREAD: Chat = { tool_call_id: "call_4we2wH5H50A2m6CIJqKbzYH8", content: 'Path problems:\n\nThe path "Cargo.toml" does not exist. There are no similar names either.\n', + tool_failed: false, }, }, { @@ -167,6 +173,7 @@ export const CHAT_CONFIG_THREAD: Chat = { tool_call_id: "call_1DUkSfLq6Io8xowqVjJEuybM", content: 'Path problems:\n\nThe path "src/lib.rs" does not exist. There are no similar names either.\n', + tool_failed: false, }, }, { @@ -175,6 +182,7 @@ export const CHAT_CONFIG_THREAD: Chat = { tool_call_id: "call_n9FACVDl6a4tllgyWaLCl8s9", content: 'Path problems:\n\nThe path "src/main.rs" does not exist. There are no similar names either.\n', + tool_failed: false, }, }, { @@ -183,6 +191,7 @@ export const CHAT_CONFIG_THREAD: Chat = { tool_call_id: "call_sNnvyOLlmulfHIikJzKhmz55", content: 'Path problems:\n\nThe path "src/Cargo.toml" does not exist. There are no similar names either.\n', + tool_failed: false, }, }, { @@ -206,6 +215,7 @@ export const CHAT_CONFIG_THREAD: Chat = { tool_call_id: "call_h8biZ8JNUjeWGbL9CCatbPcf", content: 'Path problems:\n\nThe path "src/background_tasks.rs" does not exist. There are no similar names either.\n', + tool_failed: false, }, }, { @@ -230,6 +240,7 @@ export const CHAT_CONFIG_THREAD: Chat = { tool_call_id: "call_coI5PDRF2O2Mjcfb8bdZ4Heo", content: 'Path problems:\n\nThe path "src/tools/integr_postgres.rs" does not exist. There are no similar names either.\n', + tool_failed: false, }, }, { @@ -254,6 +265,7 @@ export const CHAT_CONFIG_THREAD: Chat = { tool_call_id: "call_RXDRwr3yCJEplHud4xRoxWlC", content: 'Path problems:\n\nThe path "src/integrations/integr_postgres.rs" does not exist. There are no similar names either.\n', + tool_failed: false, }, }, { @@ -278,6 +290,7 @@ export const CHAT_CONFIG_THREAD: Chat = { tool_call_id: "call_OvYAforNKAFz0d7mv96AnTVR", content: 'Path problems:\n\nThe path "src/integrations/integr_abstract.rs" does not exist. There are no similar names either.\n', + tool_failed: false, }, }, { @@ -302,6 +315,7 @@ export const CHAT_CONFIG_THREAD: Chat = { tool_call_id: "call_3wuMILBYl0z7pBMUoJOwohQf", content: 'Path problems:\n\nThe path "src/integrations/integr_github.rs" does not exist. There are no similar names either.\n', + tool_failed: false, }, }, { @@ -326,6 +340,7 @@ export const CHAT_CONFIG_THREAD: Chat = { tool_call_id: "call_AzBRj8RiL1wc8eejuBVdaS6t", content: 'Path problems:\n\nThe path "src/integrations/integr_gitlab.rs" does not exist. There are no similar names either.\n', + tool_failed: false, }, }, { @@ -350,6 +365,7 @@ export const CHAT_CONFIG_THREAD: Chat = { tool_call_id: "call_bJ2MrMSJHk4IF6Gp5DNLhJZP", content: 'Path problems:\n\nThe path "src/integrations/integr_chrome.rs" does not exist. There are no similar names either.\n', + tool_failed: false, }, }, { @@ -374,6 +390,7 @@ export const CHAT_CONFIG_THREAD: Chat = { tool_call_id: "call_kZFTzONZdyo11FQcSudIo3vK", content: 'Path problems:\n\nThe path "src/integrations/integr_pdb.rs" does not exist. There are no similar names either.\n', + tool_failed: false, }, }, { @@ -398,6 +415,7 @@ export const CHAT_CONFIG_THREAD: Chat = { tool_call_id: "call_MDynldaxbGEuCKSuQg0Vgk5z", content: 'Path problems:\n\nThe path "src/integrations/integr_docker.rs" does not exist. There are no similar names either.\n', + tool_failed: false, }, }, { @@ -422,6 +440,7 @@ export const CHAT_CONFIG_THREAD: Chat = { tool_call_id: "call_9fCGZwstx7G1MgHs6JD5JWTn", content: 'Path problems:\n\nThe path "src/integrations/integr_abstract.rs" does not exist. There are no similar names either.\n', + tool_failed: false, }, }, { @@ -446,6 +465,7 @@ export const CHAT_CONFIG_THREAD: Chat = { tool_call_id: "call_etmMcI1UwBSaWwZHzxsuL8xu", content: 'Path problems:\n\nThe path "src/integrations/integr_postgres.rs" does not exist. There are no similar names either.\n', + tool_failed: false, }, }, ], diff --git a/refact-agent/gui/src/__fixtures__/chat_textdoc.ts b/refact-agent/gui/src/__fixtures__/chat_textdoc.ts index cd2b13e97..a7fbc113e 100644 --- a/refact-agent/gui/src/__fixtures__/chat_textdoc.ts +++ b/refact-agent/gui/src/__fixtures__/chat_textdoc.ts @@ -45,6 +45,7 @@ export const CHAT_WITH_TEXTDOC: ChatThread = { tool_call_id: "toolu_01XVhkyaDunsy4fPrDqy3toa", content: "🗃️e19af1e7b3\nYou have a specialization today: web development.\n\nYou only need to receive instructions from the user once, and then you can autonomously fill in the details of\nthe task, make the necessary changes, verify results and make adjustments and fixes.\n\nHere's your approximate web development plan:\n1. Investigate project to understand the task given by the user, start with calling tree() and looking into relevant files. If you see reference designs and sketches, read them using cat().\n2. Run the server. You don't have direct access to the command line. Look if there's a tool for that purpose. If there is not, you cannot run a web server.\n3. Make relevant screenshots of existing website using chrome(), open both desktop and mobile tabs if the task requires it.\n4. Form a complete interpretation of the task, and write a plan.\n5. Make changes in files using 📍-notation, after that call patch(). Really, first you need to write the updates using 📍-notation, only after that you can apply it using patch().\n6. Check if screenshots got better, or any errors appeared.\n7. Goto 5, unless you see the task is complete.\n\nAs a web developer agent, you need to pay attention to detail. The task is complete if all the elements\nare at the right place. You really need to cat() designs and sketches if they are present in the task.\n\nIf you don't see a way to run a real server for the website, then just use chrome() to look\nat .html pages using file:// addresses.\n\nHere is a compressed example of successful trajectory from another project:\n\nDON'T DO STUPID THINGS:\n* DON'T SKIP MAKING SCREENSHOTS\n* DON'T CALL patch() UNTIL YOU FINIHSHED WRITING CODE IN 📍-NOTATION\n* DON'T ASK USER ANYTHING, YOU HAVE AUTONOMOUS WORK TO DO\n* MAKE SURE IF HAVE A TOOL CALL IN THE END OF EACH RESPONSE, UNLESS YOU COMPLETED AND TESTED THE TASK\n\n\n🗃️d84f5c4a7c\nAdditional instructions for django web development.\n\nYou only need to receive instructions from the user once, and then you can autonomously fill in the details of\nthe task, make the necessary changes, verify results and make adjustments and fixes.\n\nHere's your approximate web development plan:\n1. Investigate project to understand the task given by the user, start with calling tree() and locate(), looking into relevant files using cat(). If you see reference designs and sketches, read them using cat()\n2. Start django server\n3. Navigate to the place on the website that user wants to change, make a screenshot to make sure you understand what exactly needs to change\n4. Form a complete interpretation of the task, and write a plan.\n5. Make changes in files using 📍-notation, after that call patch(). Really, first you need to write the updates using 📍-notation, only after that you can apply it.\n6. Check if screenshots got better, or any errors appeared.\n7. Goto 5, unless you see the task is complete.\n\nAs a web developer agent, you need to pay attention to detail. The task is complete if all the elements\nare at the right place.\n\nDON'T DO STUPID THINGS:\n* DON'T SKIP MAKING SCREENSHOTS\n* DON'T CALL patch() UNTIL YOU FINIHSHED WRITING CODE IN 📍-NOTATION\n* DON'T ASK USER ANYTHING, YOU HAVE AUTONOMOUS WORK TO DO\n* MAKE SURE YOU HAVE A TOOL CALL IN THE END OF EACH RESPONSE, UNLESS YOU COMPLETED AND TESTED THE TASK\n\n🗃️ae3f1228bd\n[\n[\"goal\", \"Rename all occurrences of 'frog' to 'bird' in the project\"],\n[\"tree(use_ast=true)\", \"Found emergency_frog_situation/ with index.html, holiday.py, work_day.py, game.js, jump_to_conclusions.py, bird.py, set_as_avatar.py\"],\n[\"search(query='frog', scope='workspace')\", \"Found frog references in work_day.py (imports, function), jump_to_conclusions.py (imports, class usage), bird.py already has Bird class\"],\n[\"thinking\", \"bird.py already has Bird class and set_as_avatar.py uses it, so we need to update work_day.py and jump_to_conclusions.py to use the existing Bird class\"],\n[\"coding\", \"📍REWRITE_WHOLE_FILE 001 'work_day.py' changed import frog->bird, bring_your_own_frog->bring_your_own_bird, frog.Frog->bird.Bird\"],\n[\"patch(tickets='001', path='tests/emergency_frog_situation/work_day.py')\", \"3 chunks applied: import change, function rename, type annotation update\"],\n[\"coding\", \"📍REWRITE_WHOLE_FILE 002 'jump_to_conclusions.py' changed import frog->bird, draw_hello_frog->draw_hello_bird, all frog.Frog->bird.Bird\"],\n[\"patch(tickets='002', path='tests/emergency_frog_situation/jump_to_conclusions.py')\", \"5 chunks applied: import, function rename, constructor call, type annotation, function call\"],\n[\"outcome\", \"SUCCESS\"]\n]\n\n🗃️2b684b6e70\nYou have a specialization today: web development.\n\nYou only need to receive instructions from the user once, and then you can autonomously fill in the details of\nthe task, make the necessary changes, verify results and make adjustments and fixes.\n\nHere's your approximate web development plan:\n1. Investigate project to understand the task given by the user, start with calling tree() and looking into relevant files. If you see reference designs and sketches, read them using cat().\n2. Run the server. You don't have direct access to the command line. Look if there's a tool for that purpose. If there is not, you cannot run a web server.\n3. Make relevant screenshots of existing website using chrome(), open both desktop and mobile tabs if the task requires it.\n4. Form a complete interpretation of the task, and write a plan.\n5. Make changes in files using 📍-notation, after that call patch(). Really, first you need to write the updates using 📍-notation, only after that you can apply it using patch().\n6. Check if screenshots got better, or any errors appeared.\n7. Goto 5, unless you see the task is complete.\n\nAs a web developer agent, you need to pay attention to detail. The task is complete if all the elements\nare at the right place. You really need to cat() designs and sketches if they are present in the task.\n\nIf you don't see a way to run a real server for the website, then just use chrome() to look\nat .html pages using file:// addresses.\n\nHere is a compressed example of successful trajectory from another project:\n\nDON'T DO STUPID THINGS:\n* DON'T SKIP MAKING SCREENSHOTS\n* DON'T CALL patch() UNTIL YOU FINIHSHED WRITING CODE IN 📍-NOTATION\n* DON'T ASK USER ANYTHING, YOU HAVE AUTONOMOUS WORK TO DO\n* MAKE SURE IF HAVE A TOOL CALL IN THE END OF EACH RESPONSE, UNLESS YOU COMPLETED AND TESTED THE TASK\n\n", + tool_failed: false, }, }, { @@ -70,6 +71,7 @@ export const CHAT_WITH_TEXTDOC: ChatThread = { tool_call_id: "toolu_01HMyLgKsLQURM9vgd3vQKXN", content: "/\n home/\n svakhreev/\n projects/\n refact-lsp/\n tests/\n emergency_frog_situation/\n holiday.py\n work_day.py\n __pycache__/\n frog.cpython-310.pyc\n frog.py\n jump_to_conclusions.py\n set_as_avatar.py", + tool_failed: false, }, }, { @@ -96,6 +98,7 @@ export const CHAT_WITH_TEXTDOC: ChatThread = { tool_call_id: "toolu_0136dUTkih5ES8rrzHa5B5ep", content: "Paths found:\n/Users/marc/Projects/refact-lsp/tests/emergency_frog_situation/frog.py\n", + tool_failed: false, }, }, { @@ -983,6 +986,7 @@ export const CHAT_WITH_TEXTDOC: ChatThread = { tool_call_id: "toolu_01LHPjgzJ8SEuczfm6Av7qfv", content: 'No replacement was performed, `pattern` \n```\n\\s*#.*$\n```\ndid not appear verbatim in "/Users/marc/Projects/refact-lsp/tests/emergency_frog_situation/test_frog.py". Consider checking the file content using `cat()`', + tool_failed: false, }, }, { @@ -1009,6 +1013,7 @@ export const CHAT_WITH_TEXTDOC: ChatThread = { tool_call_id: "toolu_019iakkKqUjKP73EmEgVhCkZ", content: "Paths found:\n/Users/marc/Projects/refact-lsp/tests/emergency_frog_situation/test_frog.py\n", + tool_failed: false, }, }, { diff --git a/refact-agent/gui/src/__fixtures__/history.ts b/refact-agent/gui/src/__fixtures__/history.ts index d8d0f7050..55339ed76 100644 --- a/refact-agent/gui/src/__fixtures__/history.ts +++ b/refact-agent/gui/src/__fixtures__/history.ts @@ -64,6 +64,7 @@ export const HISTORY: ChatHistoryItem[] = [ content: { tool_call_id: "call_D0rhujadTb1nvKlMbZ8ZYLEt", content: "performed vecdb search, results below", + tool_failed: false, }, }, { diff --git a/refact-agent/gui/src/__fixtures__/markdown-issue.ts b/refact-agent/gui/src/__fixtures__/markdown-issue.ts index b3587f6df..f141e5301 100644 --- a/refact-agent/gui/src/__fixtures__/markdown-issue.ts +++ b/refact-agent/gui/src/__fixtures__/markdown-issue.ts @@ -41,6 +41,7 @@ export const MARKDOWN_ISSUE: ChatThread = { tool_call_id: "toolu_01JbWarAwzjMyV6azDkd5skX", content: "/\n home/\n fupfv/\n git/\n benchmark1_0701/\n 12.zip\n LICENSE\n README.md\n VISUALIZATION.md\n example_new_file.py\n grafana-dashboard.json\n llm_load_test.zip\n llm_load_test/\n README.md\n requirements.txt\n src/\n llm_load_test_runner.py\n llm_test_logger.py\n load_test.py\n load_test_report_20240811_002319.csv\n load_test_report_20240811_002319.json\n make_scripts_executable.sh\n requirements.txt\n results/\n run_20250129_152629/\n load_test_report_2025-01-29T152630.827620.csv\n load_test_report_2025-01-29T152630.827620.json\n load_test_report_2025-01-29T152636.621391.csv\n load_test_report_2025-01-29T152636.621391.json\n load_test_report_2025-01-29T152642.333384.csv\n load_test_report_2025-01-29T152642.333384.json\n load_test_report_2025-01-29T152648.032846.csv\n load_test_report_2025-01-29T152648.032846.json\n load_test_report_2025-01-29T152653.733025.csv\n load_test_report_2025-01-29T152653.733025.json\n load_test_report_2025-01-29T152659.442419.csv\n load_test_report_2025-01-29T152659.442419.json\n load_test_report_20250129_152704.csv\n load_test_report_20250129_152704.json\n run_20250129_152807/\n load_test_report_2025-01-29T152808.476840.csv\n load_test_report_2025-01-29T152808.476840.json\n load_test_report_2025-01-29T152814.290370.csv\n load_test_report_2025-01-29T152814.290370.json\n load_test_report_2025-01-29T152819.988992.csv\n load_test_report_2025-01-29T152819.988992.json\n load_test_report_2025-01-29T152825.712261.csv\n load_test_report_2025-01-29T152825.712261.json\n load_test_report_2025-01-29T152831.461047.csv\n load_test_report_2025-01-29T152831.461047.json\n load_test_report_2025-01-29T152837.233726.csv\n load_test_report_2025-01-29T152837.233726.json\n load_test_report_20250129_152842.csv\n load_test_report_20250129_152842.json\n run_20250129_152930/\n load_test_report_2025-01-29T153031.809694.csv\n load_test_report_2025-01-29T153031.809694.json\n load_test_report_2025-01-29T153137.610641.csv\n load_test_report_2025-01-29T153137.610641.json\n load_test_report_2025-01-29T153243.818603.csv\n load_test_report_2025-01-29T153243.818603.json\n load_test_report_2025-01-29T153349.887918.csv\n load_test_report_2025-01-29T153349.887918.json\n load_test_report_2025-01-29T153504.701174.csv\n load_test_report_2025-01-29T153504.701174.json\n load_test_report_2025-01-29T153615.800362.csv\n load_test_report_2025-01-29T153615.800362.json\n load_test_report_20250129_153620.csv\n load_test_report_20250129_153620.json\n results_test_u1_o15.csv\n results_test_u1_o30.csv\n results_test_u2_o15.csv\n results_test_u2_o30.csv\n results_test_u50_o15.csv\n results_test_u50_o30.csv\n src/\n __pycache__/\n llm_test_logger.cpython-310.pyc\n load_test.cpython-310.pyc\n compare_runs.py\n dashboard_generator.py\n from transformers import AutoTokenizer.py\n llm_load_test_runner.py\n llm_test_logger.py\n load_test.log\n load_test.py\n load_test_aggregator.py\n load_test_tgi.py\n load_test_vllm.py\n qwen_run_20250128_193328.zip\n qwen_run_20250129_131310.zip\n results/\n run_20250129_131310/\n load_test_report_2025-01-29T131340.582736.csv\n load_test_report_2025-01-29T131340.582736.json\n load_test_report_2025-01-29T131416.770529.csv\n load_test_report_2025-01-29T131416.770529.json\n load_test_report_2025-01-29T131452.904227.csv\n load_test_report_2025-01-29T131452.904227.json\n load_test_report_2025-01-29T131529.208363.csv\n load_test_report_2025-01-29T131529.208363.json\n load_test_report_2025-01-29T131612.332502.csv\n load_test_report_2025-01-29T131612.332502.json\n load_test_report_2025-01-29T131654.024454.csv\n load_test_report_2025-01-29T131654.024454.json\n load_test_report_20250129_131659.csv\n load_test_report_20250129_131659.json\n results_test_u1_o1.csv\n results_test_u1_o50.csv\n results_test_u2_o1.csv\n results_test_u2_o50.csv\n results_test_u50_o1.csv\n results_test_u50_o50.csv\n run_20250129_131828/\n load_test_report_2025-01-29T131859.729718.csv\n load_test_report_2025-01-29T131859.729718.json\n load_test_report_2025-01-29T131935.556939.csv\n load_test_report_2025-01-29T131935.556939.json\n load_test_report_2025-01-29T132011.817203.csv\n load_test_report_2025-01-29T132011.817203.json\n load_test_report_2025-01-29T132047.948690.csv\n load_test_report_2025-01-29T132047.948690.json\n load_test_report_2025-01-29T132140.620425.csv\n load_test_report_2025-01-29T132140.620425.json\n load_test_report_2025-01-29T132237.254055.csv\n load_test_report_2025-01-29T132237.254055.json\n load_test_report_20250129_132242.csv\n load_test_report_20250129_132242.json\n results_test_u1_o1.csv\n results_test_u1_o50.csv\n results_test_u2_o1.csv\n results_test_u2_o50.csv\n results_test_u50_o1.csv\n results_test_u50_o50.csv\n run_20250129_132842/\n load_test_report_2025-01-29T132913.096074.csv\n load_test_report_2025-01-29T132913.096074.json\n load_test_report_2025-01-29T132949.286127.csv\n load_test_report_2025-01-29T132949.286127.json\n load_test_report_2025-01-29T133025.273897.csv\n load_test_report_2025-01-29T133025.273897.json\n load_test_report_2025-01-29T133102.000762.csv\n load_test_report_2025-01-29T133102.000762.json\n load_test_report_2025-01-29T133154.340248.csv\n load_test_report_2025-01-29T133154.340248.json\n load_test_report_2025-01-29T133257.783732.csv\n load_test_report_2025-01-29T133257.783732.json\n load_test_report_20250129_133302.csv\n load_test_report_20250129_133302.json\n results_test_u1_o1.csv\n results_test_u1_o50.csv\n results_test_u2_o1.csv\n results_test_u2_o50.csv\n results_test_u50_o1.csv\n results_test_u50_o50.csv\n run_20250129_133711/\n load_test_report_2025-01-29T133742.239356.csv\n load_test_report_2025-01-29T133742.239356.json\n load_test_report_2025-01-29T133818.175709.csv\n load_test_report_2025-01-29T133818.175709.json\n load_test_report_2025-01-29T133853.789246.csv\n load_test_report_2025-01-29T133853.789246.json\n load_test_report_2025-01-29T133929.633962.csv\n load_test_report_2025-01-29T133929.633962.json\n load_test_report_2025-01-29T134013.341083.csv\n load_test_report_2025-01-29T134013.341083.json\n load_test_report_2025-01-29T134101.336503.csv\n load_test_report_2025-01-29T134101.336503.json\n load_test_report_20250129_134106.csv\n load_test_report_20250129_134106.json\n results_test_u1_o1.csv\n results_test_u1_o50.csv\n results_test_u2_o1.csv\n results_test_u2_o50.csv\n results_test_u50_o1.csv\n results_test_u50_o50.csv\n run_20250129_134818/\n load_test_report_2025-01-29T134919.598778.csv\n load_test_report_2025-01-29T134919.598778.json\n load_test_report_2025-01-29T135025.745361.csv\n load_test_report_2025-01-29T135025.745361.json\n load_test_report_2025-01-29T135131.347054.csv\n load_test_report_2025-01-29T135131.347054.json\n load_test_report_2025-01-29T135237.241605.csv\n load_test_report_2025-01-29T135237.241605.json\n load_test_report_2025-01-29T135352.526234.csv\n load_test_report_2025-01-29T135352.526234.json\n load_test_report_2025-01-29T135509.169860.csv\n load_test_report_2025-01-29T135509.169860.json\n load_test_report_20250129_135514.csv\n load_test_report_20250129_135514.json\n results_test_u1_o15.csv\n results_test_u1_o30.csv\n results_test_u2_o15.csv\n results_test_u2_o30.csv\n results_test_u50_o15.csv\n results_test_u50_o30.csv\n run_20250129_135810/\n load_test_report_2025-01-29T135911.302460.csv\n load_test_report_2025-01-29T135911.302460.json\n load_test_report_2025-01-29T140017.766295.csv\n load_test_report_2025-01-29T140017.766295.json\n load_test_report_2025-01-29T140123.329253.csv\n load_test_report_2025-01-29T140123.329253.json\n load_test_report_2025-01-29T140229.087510.csv\n load_test_report_2025-01-29T140229.087510.json\n load_test_report_2025-01-29T140354.254251.csv\n load_test_report_2025-01-29T140354.254251.json\n load_test_report_2025-01-29T140522.596391.csv\n load_test_report_2025-01-29T140522.596391.json\n load_test_report_20250129_140527.csv\n load_test_report_20250129_140527.json\n results_test_u1_o15.csv\n results_test_u1_o30.csv\n results_test_u2_o15.csv\n results_test_u2_o30.csv\n results_test_u50_o15.csv\n results_test_u50_o30.csv\n run_20250129_140726/\n load_test_report_2025-01-29T140828.249744.csv\n load_test_report_2025-01-29T140828.249744.json\n load_test_report_2025-01-29T140935.241087.csv\n load_test_report_2025-01-29T140935.241087.json\n load_test_report_2025-01-29T141041.737827.csv\n load_test_report_2025-01-29T141041.737827.json\n load_test_report_2025-01-29T141148.575547.csv\n load_test_report_2025-01-29T141148.575547.json\n load_test_report_2025-01-29T141257.979330.csv\n load_test_report_2025-01-29T141257.979330.json\n load_test_report_2025-01-29T141407.813467.csv\n load_test_report_2025-01-29T141407.813467.json\n load_test_report_2025-01-29T141517.031485.csv\n load_test_report_2025-01-29T141517.031485.json\n load_test_report_2025-01-29T141626.812125.csv\n load_test_report_2025-01-29T141626.812125.json\n load_test_report_2025-01-29T141738.980843.csv\n load_test_report_2025-01-29T141738.980843.json\n load_test_report_2025-01-29T141852.372524.csv\n load_test_report_2025-01-29T141852.372524.json\n load_test_report_2025-01-29T142006.313659.csv\n load_test_report_2025-01-29T142006.313659.json\n load_test_report_2025-01-29T142122.053494.csv\n load_test_report_2025-01-29T142122.053494.json\n load_test_report_20250129_142127.csv\n load_test_report_20250129_142127.json\n results_test_u10_o1.csv\n results_test_u10_o15.csv\n results_test_u10_o30.csv\n results_test_u10_o50.csv\n results_test_u20_o1.csv\n results_test_u20_o15.csv\n results_test_u20_o30.csv\n results_test_u20_o50.csv\n results_test_u5_o1.csv\n results_test_u5_o15.csv\n results_test_u5_o30.csv\n results_test_u5_o50.csv\n run_20250129_142324/\n load_test_report_2025-01-29T142426.095040.csv\n load_test_report_2025-01-29T142426.095040.json\n load_test_report_2025-01-29T142532.101781.csv\n load_test_report_2025-01-29T142532.101781.json\n load_test_report_2025-01-29T142638.130364.csv\n load_test_report_2025-01-29T142638.130364.json\n load_test_report_2025-01-29T142744.373122.csv\n load_test_report_2025-01-29T142744.373122.json\n load_test_report_2025-01-29T142851.436595.csv\n load_test_report_2025-01-29T142851.436595.json\n load_test_report_2025-01-29T142958.649875.csv\n load_test_report_2025-01-29T142958.649875.json\n load_test_report_2025-01-29T143105.820377.csv\n load_test_report_2025-01-29T143105.820377.json\n load_test_report_2025-01-29T143213.483254.csv\n load_test_report_2025-01-29T143213.483254.json\n load_test_report_2025-01-29T143322.075349.csv\n load_test_report_2025-01-29T143322.075349.json\n load_test_report_2025-01-29T143431.160350.csv\n load_test_report_2025-01-29T143431.160350.json\n load_test_report_2025-01-29T143540.792112.csv\n load_test_report_2025-01-29T143540.792112.json\n load_test_report_2025-01-29T143651.193158.csv\n load_test_report_2025-01-29T143651.193158.json\n load_test_report_20250129_143656.csv\n load_test_report_20250129_143656.json\n results_test_u10_o1.csv\n results_test_u10_o15.csv\n results_test_u10_o30.csv\n results_test_u10_o50.csv\n results_test_u20_o1.csv\n results_test_u20_o15.csv\n results_test_u20_o30.csv\n results_test_u20_o50.csv\n results_test_u5_o1.csv\n results_test_u5_o15.csv\n results_test_u5_o30.csv\n results_test_u5_o50.csv\n run_20250129_144231/\n load_test_report_2025-01-29T144333.225207.csv\n load_test_report_2025-01-29T144333.225207.json\n load_test_report_2025-01-29T144441.892228.csv\n load_test_report_2025-01-29T144441.892228.json\n load_test_report_2025-01-29T144548.216391.csv\n load_test_report_2025-01-29T144548.216391.json\n load_test_report_2025-01-29T144654.207507.csv\n load_test_report_2025-01-29T144654.207507.json\n load_test_report_2025-01-29T144801.887104.csv\n load_test_report_2025-01-29T144801.887104.json\n load_test_report_2025-01-29T144907.892024.csv\n load_test_report_2025-01-29T144907.892024.json\n load_test_report_2025-01-29T145015.606306.csv\n load_test_report_2025-01-29T145015.606306.json\n load_test_report_2025-01-29T145124.318365.csv\n load_test_report_2025-01-29T145124.318365.json\n load_test_report_2025-01-29T145232.316758.csv\n load_test_report_2025-01-29T145232.316758.json\n load_test_report_2025-01-29T145338.561407.csv\n load_test_report_2025-01-29T145338.561407.json\n load_test_report_2025-01-29T145447.340833.csv\n load_test_report_2025-01-29T145447.340833.json\n load_test_report_2025-01-29T145556.603603.csv\n load_test_report_2025-01-29T145556.603603.json\n load_test_report_20250129_145601.csv\n load_test_report_20250129_145601.json\n results_test_u10_o1.csv\n results_test_u10_o15.csv\n results_test_u10_o30.csv\n results_test_u10_o50.csv\n results_test_u20_o1.csv\n results_test_u20_o15.csv\n results_test_u20_o30.csv\n results_test_u20_o50.csv\n results_test_u5_o1.csv\n results_test_u5_o15.csv\n results_test_u5_o30.csv\n results_test_u5_o50.csv\n run_20250129_145926/\n load_test_report_2025-01-29T150027.790900.csv\n load_test_report_2025-01-29T150027.790900.json\n load_test_report_2025-01-29T150134.652497.csv\n load_test_report_2025-01-29T150134.652497.json\n load_test_report_2025-01-29T150242.312479.csv\n load_test_report_2025-01-29T150242.312479.json\n load_test_report_2025-01-29T150348.489497.csv\n load_test_report_2025-01-29T150348.489497.json\n load_test_report_2025-01-29T150454.976232.csv\n load_test_report_2025-01-29T150454.976232.json\n load_test_report_2025-01-29T150600.673114.csv\n load_test_report_2025-01-29T150600.673114.json\n load_test_report_2025-01-29T150708.380006.csv\n load_test_report_2025-01-29T150708.380006.json\n load_test_report_2025-01-29T150814.575034.csv\n load_test_report_2025-01-29T150814.575034.json\n load_test_report_2025-01-29T150923.544283.csv\n load_test_report_2025-01-29T150923.544283.json\n load_test_report_2025-01-29T151030.283486.csv\n load_test_report_2025-01-29T151030.283486.json\n load_test_report_2025-01-29T151138.589944.csv\n load_test_report_2025-01-29T151138.589944.json\n load_test_report_2025-01-29T151248.730621.csv\n load_test_report_2025-01-29T151248.730621.json\n load_test_report_20250129_151253.csv\n load_test_report_20250129_151253.json\n results_test_u10_o1.csv\n results_test_u10_o15.csv\n results_test_u10_o30.csv\n results_test_u10_o50.csv\n results_test_u20_o1.csv\n results_test_u20_o15.csv\n results_test_u20_o30.csv\n results_test_u20_o50.csv\n results_test_u5_o1.csv\n results_test_u5_o15.csv\n results_test_u5_o30.csv\n results_test_u5_o50.csv\n run_20250129_160612/\n load_test_report_2025-01-29T160713.432216.csv\n load_test_report_2025-01-29T160713.432216.json\n load_test_report_2025-01-29T160819.907680.csv\n load_test_report_2025-01-29T160819.907680.json\n load_test_report_2025-01-29T160926.784918.csv\n load_test_report_2025-01-29T160926.784918.json\n load_test_report_2025-01-29T161033.828339.csv\n load_test_report_2025-01-29T161033.828339.json\n load_test_report_2025-01-29T161153.205639.csv\n load_test_report_2025-01-29T161153.205639.json\n load_test_report_2025-01-29T161315.237414.csv\n load_test_report_2025-01-29T161315.237414.json\n load_test_report_20250129_161320.csv\n load_test_report_20250129_161320.json\n results_test_u1_o15.csv\n results_test_u1_o30.csv\n results_test_u2_o15.csv\n results_test_u2_o30.csv\n results_test_u50_o15.csv\n results_test_u50_o30.csv\n run_20250129_161925/\n load_test_report_2025-01-29T162025.734114.csv\n load_test_report_2025-01-29T162025.734114.json\n load_test_report_2025-01-29T162131.524371.csv\n load_test_report_2025-01-29T162131.524371.json\n load_test_report_2025-01-29T162237.758517.csv\n load_test_report_2025-01-29T162237.758517.json\n load_test_report_2025-01-29T162344.818406.csv\n load_test_report_2025-01-29T162344.818406.json\n load_test_report_2025-01-29T162507.384913.csv\n load_test_report_2025-01-29T162507.384913.json\n load_test_report_2025-01-29T162613.335853.csv\n load_test_report_2025-01-29T162613.335853.json\n load_test_report_20250129_162618.csv\n load_test_report_20250129_162618.json\n results_test_u1_o1.csv\n results_test_u1_o50.csv\n results_test_u2_o1.csv\n results_test_u2_o50.csv\n results_test_u50_o1.csv\n results_test_u50_o50.csv\n run_20250129_162732/\n load_test_report_2025-01-29T162834.272459.csv\n load_test_report_2025-01-29T162834.272459.json\n load_test_report_2025-01-29T162941.672408.csv\n load_test_report_2025-01-29T162941.672408.json\n load_test_report_2025-01-29T163048.857712.csv\n load_test_report_2025-01-29T163048.857712.json\n load_test_report_2025-01-29T163157.624546.csv\n load_test_report_2025-01-29T163157.624546.json\n load_test_report_2025-01-29T163306.370415.csv\n load_test_report_2025-01-29T163306.370415.json\n load_test_report_2025-01-29T163416.065472.csv\n load_test_report_2025-01-29T163416.065472.json\n load_test_report_2025-01-29T163524.604470.csv\n load_test_report_2025-01-29T163524.604470.json\n load_test_report_2025-01-29T163632.880248.csv\n load_test_report_2025-01-29T163632.880248.json\n load_test_report_2025-01-29T163745.002002.csv\n load_test_report_2025-01-29T163745.002002.json\n load_test_report_2025-01-29T163902.036068.csv\n load_test_report_2025-01-29T163902.036068.json\n load_test_report_2025-01-29T164009.453151.csv\n load_test_report_2025-01-29T164009.453151.json\n load_test_report_2025-01-29T164122.568066.csv\n load_test_report_2025-01-29T164122.568066.json\n load_test_report_20250129_164127.csv\n load_test_report_20250129_164127.json\n results_test_u10_o1.csv\n results_test_u10_o15.csv\n results_test_u10_o30.csv\n results_test_u10_o50.csv\n results_test_u20_o1.csv\n results_test_u20_o15.csv\n results_test_u20_o30.csv\n results_test_u20_o50.csv\n results_test_u5_o1.csv\n results_test_u5_o15.csv\n results_test_u5_o30.csv\n results_test_u5_o50.csv\n run_20250129_164620/\n load_test_report_2025-01-29T164721.700661.csv\n load_test_report_2025-01-29T164721.700661.json\n load_test_report_2025-01-29T164827.520353.csv\n load_test_report_2025-01-29T164827.520353.json\n load_test_report_2025-01-29T164933.310367.csv\n load_test_report_2025-01-29T164933.310367.json\n load_test_report_2025-01-29T165039.642351.csv\n load_test_report_2025-01-29T165039.642351.json\n load_test_report_2025-01-29T165154.098239.csv\n load_test_report_2025-01-29T165154.098239.json\n load_test_report_2025-01-29T165308.831481.csv\n load_test_report_2025-01-29T165308.831481.json\n load_test_report_20250129_165313.csv\n load_test_report_20250129_165313.json\n results_test_u1_o1.csv\n results_test_u1_o50.csv\n results_test_u2_o1.csv\n results_test_u2_o50.csv\n results_test_u50_o1.csv\n results_test_u50_o50.csv\n run_20250129_165758/\n load_test_report_2025-01-29T165859.461686.csv\n load_test_report_2025-01-29T165859.461686.json\n load_test_report_2025-01-29T170005.472004.csv\n load_test_report_2025-01-29T170005.472004.json\n load_test_report_2025-01-29T170111.422122.csv\n load_test_report_2025-01-29T170111.422122.json\n load_test_report_2025-01-29T170217.557618.csv\n load_test_report_2025-01-29T170217.557618.json\n load_test_report_2025-01-29T170330.493971.csv\n load_test_report_2025-01-29T170330.493971.json\n load_test_report_2025-01-29T170447.558129.csv\n load_test_report_2025-01-29T170447.558129.json\n load_test_report_20250129_170452.csv\n load_test_report_20250129_170452.json\n results_test_u1_o1.csv\n results_test_u1_o50.csv\n results_test_u2_o1.csv\n results_test_u2_o50.csv\n results_test_u50_o1.csv\n results_test_u50_o50.csv\n run_20250129_170950/\n load_test_report_2025-01-29T171051.361008.csv\n load_test_report_2025-01-29T171051.361008.json\n load_test_report_2025-01-29T171157.323565.csv\n load_test_report_2025-01-29T171157.323565.json\n load_test_report_2025-01-29T171303.299586.csv\n load_test_report_2025-01-29T171303.299586.json\n load_test_report_2025-01-29T171409.108765.csv\n load_test_report_2025-01-29T171409.108765.json\n load_test_report_2025-01-29T171514.861147.csv\n load_test_report_2025-01-29T171514.861147.json\n load_test_report_2025-01-29T171620.615624.csv\n load_test_report_2025-01-29T171620.615624.json\n load_test_report_2025-01-29T171726.893447.csv\n load_test_report_2025-01-29T171726.893447.json\n load_test_report_2025-01-29T171833.044767.csv\n load_test_report_2025-01-29T171833.044767.json\n load_test_report_2025-01-29T171939.151837.csv\n load_test_report_2025-01-29T171939.151837.json\n load_test_report_2025-01-29T172045.358719.csv\n load_test_report_2025-01-29T172045.358719.json\n load_test_report_2025-01-29T172151.647824.csv\n load_test_report_2025-01-29T172151.647824.json\n load_test_report_2025-01-29T172257.931381.csv\n load_test_report_2025-01-29T172257.931381.json\n load_test_report_2025-01-29T172404.993732.csv\n load_test_report_2025-01-29T172404.993732.json\n load_test_report_2025-01-29T172512.469972.csv\n load_test_report_2025-01-29T172512.469972.json\n load_test_report_2025-01-29T172619.912159.csv\n load_test_report_2025-01-29T172619.912159.json\n load_test_report_2025-01-29T172727.520335.csv\n load_test_report_2025-01-29T172727.520335.json\n load_test_report_2025-01-29T172836.287202.csv\n load_test_report_2025-01-29T172836.287202.json\n load_test_report_2025-01-29T172945.243054.csv\n load_test_report_2025-01-29T172945.243054.json\n load_test_report_2025-01-29T173054.878245.csv\n load_test_report_2025-01-29T173054.878245.json\n load_test_report_2025-01-29T173205.270695.csv\n load_test_report_2025-01-29T173205.270695.json\n load_test_report_2025-01-29T173319.135777.csv\n load_test_report_2025-01-29T173319.135777.json\n load_test_report_2025-01-29T173434.082094.csv\n load_test_report_2025-01-29T173434.082094.json\n load_test_report_2025-01-29T173550.513858.csv\n load_test_report_2025-01-29T173550.513858.json\n load_test_report_2025-01-29T173708.906195.csv\n load_test_report_2025-01-29T173708.906195.json\n load_test_report_20250129_173713.csv\n load_test_report_20250129_173713.json\n results_test_u10_o1.csv\n results_test_u10_o15.csv\n results_test_u10_o30.csv\n results_test_u10_o50.csv\n results_test_u1_o1.csv\n results_test_u1_o15.csv\n results_test_u1_o30.csv\n results_test_u1_o50.csv\n results_test_u20_o1.csv\n results_test_u20_o15.csv\n results_test_u20_o30.csv\n results_test_u20_o50.csv\n results_test_u2_o1.csv\n results_test_u2_o15.csv\n results_test_u2_o30.csv\n results_test_u2_o50.csv\n results_test_u50_o1.csv\n results_test_u50_o15.csv\n results_test_u50_o30.csv\n results_test_u50_o50.csv\n results_test_u5_o1.csv\n results_test_u5_o15.csv\n results_test_u5_o30.csv\n results_test_u5_o50.csv\n run_20250129_174215/\n load_test_report_2025-01-29T174316.520550.csv\n load_test_report_2025-01-29T174316.520550.json\n load_test_report_2025-01-29T174422.384594.csv\n load_test_report_2025-01-29T174422.384594.json\n load_test_report_2025-01-29T174528.291764.csv\n load_test_report_2025-01-29T174528.291764.json\n load_test_report_2025-01-29T174633.925509.csv\n load_test_report_2025-01-29T174633.925509.json\n load_test_report_2025-01-29T174740.096886.csv\n load_test_report_2025-01-29T174740.096886.json\n load_test_report_2025-01-29T174845.697959.csv\n load_test_report_2025-01-29T174845.697959.json\n load_test_report_2025-01-29T174952.084484.csv\n load_test_report_2025-01-29T174952.084484.json\n load_test_report_2025-01-29T175058.845237.csv\n load_test_report_2025-01-29T175058.845237.json\n load_test_report_2025-01-29T175205.494738.csv\n load_test_report_2025-01-29T175205.494738.json\n load_test_report_2025-01-29T175312.831611.csv\n load_test_report_2025-01-29T175312.831611.json\n load_test_report_2025-01-29T175419.902976.csv\n load_test_report_2025-01-29T175419.902976.json\n load_test_report_2025-01-29T175527.241889.csv\n load_test_report_2025-01-29T175527.241889.json\n load_test_report_2025-01-29T175635.835204.csv\n load_test_report_2025-01-29T175635.835204.json\n load_test_report_2025-01-29T175744.448069.csv\n load_test_report_2025-01-29T175744.448069.json\n load_test_report_2025-01-29T175853.905293.csv\n load_test_report_2025-01-29T175853.905293.json\n load_test_report_2025-01-29T180003.565666.csv\n load_test_report_2025-01-29T180003.565666.json\n load_test_report_2025-01-29T180115.557518.csv\n load_test_report_2025-01-29T180115.557518.json\n load_test_report_2025-01-29T180228.466492.csv\n load_test_report_2025-01-29T180228.466492.json\n load_test_report_2025-01-29T180342.419821.csv\n load_test_report_2025-01-29T180342.419821.json\n load_test_report_2025-01-29T180457.796778.csv\n load_test_report_2025-01-29T180457.796778.json\n load_test_report_2025-01-29T180620.304565.csv\n load_test_report_2025-01-29T180620.304565.json\n load_test_report_2025-01-29T180746.057385.csv\n load_test_report_2025-01-29T180746.057385.json\n load_test_report_2025-01-29T180914.893498.csv\n load_test_report_2025-01-29T180914.893498.json\n load_test_report_2025-01-29T181046.064760.csv\n load_test_report_2025-01-29T181046.064760.json\n load_test_report_20250129_181051.csv\n load_test_report_20250129_181051.json\n results_test_u10_o1.csv\n results_test_u10_o15.csv\n results_test_u10_o30.csv\n results_test_u10_o50.csv\n results_test_u1_o1.csv\n results_test_u1_o15.csv\n results_test_u1_o30.csv\n results_test_u1_o50.csv\n results_test_u20_o1.csv\n results_test_u20_o15.csv\n results_test_u20_o30.csv\n results_test_u20_o50.csv\n results_test_u2_o1.csv\n results_test_u2_o15.csv\n results_test_u2_o30.csv\n results_test_u2_o50.csv\n results_test_u50_o1.csv\n results_test_u50_o15.csv\n results_test_u50_o30.csv\n results_test_u50_o50.csv\n results_test_u5_o1.csv\n results_test_u5_o15.csv\n results_test_u5_o30.csv\n results_test_u5_o50.csv\n starcoder2_run_20250129_123907.zip\n starcoder_run_20250128_20.zip\n starcoder_run_20250129_131828.zip\n test_single_request.py\n visualize_results.py\n temp_file_renamed.txt\n test_data.txt", + tool_failed: false, }, }, { @@ -66,6 +67,7 @@ export const MARKDOWN_ISSUE: ChatThread = { tool_call_id: "toolu_01DzbsASaCkQXY2fmUYZjXbj", content: 'Problems:\nThe path "README.md" is ambiguous. It could be interpreted as:\n/home/fupfv/git/benchmark1_0701/README.md\n/home/fupfv/git/benchmark1_0701/llm_load_test/README.md\n', + tool_failed: false, }, }, { @@ -90,6 +92,7 @@ export const MARKDOWN_ISSUE: ChatThread = { content: { tool_call_id: "toolu_01LUEfJUST74ghMbHUmuByr5", content: "Paths found:\n/home/fupfv/git/benchmark1_0701/README.md\n", + tool_failed: false, }, }, { @@ -128,6 +131,7 @@ export const MARKDOWN_ISSUE: ChatThread = { tool_call_id: "toolu_019uJg1SQ5evTU9bov6iS9hU", content: "Paths found:\n/home/fupfv/git/benchmark1_0701/VISUALIZATION.md\n", + tool_failed: false, }, }, { @@ -166,6 +170,7 @@ export const MARKDOWN_ISSUE: ChatThread = { tool_call_id: "toolu_01T48o7umn3FG5JVJWRgviUP", content: "Paths found:\n/home/fupfv/git/benchmark1_0701/src/llm_load_test_runner.py\n", + tool_failed: false, }, }, { @@ -204,6 +209,7 @@ export const MARKDOWN_ISSUE: ChatThread = { tool_call_id: "toolu_01WXJiwA9oLdRRAS4SADKvmM", content: "Paths found:\n/home/fupfv/git/benchmark1_0701/src/load_test.py\n", + tool_failed: false, }, }, { @@ -242,6 +248,7 @@ export const MARKDOWN_ISSUE: ChatThread = { tool_call_id: "toolu_01VxiuWGqPfbMSgprqkhe7uU", content: "Paths found:\n/home/fupfv/git/benchmark1_0701/src/visualize_results.py\n", + tool_failed: false, }, }, { @@ -456,6 +463,7 @@ export const MARKDOWN_ISSUE: ChatThread = { tool_call_id: "toolu_01QS5KdB2vJApy8dgHkzjmyA", content: "Knowledge entry created successfully with ID: 594ad5ff35\nTools: documentation, markdown, technical writing\nApply to: benchmark1_0701, LLM Load Testing Tool, documentation, visualization tools, developer guide\nSearch Key: Creating comprehensive documentation for LLM load testing tool with Locust, including user guides, visualization documentation, and developer documentation\nLanguage/Framework: python/locust\nEntry: I created a comprehensive documentation suite for an LLM Load Testing Tool built with Python and Locust. The documentation was structured into several key components:\n\n1. Main Documentation (README.md):\n - Provided a complete overview of the tool's functionality\n - Included installation instructions, configuration options, and usage examples\n - Documented all available metrics and how to interpret them\n - Covered troubleshooting and advanced usage scenarios\n\n2. Visualization Guide (VISUALIZATION_GUIDE.md):\n - Detailed explanation of all visualization tools (visualize_results.py, compare_runs.py, dashboard_generator.py)\n - Instructions for generating and interpreting different types of visualizations\n - Best practices for effective visualization and analysis\n - Troubleshooting for visualization-specific issues\n\n3. Developer Guide (DEVELOPER_GUIDE.md):\n - Technical architecture overview of the codebase\n - Instructions for extending the tool with new providers, metrics, and visualizations\n - Code style guidelines and testing recommendations\n - Contributing guidelines for potential contributors\n\n4. Quick Start Guide (QUICK_START.md):\n - Streamlined instructions for getting started quickly\n - Basic configuration and test execution steps\n - Common issues and solutions\n - Pointers to more detailed documentation\n\n5. Documentation Index (index.md):\n - Central navigation hub for all documentation\n - Brief overview of the tool and its capabilities\n - Links to all documentation sections\n\nThe documentation was designed to be comprehensive yet accessible, with clear navigation between different sections. It covers both user-focused aspects (how to run tests and interpret results) and developer-focused aspects (how to extend and contribute to the codebase).\n\nKey insights from analyzing the codebase:\n- The tool uses Locust for load generation and metrics collection\n- It supports multiple LLM providers through a provider class hierarchy\n- Visualization is handled by matplotlib and seaborn\n- The architecture separates concerns between test execution, data collection, and visualization\n- The tool generates both CSV and JSON reports for further analysis\n\nThis documentation structure provides a solid foundation for users to understand and effectively use the LLM Load Testing Tool, while also enabling developers to extend and improve it.", + tool_failed: false, }, }, { diff --git a/refact-agent/gui/src/__fixtures__/some_chrome_screenshots.ts b/refact-agent/gui/src/__fixtures__/some_chrome_screenshots.ts index 0bc4f80a3..7acbf9afe 100644 --- a/refact-agent/gui/src/__fixtures__/some_chrome_screenshots.ts +++ b/refact-agent/gui/src/__fixtures__/some_chrome_screenshots.ts @@ -31,6 +31,7 @@ export const CHAT_WITH_MULTI_MODAL: ChatThread = { tool_call_id: "call_leDATFRCQJRefjC45EVpS0TW", content: "/\n Users/\n kot/\n code_aprojects/\n huddle/\n .gitignore\n README-template.md\n README.md\n index.html\n style-guide.md\n styles.css\n images/\n bg-desktop.svg\n bg-mobile.svg\n favicon-32x32.png\n illustration-mockups.svg\n logo.svg\n design/\n active-states.jpg\n desktop-design.jpg\n desktop-preview.jpg\n mobile-design.jpg", + tool_failed: false, }, }, { @@ -70,6 +71,7 @@ export const CHAT_WITH_MULTI_MODAL: ChatThread = { "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", }, ], + tool_failed: false, }, }, { @@ -120,6 +122,7 @@ export const CHAT_WITH_MULTI_MODAL: ChatThread = { "opened a new tab: tab_id `3` device `desktop` uri `about:blank`\n\nnavigate_to successful: tab_id `3` device `desktop` uri `file:///Users/kot/code_aprojects/huddle/index.html`", }, ], + tool_failed: false, }, }, { @@ -133,6 +136,7 @@ export const CHAT_WITH_MULTI_MODAL: ChatThread = { "opened a new tab: tab_id `4` device `mobile` uri `about:blank`\n\nnavigate_to successful: tab_id `4` device `mobile` uri `file:///Users/kot/code_aprojects/huddle/index.html`", }, ], + tool_failed: false, }, }, { @@ -186,6 +190,7 @@ export const CHAT_WITH_MULTI_MODAL: ChatThread = { "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", }, ], + tool_failed: false, }, }, { @@ -204,6 +209,7 @@ export const CHAT_WITH_MULTI_MODAL: ChatThread = { "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", }, ], + tool_failed: false, }, }, { diff --git a/refact-agent/gui/src/components/ChatContent/ContextFiles.tsx b/refact-agent/gui/src/components/ChatContent/ContextFiles.tsx index 79fb09c7c..ac1f7a70e 100644 --- a/refact-agent/gui/src/components/ChatContent/ContextFiles.tsx +++ b/refact-agent/gui/src/components/ChatContent/ContextFiles.tsx @@ -120,8 +120,8 @@ const ContextFilesContent: React.FC<{ { event.preventDefault(); - // TODO: not optimal to do like this :/ - // maybe we can safely rename file_name -> file_path in ChatContextFile type + // TODO: this maybe will need to be reworked in the future + // but VSCode handles well file_path to be relative to the actual file_name as file_path void onOpenFile({ ...file, file_path: file.file_name, diff --git a/refact-agent/gui/src/components/ComboBox/ComboBox.test.tsx b/refact-agent/gui/src/components/ComboBox/ComboBox.test.tsx index 2969885b4..64636eb67 100644 --- a/refact-agent/gui/src/components/ComboBox/ComboBox.test.tsx +++ b/refact-agent/gui/src/components/ComboBox/ComboBox.test.tsx @@ -1,6 +1,6 @@ import React from "react"; import { describe, test, vi, expect, afterEach } from "vitest"; -import { render, cleanup } from "../../utils/test-utils"; +import { render, cleanup, waitFor } from "../../utils/test-utils"; import { ComboBox, type ComboBoxProps } from "./ComboBox"; import { TextArea, type TextAreaProps } from "../TextArea"; import { useDebounceCallback } from "usehooks-ts"; @@ -242,11 +242,13 @@ describe("ComboBox", () => { expect(textarea.textContent).toEqual("@file /foo "); }); - test("type part of the command, then press ender", async () => { + test("type part of the command, then press enter", async () => { const { user, ...app } = render(); const textarea = app.getByRole("combobox"); await user.type(textarea, "@fi{Enter}"); - expect(app.getByRole("combobox").textContent).toEqual("@file "); + await waitFor(() => { + expect(app.getByRole("combobox").textContent).toEqual("@file "); + }); }); test("multiple commands", async () => { @@ -322,7 +324,9 @@ describe("ComboBox", () => { const { user, ...app } = render(); const textarea = app.getByRole("combobox"); await user.type(textarea, "@fi{Enter}"); - expect(textarea.textContent).toEqual("@file "); + await waitFor(() => { + expect(app.getByRole("combobox").textContent).toEqual("@file "); + }); expect(app.queryByText("/foo")).not.toBeNull(); expect(app.queryByText("/bar")).not.toBeNull(); await user.keyboard("{Backspace}"); diff --git a/refact-agent/gui/src/features/Chat/Thread/reducer.ts b/refact-agent/gui/src/features/Chat/Thread/reducer.ts index ecbd06c47..07ec9c5dc 100644 --- a/refact-agent/gui/src/features/Chat/Thread/reducer.ts +++ b/refact-agent/gui/src/features/Chat/Thread/reducer.ts @@ -516,6 +516,8 @@ export function maybeAppendToolCallResultFromIdeToMessages( content: { content: message, tool_call_id: toolCallId, + // assuming, that tool_failed is always false at this point + tool_failed: false, }, }; diff --git a/refact-agent/gui/src/features/Chat/Thread/utils.test.ts b/refact-agent/gui/src/features/Chat/Thread/utils.test.ts index 1927aac8b..8ed8383df 100644 --- a/refact-agent/gui/src/features/Chat/Thread/utils.test.ts +++ b/refact-agent/gui/src/features/Chat/Thread/utils.test.ts @@ -41,6 +41,7 @@ describe("formatChatResponse", () => { content: { tool_call_id: "call_6qxVYwV6MTcazl1Fy5pRlImi", content: "stuff", + tool_failed: false, }, }, { From c48db734d7548fb89552174bdc4e3af1307ac73d Mon Sep 17 00:00:00 2001 From: Humberto Yusta Date: Wed, 14 May 2025 18:20:49 +0200 Subject: [PATCH 06/17] fix: preprocess path for normalization in /v1/fullpath to make it more robust in Windows --- .../engine/src/http/routers/v1/gui_help_handlers.rs | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/refact-agent/engine/src/http/routers/v1/gui_help_handlers.rs b/refact-agent/engine/src/http/routers/v1/gui_help_handlers.rs index 076752014..66586846b 100644 --- a/refact-agent/engine/src/http/routers/v1/gui_help_handlers.rs +++ b/refact-agent/engine/src/http/routers/v1/gui_help_handlers.rs @@ -7,7 +7,7 @@ use serde::Deserialize; use tokio::sync::RwLock as ARwLock; use crate::at_commands::at_file::{file_repair_candidates, return_one_candidate_or_a_good_error}; use crate::custom_error::ScratchError; -use crate::files_correction::correct_to_nearest_dir_path; +use crate::files_correction::{correct_to_nearest_dir_path, preprocess_path_for_normalization}; use crate::global_context::GlobalContext; #[derive(Deserialize)] @@ -22,11 +22,12 @@ pub async fn handle_v1_fullpath( let post = serde_json::from_slice::(&body_bytes) .map_err(|e| ScratchError::new(StatusCode::UNPROCESSABLE_ENTITY, format!("JSON problem: {}", e)))?; - let candidates_file = file_repair_candidates(gcx.clone(), &post.path, 10, false).await; - let candidates_dir = correct_to_nearest_dir_path(gcx.clone(), &post.path, false, 10).await; + let path = preprocess_path_for_normalization(post.path); + let candidates_file = file_repair_candidates(gcx.clone(), &path, 10, false).await; + let candidates_dir = correct_to_nearest_dir_path(gcx.clone(), &path, false, 10).await; let candidates = candidates_file.into_iter().chain(candidates_dir.clone().into_iter()).collect::>().into_iter().collect::>(); - match return_one_candidate_or_a_good_error(gcx.clone(), &post.path, &candidates, &vec![], false).await { + match return_one_candidate_or_a_good_error(gcx.clone(), &path, &candidates, &vec![], false).await { Ok(candidate) => { let is_directory = candidates_dir.contains(&candidate); Ok(Response::builder() From d90e9498122be8bb80489e5d546c6c66c87194f1 Mon Sep 17 00:00:00 2001 From: Humberto Yusta Date: Thu, 15 May 2025 10:34:48 +0200 Subject: [PATCH 07/17] fix: add tool_failed to test messages --- refact-agent/engine/src/scratchpads/chat_utils_limit_history.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/refact-agent/engine/src/scratchpads/chat_utils_limit_history.rs b/refact-agent/engine/src/scratchpads/chat_utils_limit_history.rs index aef5f3044..fe87e37bb 100644 --- a/refact-agent/engine/src/scratchpads/chat_utils_limit_history.rs +++ b/refact-agent/engine/src/scratchpads/chat_utils_limit_history.rs @@ -851,6 +851,7 @@ mod compression_tests { finish_reason: None, tool_calls, tool_call_id: tool_call_id.unwrap_or_default(), + tool_failed: if role == "tool" { Some(false) } else { None }, usage: None, checkpoints: Vec::new(), thinking_blocks: None, @@ -1280,6 +1281,7 @@ mod tests { finish_reason: None, tool_calls, tool_call_id: tool_call_id_str, + tool_failed: if role == "tool" { Some(false) } else { None }, usage: None, checkpoints: Vec::new(), thinking_blocks: None, From c36a70e38bd82a34a8ce9a3c65acba9c265a576d Mon Sep 17 00:00:00 2001 From: Humberto Yusta Date: Thu, 15 May 2025 12:59:04 +0200 Subject: [PATCH 08/17] fix: add check to create textdoc to create files only inside project dirs or config folder --- refact-agent/engine/src/files_correction.rs | 11 +++++++++++ .../engine/src/tools/file_edit/tool_create_textdoc.rs | 6 ++++-- 2 files changed, 15 insertions(+), 2 deletions(-) diff --git a/refact-agent/engine/src/files_correction.rs b/refact-agent/engine/src/files_correction.rs index 46eced7f8..dce1f02ab 100644 --- a/refact-agent/engine/src/files_correction.rs +++ b/refact-agent/engine/src/files_correction.rs @@ -456,6 +456,17 @@ pub fn canonicalize_normalized_path(p: PathBuf) -> PathBuf { p.canonicalize().unwrap_or_else(|_| absolute(&p).unwrap_or(p)) } +pub async fn check_if_its_inside_a_workspace_or_config(gcx: Arc>, path: &Path) -> Result<(), String> { + let workspace_folders = get_project_dirs(gcx.clone()).await; + let config_dir = gcx.read().await.config_dir.clone(); + + if workspace_folders.iter().any(|d| path.starts_with(d)) || path.starts_with(&config_dir) { + Ok(()) + } else { + Err(format!("Path '{path:?}' is outside of project directories:\n{workspace_folders:?}")) + } +} + pub fn any_glob_matches_path(globs: &[String], path: &Path) -> bool { globs.iter().any(|glob| { let pattern = glob::Pattern::new(glob).unwrap(); diff --git a/refact-agent/engine/src/tools/file_edit/tool_create_textdoc.rs b/refact-agent/engine/src/tools/file_edit/tool_create_textdoc.rs index 9b57fcb57..6a5435126 100644 --- a/refact-agent/engine/src/tools/file_edit/tool_create_textdoc.rs +++ b/refact-agent/engine/src/tools/file_edit/tool_create_textdoc.rs @@ -12,7 +12,7 @@ use std::collections::HashMap; use std::path::PathBuf; use std::sync::Arc; use tokio::sync::Mutex as AMutex; -use crate::files_correction::{canonicalize_normalized_path, correct_to_nearest_dir_path, get_project_dirs, preprocess_path_for_normalization}; +use crate::files_correction::{canonicalize_normalized_path, check_if_its_inside_a_workspace_or_config, correct_to_nearest_dir_path, get_project_dirs, is_inside_a_workspace_or_config, preprocess_path_for_normalization}; use crate::global_context::GlobalContext; use tokio::sync::RwLock as ARwLock; use crate::at_commands::at_file::return_one_candidate_or_a_good_error; @@ -56,7 +56,9 @@ async fn parse_args( )); } } else { - raw_path + let path = canonicalize_normalized_path(raw_path); + check_if_its_inside_a_workspace_or_config(gcx.clone(), &path).await?; + path }; if check_file_privacy(privacy_settings, &path, &FilePrivacyLevel::AllowToSendAnywhere).is_err() { return Err(format!( From f9ff7be97b3c54c3068328bd49c3a311db031157 Mon Sep 17 00:00:00 2001 From: Humberto Yusta Date: Thu, 15 May 2025 12:59:43 +0200 Subject: [PATCH 09/17] fix: improve path normalization in Windows for file edit tools --- .../tools/file_edit/tool_update_textdoc.rs | 11 ++++---- .../file_edit/tool_update_textdoc_regex.rs | 11 ++++---- refact-agent/engine/src/tools/tool_mv.rs | 26 ++++++++++--------- refact-agent/engine/src/tools/tool_rm.rs | 3 ++- 4 files changed, 28 insertions(+), 23 deletions(-) diff --git a/refact-agent/engine/src/tools/file_edit/tool_update_textdoc.rs b/refact-agent/engine/src/tools/file_edit/tool_update_textdoc.rs index 369658d8d..66f71d4cf 100644 --- a/refact-agent/engine/src/tools/file_edit/tool_update_textdoc.rs +++ b/refact-agent/engine/src/tools/file_edit/tool_update_textdoc.rs @@ -31,10 +31,11 @@ async fn parse_args( ) -> Result { let path = match args.get("path") { Some(Value::String(s)) => { - let candidates_file = file_repair_candidates(gcx.clone(), &s, 3, false).await; - let path = match return_one_candidate_or_a_good_error(gcx.clone(), &s, &candidates_file, &get_project_dirs(gcx.clone()).await, false).await { - Ok(f) => canonicalize_normalized_path(PathBuf::from(preprocess_path_for_normalization(f.trim().to_string()))), - Err(e) => return Err(e) + let raw_path = preprocess_path_for_normalization(s.trim().to_string()); + let candidates_file = file_repair_candidates(gcx.clone(), &raw_path, 3, false).await; + let path = match return_one_candidate_or_a_good_error(gcx.clone(), &raw_path, &candidates_file, &get_project_dirs(gcx.clone()).await, false).await { + Ok(f) => canonicalize_normalized_path(PathBuf::from(f)), + Err(e) => return Err(e), }; if check_file_privacy(privacy_settings, &path, &FilePrivacyLevel::AllowToSendAnywhere).is_err() { return Err(format!( @@ -133,7 +134,7 @@ impl Tool for ToolUpdateTextDoc { ) -> Result { let gcx = ccx.lock().await.global_context.clone(); let privacy_settings = load_privacy_if_needed(gcx.clone()).await; - + async fn can_execute_tool_edit(gcx: Arc>, args: &HashMap, privacy_settings: Arc) -> Result<(), String> { let _ = parse_args(gcx.clone(), args, privacy_settings).await?; Ok(()) diff --git a/refact-agent/engine/src/tools/file_edit/tool_update_textdoc_regex.rs b/refact-agent/engine/src/tools/file_edit/tool_update_textdoc_regex.rs index 24e60c2a8..3a82b0d31 100644 --- a/refact-agent/engine/src/tools/file_edit/tool_update_textdoc_regex.rs +++ b/refact-agent/engine/src/tools/file_edit/tool_update_textdoc_regex.rs @@ -32,10 +32,11 @@ async fn parse_args( ) -> Result { let path = match args.get("path") { Some(Value::String(s)) => { - let candidates_file = file_repair_candidates(gcx.clone(), &s, 3, false).await; - let path = match return_one_candidate_or_a_good_error(gcx.clone(), &s, &candidates_file, &get_project_dirs(gcx.clone()).await, false).await { - Ok(f) => canonicalize_normalized_path(PathBuf::from(preprocess_path_for_normalization(f.trim().to_string()))), - Err(e) => return Err(e) + let raw_path = preprocess_path_for_normalization(s.trim().to_string()); + let candidates_file = file_repair_candidates(gcx.clone(), &raw_path, 3, false).await; + let path = match return_one_candidate_or_a_good_error(gcx.clone(), &raw_path, &candidates_file, &get_project_dirs(gcx.clone()).await, false).await { + Ok(f) => canonicalize_normalized_path(PathBuf::from(f)), + Err(e) => return Err(e), }; if check_file_privacy(privacy_settings, &path, &FilePrivacyLevel::AllowToSendAnywhere).is_err() { return Err(format!( @@ -141,7 +142,7 @@ impl Tool for ToolUpdateTextDocRegex { ) -> Result { let gcx = ccx.lock().await.global_context.clone(); let privacy_settings = load_privacy_if_needed(gcx.clone()).await; - + async fn can_execute_tool_edit(gcx: Arc>, args: &HashMap, privacy_settings: Arc) -> Result<(), String> { let _ = parse_args(gcx.clone(), args, privacy_settings).await?; Ok(()) diff --git a/refact-agent/engine/src/tools/tool_mv.rs b/refact-agent/engine/src/tools/tool_mv.rs index c59dd9140..0d6cb16e9 100644 --- a/refact-agent/engine/src/tools/tool_mv.rs +++ b/refact-agent/engine/src/tools/tool_mv.rs @@ -10,7 +10,7 @@ use serde_json::json; use crate::at_commands::at_commands::AtCommandsContext; use crate::at_commands::at_file::return_one_candidate_or_a_good_error; use crate::call_validation::{ChatMessage, ChatContent, ContextEnum, DiffChunk}; -use crate::files_correction::{get_project_dirs, canonical_path, correct_to_nearest_filename, correct_to_nearest_dir_path}; +use crate::files_correction::{canonical_path, correct_to_nearest_dir_path, correct_to_nearest_filename, get_project_dirs, preprocess_path_for_normalization}; use crate::files_in_workspace::get_file_text_from_memory_or_disk; use crate::tools::tools_description::{MatchConfirmDeny, MatchConfirmDenyResult, Tool, ToolDesc, ToolParam}; use crate::integrations::integr_abstract::IntegrationConfirmation; @@ -55,6 +55,8 @@ impl Tool for ToolMv { Some(Value::String(s)) if !s.trim().is_empty() => Self::preformat_path(&s.trim().to_string()), _ => return Err("Missing required argument `destination`".to_string()), }; + let src_str = preprocess_path_for_normalization(src_str); + let dst_str = preprocess_path_for_normalization(dst_str); let overwrite = Self::parse_overwrite(args)?; let gcx = ccx.lock().await.global_context.clone(); @@ -114,15 +116,15 @@ impl Tool for ToolMv { let privacy_settings = load_privacy_if_needed(gcx.clone()).await; if let Err(e) = check_file_privacy( - privacy_settings.clone(), - &src_true_path, + privacy_settings.clone(), + &src_true_path, &FilePrivacyLevel::AllowToSendAnywhere ) { return Err(format!("Cannot move '{}': {}", src_str, e)); } if let Err(e) = check_file_privacy( - privacy_settings.clone(), - &dst_true_path, + privacy_settings.clone(), + &dst_true_path, &FilePrivacyLevel::AllowToSendAnywhere ) { return Err(format!("Cannot move to '{}': {}", src_str, e)); @@ -139,7 +141,7 @@ impl Tool for ToolMv { let src_metadata = fs::symlink_metadata(&src_true_path).await .map_err(|e| format!("Failed to access source '{}': {}", src_str, e))?; - + let mut src_file_content = String::new(); if !src_is_dir { src_file_content = get_file_text_from_memory_or_disk(gcx.clone(), &src_true_path).await?; @@ -184,10 +186,10 @@ impl Tool for ToolMv { line1: 1, line2: src_file_content.lines().count(), lines_remove: src_file_content.clone(), - lines_add: "".to_string(), + lines_add: "".to_string(), file_name_rename: Some(dst_corrected_path.clone()), is_file: true, - application_details: format!("File {} from '{}' to '{}'", + application_details: format!("File {} from '{}' to '{}'", if src_true_path.parent() == dst_true_path.parent() { "renamed" } else { "moved" }, src_corrected_path, dst_corrected_path), }; @@ -231,9 +233,9 @@ impl Tool for ToolMv { .map_err(|e| format!("Failed to copy '{}' to '{}': {}", src_str, dst_str, e))?; fs::remove_file(&src_true_path).await .map_err(|e| format!("Failed to remove source file '{}' after copy: {}", src_str, e))?; - + let mut messages = vec![]; - + if !src_file_content.is_empty() { let diff_chunk = DiffChunk { file_name: src_corrected_path.clone(), @@ -241,10 +243,10 @@ impl Tool for ToolMv { line1: 1, line2: src_file_content.lines().count(), lines_remove: src_file_content.clone(), - lines_add: "".to_string(), + lines_add: "".to_string(), file_name_rename: Some(dst_corrected_path.clone()), is_file: true, - application_details: format!("File renamed from '{}' to '{}'", + application_details: format!("File renamed from '{}' to '{}'", src_corrected_path, dst_corrected_path), }; if !dst_file_content.is_empty() { diff --git a/refact-agent/engine/src/tools/tool_rm.rs b/refact-agent/engine/src/tools/tool_rm.rs index ae8afffd1..3dd71851a 100644 --- a/refact-agent/engine/src/tools/tool_rm.rs +++ b/refact-agent/engine/src/tools/tool_rm.rs @@ -9,7 +9,7 @@ use serde_json::json; use crate::at_commands::at_commands::AtCommandsContext; use crate::at_commands::at_file::return_one_candidate_or_a_good_error; use crate::call_validation::{ChatMessage, ChatContent, ContextEnum, DiffChunk}; -use crate::files_correction::{get_project_dirs, canonical_path, correct_to_nearest_filename, correct_to_nearest_dir_path}; +use crate::files_correction::{canonical_path, correct_to_nearest_dir_path, correct_to_nearest_filename, get_project_dirs, preprocess_path_for_normalization}; use crate::files_in_workspace::get_file_text_from_memory_or_disk; use crate::privacy::{check_file_privacy, load_privacy_if_needed, FilePrivacyLevel}; use crate::tools::tools_description::{MatchConfirmDeny, MatchConfirmDenyResult, Tool, ToolDesc, ToolParam}; @@ -97,6 +97,7 @@ impl Tool for ToolRm { Some(Value::String(s)) if !s.trim().is_empty() => Self::preformat_path(&s.trim().to_string()), _ => return Err("Missing required argument `path`".to_string()), }; + let path_str = preprocess_path_for_normalization(path_str); // Reject if wildcards are present, '?' is allowed if preceeded by '\' or '/' only, like \\?\C:\Some\Path if path_str.contains('*') || path_str.contains('[') || From 025687f1141e7ef26a76f129c7fb17fefed56b72 Mon Sep 17 00:00:00 2001 From: Humberto Yusta Date: Thu, 15 May 2025 13:00:42 +0200 Subject: [PATCH 10/17] fix: improve workdir handling, to disallow running commands outside of project folders, and properly resolve relative-ish paths --- .../engine/src/integrations/integr_shell.rs | 25 +++++++++++++++++-- 1 file changed, 23 insertions(+), 2 deletions(-) diff --git a/refact-agent/engine/src/integrations/integr_shell.rs b/refact-agent/engine/src/integrations/integr_shell.rs index f3ce72051..ec9aeb7b1 100644 --- a/refact-agent/engine/src/integrations/integr_shell.rs +++ b/refact-agent/engine/src/integrations/integr_shell.rs @@ -1,6 +1,7 @@ use std::path::PathBuf; use std::collections::HashMap; use std::sync::Arc; +use axum::extract::path; use serde::Deserialize; use serde::Serialize; use serde_json::Value; @@ -9,7 +10,14 @@ use async_trait::async_trait; use tokio::process::Command; use crate::at_commands::at_commands::AtCommandsContext; +use crate::at_commands::at_file::return_one_candidate_or_a_good_error; +use crate::files_correction::canonical_path; +use crate::files_correction::canonicalize_normalized_path; +use crate::files_correction::check_if_its_inside_a_workspace_or_config; +use crate::files_correction::correct_to_nearest_dir_path; use crate::files_correction::get_active_project_path; +use crate::files_correction::get_project_dirs; +use crate::files_correction::preprocess_path_for_normalization; use crate::files_correction::CommandSimplifiedDirExt; use crate::global_context::GlobalContext; use crate::integrations::process_io_utils::execute_command; @@ -221,7 +229,7 @@ pub async fn execute_shell_command( Ok(out) } -fn parse_args(args: &HashMap) -> Result<(String, Option), String> { +async fn parse_args(gcx: Arc>, args: &HashMap) -> Result<(String, Option), String> { let command = match args.get("command") { Some(Value::String(s)) => { if s.is_empty() { @@ -239,7 +247,20 @@ fn parse_args(args: &HashMap) -> Result<(String, Option) if s.is_empty() { None } else { - let workdir = crate::files_correction::canonical_path(s); + let path_str = preprocess_path_for_normalization(s.to_string()); + let path = PathBuf::from(&path_str); + + let workdir = if path.is_absolute() { + let path = canonicalize_normalized_path(path); + check_if_its_inside_a_workspace_or_config(gcx.clone(), &path).await?; + path + } else { + let project_dirs = get_project_dirs(gcx.clone()).await; + let candidates = correct_to_nearest_dir_path(gcx.clone(), &path_str, false, 3).await; + canonical_path( + return_one_candidate_or_a_good_error(gcx.clone(), &path_str, &candidates, &project_dirs, true).await? + ) + }; if !workdir.exists() { return Err("Workdir doesn't exist".to_string()); } else { From e9594a3fc9ea1391b8a8ed1487eaf8ff0e368f6f Mon Sep 17 00:00:00 2001 From: Humberto Yusta Date: Thu, 15 May 2025 13:20:13 +0200 Subject: [PATCH 11/17] fix: pass ccx to commant to match against confirm deny, so it can be used to resolve paths --- .../src/integrations/docker/integr_docker.rs | 3 ++- .../engine/src/integrations/integr_cmdline.rs | 3 ++- .../engine/src/integrations/integr_github.rs | 3 ++- .../engine/src/integrations/integr_gitlab.rs | 3 ++- .../engine/src/integrations/integr_mcp.rs | 3 ++- .../engine/src/integrations/integr_mysql.rs | 3 ++- .../engine/src/integrations/integr_pdb.rs | 3 ++- .../engine/src/integrations/integr_postgres.rs | 3 ++- .../engine/src/integrations/integr_shell.rs | 15 ++++++++------- .../src/tools/file_edit/tool_create_textdoc.rs | 5 +++-- .../src/tools/file_edit/tool_update_textdoc.rs | 3 ++- .../tools/file_edit/tool_update_textdoc_regex.rs | 3 ++- refact-agent/engine/src/tools/tool_mv.rs | 7 ++++--- refact-agent/engine/src/tools/tool_rm.rs | 7 ++++--- .../engine/src/tools/tools_description.rs | 11 ++++++----- refact-agent/engine/src/tools/tools_execute.rs | 2 +- 16 files changed, 46 insertions(+), 31 deletions(-) diff --git a/refact-agent/engine/src/integrations/docker/integr_docker.rs b/refact-agent/engine/src/integrations/docker/integr_docker.rs index bedbe4a5c..163b01df0 100644 --- a/refact-agent/engine/src/integrations/docker/integr_docker.rs +++ b/refact-agent/engine/src/integrations/docker/integr_docker.rs @@ -163,8 +163,9 @@ impl Tool for ToolDocker { ])) } - fn command_to_match_against_confirm_deny( + async fn command_to_match_against_confirm_deny( &self, + _ccx: Arc>, args: &HashMap, ) -> Result { let command = parse_command(args)?; diff --git a/refact-agent/engine/src/integrations/integr_cmdline.rs b/refact-agent/engine/src/integrations/integr_cmdline.rs index 88c3dc8fb..50bec636d 100644 --- a/refact-agent/engine/src/integrations/integr_cmdline.rs +++ b/refact-agent/engine/src/integrations/integr_cmdline.rs @@ -305,8 +305,9 @@ impl Tool for ToolCmdline { } } - fn command_to_match_against_confirm_deny( + async fn command_to_match_against_confirm_deny( &self, + _ccx: Arc>, args: &HashMap, ) -> Result { let (command, _workdir) = _parse_command_args(args, &self.cfg)?; diff --git a/refact-agent/engine/src/integrations/integr_github.rs b/refact-agent/engine/src/integrations/integr_github.rs index 95e88aa9d..6685a7dbd 100644 --- a/refact-agent/engine/src/integrations/integr_github.rs +++ b/refact-agent/engine/src/integrations/integr_github.rs @@ -131,8 +131,9 @@ impl Tool for ToolGithub { Ok((false, results)) } - fn command_to_match_against_confirm_deny( + async fn command_to_match_against_confirm_deny( &self, + _ccx: Arc>, args: &HashMap, ) -> Result { let mut command_args = parse_command_args(args)?; diff --git a/refact-agent/engine/src/integrations/integr_gitlab.rs b/refact-agent/engine/src/integrations/integr_gitlab.rs index 74038273e..c98a0ae8e 100644 --- a/refact-agent/engine/src/integrations/integr_gitlab.rs +++ b/refact-agent/engine/src/integrations/integr_gitlab.rs @@ -129,8 +129,9 @@ impl Tool for ToolGitlab { Ok((false, results)) } - fn command_to_match_against_confirm_deny( + async fn command_to_match_against_confirm_deny( &self, + _ccx: Arc>, args: &HashMap, ) -> Result { let mut command_args = parse_command_args(args)?; diff --git a/refact-agent/engine/src/integrations/integr_mcp.rs b/refact-agent/engine/src/integrations/integr_mcp.rs index 5f5d3da1d..4f4e5a60b 100644 --- a/refact-agent/engine/src/integrations/integr_mcp.rs +++ b/refact-agent/engine/src/integrations/integr_mcp.rs @@ -534,8 +534,9 @@ impl Tool for ToolMCP { sanitized_yaml_name } - fn command_to_match_against_confirm_deny( + async fn command_to_match_against_confirm_deny( &self, + _ccx: Arc>, _args: &HashMap, ) -> Result { let command = self.mcp_tool.name.clone(); diff --git a/refact-agent/engine/src/integrations/integr_mysql.rs b/refact-agent/engine/src/integrations/integr_mysql.rs index 6b6199be7..bb1d166ae 100644 --- a/refact-agent/engine/src/integrations/integr_mysql.rs +++ b/refact-agent/engine/src/integrations/integr_mysql.rs @@ -137,8 +137,9 @@ impl Tool for ToolMysql { Ok((true, results)) } - fn command_to_match_against_confirm_deny( + async fn command_to_match_against_confirm_deny( &self, + _ccx: Arc>, args: &HashMap, ) -> Result { let query = match args.get("query") { diff --git a/refact-agent/engine/src/integrations/integr_pdb.rs b/refact-agent/engine/src/integrations/integr_pdb.rs index 0aeafdf00..2a7347267 100644 --- a/refact-agent/engine/src/integrations/integr_pdb.rs +++ b/refact-agent/engine/src/integrations/integr_pdb.rs @@ -156,8 +156,9 @@ impl Tool for ToolPdb { Ok(tool_answer(output, tool_call_id)) } - fn command_to_match_against_confirm_deny( + async fn command_to_match_against_confirm_deny( &self, + _ccx: Arc>, args: &HashMap, ) -> Result { let (command, _) = parse_args(args)?; diff --git a/refact-agent/engine/src/integrations/integr_postgres.rs b/refact-agent/engine/src/integrations/integr_postgres.rs index a15ae8e51..f4030bed0 100644 --- a/refact-agent/engine/src/integrations/integr_postgres.rs +++ b/refact-agent/engine/src/integrations/integr_postgres.rs @@ -136,8 +136,9 @@ impl Tool for ToolPostgres { Ok((true, results)) } - fn command_to_match_against_confirm_deny( + async fn command_to_match_against_confirm_deny( &self, + _ccx: Arc>, args: &HashMap, ) -> Result { let query = match args.get("query") { diff --git a/refact-agent/engine/src/integrations/integr_shell.rs b/refact-agent/engine/src/integrations/integr_shell.rs index ec9aeb7b1..b07b1b924 100644 --- a/refact-agent/engine/src/integrations/integr_shell.rs +++ b/refact-agent/engine/src/integrations/integr_shell.rs @@ -1,7 +1,6 @@ use std::path::PathBuf; use std::collections::HashMap; use std::sync::Arc; -use axum::extract::path; use serde::Deserialize; use serde::Serialize; use serde_json::Value; @@ -87,10 +86,10 @@ impl Tool for ToolShell { tool_call_id: &String, args: &HashMap, ) -> Result<(bool, Vec), String> { - let (command, workdir_maybe) = parse_args(args)?; + let gcx = ccx.lock().await.global_context.clone(); + let (command, workdir_maybe) = parse_args(gcx.clone(), args).await?; let timeout = self.cfg.timeout.parse::().unwrap_or(10); - let gcx = ccx.lock().await.global_context.clone(); let mut error_log = Vec::::new(); let env_variables = crate::integrations::setting_up_integrations::get_vars_for_replacements(gcx.clone(), &mut error_log).await; @@ -145,10 +144,10 @@ impl Tool for ToolShell { async fn match_against_confirm_deny( &self, - _ccx: Arc>, + ccx: Arc>, args: &HashMap ) -> Result { - let command_to_match = self.command_to_match_against_confirm_deny(&args).map_err(|e| { + let command_to_match = self.command_to_match_against_confirm_deny(ccx.clone(), &args).await.map_err(|e| { format!("Error getting tool command to match: {}", e) })?; if command_to_match.is_empty() { @@ -172,11 +171,13 @@ impl Tool for ToolShell { }) } - fn command_to_match_against_confirm_deny( + async fn command_to_match_against_confirm_deny( &self, + ccx: Arc>, args: &HashMap, ) -> Result { - let (command, _) = parse_args(args)?; + let gcx = ccx.lock().await.global_context.clone(); + let (command, _) = parse_args(gcx, args).await?; Ok(command) } diff --git a/refact-agent/engine/src/tools/file_edit/tool_create_textdoc.rs b/refact-agent/engine/src/tools/file_edit/tool_create_textdoc.rs index 6a5435126..efa40edbd 100644 --- a/refact-agent/engine/src/tools/file_edit/tool_create_textdoc.rs +++ b/refact-agent/engine/src/tools/file_edit/tool_create_textdoc.rs @@ -12,7 +12,7 @@ use std::collections::HashMap; use std::path::PathBuf; use std::sync::Arc; use tokio::sync::Mutex as AMutex; -use crate::files_correction::{canonicalize_normalized_path, check_if_its_inside_a_workspace_or_config, correct_to_nearest_dir_path, get_project_dirs, is_inside_a_workspace_or_config, preprocess_path_for_normalization}; +use crate::files_correction::{canonicalize_normalized_path, check_if_its_inside_a_workspace_or_config, correct_to_nearest_dir_path, get_project_dirs, preprocess_path_for_normalization}; use crate::global_context::GlobalContext; use tokio::sync::RwLock as ARwLock; use crate::at_commands::at_file::return_one_candidate_or_a_good_error; @@ -167,8 +167,9 @@ impl Tool for ToolCreateTextDoc { }) } - fn command_to_match_against_confirm_deny( + async fn command_to_match_against_confirm_deny( &self, + _ccx: Arc>, _args: &HashMap, ) -> Result { Ok("create_textdoc".to_string()) diff --git a/refact-agent/engine/src/tools/file_edit/tool_update_textdoc.rs b/refact-agent/engine/src/tools/file_edit/tool_update_textdoc.rs index 66f71d4cf..b8745d636 100644 --- a/refact-agent/engine/src/tools/file_edit/tool_update_textdoc.rs +++ b/refact-agent/engine/src/tools/file_edit/tool_update_textdoc.rs @@ -160,8 +160,9 @@ impl Tool for ToolUpdateTextDoc { }) } - fn command_to_match_against_confirm_deny( + async fn command_to_match_against_confirm_deny( &self, + _ccx: Arc>, _args: &HashMap, ) -> Result { Ok("update_textdoc".to_string()) diff --git a/refact-agent/engine/src/tools/file_edit/tool_update_textdoc_regex.rs b/refact-agent/engine/src/tools/file_edit/tool_update_textdoc_regex.rs index 3a82b0d31..0094a04ba 100644 --- a/refact-agent/engine/src/tools/file_edit/tool_update_textdoc_regex.rs +++ b/refact-agent/engine/src/tools/file_edit/tool_update_textdoc_regex.rs @@ -168,8 +168,9 @@ impl Tool for ToolUpdateTextDocRegex { }) } - fn command_to_match_against_confirm_deny( + async fn command_to_match_against_confirm_deny( &self, + _ccx: Arc>, _args: &HashMap, ) -> Result { Ok("update_textdoc_regex".to_string()) diff --git a/refact-agent/engine/src/tools/tool_mv.rs b/refact-agent/engine/src/tools/tool_mv.rs index 0d6cb16e9..243519d5e 100644 --- a/refact-agent/engine/src/tools/tool_mv.rs +++ b/refact-agent/engine/src/tools/tool_mv.rs @@ -287,8 +287,9 @@ impl Tool for ToolMv { } } - fn command_to_match_against_confirm_deny( + async fn command_to_match_against_confirm_deny( &self, + _ccx: Arc>, args: &HashMap, ) -> Result { let src = match args.get("source") { @@ -312,10 +313,10 @@ impl Tool for ToolMv { async fn match_against_confirm_deny( &self, - _: Arc>, + ccx: Arc>, args: &HashMap, ) -> Result { - let command_to_match = self.command_to_match_against_confirm_deny(&args).map_err(|e| { + let command_to_match = self.command_to_match_against_confirm_deny(ccx.clone(), &args).await.map_err(|e| { format!("Error getting tool command to match: {}", e) })?; Ok(MatchConfirmDeny { diff --git a/refact-agent/engine/src/tools/tool_rm.rs b/refact-agent/engine/src/tools/tool_rm.rs index 3dd71851a..41fb14b56 100644 --- a/refact-agent/engine/src/tools/tool_rm.rs +++ b/refact-agent/engine/src/tools/tool_rm.rs @@ -49,8 +49,9 @@ impl ToolRm { impl Tool for ToolRm { fn as_any(&self) -> &dyn std::any::Any { self } - fn command_to_match_against_confirm_deny( + async fn command_to_match_against_confirm_deny( &self, + _ccx: Arc>, args: &HashMap, ) -> Result { let path = match args.get("path") { @@ -73,10 +74,10 @@ impl Tool for ToolRm { async fn match_against_confirm_deny( &self, - _: Arc>, + ccx: Arc>, args: &HashMap, ) -> Result { - let command_to_match = self.command_to_match_against_confirm_deny(&args).map_err(|e| { + let command_to_match = self.command_to_match_against_confirm_deny(ccx.clone(), &args).await.map_err(|e| { format!("Error getting tool command to match: {}", e) })?; Ok(MatchConfirmDeny { diff --git a/refact-agent/engine/src/tools/tools_description.rs b/refact-agent/engine/src/tools/tools_description.rs index 8af93006d..93a0d9cfe 100644 --- a/refact-agent/engine/src/tools/tools_description.rs +++ b/refact-agent/engine/src/tools/tools_description.rs @@ -43,10 +43,10 @@ pub trait Tool: Send + Sync { async fn match_against_confirm_deny( &self, - _ccx: Arc>, + ccx: Arc>, args: &HashMap ) -> Result { - let command_to_match = self.command_to_match_against_confirm_deny(&args).map_err(|e| { + let command_to_match = self.command_to_match_against_confirm_deny(ccx.clone(), &args).await.map_err(|e| { format!("Error getting tool command to match: {}", e) })?; @@ -80,8 +80,9 @@ pub trait Tool: Send + Sync { }) } - fn command_to_match_against_confirm_deny( + async fn command_to_match_against_confirm_deny( &self, + _ccx: Arc>, _args: &HashMap, ) -> Result { Ok("".to_string()) @@ -435,7 +436,7 @@ tools: description: "Search keys for the knowledge database. Write combined elements from all fields (tools, project components, objectives, and language/framework). This field is used for vector similarity search." parameters_required: - "search_key" - + - name: "regex_search" description: "Search for exact text patterns in files using regular expressions (pattern matching)" parameters: @@ -539,7 +540,7 @@ fn default_param_type() -> String { } /// TODO: Think a better way to know if we can send array type to the model -/// +/// /// For now, anthropic models support it, gpt models don't, for other, we'll need to test pub fn model_supports_array_param_type(model_id: &str) -> bool { model_id.contains("claude") diff --git a/refact-agent/engine/src/tools/tools_execute.rs b/refact-agent/engine/src/tools/tools_execute.rs index 5652f24ab..5218452d2 100644 --- a/refact-agent/engine/src/tools/tools_execute.rs +++ b/refact-agent/engine/src/tools/tools_execute.rs @@ -207,7 +207,7 @@ pub async fn run_tools( match res.result { MatchConfirmDenyResult::DENY => { let command_to_match = cmd - .command_to_match_against_confirm_deny(&args) + .command_to_match_against_confirm_deny(ccx.clone(), &args).await .unwrap_or("".to_string()); generated_tool.push(tool_answer_err(format!("tool use: command '{command_to_match}' is denied"), t_call.id.to_string())); continue; From 4d6f4aefe7318c6add5ca5ff71cb1f610ba23797 Mon Sep 17 00:00:00 2001 From: Humberto Yusta Date: Thu, 15 May 2025 13:24:45 +0200 Subject: [PATCH 12/17] refactor: resolve shell workdir in a separate method --- .../engine/src/integrations/integr_shell.rs | 42 ++++++++++--------- 1 file changed, 23 insertions(+), 19 deletions(-) diff --git a/refact-agent/engine/src/integrations/integr_shell.rs b/refact-agent/engine/src/integrations/integr_shell.rs index b07b1b924..a3ee3bdc3 100644 --- a/refact-agent/engine/src/integrations/integr_shell.rs +++ b/refact-agent/engine/src/integrations/integr_shell.rs @@ -248,25 +248,7 @@ async fn parse_args(gcx: Arc>, args: &HashMap return Err(format!("argument `workdir` is not a string: {:?}", v)), @@ -276,6 +258,28 @@ async fn parse_args(gcx: Arc>, args: &HashMap>, raw_path: &str) -> Result { + let path_str = preprocess_path_for_normalization(raw_path.to_string()); + let path = PathBuf::from(&path_str); + + let workdir = if path.is_absolute() { + let path = canonicalize_normalized_path(path); + check_if_its_inside_a_workspace_or_config(gcx.clone(), &path).await?; + path + } else { + let project_dirs = get_project_dirs(gcx.clone()).await; + let candidates = correct_to_nearest_dir_path(gcx.clone(), &path_str, false, 3).await; + canonical_path( + return_one_candidate_or_a_good_error(gcx.clone(), &path_str, &candidates, &project_dirs, true).await? + ) + }; + if !workdir.exists() { + Err("Workdir doesn't exist".to_string()) + } else { + Ok(workdir) + } +} + pub const SHELL_INTEGRATION_SCHEMA: &str = r#" fields: timeout: From 908b9d1d23b9303065cd8447f7d5acfb173236e8 Mon Sep 17 00:00:00 2001 From: Humberto Yusta Date: Thu, 15 May 2025 17:33:16 +0200 Subject: [PATCH 13/17] fix: no need to try join with abs path in the right --- refact-agent/engine/src/files_correction.rs | 4 ---- 1 file changed, 4 deletions(-) diff --git a/refact-agent/engine/src/files_correction.rs b/refact-agent/engine/src/files_correction.rs index dce1f02ab..8d4e59108 100644 --- a/refact-agent/engine/src/files_correction.rs +++ b/refact-agent/engine/src/files_correction.rs @@ -135,10 +135,6 @@ async fn complete_path_with_project_dir( if path_exists(&candidate_path, is_dir) && candidate_path.starts_with(&p) { return Some(candidate_path); } - let j_path = p.join(&candidate_path); - if path_exists(&j_path, is_dir) { - return Some(j_path); - } // This might save a roundtrip: // .../project1/project1/1.cpp From 4c7c4b7bc88cb2296bf0fba1c556137b5663134f Mon Sep 17 00:00:00 2001 From: alashchev17 Date: Thu, 15 May 2025 19:52:39 +0200 Subject: [PATCH 14/17] fix: make tool_failed optional in type definition --- refact-agent/gui/src/services/refact/types.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/refact-agent/gui/src/services/refact/types.ts b/refact-agent/gui/src/services/refact/types.ts index d48a44f56..8a45b0108 100644 --- a/refact-agent/gui/src/services/refact/types.ts +++ b/refact-agent/gui/src/services/refact/types.ts @@ -71,7 +71,7 @@ export interface BaseToolResult { finish_reason?: string; // "call_failed" | "call_worked"; content: ToolContent; compression_strength?: CompressionStrength; - tool_failed: boolean; + tool_failed?: boolean; } export interface SingleModelToolResult extends BaseToolResult { @@ -439,7 +439,7 @@ export type ChatUserMessageResponse = export type ToolResponse = { id: string; role: "tool"; - tool_failed: boolean; + tool_failed?: boolean; } & ToolResult; export function isChatUserMessageResponse( From 4c2c34793a5c0e43bd4891af28f32e953623f571 Mon Sep 17 00:00:00 2001 From: alashchev17 Date: Thu, 15 May 2025 20:36:54 +0200 Subject: [PATCH 15/17] fix: made some fields optional in metering to avoid coins information vanishing on chats from current stable release --- refact-agent/gui/src/utils/getMetering.ts | 29 ++++++++++++----------- 1 file changed, 15 insertions(+), 14 deletions(-) diff --git a/refact-agent/gui/src/utils/getMetering.ts b/refact-agent/gui/src/utils/getMetering.ts index ce021e7f6..cb7ad413e 100644 --- a/refact-agent/gui/src/utils/getMetering.ts +++ b/refact-agent/gui/src/utils/getMetering.ts @@ -58,14 +58,15 @@ export function getTotalTokenMeteringForMessages(messages: ChatMessages) { } = message; return { metering_prompt_tokens_n: - acc.metering_prompt_tokens_n + metering_prompt_tokens_n, + acc.metering_prompt_tokens_n + (metering_prompt_tokens_n ?? 0), metering_generated_tokens_n: - acc.metering_generated_tokens_n + metering_generated_tokens_n, + acc.metering_generated_tokens_n + (metering_generated_tokens_n ?? 0), metering_cache_creation_tokens_n: acc.metering_cache_creation_tokens_n + - metering_cache_creation_tokens_n, + (metering_cache_creation_tokens_n ?? 0), metering_cache_read_tokens_n: - acc.metering_cache_read_tokens_n + metering_cache_read_tokens_n, + acc.metering_cache_read_tokens_n + + (metering_cache_read_tokens_n ?? 0), }; }, { @@ -88,10 +89,10 @@ function hasUsageAndPrice(message: ChatMessage): message is AssistantMessage & { metering_coins_cache_creation: number; metering_coins_cache_read: number; - metering_prompt_tokens_n: number; - metering_generated_tokens_n: number; - metering_cache_creation_tokens_n: number; - metering_cache_read_tokens_n: number; + metering_prompt_tokens_n?: number; + metering_generated_tokens_n?: number; + metering_cache_creation_tokens_n?: number; + metering_cache_read_tokens_n?: number; } { if (!isAssistantMessage(message)) return false; if (!("usage" in message)) return false; @@ -103,12 +104,12 @@ function hasUsageAndPrice(message: ChatMessage): message is AssistantMessage & { if (typeof message.metering_coins_cache_creation !== "number") return false; if (typeof message.metering_coins_cache_read !== "number") return false; - if (typeof message.metering_prompt_tokens_n !== "number") return false; - if (typeof message.metering_generated_tokens_n !== "number") return false; - if (typeof message.metering_cache_creation_tokens_n !== "number") { - return false; - } - if (typeof message.metering_cache_read_tokens_n !== "number") return false; + // if (typeof message.metering_prompt_tokens_n !== "number") return false; + // if (typeof message.metering_generated_tokens_n !== "number") return false; + // if (typeof message.metering_cache_creation_tokens_n !== "number") { + // return false; + // } + // if (typeof message.metering_cache_read_tokens_n !== "number") return false; return true; } From 1b6ce5471c936eeae7a9fb397dcc16666b5b0705 Mon Sep 17 00:00:00 2001 From: alashchev17 Date: Thu, 15 May 2025 20:43:18 +0200 Subject: [PATCH 16/17] chore: assigning 0 to destructured elements instead of nullish operator ?? --- refact-agent/gui/src/utils/getMetering.ts | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) diff --git a/refact-agent/gui/src/utils/getMetering.ts b/refact-agent/gui/src/utils/getMetering.ts index cb7ad413e..9426529f9 100644 --- a/refact-agent/gui/src/utils/getMetering.ts +++ b/refact-agent/gui/src/utils/getMetering.ts @@ -51,22 +51,21 @@ export function getTotalTokenMeteringForMessages(messages: ChatMessages) { }>( (acc, message) => { const { - metering_prompt_tokens_n, - metering_generated_tokens_n, - metering_cache_read_tokens_n, - metering_cache_creation_tokens_n, + metering_prompt_tokens_n = 0, + metering_generated_tokens_n = 0, + metering_cache_read_tokens_n = 0, + metering_cache_creation_tokens_n = 0, } = message; return { metering_prompt_tokens_n: - acc.metering_prompt_tokens_n + (metering_prompt_tokens_n ?? 0), + acc.metering_prompt_tokens_n + metering_prompt_tokens_n, metering_generated_tokens_n: - acc.metering_generated_tokens_n + (metering_generated_tokens_n ?? 0), + acc.metering_generated_tokens_n + metering_generated_tokens_n, metering_cache_creation_tokens_n: acc.metering_cache_creation_tokens_n + - (metering_cache_creation_tokens_n ?? 0), + metering_cache_creation_tokens_n, metering_cache_read_tokens_n: - acc.metering_cache_read_tokens_n + - (metering_cache_read_tokens_n ?? 0), + acc.metering_cache_read_tokens_n + metering_cache_read_tokens_n, }; }, { From 4a6af8d97a5c94e8c71c63c4085ca2ed839b5d32 Mon Sep 17 00:00:00 2001 From: Humberto Yusta Date: Fri, 16 May 2025 16:17:27 +0200 Subject: [PATCH 17/17] update libgit2 and shadow rs --- refact-agent/engine/Cargo.toml | 6 +++--- refact-agent/engine/build.rs | 4 ++-- refact-agent/engine/src/caps/caps.rs | 2 +- .../engine/src/forward_to_openai_endpoint.rs | 12 ++++++------ refact-agent/engine/src/http/routers/info.rs | 10 +++++----- refact-agent/engine/src/version.rs | 2 +- 6 files changed, 18 insertions(+), 18 deletions(-) diff --git a/refact-agent/engine/Cargo.toml b/refact-agent/engine/Cargo.toml index ac7a12952..15d1ba2a6 100644 --- a/refact-agent/engine/Cargo.toml +++ b/refact-agent/engine/Cargo.toml @@ -16,7 +16,7 @@ default = ["vecdb"] vecdb = ["sqlite-vec"] [build-dependencies] -shadow-rs = "0.36.0" +shadow-rs = "1.1.0" [dependencies] astral-tokio-tar = "0.5.2" @@ -31,7 +31,7 @@ diff = "0.1.13" dunce = "1.0.5" dyn_partial_eq = "=0.1.2" futures = "0.3" -git2 = "0.19.0" +git2 = "0.20.2" glob = "0.3.1" hashbrown = "0.15.2" headless_chrome = "1.0.16" @@ -63,7 +63,7 @@ serde_cbor = "0.11.2" serde_json = { version = "1", features = ["preserve_order"] } serde_yaml = "0.9.31" # all features = ["compression", "docs", "event_log", "failpoints", "io_uring", "lock_free_delays", "measure_allocs", "miri_optimizations", "mutex", "no_inline", "no_logs", "pretty_backtrace", "testing"] -shadow-rs = { version = "0.36.0", features = [], default-features = false } +shadow-rs = { version = "1.1.0", features = [], default-features = false } sha2 = "0.10.8" shell-words = "1.1.0" shell-escape = "0.1.5" diff --git a/refact-agent/engine/build.rs b/refact-agent/engine/build.rs index 4d883eac5..cfe1015ca 100644 --- a/refact-agent/engine/build.rs +++ b/refact-agent/engine/build.rs @@ -1,4 +1,4 @@ -fn main() -> shadow_rs::SdResult<()> { - shadow_rs::new() +fn main() { + shadow_rs::ShadowBuilder::builder().build().unwrap(); } diff --git a/refact-agent/engine/src/caps/caps.rs b/refact-agent/engine/src/caps/caps.rs index dc1ab93cd..7e9349b0f 100644 --- a/refact-agent/engine/src/caps/caps.rs +++ b/refact-agent/engine/src/caps/caps.rs @@ -283,7 +283,7 @@ pub async fn load_caps_value_from_url( if !cmdline.api_key.is_empty() { headers.insert(reqwest::header::AUTHORIZATION, reqwest::header::HeaderValue::from_str(&format!("Bearer {}", cmdline.api_key)).unwrap()); - headers.insert(reqwest::header::USER_AGENT, reqwest::header::HeaderValue::from_str(&format!("refact-lsp {}", crate::version::build_info::PKG_VERSION)).unwrap()); + headers.insert(reqwest::header::USER_AGENT, reqwest::header::HeaderValue::from_str(&format!("refact-lsp {}", crate::version::build::PKG_VERSION)).unwrap()); } let mut last_status = 0; diff --git a/refact-agent/engine/src/forward_to_openai_endpoint.rs b/refact-agent/engine/src/forward_to_openai_endpoint.rs index 8879a2188..0242750ba 100644 --- a/refact-agent/engine/src/forward_to_openai_endpoint.rs +++ b/refact-agent/engine/src/forward_to_openai_endpoint.rs @@ -29,7 +29,7 @@ pub async fn forward_to_openai_style_endpoint( headers.insert(AUTHORIZATION, HeaderValue::from_str(&format!("Bearer {}", model_rec.api_key)).unwrap()); } if model_rec.support_metadata { - headers.insert(USER_AGENT, HeaderValue::from_str(&format!("refact-lsp {}", crate::version::build_info::PKG_VERSION)).unwrap()); + headers.insert(USER_AGENT, HeaderValue::from_str(&format!("refact-lsp {}", crate::version::build::PKG_VERSION)).unwrap()); } let mut data = json!({ "model": model_rec.name.clone(), @@ -61,7 +61,7 @@ pub async fn forward_to_openai_style_endpoint( if let Some(meta) = meta { data["meta"] = json!(meta); } - + // When cancelling requests, coroutine ususally gets aborted here on the following line. let req = client.post(&model_rec.endpoint) .headers(headers) @@ -102,7 +102,7 @@ pub async fn forward_to_openai_style_endpoint_streaming( headers.insert(AUTHORIZATION, HeaderValue::from_str(&format!("Bearer {}", model_rec.api_key)).unwrap()); } if model_rec.support_metadata { - headers.insert(USER_AGENT, HeaderValue::from_str(format!("refact-lsp {}", crate::version::build_info::PKG_VERSION).as_str()).unwrap()); + headers.insert(USER_AGENT, HeaderValue::from_str(format!("refact-lsp {}", crate::version::build::PKG_VERSION).as_str()).unwrap()); } let mut data = json!({ @@ -140,7 +140,7 @@ pub async fn forward_to_openai_style_endpoint_streaming( if let Some(meta) = meta { data["meta"] = json!(meta); } - + if model_rec.endpoint.is_empty() { return Err(format!("No endpoint configured for {}", model_rec.id)); } @@ -246,7 +246,7 @@ pub async fn get_embedding_openai_style( // info!("get_embedding_openai_style: {:?}", json); // {"data":[{"embedding":[0.0121664945...],"index":0,"object":"embedding"}, {}, {}]} // or {"data":[{"embedding":[0.0121664945...]}, {}, {}]} without index - + let mut result: Vec> = vec![vec![]; B]; match serde_json::from_value::>(json["data"].clone()) { Ok(unordered) => { @@ -262,7 +262,7 @@ pub async fn get_embedding_openai_style( match serde_json::from_value::>(json["data"].clone()) { Ok(ordered) => { if ordered.len() != B { - return Err(format!("get_embedding_openai_style: response length mismatch: expected {}, got {}", + return Err(format!("get_embedding_openai_style: response length mismatch: expected {}, got {}", B, ordered.len())); } for (i, res) in ordered.into_iter().enumerate() { diff --git a/refact-agent/engine/src/http/routers/info.rs b/refact-agent/engine/src/http/routers/info.rs index 342affde5..1a9098f52 100644 --- a/refact-agent/engine/src/http/routers/info.rs +++ b/refact-agent/engine/src/http/routers/info.rs @@ -9,11 +9,11 @@ use crate::custom_error::ScratchError; pub fn get_build_info() -> IndexMap<&'static str, &'static str> { IndexMap::from([ - ("version", crate::version::build_info::PKG_VERSION), - ("commit", crate::version::build_info::COMMIT_HASH), - ("build_os", crate::version::build_info::BUILD_OS), - ("rust_version", crate::version::build_info::RUST_VERSION), - ("cargo_version", crate::version::build_info::CARGO_VERSION), + ("version", crate::version::build::PKG_VERSION), + ("commit", crate::version::build::COMMIT_HASH), + ("build_os", crate::version::build::BUILD_OS), + ("rust_version", crate::version::build::RUST_VERSION), + ("cargo_version", crate::version::build::CARGO_VERSION), ]) } diff --git a/refact-agent/engine/src/version.rs b/refact-agent/engine/src/version.rs index 29a853607..1c5a80c2e 100644 --- a/refact-agent/engine/src/version.rs +++ b/refact-agent/engine/src/version.rs @@ -1,3 +1,3 @@ use shadow_rs::shadow; -shadow!(build_info); +shadow!(build);