@@ -53,8 +53,11 @@ In headless mode, Aictrl automatically rejects all interactive permission reques
 ### CI/CD Integration
 Set `AICTRL_HEADLESS=true` in your environment to force headless behavior even in pseudo-TTYs.
 
+### Model Stream Idle Timeout
+
 Model streams have a five-minute idle timeout by default. Every stream event resets
-the timer, so long-running responses that continue making progress are unaffected.
+the timer, so long-running responses that continue making progress are unaffected. Local
+tool execution uses a ceiling twelve times the configured model timeout (one hour by default).
 Set `AICTRL_MODEL_STREAM_IDLE_TIMEOUT_MS` to a decimal integer of milliseconds through
 2147483647 to override the timeout, or `0` to disable it. Missing, empty, negative,
 fractional, non-decimal, non-numeric, or unsupported values use the 300000 ms default.
 
@@ -1,9 +1,9 @@
 import { MessageV2 } from "./message-v2"
 
 export namespace StreamIdle {
-  function error(ms: number) {
+  function error(ms: number, message = `Model stream produced no events for ${ms}ms`) {
     return new MessageV2.StreamIdleTimeoutError({
-      message: `Model stream produced no events for ${ms}ms`,
+      message,
       timeout: ms,
     })
   }
@@ -21,6 +21,7 @@ export namespace StreamIdle {
     ms: number,
     abort: () => void,
     updateSuspended: (value: T) => boolean = () => false,
+    suspendedTimeout = ms,
   ) {
     if (ms === 0) {
       yield* stream
@@ -31,18 +32,19 @@ export namespace StreamIdle {
     let suspended = false
     try {
       while (true) {
-        if (suspended) {
-          const next = await iterator.next()
-          if (next.done) return
-          suspended = updateSuspended(next.value)
-          yield next.value
-          continue
-        }
         const timer = Promise.withResolvers<never>()
+        const timeout = suspended ? suspendedTimeout : ms
         const id = setTimeout(() => {
-          timer.reject(error(ms))
+          timer.reject(
+            error(
+              timeout,
+              suspended
+                ? `Local tool execution produced no result for ${timeout}ms`
+                : `Model stream produced no events for ${timeout}ms`,
+            ),
+          )
           abort()
-        }, ms)
+        }, timeout)
         const next = await Promise.race([iterator.next(), timer.promise]).finally(() => clearTimeout(id))
         if (next.done) return
         suspended = updateSuspended(next.value)
 
@@ -21,6 +21,7 @@ import { NamedError } from "@aictrl/util/error"
 
 export namespace SessionProcessor {
   const DOOM_LOOP_THRESHOLD = 3
+  const LOCAL_TOOL_TIMEOUT_MULTIPLIER = 12
   const log = Log.create({ service: "session.processor" })
 
   export type Info = Awaited<ReturnType<typeof create>>
@@ -68,7 +69,7 @@ export namespace SessionProcessor {
                 if (
                   value.type === "tool-call" &&
                   !value.providerExecuted &&
-                  typeof streamInput.tools[value.toolName]?.execute === "function"
+                  typeof streamInput.tools?.[value.toolName]?.execute === "function"
                 ) {
                   runningTools.add(value.toolCallId)
                 }
@@ -77,6 +78,10 @@ export namespace SessionProcessor {
                 }
                 return runningTools.size > 0
               },
+              Math.min(
+                Flag.AICTRL_MODEL_STREAM_IDLE_TIMEOUT_MS * LOCAL_TOOL_TIMEOUT_MULTIPLIER,
+                Flag.AICTRL_MODEL_STREAM_IDLE_TIMEOUT_MAX,
+              ),
             )) {
               input.abort.throwIfAborted()
               switch (value.type) {
 
@@ -105,6 +105,32 @@ describe("model stream idle timeout", () => {
     expect(values).toEqual([1, 2, 3])
   })
 
+  test("bounds a suspended local tool wait", async () => {
+    async function* stream() {
+      yield "tool-call"
+      await new Promise(() => {})
+    }
+    let aborted = false
+    const result = StreamIdle.timeout(
+      stream(),
+      10,
+      () => {
+        aborted = true
+      },
+      (value) => value === "tool-call",
+      30,
+    )
+
+    expect(await result.next()).toEqual({ done: false, value: "tool-call" })
+    const error = await result.next().catch((value) => value)
+    expect(aborted).toBe(true)
+    expect(MessageV2.StreamIdleTimeoutError.isInstance(error)).toBe(true)
+    expect(error.data).toEqual({
+      message: "Local tool execution produced no result for 30ms",
+      timeout: 30,
+    })
+  })
+
   test("zero disables the timeout", async () => {
     async function* stream() {
       await Bun.sleep(15)