enhance(cli, config): Support interactive tool mode switching (#372)

Users can now interactively toggle between different run and result
modes when prompted to execute a tool. This allows switching from "Ask"
to "Edit" or "Unattended" modes on the fly, providing better control
over the tool execution flow without restarting the session.

A new skip functionality has been added, allowing users to bypass tool
execution entirely. When skipping, users can optionally provide
reasoning through their configured editor, which is then communicated
back to the assistant to maintain conversation context.

It is now also possible, after seeing the tool call arguments provided
by the LLM, and having the run mode set to "ask", to allow the tool to
run, but modify the response after, even if by default response mode is
set to "Unattended". This allows for providing more context to the LLM
after the tool call, essentially injecting a "user turn" into the
conversation.

Additionally, local tools can now return a structured `Outcome::Error`
to distinguish between transient and permanent failures. A transient
failure is reported back to the LLM for correction, while a permanent
failure stops the conversation and is reported back to the user.

Finally, the CLI now respects the `InlineResults::Off` configuration to
suppress tool result rendering when desired.

---------

Signed-off-by: Jean Mertz <git@jeanmertz.com>

Author: JeanMertz

crates/jp_cli/src/cmd/query/event.rs

@@ -167,12 +167,7 @@ impl StreamEventHandler {
                             };
 
                             self.tool_call_responses.push(response.clone());
-                            return build_tool_call_response(
-                                &cfg.style,
-                                &response,
-                                &tool_config,
-                                handler,
-                            );
+                            return Ok(None);
                         }
                     }
                 }
@@ -205,6 +200,20 @@ impl StreamEventHandler {
                     self.tool_call_responses.push(result.clone());
                     return build_tool_call_response(&cfg.style, &result, &tool_config, handler);
                 }
+                Err(ToolError::Skipped { reason }) => {
+                    self.tool_call_responses.push(ToolCallResponse {
+                        id: call.id.clone(),
+                        result: {
+                            let mut msg = "Tool execution skipped by user.".to_string();
+                            if let Some(reason) = reason {
+                                msg.push_str(&format!("\n\n{reason}"));
+                            }
+                            Ok(msg)
+                        },
+                    });
+
+                    return Ok(None);
+                }
                 Err(ToolError::NeedsInput { question }) => {
                     // Check answers in priority order:
                     // 1. Turn-level persisted answers
@@ -353,7 +362,9 @@ fn build_tool_call_response(
         _ => content.lines().count(),
     };
 
-    if handler.render_tool_calls {
+    if handler.render_tool_calls
+        && !matches!(tool_config.style().inline_results, InlineResults::Off)
+    {
         let mut intro = "\nTool call result".to_owned();
         match tool_config.style().inline_results {
             InlineResults::Truncate(TruncateLines { lines }) if lines < content.lines().count() => {

crates/jp_config/src/conversation/tool.rs

@@ -872,6 +872,9 @@ pub enum RunMode {
 
     /// Open an editor to edit the tool call before running it.
     Edit,
+
+    /// Skip running the tool.
+    Skip,
 }
 
 /// How to deliver the results of the tool to the assistant.
@@ -887,6 +890,9 @@ pub enum ResultMode {
 
     /// Open an editor to edit the tool call result before delivering it.
     Edit,
+
+    /// Skip delivering the results of the tool call.
+    Skip,
 }
 
 /// Tool configuration with global defaults.

crates/jp_llm/src/error.rs

@@ -152,6 +152,9 @@ pub enum ToolError {
         error: serde_json::Error,
     },
 
+    #[error("Tool call failed: {0}")]
+    ToolCallFailed(String),
+
     #[error("Failed to open editor to edit tool call")]
     OpenEditorError {
         arguments: serde_json::Value,
@@ -183,6 +186,9 @@ pub enum ToolError {
     #[error("Needs input: {question:?}")]
     NeedsInput { question: jp_tool::Question },
 
+    #[error("Skipped tool execution")]
+    Skipped { reason: Option<String> },
+
     #[error("Serialization error")]
     Serde(#[from] serde_json::Error),