Fix agent lifecycle timeouts and retries

Author: claude

README.md

@@ -192,6 +192,7 @@ environment; commit templates, not local secrets.
 default_model = "provider/model-id"
 max_parallel_tasks = 4
 auto_parallel = false
+llm_api_timeout_ms = 120000
 
 providers "provider" {
   apiKey = env("PROVIDER_API_KEY")
@@ -220,6 +221,9 @@ auto_delegation {
 }
 ```
 
+`llm_api_timeout_ms` applies only to model provider HTTP calls. Tool execution
+timeouts are configured separately through `SessionOptions::with_tool_timeout`.
+
 `storage_backend = "file"` is only useful for local session persistence when it
 has a `sessions_dir`; otherwise pass a typed `FileSessionStore` from the SDK.
 

core/src/agent.rs

@@ -110,6 +110,11 @@ pub(crate) struct AgentConfig {
     /// A timeout produces an error result sent back to the LLM rather than
     /// crashing the session.
     pub tool_timeout_ms: Option<u64>,
+    /// Per-model API HTTP timeout in milliseconds (`None` = no timeout).
+    ///
+    /// This is intentionally separate from `tool_timeout_ms`: slow shell/web
+    /// tools and slow model providers have different operational envelopes.
+    pub llm_api_timeout_ms: Option<u64>,
     /// Maximum number of sibling branches/tools to run concurrently in bounded
     /// parallel fan-out paths.
     pub max_parallel_tasks: usize,
@@ -193,6 +198,7 @@ impl std::fmt::Debug for AgentConfig {
             )
             .field("max_parse_retries", &self.max_parse_retries)
             .field("tool_timeout_ms", &self.tool_timeout_ms)
+            .field("llm_api_timeout_ms", &self.llm_api_timeout_ms)
             .field("max_parallel_tasks", &self.max_parallel_tasks)
             .field("auto_delegation", &self.auto_delegation)
             .field(
@@ -234,6 +240,7 @@ impl Default for AgentConfig {
             enforce_active_skill_tool_restrictions: false,
             max_parse_retries: 2,
             tool_timeout_ms: None,
+            llm_api_timeout_ms: None,
             max_parallel_tasks: DEFAULT_MAX_PARALLEL_TASKS,
             auto_delegation: crate::config::AutoDelegationConfig::default(),
             agent_registry: None,

core/src/agent/completion_runtime.rs

@@ -6,6 +6,16 @@ use crate::verification::VerificationSummary;
 use futures::future::join_all;
 use tokio::sync::mpsc;
 
+const REASONING_ONLY_REPAIR: &str = "\
+Your previous assistant message contained reasoning/thinking content but no \
+normal reply content and no tool call. Continue from that state now. If tool \
+work is still required, call the needed tool. Otherwise provide the final answer \
+in normal assistant content only; do not put the final answer in reasoning.";
+
+const REASONING_ONLY_FALLBACK: &str = "\
+The model completed but returned only reasoning content and did not provide a \
+final answer.";
+
 pub(super) enum CompletionFlow {
     Continue,
     Finished(String),
@@ -25,6 +35,18 @@ impl AgentLoop {
     ) -> CompletionFlow {
         let candidate_text = response.text();
 
+        if self.inject_reasoning_only_repair_if_needed(state, turn, response) {
+            return CompletionFlow::Continue;
+        }
+
+        let candidate_text = if candidate_text.trim().is_empty()
+            && Self::is_terminal_reasoning_only_response(response)
+        {
+            REASONING_ONLY_FALLBACK.to_string()
+        } else {
+            candidate_text
+        };
+
         if self.inject_continuation_if_needed(state, turn, &candidate_text) {
             return CompletionFlow::Continue;
         }
@@ -42,6 +64,57 @@ impl AgentLoop {
         CompletionFlow::Finished(final_text)
     }
 
+    fn inject_reasoning_only_repair_if_needed(
+        &self,
+        state: &mut ExecutionLoopState,
+        turn: usize,
+        response: &LlmResponse,
+    ) -> bool {
+        if !Self::is_terminal_reasoning_only_response(response) {
+            return false;
+        }
+
+        if !state.should_inject_reasoning_only_repair(
+            self.config.continuation_enabled,
+            self.config.max_tool_rounds,
+        ) {
+            return false;
+        }
+
+        tracing::info!(
+            turn = turn,
+            "Injecting reasoning-only repair message - response had no content"
+        );
+        state.messages.push(Message::user(REASONING_ONLY_REPAIR));
+        true
+    }
+
+    fn is_terminal_reasoning_only_response(response: &LlmResponse) -> bool {
+        if !response.text().trim().is_empty() {
+            return false;
+        }
+        if response
+            .message
+            .reasoning_content
+            .as_deref()
+            .map(str::trim)
+            .unwrap_or_default()
+            .is_empty()
+        {
+            return false;
+        }
+
+        let reason = response
+            .stop_reason
+            .as_deref()
+            .unwrap_or_default()
+            .to_ascii_lowercase();
+        !(reason.contains("length")
+            || reason.contains("max_tokens")
+            || reason.contains("tool")
+            || reason.contains("filter"))
+    }
+
     fn inject_continuation_if_needed(
         &self,
         state: &mut ExecutionLoopState,

core/src/agent/execution_state.rs

@@ -14,6 +14,7 @@ pub(super) struct ExecutionLoopState {
     turn: usize,
     parse_error_count: u32,
     continuation_count: u32,
+    reasoning_only_repair_count: u32,
     recent_tool_signatures: Vec<String>,
     execution_start: Instant,
 }
@@ -58,6 +59,7 @@ impl ExecutionLoopState {
             turn: 0,
             parse_error_count: 0,
             continuation_count: 0,
+            reasoning_only_repair_count: 0,
             recent_tool_signatures: Vec::new(),
             execution_start: Instant::now(),
         }
@@ -201,6 +203,19 @@ impl ExecutionLoopState {
         false
     }
 
+    pub(super) fn should_inject_reasoning_only_repair(
+        &mut self,
+        enabled: bool,
+        max_tool_rounds: usize,
+    ) -> bool {
+        if enabled && self.reasoning_only_repair_count == 0 && self.turn < max_tool_rounds {
+            self.reasoning_only_repair_count += 1;
+            return true;
+        }
+
+        false
+    }
+
     pub(super) fn finish(self, text: String) -> AgentResult {
         AgentResult {
             text,

core/src/agent/extra_agent_tests.rs

@@ -1692,6 +1692,7 @@ fn test_agent_config_resilience_defaults() {
     let config = AgentConfig::default();
     assert_eq!(config.max_parse_retries, 2);
     assert_eq!(config.tool_timeout_ms, None);
+    assert_eq!(config.llm_api_timeout_ms, None);
     assert_eq!(config.circuit_breaker_threshold, 3);
 }
 

core/src/agent/tests.rs

@@ -267,6 +267,25 @@ impl MockLlmClient {
         }
     }
 
+    pub(crate) fn reasoning_only_response(reasoning: &str) -> LlmResponse {
+        LlmResponse {
+            message: Message {
+                role: "assistant".to_string(),
+                content: Vec::new(),
+                reasoning_content: Some(reasoning.to_string()),
+            },
+            usage: TokenUsage {
+                prompt_tokens: 10,
+                completion_tokens: 5,
+                total_tokens: 15,
+                cache_read_tokens: None,
+                cache_write_tokens: None,
+            },
+            stop_reason: Some("stop".to_string()),
+            meta: None,
+        }
+    }
+
     /// Create a response with a tool call
     pub(crate) fn tool_call_response(
         tool_id: &str,
@@ -404,6 +423,57 @@ async fn test_agent_simple_response() {
     assert_eq!(mock_client.call_count.load(Ordering::SeqCst), 1);
 }
 
+#[tokio::test]
+async fn test_agent_repairs_reasoning_only_response_once() {
+    let mock_client = Arc::new(MockLlmClient::new(vec![
+        MockLlmClient::reasoning_only_response("I have the answer but put it in reasoning."),
+        MockLlmClient::text_response("The answer is 42."),
+    ]));
+
+    let tool_executor = Arc::new(ToolExecutor::new("/tmp".to_string()));
+    let config = AgentConfig {
+        max_continuation_turns: 0,
+        ..Default::default()
+    };
+
+    let agent = AgentLoop::new(
+        mock_client.clone(),
+        tool_executor,
+        test_tool_context(),
+        config,
+    );
+    let result = agent.execute(&[], "Answer plainly", None).await.unwrap();
+
+    assert_eq!(result.text, "The answer is 42.");
+    assert_eq!(mock_client.call_count.load(Ordering::SeqCst), 2);
+}
+
+#[tokio::test]
+async fn test_agent_stops_after_repeated_reasoning_only_response() {
+    let mock_client = Arc::new(MockLlmClient::new(vec![
+        MockLlmClient::reasoning_only_response("Thinking only, first pass."),
+        MockLlmClient::reasoning_only_response("Thinking only, second pass."),
+        MockLlmClient::text_response("This response should not be consumed."),
+    ]));
+
+    let tool_executor = Arc::new(ToolExecutor::new("/tmp".to_string()));
+    let config = AgentConfig::default();
+
+    let agent = AgentLoop::new(
+        mock_client.clone(),
+        tool_executor,
+        test_tool_context(),
+        config,
+    );
+    let result = agent.execute(&[], "Answer plainly", None).await.unwrap();
+
+    assert_eq!(
+        result.text,
+        "The model completed but returned only reasoning content and did not provide a final answer."
+    );
+    assert_eq!(mock_client.call_count.load(Ordering::SeqCst), 2);
+}
+
 #[tokio::test]
 async fn test_agent_with_tool_call() {
     let mock_client = Arc::new(MockLlmClient::new(vec![

core/src/agent_api.rs

@@ -218,6 +218,9 @@ pub struct SessionOptions {
     /// Per-tool execution timeout in milliseconds.
     /// `None` = no timeout (default).
     pub tool_timeout_ms: Option<u64>,
+    /// Per-model API HTTP timeout in milliseconds.
+    /// `None` = no timeout (default).
+    pub llm_api_timeout_ms: Option<u64>,
     /// Circuit-breaker threshold: max consecutive LLM API failures before
     /// aborting in non-streaming mode (overrides default of 3).
     /// `None` uses the `AgentConfig` default.
@@ -1047,6 +1050,7 @@ impl AgentSession {
             hook_engine: None,
             skill_registry: self.config.skill_registry.clone(),
             tool_timeout_ms: self.config.tool_timeout_ms,
+            llm_api_timeout_ms: self.config.llm_api_timeout_ms,
             max_parallel_tasks: Some(self.config.max_parallel_tasks),
             max_execution_time_ms: self.config.max_execution_time_ms,
             circuit_breaker_threshold: Some(self.config.circuit_breaker_threshold),

core/src/agent_api/agent_bootstrap.rs

@@ -94,6 +94,7 @@ fn base_agent_config(config: &CodeConfig) -> AgentConfig {
             .max_parallel_tasks
             .unwrap_or(AgentConfig::default().max_parallel_tasks)
             .max(1),
+        llm_api_timeout_ms: config.llm_api_timeout_ms,
         auto_delegation,
         ..AgentConfig::default()
     }

core/src/agent_api/capabilities.rs

@@ -190,6 +190,7 @@ fn register_task_capability(
         hook_engine: None,
         skill_registry: opts.skill_registry.clone(),
         tool_timeout_ms: opts.tool_timeout_ms,
+        llm_api_timeout_ms: opts.llm_api_timeout_ms.or(code_config.llm_api_timeout_ms),
         max_parallel_tasks: opts.max_parallel_tasks.or(code_config.max_parallel_tasks),
         max_execution_time_ms: opts.max_execution_time_ms,
         circuit_breaker_threshold: opts.circuit_breaker_threshold,

core/src/agent_api/run_lifecycle.rs

@@ -29,22 +29,25 @@ impl StreamRunWorkerState {
     where
         E: std::fmt::Display,
     {
+        let cancelled = self
+            .cancel_token
+            .lock()
+            .await
+            .as_ref()
+            .map(|t| t.is_cancelled())
+            .unwrap_or(false);
         match result {
             Ok(result) => {
                 if let Some(persistence) = &self.persistence {
                     persistence.record_result(&result);
                     self.should_auto_save
                         .store(true, std::sync::atomic::Ordering::Release);
                 }
+                if cancelled {
+                    let _ = self.run_store.mark_cancelled(&self.run_id).await;
+                }
             }
             Err(error) => {
-                let cancelled = self
-                    .cancel_token
-                    .lock()
-                    .await
-                    .as_ref()
-                    .map(|t| t.is_cancelled())
-                    .unwrap_or(false);
                 if cancelled {
                     let _ = self.run_store.mark_cancelled(&self.run_id).await;
                 } else {
@@ -190,6 +193,9 @@ impl BlockingRunLifecycle {
                     persistence.record_result(&result);
                     persistence.auto_save_if_enabled().await;
                 }
+                if cancelled {
+                    let _ = self.run_store.mark_cancelled(self.cleanup.run_id()).await;
+                }
                 self.cleanup.finish().await;
                 Ok(result)
             }