Add ToolChoice enum to control function calling behavior and improve Ollama thinking mode handling

- Add ToolChoice enum (Auto, Required, None) to providers/common.rs for controlling tool execution policy
- Extend GenerateOptions with tool_choice field and with_tool_choice() builder method
- Update Ollama provider: add note about tool_choice parameter not yet supported by Ollama API
- Improve parse_response() in Ollama completion: handle thinking mode content properly, log thinking field when present but

Author: gitctrlx

machi/src/providers/common.rs

@@ -122,6 +122,19 @@ pub type ModelStream =
 #[cfg(target_arch = "wasm32")]
 pub type ModelStream = Pin<Box<dyn Stream<Item = Result<ChatMessageStreamDelta, AgentError>>>>;
 
+/// Tool choice mode for function calling.
+#[derive(Debug, Clone, Copy, Default, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "lowercase")]
+pub enum ToolChoice {
+    /// Model decides whether to call tools.
+    #[default]
+    Auto,
+    /// Model must call at least one tool.
+    Required,
+    /// Model should not call any tools.
+    None,
+}
+
 /// Options for model generation requests.
 #[derive(Debug, Clone, Default, Serialize, Deserialize)]
 pub struct GenerateOptions {
@@ -131,6 +144,9 @@ pub struct GenerateOptions {
     /// Available tools for function calling.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub tools: Option<Vec<ToolDefinition>>,
+    /// Tool choice mode - controls whether model must/can/cannot call tools.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tool_choice: Option<ToolChoice>,
     /// Temperature for sampling (0.0 to 2.0).
     #[serde(skip_serializing_if = "Option::is_none")]
     pub temperature: Option<f32>,
@@ -166,6 +182,13 @@ impl GenerateOptions {
         self
     }
 
+    /// Set tool choice mode.
+    #[must_use]
+    pub fn with_tool_choice(mut self, choice: ToolChoice) -> Self {
+        self.tool_choice = Some(choice);
+        self
+    }
+
     /// Set temperature.
     #[must_use]
     pub const fn with_temperature(mut self, temp: f32) -> Self {

machi/src/providers/ollama/completion.rs

@@ -201,6 +201,8 @@ impl CompletionModel {
             // Enable thinking mode for models like qwen3 that need it for tool calling
             // When think=true, response has "thinking" field with reasoning and "tool_calls" with calls
             body["think"] = serde_json::json!(true);
+            // Note: Ollama doesn't support tool_choice parameter yet, but we handle
+            // native tool_calls in parse_response() which takes priority over text parsing
         }
 
         body
@@ -209,7 +211,18 @@ impl CompletionModel {
     /// Parse the API response into a `ModelResponse`.
     fn parse_response(&self, json: Value) -> Result<ModelResponse, AgentError> {
         let message_json = &json["message"];
+        
+        // Get content - in think mode, actual response may be in "thinking" field
         let content = message_json["content"].as_str().map(String::from);
+        
+        // If content is empty but thinking exists, log it for debugging
+        // The tool_calls should still be present when think=true
+        if content.as_ref().is_none_or(|c| c.is_empty()) {
+            if let Some(thinking) = message_json["thinking"].as_str() {
+                debug!(thinking_len = thinking.len(), "Model returned thinking content");
+                // Don't use thinking as content - tool_calls should be parsed below
+            }
+        }
 
         // Parse tool calls
         let tool_calls = if message_json["tool_calls"].is_array() {