port thinking tool

Author: chaynabors

crates/chat-cli/src/cli/chat/tool_manager.rs

@@ -501,7 +501,11 @@ impl ToolManager {
         let tx = self.loading_status_sender.take();
         let display_task = self.loading_display_task.take();
         let tool_specs = {
-            let tool_specs = serde_json::from_str::<HashMap<String, ToolSpec>>(include_str!("tools/tool_index.json"))?;
+            let mut tool_specs =
+                serde_json::from_str::<HashMap<String, ToolSpec>>(include_str!("tools/tool_index.json"))?;
+            if !crate::cli::chat::tools::thinking::Thinking::is_enabled() {
+                tool_specs.remove("q_think_tool");
+            }
             Arc::new(Mutex::new(tool_specs))
         };
         let conversation_id = self.conversation_id.clone();
@@ -672,6 +676,7 @@ impl ToolManager {
             "execute_bash" => Tool::ExecuteBash(serde_json::from_value::<ExecuteBash>(value.args).map_err(map_err)?),
             "use_aws" => Tool::UseAws(serde_json::from_value::<UseAws>(value.args).map_err(map_err)?),
             "report_issue" => Tool::GhIssue(serde_json::from_value::<GhIssue>(value.args).map_err(map_err)?),
+            "q_think_tool" => Tool::Thinking(serde_json::from_value::<Think>(value.args).map_err(map_err)?),
             // Note that this name is namespaced with server_name{DELIMITER}tool_name
             name => {
                 let name = self.tn_map.get(name).map_or(name, String::as_str);

crates/chat-cli/src/cli/chat/tools/mod.rs

@@ -3,6 +3,7 @@ pub mod execute_bash;
 pub mod fs_read;
 pub mod fs_write;
 pub mod gh_issue;
+pub mod thinking;
 pub mod use_aws;
 
 use std::collections::HashMap;
@@ -27,6 +28,7 @@ use serde::{
     Deserialize,
     Serialize,
 };
+use thinking::Thinking;
 use use_aws::UseAws;
 
 use super::consts::MAX_TOOL_RESPONSE_SIZE;
@@ -42,6 +44,7 @@ pub enum Tool {
     UseAws(UseAws),
     Custom(CustomTool),
     GhIssue(GhIssue),
+    Thinking(Thinking),
 }
 
 impl Tool {
@@ -54,6 +57,7 @@ impl Tool {
             Tool::UseAws(_) => "use_aws",
             Tool::Custom(custom_tool) => &custom_tool.name,
             Tool::GhIssue(_) => "gh_issue",
+            Tool::Thinking(_) => "thinking (prerelease)",
         }
         .to_owned()
     }
@@ -67,6 +71,7 @@ impl Tool {
             Tool::UseAws(use_aws) => use_aws.requires_acceptance(),
             Tool::Custom(_) => true,
             Tool::GhIssue(_) => false,
+            Tool::Thinking(_) => false,
         }
     }
 
@@ -79,6 +84,7 @@ impl Tool {
             Tool::UseAws(use_aws) => use_aws.invoke(context, updates).await,
             Tool::Custom(custom_tool) => custom_tool.invoke(context, updates).await,
             Tool::GhIssue(gh_issue) => gh_issue.invoke(updates).await,
+            Tool::Thinking(think) => think.invoke(updates).await,
         }
     }
 
@@ -91,6 +97,7 @@ impl Tool {
             Tool::UseAws(use_aws) => use_aws.queue_description(updates),
             Tool::Custom(custom_tool) => custom_tool.queue_description(updates),
             Tool::GhIssue(gh_issue) => gh_issue.queue_description(updates),
+            Tool::Thinking(thinking) => thinking.queue_description(updates),
         }
     }
 
@@ -103,6 +110,7 @@ impl Tool {
             Tool::UseAws(use_aws) => use_aws.validate(ctx).await,
             Tool::Custom(custom_tool) => custom_tool.validate(ctx).await,
             Tool::GhIssue(gh_issue) => gh_issue.validate(ctx).await,
+            Tool::Thinking(think) => think.validate(ctx).await,
         }
     }
 }
@@ -176,6 +184,7 @@ impl ToolPermissions {
             "execute_bash" => "trust read-only commands".dark_grey(),
             "use_aws" => "trust read-only commands".dark_grey(),
             "report_issue" => "trusted".dark_green().bold(),
+            "thinking" => "trusted (prerelease)".dark_green().bold(),
             _ => "not trusted".dark_grey(),
         };
 

crates/chat-cli/src/cli/chat/tools/thinking.rs

@@ -0,0 +1,70 @@
+use std::io::Write;
+
+use crossterm::queue;
+use crossterm::style::{
+    self,
+    Color,
+};
+use eyre::Result;
+use serde::Deserialize;
+
+use super::{
+    InvokeOutput,
+    OutputKind,
+};
+use crate::fig_settings::settings;
+
+/// The Think tool allows the model to reason through complex problems during response generation.
+/// It provides a dedicated space for the model to process information from tool call results,
+/// navigate complex decision trees, and improve the quality of responses in multi-step scenarios.
+///
+/// This is a beta feature that can be enabled/disabled via settings:
+/// `q settings chat.enableThinking true`
+#[derive(Debug, Clone, Deserialize)]
+pub struct Thinking {
+    /// The thought content that the model wants to process
+    pub thought: String,
+}
+
+impl Thinking {
+    /// Checks if the thinking feature is enabled in settings
+    pub fn is_enabled() -> bool {
+        // Default to enabled if setting doesn't exist or can't be read
+        settings::get_bool_or("chat.enableThinking", true)
+    }
+
+    /// Queues up a description of the think tool for the user
+    pub fn queue_description(&self, updates: &mut impl Write) -> Result<()> {
+        // Only show a description if there's actual thought content
+        if !self.thought.trim().is_empty() {
+            // Show a preview of the thought that will be displayed
+            queue!(
+                updates,
+                style::SetForegroundColor(Color::Blue),
+                style::Print("I'll share my reasoning process: "),
+                style::SetForegroundColor(Color::Reset),
+                style::Print(&self.thought),
+                style::Print("\n")
+            )?;
+        }
+        Ok(())
+    }
+
+    /// Invokes the think tool. This doesn't actually perform any system operations,
+    /// it's purely for the model's internal reasoning process.
+    pub async fn invoke(&self, _updates: &mut impl Write) -> Result<InvokeOutput> {
+        // The think tool always returns an empty output because:
+        // 1. When enabled with content: We've already shown the thought in queue_description
+        // 2. When disabled or empty: Nothing should be shown
+        Ok(InvokeOutput {
+            output: OutputKind::Text(String::new()),
+        })
+    }
+
+    /// Validates the thought - accepts empty thoughts
+    pub async fn validate(&mut self, _ctx: &crate::fig_os_shim::Context) -> Result<()> {
+        // We accept empty thoughts - they'll just be ignored
+        // This makes the tool more robust and prevents errors from blocking the model
+        Ok(())
+    }
+}

crates/chat-cli/src/cli/chat/tools/tool_index.json

@@ -10,9 +10,7 @@
           "description": "Bash command to execute"
         }
       },
-      "required": [
-        "command"
-      ]
+      "required": ["command"]
     }
   },
   "fs_read": {
@@ -27,11 +25,7 @@
         },
         "mode": {
           "type": "string",
-          "enum": [
-            "Line",
-            "Directory",
-            "Search"
-          ],
+          "enum": ["Line", "Directory", "Search"],
           "description": "The mode to run in: `Line`, `Directory`, `Search`. `Line` and `Search` are only for text files, and `Directory` is only for directories."
         },
         "start_line": {
@@ -59,10 +53,7 @@
           "default": 0
         }
       },
-      "required": [
-        "path",
-        "mode"
-      ]
+      "required": ["path", "mode"]
     }
   },
   "fs_write": {
@@ -73,12 +64,7 @@
       "properties": {
         "command": {
           "type": "string",
-          "enum": [
-            "create",
-            "str_replace",
-            "insert",
-            "append"
-          ],
+          "enum": ["create", "str_replace", "insert", "append"],
           "description": "The commands to run. Allowed options are: `create`, `str_replace`, `insert`, `append`."
         },
         "file_text": {
@@ -102,10 +88,7 @@
           "type": "string"
         }
       },
-      "required": [
-        "command",
-        "path"
-      ]
+      "required": ["command", "path"]
     }
   },
   "use_aws": {
@@ -139,12 +122,7 @@
           "description": "Human readable description of the api that is being called."
         }
       },
-      "required": [
-        "region",
-        "service_name",
-        "operation_name",
-        "label"
-      ]
+      "required": ["region", "service_name", "operation_name", "label"]
     }
   },
   "gh_issue": {
@@ -172,5 +150,19 @@
       },
       "required": ["title"]
     }
+  },
+  "thinking": {
+    "name": "thinking",
+    "description": "Thinking is an internal reasoning mechanism improving the quality of complex tasks by breaking their atomic actions down; use it specifically for multi-step problems requiring step-by-step dependencies, reasoning through multiple constraints, synthesizing results from previous tool calls, planning intricate sequences of actions, troubleshooting complex errors, or making decisions involving multiple trade-offs. Avoid using it for straightforward tasks, basic information retrieval, summaries, always clearly define the reasoning challenge, structure thoughts explicitly, consider multiple perspectives, and summarize key insights before important decisions or complex tool interactions.",
+    "input_schema": {
+      "type": "object",
+      "properties": {
+        "thought": {
+          "type": "string",
+          "description": "A reflective note or intermediate reasoning step such as \"The user needs to prepare their application for production. I need to complete three major asks including 1: building their code from source, 2: bundling their release artifacts together, and 3: signing the application bundle."
+        }
+      },
+      "required": ["thought"]
+    }
   }
 }