Merge branch 'main' into feat/telegram-send-audio

Author: jamiepine

src/llm/model.rs

@@ -1236,15 +1236,21 @@ fn parse_anthropic_response(
         }
     }
 
-    let choice = OneOrMany::many(assistant_content).map_err(|_| {
+    let choice = OneOrMany::many(assistant_content).unwrap_or_else(|_| {
+        // Anthropic returns an empty content array when stop_reason is end_turn
+        // and the model has nothing further to say (e.g. after a side-effect-only
+        // tool call like react/skip). Treat this as a clean empty response rather
+        // than an error so the agentic loop terminates gracefully.
+        let stop_reason = body["stop_reason"].as_str().unwrap_or("unknown");
         tracing::debug!(
-            stop_reason = body["stop_reason"].as_str().unwrap_or("unknown"),
+            stop_reason,
             content_blocks = content_blocks.len(),
-            raw_content = %body["content"],
-            "empty assistant_content after parsing Anthropic response"
+            "empty assistant_content from Anthropic — returning synthetic empty text"
         );
-        CompletionError::ResponseError("empty response from Anthropic".into())
-    })?;
+        OneOrMany::one(AssistantContent::Text(Text {
+            text: String::new(),
+        }))
+    });
 
     let input_tokens = body["usage"]["input_tokens"].as_u64().unwrap_or(0);
     let output_tokens = body["usage"]["output_tokens"].as_u64().unwrap_or(0);

src/tools.rs

@@ -88,6 +88,51 @@ use std::path::PathBuf;
 use std::sync::Arc;
 use tokio::sync::{broadcast, mpsc};
 
+/// Deserialize a `u64` that may arrive as either a JSON number or a JSON string.
+///
+/// LLMs sometimes send `"timeout_seconds": "400"` instead of `"timeout_seconds": 400`.
+/// This helper accepts both forms so the tool call doesn't fail on a type mismatch.
+pub fn deserialize_string_or_u64<'de, D>(deserializer: D) -> Result<u64, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    use serde::de;
+
+    struct StringOrU64;
+
+    impl<'de> de::Visitor<'de> for StringOrU64 {
+        type Value = u64;
+
+        fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+            formatter.write_str("a u64 or a string containing a u64")
+        }
+
+        fn visit_u64<E: de::Error>(self, value: u64) -> Result<u64, E> {
+            Ok(value)
+        }
+
+        fn visit_i64<E: de::Error>(self, value: i64) -> Result<u64, E> {
+            u64::try_from(value).map_err(|_| E::custom(format!("negative value: {value}")))
+        }
+
+        fn visit_f64<E: de::Error>(self, value: f64) -> Result<u64, E> {
+            if value >= 0.0 && value <= u64::MAX as f64 && value.fract() == 0.0 {
+                Ok(value as u64)
+            } else {
+                Err(E::custom(format!("invalid timeout value: {value}")))
+            }
+        }
+
+        fn visit_str<E: de::Error>(self, value: &str) -> Result<u64, E> {
+            value
+                .parse::<u64>()
+                .map_err(|_| E::custom(format!("cannot parse \"{value}\" as a positive integer")))
+        }
+    }
+
+    deserializer.deserialize_any(StringOrU64)
+}
+
 /// Maximum byte length for tool output strings (stdout, stderr, file content).
 /// ~50KB keeps a single tool result under ~12,500 tokens (at ~4 chars/token).
 pub const MAX_TOOL_OUTPUT_BYTES: usize = 50_000;
@@ -296,3 +341,49 @@ pub fn create_cortex_chat_tool_server(
 
     server.run()
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn shell_args_parses_timeout_as_integer() {
+        let args: shell::ShellArgs =
+            serde_json::from_str(r#"{"command": "ls", "timeout_seconds": 120}"#).unwrap();
+        assert_eq!(args.timeout_seconds, 120);
+    }
+
+    #[test]
+    fn shell_args_parses_timeout_as_string() {
+        let args: shell::ShellArgs =
+            serde_json::from_str(r#"{"command": "ls", "timeout_seconds": "400"}"#).unwrap();
+        assert_eq!(args.timeout_seconds, 400);
+    }
+
+    #[test]
+    fn shell_args_uses_default_when_timeout_missing() {
+        let args: shell::ShellArgs = serde_json::from_str(r#"{"command": "ls"}"#).unwrap();
+        assert_eq!(args.timeout_seconds, 60);
+    }
+
+    #[test]
+    fn shell_args_rejects_non_numeric_string() {
+        let result: Result<shell::ShellArgs, _> =
+            serde_json::from_str(r#"{"command": "ls", "timeout_seconds": "abc"}"#);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn exec_args_parses_timeout_as_string() {
+        let args: exec::ExecArgs =
+            serde_json::from_str(r#"{"program": "/bin/ls", "timeout_seconds": "300"}"#).unwrap();
+        assert_eq!(args.timeout_seconds, 300);
+    }
+
+    #[test]
+    fn exec_args_parses_timeout_as_integer() {
+        let args: exec::ExecArgs =
+            serde_json::from_str(r#"{"program": "/bin/ls", "timeout_seconds": 90}"#).unwrap();
+        assert_eq!(args.timeout_seconds, 90);
+    }
+}

src/tools/exec.rs

@@ -81,7 +81,10 @@ pub struct ExecArgs {
     #[serde(default)]
     pub env: Vec<EnvVar>,
     /// Timeout in seconds (default: 60).
-    #[serde(default = "default_timeout")]
+    #[serde(
+        default = "default_timeout",
+        deserialize_with = "crate::tools::deserialize_string_or_u64"
+    )]
     pub timeout_seconds: u64,
 }
 

src/tools/shell.rs

@@ -248,7 +248,10 @@ pub struct ShellArgs {
     /// Optional working directory for the command.
     pub working_dir: Option<String>,
     /// Optional timeout in seconds (default: 60).
-    #[serde(default = "default_timeout")]
+    #[serde(
+        default = "default_timeout",
+        deserialize_with = "crate::tools::deserialize_string_or_u64"
+    )]
     pub timeout_seconds: u64,
 }