The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
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.tsindex 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.tsindex 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.tsindex 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 }: Gatreturn 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 }: Gatreturn 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 } = ctxdiff --git a/apps/desktop/src/components/assistant-ui/tool/fallback.tsx b/apps/desktop/src/components/assistant-ui/tool/fallback.tsxindex 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.tsindex 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.pyindex 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()returnif 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_emojilabel = 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 completionself._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.pyindex 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.0self._pending_tool_info.clear()+ self.__dict__.pop("_running_tool_labels", None)self._pet_react_turn_end()self._turn_summary_emit()self._interactive_turn = Falsediff --git a/tests/tools/test_mcp_tool_progress.py b/tests/tools/test_mcp_tool_progress.pyindex 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, tmassert 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) < 20assert 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]