fix: drive tool rounds iteratively instead of recursively to prevent stack overflow on long agentic turns to fix latent stack overflow recursion bug

src/main.rs

@@ -556,7 +556,6 @@ async fn run(
     }
 }
 
-#[async_recursion::async_recursion]
 async fn start_directive(
     ctx: &mut RequestContext,
     input: Input,
@@ -576,8 +575,10 @@ async fn start_directive(
         return Ok(());
     }
 
-    let client = input.create_client()?;
     let extract_code = !*IS_STDOUT_TERMINAL && code_mode;
+    let mut input = input;
+    loop {
+        let client = input.create_client()?;
         ctx.before_chat_completion(&input)?;
         let (output, tool_results) = if !input.stream() || extract_code {
             call_chat_completions(
@@ -590,23 +591,20 @@ async fn start_directive(
             )
             .await?
         } else {
-        call_chat_completions_streaming(&input, client.as_ref(), ctx, abort_signal.clone()).await?
+            call_chat_completions_streaming(&input, client.as_ref(), ctx, abort_signal.clone())
+                .await?
         };
         ctx.after_chat_completion(app.as_ref(), &input, &output, &tool_results)?;
 
         if !tool_results.is_empty() {
-        start_directive(
-            ctx,
-            input.merge_tool_results(output, tool_results),
-            code_mode,
-            abort_signal,
-        )
-        .await?;
-    } else {
+            input = input.merge_tool_results(output, tool_results);
+            continue;
+        }
+
         match check_pending_tasks_guardrail(ctx) {
             GuardrailAction::Inject(prompt) => {
-                let guardrail_input = Input::from_str(ctx, &prompt, None)?;
-                return start_directive(ctx, guardrail_input, code_mode, abort_signal).await;
+                input = Input::from_str(ctx, &prompt, None)?;
+                continue;
             }
             GuardrailAction::ForceTerminate(ids) => {
                 warn!(
@@ -617,6 +615,8 @@ async fn start_directive(
             }
             GuardrailAction::NoAction => {}
         }
+
+        break;
     }
 
     ctx.exit_session()?;

src/repl/mod.rs

@@ -1424,19 +1424,22 @@ pub async fn run_repl_command(
     Ok(false)
 }
 
-#[async_recursion::async_recursion]
 async fn ask(
     ctx: &mut RequestContext,
     abort_signal: AbortSignal,
-    mut input: Input,
+    input: Input,
     with_embeddings: bool,
 ) -> Result<()> {
+    let mut input = input;
+    let mut with_embeddings = with_embeddings;
+    loop {
         if input.is_empty() {
             return Ok(());
         }
         ctx.session_abort = Some(abort_signal.clone());
         if with_embeddings {
             input.use_embeddings(abort_signal.clone()).await?;
+            with_embeddings = false;
         }
         while ctx.is_compressing_session() {
             tokio::time::sleep(std::time::Duration::from_millis(100)).await;
@@ -1480,18 +1483,14 @@ async fn ask(
         };
         ctx.after_chat_completion(app.as_ref(), &input, &output, &tool_results)?;
         if !tool_results.is_empty() {
-        ask(
-            ctx,
-            abort_signal,
-            input.merge_tool_results(output, tool_results),
-            false,
-        )
-        .await
-    } else {
+            input = input.merge_tool_results(output, tool_results);
+            continue;
+        }
+
         match check_pending_tasks_guardrail(ctx) {
             GuardrailAction::Inject(prompt) => {
-                let guardrail_input = Input::from_str(ctx, &prompt, None)?;
-                return ask(ctx, abort_signal, guardrail_input, false).await;
+                input = Input::from_str(ctx, &prompt, None)?;
+                continue;
             }
             GuardrailAction::ForceTerminate(ids) => {
                 warn!(
@@ -1533,9 +1532,10 @@ async fn ask(
 
                 format!("{prompt}\n\n{todo_state}")
             };
-            let continuation_input = Input::from_str(ctx, &full_prompt, None)?;
-            ask(ctx, abort_signal, continuation_input, false).await
-        } else {
+            input = Input::from_str(ctx, &full_prompt, None)?;
+            continue;
+        }
+
         reset_continuation(ctx);
         if let Some(reason) = ctx.auto_continue_paused.clone()
             && ctx.todo_list.has_incomplete()
@@ -1623,13 +1623,12 @@ async fn ask(
 
                     format!("{prompt}\n\n{todo_state}")
                 };
-                    let continuation_input = Input::from_str(ctx, &full_prompt, None)?;
-                    return ask(ctx, abort_signal, continuation_input, false).await;
+                input = Input::from_str(ctx, &full_prompt, None)?;
+                continue;
             }
         }
 
-            Ok(())
-        }
+        return Ok(());
     }
 }