[oxoxDev]

Summary

• Long-running Reasoning-mode turns no longer hit a false "No response from the agent after 2 minutes" timeout that discarded the in-flight turn.
• The core progress bridge now emits a periodic inference_heartbeat (every 20s) for the whole duration of an in-flight turn.
• The frontend silence timer rearms on that beat, so a turn that streams no other progress for minutes stays alive — while a genuine disconnect (beats stop) still fails fast.
• No new user-facing UI; reuses the existing chat.safetyTimeout error for true connectivity failures.

Problem

The 2-minute timeout is a purely frontend silence timer in app/src/pages/Conversations.tsx (armSilenceTimer, 120s). It only rearms when one of four redux slices changes (inferenceStatusByThread, streamingAssistantByThread, toolTimelineByThread, taskBoardByThread). inference_start arms it once at turn start; after that, two legitimate cases produce zero progress events for >120s while the turn is genuinely working:

1. A long prefill / time-to-first-token on a large context (the report was at 223K/1M tokens).
2. A reasoning-tier model whose provider buffers reasoning_content server-side and streams no intermediate delta.

In both, the silence timer fires, surfaces chat.safetyTimeout, clears the runtime, and the user loses the turn with no output. No core-side liveness signal existed (the heartbeat module is the unrelated subconscious loop).

Solution

• Core (channels/providers/web/progress_bridge.rs): convert the bridge's while let event loop to a loop { tokio::select! { … } } with a biased interval branch. Every INFERENCE_HEARTBEAT_SECS (20s) it publishes a WebChannelEvent { event: "inference_heartbeat", … }, gated on turn_active (set on TurnStarted, cleared on TurnCompleted). The beat rides the same socket as real progress, so it stops the instant the socket/core dies.
• Frontend: subscribe to inference_heartbeat (chatService.ts), bump a per-thread inferenceHeartbeatByThread counter (chatRuntimeSlice.ts) from ChatRuntimeProvider.tsx, and add that counter to the silence-timer rearm signature in Conversations.tsx (kept last so the done-transition probe on current[0] is unaffected).
• Design note: a fixed/per-mode timeout bump was rejected — it just moves the wall and slows the genuine-disconnect error. A heartbeat is the right layer: 120s now measures heartbeat gaps (6 missed beats), preserving fail-fast on real disconnects.

Submission Checklist

If a section does not apply to this change, mark the item as N/A with a one-line reason. Do not delete items.

• Tests added or updated (happy path + at least one failure / edge case) per Testing Strategy
• Diff coverage ≥ 80% — Rust paused-clock tests cover the heartbeat emit + gate; Vitest covers service wiring, slice reducer, rearm liveness, and the beats-stop regression path.
• N/A — Coverage matrix: internal liveness signal, no new user-facing feature ID
• All affected feature IDs from the matrix are listed in the PR description under ## Related
• No new external network dependencies introduced (tokio test-util is a test-only dev-dependency)
• N/A — Manual smoke: timing-only fix; automated paused-clock + fake-timer tests exercise both repro-gone and regression-safety paths
• Linked issue closed via Closes #NNN in the ## Related section

Impact

• Desktop only behavior: in-flight chat turns gain a 20s liveness beat over the existing Socket.IO channel — negligible overhead (one tiny event with no payload).
• No migration, no schema, no security surface. Backwards-compatible: older FE clients ignore the unknown event; the beat is purely additive.
• Genuine connectivity failures still surface chat.safetyTimeout within ~120s of the last beat.

Related

• Closes: Agent times out after 2 minutes on long-running reasoning tasks #4270
• Follow-up PR(s)/TODOs: Research agent intermittently hangs mid-run #4269 (Research agent intermittent hang — may share this root cause; not addressed here)

---

AI Authored PR Metadata (required for Codex/Linear PRs)

Linear Issue

• Key: N/A
• URL: N/A

Commit & Branch

• Branch: fix/4270-inference-heartbeat-timeout
• Commit SHA: 5e45cdb6f

Validation Run

• pnpm --filter openhuman-app format:check
• pnpm typecheck
• Focused tests: vitest run Conversations.render / chatService / chatRuntimeSlice (110 passed); cargo test --lib …web::progress_bridge (6 passed)
• Rust fmt/check (if changed): cargo fmt --check, cargo check, cargo clippy --lib (clean for changed file)
• N/A — Tauri fmt/check: no src-tauri code changed

Validation Blocked

• command: N/A
• error: N/A
• impact: N/A

Behavior Changes

• Intended behavior change: long silent reasoning turns are kept alive by a liveness beat instead of false-timing-out at 2 minutes.
• User-visible effect: Reasoning-mode tasks that take >2 minutes now complete and render instead of showing the timeout error.

Parity Contract

• Legacy behavior preserved: genuine disconnects still trip the 120s silence timer and surface chat.safetyTimeout.
• Guard/fallback/dispatch parity checks: rearm signature keeps status at index 0 so the done-transition (chat_done/chat_error) detection is unchanged; heartbeat counter cleared on clearRuntimeForThread.

Duplicate / Superseded PR Handling

• Duplicate PR(s): none found (searched open + 30d-merged for timeout/reasoning/Agent times out after 2 minutes on long-running reasoning tasks #4270)
• Canonical PR: this PR
• Resolution: N/A

Summary by CodeRabbit

• New Features

  • Added periodic “inference heartbeat” updates during long-running turns so conversation threads stay active even when no other progress is reported.

• Bug Fixes

  • Prevented the 120-second inactivity/silence timer from prematurely clearing threads during silent reasoning phases.
  • Heartbeats now apply to the primary turn only, not parallel/lane requests.

• Tests

  • Added end-to-end and unit test coverage to verify heartbeat behavior, timer rearming/clearing, and correct thread targeting.
  • Updated test tooling to use Tokio’s paused time for reliable heartbeat timing.

[coderabbitai]

No actionable comments were generated in the recent review. 🎉

ℹ️ Recent review info

⚙️ Run configuration

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro

Run ID: 49750fe9-a0f2-44bf-9082-a615ffea2a04

📥 Commits

Reviewing files that changed from the base of the PR and between bf42574 and dac701a.

📒 Files selected for processing (3)

• Cargo.toml
• app/src/pages/Conversations.tsx
• app/src/pages/__tests__/Conversations.render.test.tsx

🚧 Files skipped from review as they are similar to previous changes (3)

• Cargo.toml
• app/src/pages/Conversations.tsx
• app/src/pages/tests/Conversations.render.test.tsx

---

📝 Walkthrough

Walkthrough

Adds periodic inference_heartbeat events from the Rust progress bridge and threads them through the frontend service, store, provider, and Conversations silence timer.

Changes

Inference Heartbeat End-to-End

Layer / File(s)	Summary
Progress bridge heartbeat emission src/openhuman/channels/providers/web/progress_bridge.rs, Cargo.toml	Defines the 20s heartbeat interval, rewrites the bridge loop to emit inference_heartbeat only while a turn is active, toggles that state on turn start/completion, and adds paused-time tests plus tokio test utilities.
Chat service heartbeat subscription app/src/services/chatService.ts, app/src/services/__tests__/chatService.test.ts	Adds the heartbeat event type, listener hook, socket mapping, and forwarding logic, with a test that verifies the event is subscribed and passed through unchanged.
Runtime heartbeat counter state app/src/store/chatRuntimeSlice.ts, app/src/store/__tests__/chatRuntimeSlice.test.ts	Adds the per-thread heartbeat counter, reducer, cleanup paths, and store coverage for incrementing and reset behavior.
Provider dispatch and silence-timer rearm app/src/providers/ChatRuntimeProvider.tsx, app/src/pages/Conversations.tsx, app/src/providers/__tests__/ChatRuntimeProvider.test.tsx, app/src/pages/__tests__/Conversations.render.test.tsx	Dispatches heartbeat updates from the socket, ignores parallel lanes, folds the counter into Conversations timer rearming, and adds regression tests for active-heartbeat and heartbeat-stop cases.

Sequence Diagram(s)

sequenceDiagram
  participant progress_bridge
  participant socket
  participant provider as ChatRuntimeProvider
  participant store as Redux Store
  participant conv as Conversations.tsx

  progress_bridge->>socket: inference_heartbeat
  socket->>provider: onInferenceHeartbeat(event)
  provider->>store: dispatch bumpInferenceHeartbeatForThread(thread_id)
  store-->>conv: inferenceHeartbeatByThread updated
  conv->>conv: rearm 120s silence timer

Loading

Estimated code review effort

🎯 4 (Complex) | ⏱️ ~45 minutes

Poem

🐇 Thump, thump — a heartbeat in flight,
Long quiet turns stay bright tonight.
One tiny pulse, then one more too,
Keeps the rabbit trail alive and true.

🚥 Pre-merge checks | ✅ 4 | ❌ 1

❌ Failed checks (1 inconclusive)

Check name	Status	Explanation	Resolution
Linked Issues check	❓ Inconclusive	The heartbeat-based timeout fix matches #4270 and regression tests cover the long-running and failure paths, but coverage gate compliance isn't verifiable here.	Provide the changed-lines coverage report or CI evidence showing the PR meets the ≥80% diff coverage requirement.

✅ Passed checks (4 passed)

Check name	Status	Explanation
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.
Title check	✅ Passed	The title clearly summarizes the main fix: adding heartbeat support to keep long reasoning turns alive past the 2-minute timeout.
Out of Scope Changes check	✅ Passed	The changes stay focused on timeout prevention, socket handling, state tracking, and tests for the linked issue.
Docstring Coverage	✅ Passed	Docstring coverage is 100.00% which is sufficient. The required threshold is 80.00%.

---

_{Comment @coderabbitai help to get the list of available commands.}

[coderabbitai]

Actionable comments posted: 2

🤖 Prompt for all review comments with AI agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@app/src/providers/ChatRuntimeProvider.tsx`:
- Around line 478-484: The heartbeat handling in ChatRuntimeProvider is
collapsing liveness to thread scope, which lets parallel requests on the same
thread incorrectly keep the primary turn alive. Update the onInferenceHeartbeat
path to preserve request scoping using ChatInferenceHeartbeatEvent.request_id,
and make bumpInferenceHeartbeatForThread or the surrounding runtime state filter
by the owning request before dispatching the keepalive. Ensure the primary
silence timer attached by handleSendParallel only gets bumped by its own
request’s heartbeat, not sibling branches.

In `@app/src/store/chatRuntimeSlice.ts`:
- Around line 414-422: Add `inferenceHeartbeatByThread` to the state reset
performed by `clearAllChatRuntime()` in `chatRuntimeSlice`, so the slice is
fully cleared and no stale per-thread heartbeat counters survive. Use the
existing `clearAllChatRuntime` reducer and the new `inferenceHeartbeatByThread`
bucket to locate the change, and update the slice test to assert this map is
reset along with the other chat runtime fields.

🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro

Run ID: 5e358638-415b-4062-bb6e-1a8d32560b02

📥 Commits

Reviewing files that changed from the base of the PR and between d867c1f and 2ccaf10.

📒 Files selected for processing (9)

• Cargo.toml
• app/src/pages/Conversations.tsx
• app/src/pages/__tests__/Conversations.render.test.tsx
• app/src/providers/ChatRuntimeProvider.tsx
• app/src/services/__tests__/chatService.test.ts
• app/src/services/chatService.ts
• app/src/store/__tests__/chatRuntimeSlice.test.ts
• app/src/store/chatRuntimeSlice.ts
• src/openhuman/channels/providers/web/progress_bridge.rs

[M3gA-Mind]

Reviewed and verified: correct, well-tested, CI green. Approving. Thanks for the contribution!