Skip to content

The agent that grows with you

fix(mcp-progress): progress is owned per chat, CLI shows it only for its own call, stores are released

Tekniumbcb054ccc1bb
diff --git a/apps/desktop/src/app/session/hooks/use-message-stream/gateway-event/index.ts b/apps/desktop/src/app/session/hooks/use-message-stream/gateway-event/index.ts
index 6cd610631d2..1673a615aba 100644
--- a/apps/desktop/src/app/session/hooks/use-message-stream/gateway-event/index.ts
+++ b/apps/desktop/src/app/session/hooks/use-message-stream/gateway-event/index.ts
@@ -27,7 +27,7 @@ import { handleOnboardingEvent } from './onboarding'
import { handleControlEvent } from './session-control'
import { handleSessionInfoEvent } from './session-info'
import { handleStatusEvent } from './status'
-import { handleToolEvent, handleToolProgressEvent } from './tools'
+import { handleToolEvent, handleToolProgressEvent, retireTurnToolProgress } from './tools'
import type { GatewayEventContext, GatewayEventDeps, GatewayEventHandler } from './types'
export type { GatewayEventDeps } from './types'
@@ -299,6 +299,7 @@ export function useGatewayEventHandler(deps: GatewayEventDeps) {
// last one force-settles a dead turn, partial payload included.
if (sessionId) {
noteSessionEvent(sessionId)
+ retireTurnToolProgress(event.type, sessionId)
}
}
},
diff --git a/apps/desktop/src/app/session/hooks/use-message-stream/gateway-event/tools-progress.test.ts b/apps/desktop/src/app/session/hooks/use-message-stream/gateway-event/tools-progress.test.ts
index 98a6e5b5697..92d79d396f2 100644
--- a/apps/desktop/src/app/session/hooks/use-message-stream/gateway-event/tools-progress.test.ts
+++ b/apps/desktop/src/app/session/hooks/use-message-stream/gateway-event/tools-progress.test.ts
@@ -1,16 +1,16 @@
import type { GatewayEvent } from '@hermes/shared'
import { afterEach, expect, it, vi } from 'vitest'
-import { $toolProgress, $toolProgressFor, formatToolProgress } from '@/store/tool-progress'
+import { $toolProgress, $toolProgressFor, clearSessionToolProgress, formatToolProgress } from '@/store/tool-progress'
import { handleToolProgressEvent } from './tools'
import type { GatewayEventContext } from './types'
-function deliver(event: GatewayEvent) {
+function deliver(event: GatewayEvent, sessionId = 's1') {
return handleToolProgressEvent({
event,
payload: event.payload,
- sessionId: 's1',
+ sessionId,
occurredAt: 1,
isActiveEvent: true,
deps: {
@@ -23,19 +23,35 @@ function deliver(event: GatewayEvent) {
} as unknown as GatewayEventContext)
}
+const progress = (sessionId: string, percent: number, message: string) =>
+ ({
+ type: 'tool.progress',
+ session_id: sessionId,
+ payload: { tool_id: 'call_0', name: 'mcp__meshy__refine', progress: percent, total: 100, percent, message }
+ }) as unknown as GatewayEvent
+
afterEach(() => $toolProgress.set({}))
it('shows tool.progress on its running row and drops it when the call completes', () => {
- const progress = {
- type: 'tool.progress',
- session_id: 's1',
- payload: { tool_id: 'c1', name: 'mcp__meshy__refine', progress: 42, total: 100, percent: 42, message: 'refining' }
- } as unknown as GatewayEvent
-
- expect(deliver(progress)).toBe(true)
+ expect(deliver(progress('s1', 42, 'refining'))).toBe(true)
// MCP rows render each batched call as `<call id>:<index>`.
- expect(formatToolProgress($toolProgressFor('c1:0').get())).toBe('42% · refining')
+ expect(formatToolProgress($toolProgressFor('s1', 'call_0:0').get())).toBe('42% · refining')
+
+ deliver({ type: 'tool.complete', session_id: 's1', payload: { tool_id: 'call_0', name: 'mcp__meshy__refine' } } as GatewayEvent)
+ expect($toolProgressFor('s1', 'call_0:0').get()).toBeUndefined()
+})
+
+it('keeps two chats reusing one call id apart, and a turn end sweeps only its own chat', () => {
+ deliver(progress('s1', 42, 'refining'), 's1')
+ deliver(progress('s2', 7, 'previewing'), 's2')
+
+ expect(formatToolProgress($toolProgressFor('s1', 'call_0').get())).toBe('42% · refining')
+ expect(formatToolProgress($toolProgressFor('s2', 'call_0').get())).toBe('7% · previewing')
+
+ deliver({ type: 'tool.complete', session_id: 's2', payload: { tool_id: 'call_0' } } as GatewayEvent, 's2')
+ expect($toolProgressFor('s2', 'call_0').get()).toBeUndefined()
+ expect(formatToolProgress($toolProgressFor('s1', 'call_0').get())).toBe('42% · refining')
- deliver({ type: 'tool.complete', session_id: 's1', payload: { tool_id: 'c1', name: 'mcp__meshy__refine' } } as GatewayEvent)
- expect($toolProgressFor('c1:0').get()).toBeUndefined()
+ clearSessionToolProgress('s1')
+ expect($toolProgressFor('s1', 'call_0').get()).toBeUndefined()
})
diff --git a/apps/desktop/src/app/session/hooks/use-message-stream/gateway-event/tools.ts b/apps/desktop/src/app/session/hooks/use-message-stream/gateway-event/tools.ts
index a04ad8bfd24..346267af733 100644
--- a/apps/desktop/src/app/session/hooks/use-message-stream/gateway-event/tools.ts
+++ b/apps/desktop/src/app/session/hooks/use-message-stream/gateway-event/tools.ts
@@ -15,7 +15,7 @@ import { reportMcpToolResult } from '@/store/suggestion-providers/repair'
import { invalidateSkillSuggestionIndex } from '@/store/suggestion-providers/skill'
import { restoreSessionTodosFromSnapshot } from '@/store/todos'
import { setSessionDraftingTool } from '@/store/tool-drafting'
-import { clearToolProgress, setToolProgress } from '@/store/tool-progress'
+import { clearSessionToolProgress, clearToolProgress, setToolProgress } from '@/store/tool-progress'
import { notifyWorkspaceChanged, toolChangedPath, toolMayMutateFiles } from '@/store/workspace-events'
import { SUBAGENT_EVENT_TYPES, toTodoPayload } from '../utils'
@@ -71,12 +71,17 @@ function appliedLayout(name: string | undefined, result: ToolCallMessagePart['re
}
/** tool.progress (live MCP progress for a running call): a row annotation, never a transcript
- * mutation. Also retires it on tool.complete, which then falls through to handleToolEvent. */
+ * mutation. Retired on tool.complete (which then falls through to handleToolEvent); the dispatcher
+ * also sweeps a session's leftovers when its turn ends (index.ts). */
export function handleToolProgressEvent({ deps, event, payload, sessionId }: GatewayEventContext): boolean {
const toolId = typeof payload?.tool_id === 'string' ? payload.tool_id : ''
+ if (!sessionId) {
+ return event.type === 'tool.progress'
+ }
+
if (event.type === 'tool.complete') {
- clearToolProgress(toolId)
+ clearToolProgress(sessionId, toolId)
return false
}
@@ -85,8 +90,8 @@ export function handleToolProgressEvent({ deps, event, payload, sessionId }: Gat
return false
}
- if (sessionId && !deps.sessionInterrupted(sessionId)) {
- setToolProgress(toolId, {
+ if (!deps.sessionInterrupted(sessionId)) {
+ setToolProgress(sessionId, toolId, {
message: typeof payload?.message === 'string' && payload.message ? payload.message : null,
percent: typeof payload?.percent === 'number' ? payload.percent : null
})
@@ -95,6 +100,14 @@ export function handleToolProgressEvent({ deps, event, payload, sessionId }: Gat
return true
}
+/** A finished turn retires its live tool progress even if a tool.complete went missing. Runs for every
+ * event (the dispatcher's finally), because message.complete is consumed by an earlier handler. */
+export function retireTurnToolProgress(eventType: string, sessionId: string): void {
+ if (eventType === 'message.complete' || eventType === 'error') {
+ clearSessionToolProgress(sessionId)
+ }
+}
+
/** tool.generating / tool.start / tool.complete / subagent.*. */
export function handleToolEvent(ctx: GatewayEventContext): boolean {
const { deps, event, payload, sessionId, isActiveEvent, occurredAt } = ctx
diff --git a/apps/desktop/src/components/assistant-ui/tool/fallback.tsx b/apps/desktop/src/components/assistant-ui/tool/fallback.tsx
index 6b05f7d8006..8eb909d6281 100644
--- a/apps/desktop/src/components/assistant-ui/tool/fallback.tsx
+++ b/apps/desktop/src/components/assistant-ui/tool/fallback.tsx
@@ -347,7 +347,9 @@ function useDisclosureOpen(disclosureId: string, fallbackOpen = false): boolean
/** A running row's trailing meta: live MCP progress (`42% · message`, when the server sends it) + the timer. */
function ToolRunningMeta({ seconds, toolCallId = '' }: { seconds: number; toolCallId?: string }) {
- const progressText = formatToolProgress(useStore($toolProgressFor(toolCallId)))
+ const sessionId = useStore(useSessionView().$runtimeId) ?? ''
+ const progress = useMemo(() => $toolProgressFor(sessionId, toolCallId), [sessionId, toolCallId])
+ const progressText = formatToolProgress(useStore(progress))
return (
<>
diff --git a/apps/desktop/src/store/tool-progress.ts b/apps/desktop/src/store/tool-progress.ts
index d90a6d61e4a..17e226d0727 100644
--- a/apps/desktop/src/store/tool-progress.ts
+++ b/apps/desktop/src/store/tool-progress.ts
@@ -1,4 +1,4 @@
-import { atom, computed, type ReadableAtom } from 'nanostores'
+import { atom, computed, onStop, type ReadableAtom } from 'nanostores'
/** Latest live progress of a running tool call (`tool.progress`, from MCP `notifications/progress`). */
export interface ToolProgress {
@@ -6,40 +6,63 @@ export interface ToolProgress {
percent: null | number
}
-// Keyed by tool call id. Ephemeral by design: progress only exists while a call
-// runs, so it is never persisted and the row drops it once the call completes.
+// Keyed by `<session>\u0000<tool call id>`: providers reuse call ids (`call_0`) across chats, so the
+// call id alone is not an owner. Ephemeral by design: progress only exists while a call runs, so it is
+// never persisted, the row drops it on tool.complete and the session's turn end sweeps any leftover.
export const $toolProgress = atom<Record<string, ToolProgress>>({})
+const progressKey = (sessionId: string, toolCallId: string) => `${sessionId}\u0000${toolCallId}`
+
const progressCache = new Map<string, ReadableAtom<ToolProgress | undefined>>()
-export function $toolProgressFor(toolCallId: string): ReadableAtom<ToolProgress | undefined> {
- let cached = progressCache.get(toolCallId)
+export function $toolProgressFor(sessionId: string, toolCallId: string): ReadableAtom<ToolProgress | undefined> {
+ const key = progressKey(sessionId, toolCallId)
+ let cached = progressCache.get(key)
if (!cached) {
// MCP rows render per batched call as `<call id>:<index>`; progress is reported for the call.
- const callId = toolCallId.replace(/:\d+$/, '')
- cached = computed($toolProgress, rows => rows[toolCallId] ?? rows[callId])
- progressCache.set(toolCallId, cached)
+ const callKey = progressKey(sessionId, toolCallId.replace(/:\d+$/, ''))
+ const store = computed($toolProgress, rows => rows[key] ?? rows[callKey])
+ // Evict once no row listens, so finished or never-progressing rows do not pin a store forever.
+ onStop(store, () => {
+ if (progressCache.get(key) === store) {
+ progressCache.delete(key)
+ }
+ })
+ progressCache.set(key, store)
+ cached = store
}
return cached
}
-export function setToolProgress(toolCallId: string, progress: ToolProgress): void {
- if (toolCallId) {
- $toolProgress.set({ ...$toolProgress.get(), [toolCallId]: progress })
+export function setToolProgress(sessionId: string, toolCallId: string, progress: ToolProgress): void {
+ if (sessionId && toolCallId) {
+ $toolProgress.set({ ...$toolProgress.get(), [progressKey(sessionId, toolCallId)]: progress })
}
}
-export function clearToolProgress(toolCallId: string): void {
+export function clearToolProgress(sessionId: string, toolCallId: string): void {
const rows = $toolProgress.get()
+ const key = progressKey(sessionId, toolCallId)
- if (toolCallId && rows[toolCallId]) {
- const { [toolCallId]: _done, ...rest } = rows
+ if (key in rows) {
+ const { [key]: _done, ...rest } = rows
$toolProgress.set(rest)
}
}
+/** Drop every progress entry a session still holds (its turn ended; a missed tool.complete never lingers). */
+export function clearSessionToolProgress(sessionId: string): void {
+ const prefix = `${sessionId}\u0000`
+ const rows = $toolProgress.get()
+ const kept = Object.fromEntries(Object.entries(rows).filter(([key]) => !key.startsWith(prefix)))
+
+ if (Object.keys(kept).length !== Object.keys(rows).length) {
+ $toolProgress.set(kept)
+ }
+}
+
/** `42% · refining mesh` — the text a running tool row shows beside its timer. */
export function formatToolProgress(progress: ToolProgress | undefined): string {
if (!progress) {
diff --git a/hermes_cli/cli_stream_mixin.py b/hermes_cli/cli_stream_mixin.py
index a00e1890c50..12c7e37caee 100644
--- a/hermes_cli/cli_stream_mixin.py
+++ b/hermes_cli/cli_stream_mixin.py
@@ -763,7 +763,7 @@ class CLIStreamMixin:
if event_type == "tool.completed":
self._tool_start_time = 0.0
- self.__dict__.pop("_tool_spinner_base", None)
+ self._forget_tool_label(function_name)
self._turn_summary_record(
function_name, kwargs.get("result"), kwargs.get("is_error", False))
# Focus view: count the hidden scrollback line for the post-turn recovery report.
@@ -811,25 +811,36 @@ class CLIStreamMixin:
self._invalidate()
return
if event_type != "tool.started":
- return self._show_tool_progress(event_type, preview, kwargs.get("percent"))
+ return self._show_tool_progress(event_type, function_name, preview, kwargs.get("percent"))
if function_name and not function_name.startswith("_"):
from agent.display import get_tool_preview_max_len, tool_row_emoji
label = preview or function_name
_pl = get_tool_preview_max_len()
if _pl > 0 and len(label) > _pl:
label = label[:_pl - 3] + "..."
- self._spinner_text = self._tool_spinner_base = f"{tool_row_emoji(function_name, function_args)} {label}"
+ self._spinner_text = f"{tool_row_emoji(function_name, function_args)} {label}"
+ self.__dict__.setdefault("_running_tool_labels", {}).setdefault(function_name, []).append(self._spinner_text)
self._tool_start_time = time.monotonic()
# Store args for stacked scrollback line on completion
self._pending_tool_info.setdefault(function_name, []).append(
function_args if function_args is not None else {})
self._invalidate()
- def _show_tool_progress(self, event_type, message, percent) -> None:
- """Live MCP progress rides the running tool's spinner line: ``<tool label> · 42% · message``."""
- base = self.__dict__.get("_tool_spinner_base")
- if event_type == "tool.progress" and base:
- parts = [base] + ([f"{percent}%"] if percent is not None else []) + ([message] if message else [])
+ def _forget_tool_label(self, function_name) -> None:
+ labels = self.__dict__.get("_running_tool_labels", {})
+ if labels.get(function_name):
+ labels[function_name].pop(0)
+ if not labels[function_name]:
+ del labels[function_name]
+
+ def _show_tool_progress(self, event_type, function_name, message, percent) -> None:
+ """Live MCP progress rides the spinner line: ``<tool label> · 42% · message``. The CLI has one
+ spinner, so progress shows only while exactly one call of that tool runs and nothing else does:
+ with parallel calls the label could belong to another call (tool.started carries no call id)."""
+ labels = self.__dict__.get("_running_tool_labels", {})
+ running = labels.get(function_name) or []
+ if event_type == "tool.progress" and len(running) == 1 and sum(map(len, labels.values())) == 1:
+ parts = [running[0]] + ([f"{percent}%"] if percent is not None else []) + ([message] if message else [])
self._spinner_text = " · ".join(parts)
self._invalidate()
diff --git a/hermes_cli/cli_tui_runtime_mixin.py b/hermes_cli/cli_tui_runtime_mixin.py
index 5dc81cd048a..0db42bcd0cc 100644
--- a/hermes_cli/cli_tui_runtime_mixin.py
+++ b/hermes_cli/cli_tui_runtime_mixin.py
@@ -186,6 +186,7 @@ class CLITuiRuntimeMixin:
self._spinner_text = self._last_scrollback_tool = ""
self._tool_start_time = 0.0
self._pending_tool_info.clear()
+ self.__dict__.pop("_running_tool_labels", None)
self._pet_react_turn_end()
self._turn_summary_emit()
self._interactive_turn = False
diff --git a/tests/tools/test_mcp_tool_progress.py b/tests/tools/test_mcp_tool_progress.py
index 5e051534cfc..7c519ce6ad9 100644
--- a/tests/tools/test_mcp_tool_progress.py
+++ b/tests/tools/test_mcp_tool_progress.py
@@ -54,6 +54,23 @@ def test_mcp_progress_notifications_reach_tool_progress_callback(monkeypatch, tm
assert events and all(a[0] == "tool.progress" and a[1] == "mcp__prog__slow" for a, _ in events)
assert {kw["tool_call_id"] for _, kw in events} == {"call-7"}
- # 20 notifications over ~2 s, throttled to <= one per 500 ms, the final 100% always delivered.
- assert 2 <= len(events) <= 8
+ # The throttle drops intermediates (20 sent), never the final 100%; exact pacing is pinned below
+ # on a controlled clock, since sleep() only bounds the delay from below on a loaded runner.
+ assert len(events) < 20
assert events[-1][1]["percent"] == 100 and events[-1][0][2] == "stage 20"
+
+
+def test_progress_throttle_is_per_call_and_always_passes_first_and_final(monkeypatch):
+ from agent import tool_progress_relay as relay
+
+ clock = [0.0]
+ monkeypatch.setattr(relay.time, "monotonic", lambda: 100.0 + clock[0] / 8)
+ events = []
+ with relay.bound_tool_progress(lambda *a, **kw: events.append(kw["progress"]), "t", "call-1"):
+ report = relay.current_tool_progress()
+ for step in range(1, 11): # one update every 1/8 s (exact in binary floats), total 100
+ report(step * 10.0, 100.0, None)
+ clock[0] += 1
+
+ # First (10), then one per 500 ms (50: 4/8 s later), and the final 100 regardless of the interval.
+ assert events == [10.0, 50.0, 90.0, 100.0]