Merge current upstream into hybrid remote Bot routing
Adopt upstream's one-hidden-forever-chat model and remove the per-bot hidden session browser while preserving connection-bound remote Bot opening, the full remote action menu, same-name isolation, and global Sessions navigation.
This commit is contained in:
@@ -1342,6 +1342,47 @@ while the agent is blocked (e.g. approval prompts) MUST bypass BOTH
|
||||
guards and be dispatched inline, not via `_process_message_background()`
|
||||
(which races session lifecycle).
|
||||
|
||||
### Streaming delivery contract (stream-is-the-message adapters) — duplicate-final class
|
||||
Adapters with `draft_stream_is_message = True` (relay Slack native streaming)
|
||||
keep ONE cumulative native stream per turn; the stream IS the final message.
|
||||
Four invariants, each learned from a live duplicate-final incident (NS-658
|
||||
canary ledger, hermes#85796 / gateway-gateway#210). Violating any of them
|
||||
re-creates a duplicate or a frozen stream:
|
||||
|
||||
1. **Draft frames must be prefix-stable.** The connector computes append-only
|
||||
deltas: frame N must be a string prefix of frame N+1. NEVER mutate draft
|
||||
frames per-tick — no fence-closing (`ensure_closed_code_fences`), no cursor
|
||||
suffix, no segment-state resets at tool boundaries, no mrkdwn conversion.
|
||||
Any non-prefix frame triggers a whole-snapshot re-append on the platform
|
||||
("stacked copies"). The finalize path may still transform the real final.
|
||||
2. **The consumer declares the final; the adapter never guesses.**
|
||||
`finish(final_text)` carries the completed `final_response` (verifier
|
||||
footer, completion explainer included) as the authoritative finalize
|
||||
payload. New post-stream response augmentation MUST ride this payload —
|
||||
if it mutates `final_response` after the stream sealed, it re-opens the
|
||||
#11 bug (`delivered_final_matches` mismatch → corrective duplicate send).
|
||||
3. **Interim sends must carry `_interim_send` metadata.** Any consumer-side
|
||||
`adapter.send()` that is NOT the turn-final (commentary, segment-tail
|
||||
flushes) must set `metadata["_interim_send"] = True`, or the relay
|
||||
adapter's seal-interception will seal the live stream with interim text.
|
||||
Seal-interception exists at BOTH egress doors (`send()` AND
|
||||
`send_for_platform()`); a new egress door needs the same two checks.
|
||||
4. **Reconcile by edit, never by plain send.** Any lane that delivers a final
|
||||
beside an already-sealed stream (queued follow-ups, media-accompanied
|
||||
finals, future lanes) must first try `edit_message` on the consumer's
|
||||
`message_id`; plain `send()` is the fallback only when no editable message
|
||||
exists. A sealed native stream is a regular message — `chat.update` on it
|
||||
works (live-verified).
|
||||
|
||||
Contract tests: `tests/gateway/test_stream_final_contract.py` (all four
|
||||
invariants, mutation-checked). Slack streaming API ground truth (live-probed,
|
||||
also encoded in connector comments/tests): `chat.*Stream` speaks STANDARD
|
||||
markdown, not mrkdwn; `stopStream.markdown_text` APPENDS (never replaces);
|
||||
`startStream`/`stopStream` are rate-limit Tier 2 (~20/min).
|
||||
|
||||
Guard style note: check `draft_stream_is_message` with `is True` — MagicMock
|
||||
adapters in older tests auto-create truthy attributes.
|
||||
|
||||
### Squash merges from stale branches silently revert recent fixes
|
||||
Before squash-merging a PR, ensure the branch is up to date with `main`
|
||||
(`git fetch origin main && git reset --hard origin/main` in the worktree,
|
||||
|
||||
+1
-1
@@ -582,7 +582,7 @@ test(tools): añadir tests unitarios para file_operations
|
||||
## Reportar Issues
|
||||
|
||||
- Usa [GitHub Issues](https://github.com/NousResearch/hermes-agent/issues)
|
||||
- Incluye: SO, versión de Python, versión de Hermes (`hermes version`), traza de error completa
|
||||
- Incluye: SO, versión de Python, versión de Hermes (`hermes --version`), traza de error completa
|
||||
- Incluye pasos para reproducir
|
||||
- Verifica los issues existentes antes de crear duplicados
|
||||
- Para vulnerabilidades de seguridad, por favor reporta de forma privada
|
||||
|
||||
+1
-1
@@ -973,7 +973,7 @@ test(tools): add unit tests for file_operations
|
||||
## Reporting Issues
|
||||
|
||||
- Use [GitHub Issues](https://github.com/NousResearch/hermes-agent/issues)
|
||||
- Include: OS, Python version, Hermes version (`hermes version`), full error traceback
|
||||
- Include: OS, Python version, Hermes version (`hermes --version`), full error traceback
|
||||
- Include steps to reproduce
|
||||
- Check existing issues before creating duplicates
|
||||
- For security vulnerabilities, please report privately
|
||||
|
||||
+1
-1
@@ -16,7 +16,7 @@ Un informe útil incluye:
|
||||
- Una descripción concisa y evaluación de severidad.
|
||||
- El componente afectado, identificado por ruta de archivo y rango de líneas
|
||||
(ej. `path/to/file.py:120-145`).
|
||||
- Detalles del entorno (`hermes version`, SHA del commit, SO, versión de Python).
|
||||
- Detalles del entorno (`hermes --version`, SHA del commit, SO, versión de Python).
|
||||
- Una reproducción contra `main` o el último release.
|
||||
- Una declaración de qué límite de confianza del §2 se cruza.
|
||||
|
||||
|
||||
+1
-1
@@ -16,7 +16,7 @@ A useful report includes:
|
||||
- A concise description and severity assessment.
|
||||
- The affected component, identified by file path and line range
|
||||
(e.g. `path/to/file.py:120-145`).
|
||||
- Environment details (`hermes version`, commit SHA, OS, Python
|
||||
- Environment details (`hermes --version`, commit SHA, OS, Python
|
||||
version).
|
||||
- A reproduction against `main` or the latest release.
|
||||
- A statement of which trust boundary in §2 is crossed.
|
||||
|
||||
+53
-1
@@ -490,6 +490,25 @@ def _merge_custom_provider_extra_body(agent, custom_providers: List[Dict[str, An
|
||||
agent.request_overrides = overrides
|
||||
|
||||
|
||||
def _normalize_run_budget_seconds(value) -> Optional[float]:
|
||||
"""Normalize a wall-clock run budget value to a positive float or None.
|
||||
|
||||
None / absent / non-numeric / non-positive all resolve to ``None``
|
||||
(feature off) so a malformed config value can never activate the
|
||||
deadline machinery, only leave it dormant. ``bool`` is rejected because
|
||||
YAML ``true`` would otherwise become a 1-second budget.
|
||||
"""
|
||||
if value is None or isinstance(value, bool):
|
||||
return None
|
||||
try:
|
||||
seconds = float(value)
|
||||
except (TypeError, ValueError):
|
||||
return None
|
||||
if seconds != seconds or seconds <= 0: # NaN or non-positive
|
||||
return None
|
||||
return seconds
|
||||
|
||||
|
||||
def init_agent(
|
||||
agent,
|
||||
base_url: str = None,
|
||||
@@ -501,7 +520,7 @@ def init_agent(
|
||||
command: str = None,
|
||||
args: list[str] | None = None,
|
||||
model: str = "",
|
||||
max_iterations: int = 90, # Default tool-calling iterations (shared with subagents)
|
||||
max_iterations: int = sys.maxsize, # Default: unlimited tool-calling iterations (shared with subagents)
|
||||
enabled_toolsets: List[str] = None,
|
||||
disabled_toolsets: List[str] = None,
|
||||
save_trajectories: bool = False,
|
||||
@@ -527,6 +546,7 @@ def init_agent(
|
||||
clarify_callback: callable = None,
|
||||
read_terminal_callback: callable = None,
|
||||
read_preview_callback: callable = None,
|
||||
drive_preview_callback: callable = None,
|
||||
read_window_below_callback: callable = None,
|
||||
setup_mcp_callback: callable = None,
|
||||
tour_callback: callable = None,
|
||||
@@ -560,6 +580,7 @@ def init_agent(
|
||||
session_db=None,
|
||||
parent_session_id: str = None,
|
||||
iteration_budget: "IterationBudget" = None,
|
||||
run_budget_seconds: Optional[float] = None,
|
||||
fallback_model: Dict[str, Any] = None,
|
||||
credential_pool=None,
|
||||
checkpoints_enabled: bool = False,
|
||||
@@ -823,6 +844,7 @@ def init_agent(
|
||||
agent.clarify_callback = clarify_callback
|
||||
agent.read_terminal_callback = read_terminal_callback
|
||||
agent.read_preview_callback = read_preview_callback
|
||||
agent.drive_preview_callback = drive_preview_callback
|
||||
agent.read_window_below_callback = read_window_below_callback
|
||||
agent.setup_mcp_callback = setup_mcp_callback
|
||||
agent.tour_callback = tour_callback
|
||||
@@ -972,6 +994,17 @@ def init_agent(
|
||||
agent._budget_exhausted_injected = False
|
||||
agent._budget_grace_call = False
|
||||
|
||||
# Optional wall-clock run budget (seconds per run_conversation turn).
|
||||
# Explicit constructor arg wins; else resolved from config.yaml
|
||||
# (agent.run_budget_seconds) further below. None = feature fully off:
|
||||
# no clock reads, no injection, no stale-timeout capping.
|
||||
agent.run_budget_seconds = _normalize_run_budget_seconds(run_budget_seconds)
|
||||
# Wall-clock start of the CURRENT run_conversation turn. Set by
|
||||
# turn_context.prepare_turn when a run budget is active; None otherwise.
|
||||
agent._run_budget_started_at = None
|
||||
# One-shot latch for the 80% wrap-up notice (reset each turn).
|
||||
agent._run_budget_wrapup_injected = False
|
||||
|
||||
# Activity tracking — updated on each API call, tool execution, and
|
||||
# stream chunk. Used by the gateway timeout handler to report what the
|
||||
# agent was doing when it was killed, and by the "still working"
|
||||
@@ -1896,6 +1929,20 @@ def init_agent(
|
||||
_agent_section = {}
|
||||
agent._tool_use_enforcement = _agent_section.get("tool_use_enforcement", "auto")
|
||||
|
||||
# Execution-discipline guidance gate: "auto" (default — matches
|
||||
# EXECUTION_GUIDANCE_MODELS), true (always), false (never), or list of
|
||||
# model-name substrings. Independent of tool_use_enforcement — see
|
||||
# agent/system_prompt.py for the injection gate.
|
||||
agent._execution_guidance = _agent_section.get("execution_guidance", "auto")
|
||||
|
||||
# Wall-clock run budget from config (agent.run_budget_seconds) — only
|
||||
# consulted when the constructor arg was not given. Absent/None/invalid
|
||||
# keeps the feature fully off (zero behavior change in the default path).
|
||||
if agent.run_budget_seconds is None:
|
||||
agent.run_budget_seconds = _normalize_run_budget_seconds(
|
||||
_agent_section.get("run_budget_seconds")
|
||||
)
|
||||
|
||||
# Empty-response retry guard config (NS-503): additive
|
||||
# ``agent.empty_response_guard`` subsection. Resolution is tolerant —
|
||||
# a malformed section falls back to the schema defaults (guard on,
|
||||
@@ -1912,6 +1959,11 @@ def init_agent(
|
||||
# conversation loop's intent-ack block.
|
||||
agent._intent_ack_continuation = _agent_section.get("intent_ack_continuation", "auto")
|
||||
|
||||
# Runtime anti-stall guards (identical-call loop-breaker notice on tool
|
||||
# results + continue-intent extension of the empty-response recovery).
|
||||
# Single boolean gate, default True. Notice-only — never blocks a call.
|
||||
agent._stall_guards = bool(_agent_section.get("stall_guards", True))
|
||||
|
||||
# Universal task-completion guidance toggle. Default True. Surfaced
|
||||
# as a separate flag from tool_use_enforcement because the guidance
|
||||
# applies to ALL models, not just the model families enforcement
|
||||
|
||||
@@ -99,7 +99,7 @@ def _ra():
|
||||
|
||||
|
||||
AGENT_RUNTIME_POST_HOOK_TOOL_NAMES = frozenset(
|
||||
{"todo", "session_search", "memory", "clarify", "read_terminal", "read_preview", "read_window_below", "setup_mcp", "tour", "delegate_task"}
|
||||
{"todo", "session_search", "memory", "clarify", "read_terminal", "read_preview", "drive_preview", "annotate_preview", "read_window_below", "setup_mcp", "tour", "delegate_task"}
|
||||
)
|
||||
|
||||
|
||||
@@ -3234,6 +3234,37 @@ def invoke_tool(agent, function_name: str, function_args: dict, effective_task_i
|
||||
),
|
||||
next_args,
|
||||
)
|
||||
elif function_name == "drive_preview":
|
||||
def _execute(next_args: dict) -> Any:
|
||||
from tools.drive_preview_tool import drive_preview_tool as _drive_preview_tool
|
||||
return _finish_agent_tool(
|
||||
_drive_preview_tool(
|
||||
action=next_args.get("action", ""),
|
||||
ref=next_args.get("ref"),
|
||||
selector=next_args.get("selector"),
|
||||
text=next_args.get("text"),
|
||||
key=next_args.get("key"),
|
||||
submit=next_args.get("submit"),
|
||||
amount=next_args.get("amount"),
|
||||
to=next_args.get("to"),
|
||||
limit=next_args.get("max"),
|
||||
callback=getattr(agent, "drive_preview_callback", None),
|
||||
),
|
||||
next_args,
|
||||
)
|
||||
elif function_name == "annotate_preview":
|
||||
def _execute(next_args: dict) -> Any:
|
||||
from tools.annotate_preview_tool import annotate_preview_tool as _annotate_preview_tool
|
||||
return _finish_agent_tool(
|
||||
_annotate_preview_tool(
|
||||
action=next_args.get("action", "add"),
|
||||
ref=next_args.get("ref"),
|
||||
selector=next_args.get("selector"),
|
||||
label=next_args.get("label"),
|
||||
callback=getattr(agent, "drive_preview_callback", None),
|
||||
),
|
||||
next_args,
|
||||
)
|
||||
elif function_name == "read_window_below":
|
||||
def _execute(next_args: dict) -> Any:
|
||||
from tools.read_window_tool import read_window_below_tool as _read_window_below_tool
|
||||
@@ -3863,6 +3894,37 @@ def looks_like_codex_intermediate_ack(
|
||||
return user_targets_workspace or assistant_targets_workspace
|
||||
|
||||
|
||||
# Conservative "trailing continue-intent" detector for the said-continue-but-
|
||||
# stopped stall guard (agent.stall_guards). Matches only when the message TAIL
|
||||
# announces an immediate next action ("Let me now…", "I will now…",
|
||||
# "Next, I…"), which is the observed stall shape: the model narrates the next
|
||||
# step and then ends the turn with no tool call. Kept deliberately narrow so
|
||||
# ordinary answers that merely contain "I will" mid-sentence never trip it.
|
||||
_TRAILING_CONTINUE_INTENT_RE = re.compile(
|
||||
r"(?:\blet me now\b|\bi(?:['\u2019])?ll now\b|\bi will now\b"
|
||||
r"|\bnow i(?:['\u2019]ll| will)\b|\bnext[,:] i\b)"
|
||||
r"[^.!?\n]{0,100}[.:\u2026]?\s*$",
|
||||
re.IGNORECASE,
|
||||
)
|
||||
|
||||
# Content longer than this is a substantive reply, not a dangling ack.
|
||||
_TRAILING_CONTINUE_INTENT_MAX_CHARS = 400
|
||||
|
||||
|
||||
def trailing_continue_intent(text: str) -> bool:
|
||||
"""Whether ``text`` is a short reply ENDING on an announced next action.
|
||||
|
||||
Used by the stall-guard extension of the intent-ack continuation path in
|
||||
``agent.conversation_loop``: when a turn is about to end with this shape
|
||||
(no tool calls, short content, trailing intent), the loop re-prompts via
|
||||
the existing bounded continuation mechanism instead of stopping.
|
||||
"""
|
||||
t = (text or "").strip()
|
||||
if not t or len(t) > _TRAILING_CONTINUE_INTENT_MAX_CHARS:
|
||||
return False
|
||||
return bool(_TRAILING_CONTINUE_INTENT_RE.search(t[-160:]))
|
||||
|
||||
|
||||
def intent_ack_continuation_mode(agent) -> str:
|
||||
"""Classify the resolved intent-ack continuation mode for this turn.
|
||||
|
||||
|
||||
@@ -1551,10 +1551,16 @@ class _CodexCompletionsAdapter:
|
||||
# Codex backend, which rejects e.g. {"effort": null}
|
||||
# with a 400.
|
||||
effort = reasoning_cfg.get("effort") or "medium"
|
||||
# Codex backend rejects "minimal"; clamp to "low" to
|
||||
# match the main-agent Codex transport behavior.
|
||||
if effort == "minimal":
|
||||
effort = "low"
|
||||
# Same declared vocabulary + shared clamp as the main
|
||||
# Codex transport (agent.reasoning_effort): per-model —
|
||||
# "max" is gpt-5.6-only, "minimal"/"ultra" always
|
||||
# rejected (live-verified, #68365).
|
||||
from agent.reasoning_effort import (
|
||||
clamp_effort,
|
||||
codex_supported_efforts,
|
||||
)
|
||||
|
||||
effort = clamp_effort(effort, codex_supported_efforts(model))
|
||||
resp_kwargs["reasoning"] = {
|
||||
"effort": effort,
|
||||
"summary": "auto",
|
||||
|
||||
+60
-1
@@ -1305,6 +1305,62 @@ def _consume_codex_event_stream(
|
||||
return final
|
||||
|
||||
|
||||
def _sanitize_consumer_codex_request(
|
||||
agent: Any,
|
||||
request: dict[str, Any],
|
||||
) -> dict[str, Any]:
|
||||
"""Drop fields the ChatGPT OAuth Codex endpoint does not accept.
|
||||
|
||||
This guard intentionally lives at the final wire boundary, after Relay or
|
||||
other request middleware has had a chance to transform the request. The
|
||||
normal transport builder already omits ``prompt_cache_retention`` for this
|
||||
endpoint, but a late mutation must not be allowed to turn a valid tool
|
||||
follow-up into a non-retryable HTTP 400.
|
||||
|
||||
Explicit ``request_overrides`` are subject to the same endpoint contract:
|
||||
unsupported retention is dropped with a warning instead of being sent and
|
||||
rejected by the provider. The check covers both the top-level kwarg and a
|
||||
nested ``extra_body`` entry — the OpenAI SDK merges ``extra_body`` into
|
||||
the outgoing JSON body, so either shape reaches the endpoint.
|
||||
"""
|
||||
sanitized = dict(request)
|
||||
# Resolved defensively on purpose: run_codex_stream is also driven with
|
||||
# lightweight stand-in agents that carry only the attributes a given path
|
||||
# needs (see tests/agent/test_codex_request_transport_diagnostics.py), so a
|
||||
# bare agent._is_codex_backend() here would raise AttributeError on them.
|
||||
backend_predicate = getattr(agent, "_is_codex_backend", None)
|
||||
is_consumer_codex = (
|
||||
bool(backend_predicate()) if callable(backend_predicate) else False
|
||||
)
|
||||
if not is_consumer_codex:
|
||||
return sanitized
|
||||
dropped_from: list[str] = []
|
||||
if "prompt_cache_retention" in sanitized:
|
||||
sanitized.pop("prompt_cache_retention")
|
||||
dropped_from.append("top-level")
|
||||
# The OpenAI SDK merges ``extra_body`` into the outgoing JSON body, so a
|
||||
# nested ``extra_body.prompt_cache_retention`` reaches the endpoint just
|
||||
# like the top-level field would. Copy before editing — the caller's
|
||||
# mapping must not be mutated — and drop the mapping when it empties.
|
||||
extra_body = sanitized.get("extra_body")
|
||||
if isinstance(extra_body, dict) and "prompt_cache_retention" in extra_body:
|
||||
extra_body = dict(extra_body)
|
||||
extra_body.pop("prompt_cache_retention")
|
||||
if extra_body:
|
||||
sanitized["extra_body"] = extra_body
|
||||
else:
|
||||
sanitized.pop("extra_body")
|
||||
dropped_from.append("extra_body")
|
||||
if dropped_from:
|
||||
logger.warning(
|
||||
"Dropped unsupported prompt_cache_retention at consumer Codex "
|
||||
"wire boundary (model=%s, via %s).",
|
||||
sanitized.get("model", getattr(agent, "model", "unknown")),
|
||||
", ".join(dropped_from),
|
||||
)
|
||||
return sanitized
|
||||
|
||||
|
||||
def run_codex_stream(agent, api_kwargs: dict, client: Any = None, on_first_delta=None):
|
||||
"""Execute one streaming Responses API request and return the final response.
|
||||
|
||||
@@ -1347,7 +1403,10 @@ def run_codex_stream(agent, api_kwargs: dict, client: Any = None, on_first_delta
|
||||
writer_token = {"value": None}
|
||||
|
||||
def _open_codex_stream(next_api_kwargs: dict[str, Any]):
|
||||
stream_kwargs = dict(next_api_kwargs)
|
||||
stream_kwargs = _sanitize_consumer_codex_request(
|
||||
agent,
|
||||
next_api_kwargs,
|
||||
)
|
||||
stream_kwargs["stream"] = True
|
||||
return active_client.responses.create(**stream_kwargs)
|
||||
|
||||
|
||||
@@ -350,6 +350,147 @@ _SUMMARY_END_MARKER = (
|
||||
_MERGED_PRIOR_CONTEXT_HEADER = "[PRIOR CONTEXT — for reference only; not a new message]"
|
||||
_MERGED_SUMMARY_DELIMITER = "[END OF PRIOR CONTEXT — COMPACTION SUMMARY BELOW]"
|
||||
|
||||
_SALVAGE_SUMMARY_MAX_CHARS = 8_000
|
||||
_SALVAGE_KEEP_RECENT_TOOLS = 2
|
||||
|
||||
|
||||
def _looks_like_compaction_summary(msg: Dict[str, Any], content: str) -> bool:
|
||||
# Only cap a standalone handoff. Merged carriers preserve a real tail ask
|
||||
# in the same content string; truncating those could delete live user text.
|
||||
if not content.rstrip().endswith(_SUMMARY_END_MARKER):
|
||||
return False
|
||||
if content.startswith(_MERGED_PRIOR_CONTEXT_HEADER):
|
||||
return False
|
||||
# Content heuristics alone must never authorize mutating a live turn.
|
||||
# Compressor-generated summaries carry this private marker; ordinary
|
||||
# user input — and live assistant replies or kept tool bodies that
|
||||
# merely quote a summary header/marker — do not. Tool messages are
|
||||
# handled exclusively by the stub/keep-recent pass, never the cap.
|
||||
if msg.get("role") == "tool":
|
||||
return False
|
||||
if (
|
||||
msg.get("role") in ("user", "assistant")
|
||||
and not msg.get(COMPRESSED_SUMMARY_METADATA_KEY)
|
||||
):
|
||||
return False
|
||||
head = content[:280]
|
||||
return (
|
||||
bool(msg.get(COMPRESSED_SUMMARY_METADATA_KEY))
|
||||
or "CONTEXT COMPACTION" in head
|
||||
or "[CONTEXT COMPACTION]" in head
|
||||
or "Conversation Summary" in head
|
||||
)
|
||||
|
||||
|
||||
def _salvage_reduce_todo_snapshot(out: List[Dict[str, Any]]) -> None:
|
||||
"""Last-resort shrink: reduce or drop the synthetic todo snapshot.
|
||||
|
||||
The snapshot is the only in-transcript todo re-injection at a compaction
|
||||
boundary, and since 7a16840add the pruned-skill reload notice is coupled
|
||||
into the same string — so it is only touched when the cheaper shrink ops
|
||||
could not get under budget. When the snapshot carries a reload notice,
|
||||
keep just the notice (the coupling must survive salvage); otherwise drop
|
||||
the row entirely.
|
||||
"""
|
||||
from agent.conversation_compression import _PRUNED_SKILL_RELOAD_NOTICE_HEADER
|
||||
|
||||
for i in range(len(out) - 1, -1, -1):
|
||||
msg = out[i]
|
||||
if not isinstance(msg, dict):
|
||||
continue
|
||||
if msg.get("_todo_snapshot_synthetic") and msg.get("role") == "user":
|
||||
content = msg.get("content")
|
||||
notice_idx = (
|
||||
content.find(_PRUNED_SKILL_RELOAD_NOTICE_HEADER)
|
||||
if isinstance(content, str)
|
||||
else -1
|
||||
)
|
||||
if isinstance(content, str) and notice_idx >= 0:
|
||||
msg["content"] = content[notice_idx:]
|
||||
else:
|
||||
del out[i]
|
||||
return
|
||||
|
||||
|
||||
def salvage_grown_transcript(
|
||||
original: List[Dict[str, Any]],
|
||||
candidate: List[Dict[str, Any]],
|
||||
budget: Optional[int] = None,
|
||||
) -> Optional[List[Dict[str, Any]]]:
|
||||
"""Mechanically shrink a compression candidate, or return ``None``.
|
||||
|
||||
Already-compacted middles can be summarized slightly larger while retained
|
||||
tool bodies, stale reasoning, or a synthetic todo snapshot tip the final
|
||||
candidate over the input size. Work on copies and admit the salvage only
|
||||
when the same rough estimator proves it is strictly smaller than the input.
|
||||
|
||||
Shrink order is cheapest-information-loss first: stale reasoning keys and
|
||||
codex replay sidecars, then old tool bodies, then an oversized summary cap.
|
||||
The synthetic todo snapshot (which carries the pruned-skill reload notice,
|
||||
see ``_salvage_reduce_todo_snapshot``) is only reduced as a LAST resort
|
||||
when everything else still leaves the candidate at or over budget.
|
||||
"""
|
||||
if not candidate or not original:
|
||||
return None
|
||||
if budget is None:
|
||||
budget = estimate_messages_tokens_rough(original)
|
||||
if budget <= 0:
|
||||
return None
|
||||
|
||||
out: List[Dict[str, Any]] = []
|
||||
tool_indices: List[int] = []
|
||||
last_assistant_idx = -1
|
||||
for msg in candidate:
|
||||
if not isinstance(msg, dict):
|
||||
out.append(msg)
|
||||
continue
|
||||
copied = dict(msg)
|
||||
out.append(copied)
|
||||
role = copied.get("role")
|
||||
if role == "tool":
|
||||
tool_indices.append(len(out) - 1)
|
||||
elif role == "assistant":
|
||||
last_assistant_idx = len(out) - 1
|
||||
|
||||
salvage_reasoning_keys = _NEWEST_TURN_ONLY_BUDGET_KEYS + ("reasoning_details",)
|
||||
keep_tools = set(tool_indices[-_SALVAGE_KEEP_RECENT_TOOLS:])
|
||||
for index, msg in enumerate(out):
|
||||
if not isinstance(msg, dict):
|
||||
continue
|
||||
if msg.get("role") == "assistant" and index != last_assistant_idx:
|
||||
for key in salvage_reasoning_keys:
|
||||
msg.pop(key, None)
|
||||
if msg.get("role") == "tool" and index not in keep_tools:
|
||||
content = msg.get("content")
|
||||
if isinstance(content, str) and len(content) > _PRUNE_MIN_CHARS:
|
||||
msg["content"] = _PRUNED_TOOL_PLACEHOLDER
|
||||
content = msg.get("content")
|
||||
if (
|
||||
isinstance(content, str)
|
||||
and len(content) > _SALVAGE_SUMMARY_MAX_CHARS
|
||||
and _looks_like_compaction_summary(msg, content)
|
||||
):
|
||||
msg["content"] = (
|
||||
content[:_SALVAGE_SUMMARY_MAX_CHARS].rstrip()
|
||||
+ "\n…[summary truncated so compaction can shrink]\n\n"
|
||||
+ _SUMMARY_END_MARKER
|
||||
)
|
||||
# Heavier codex replay sidecars (encrypted reasoning blobs) — reuse the
|
||||
# proven prune with its last-user-turn safety boundary (#71058).
|
||||
_prune_stale_reasoning_replay(out)
|
||||
|
||||
if estimate_messages_tokens_rough(out) >= budget:
|
||||
_salvage_reduce_todo_snapshot(out)
|
||||
|
||||
if not any(
|
||||
isinstance(message, dict) and message.get("role") == "user"
|
||||
for message in out
|
||||
):
|
||||
return None
|
||||
if estimate_messages_tokens_rough(out) < budget:
|
||||
return out
|
||||
return None
|
||||
|
||||
# Handoff prefixes that shipped in earlier releases. A summary persisted under
|
||||
# one of these can be inherited into a resumed lineage (#35344); when it is
|
||||
# re-normalized on re-compaction we must strip the OLD prefix too, otherwise the
|
||||
@@ -1885,6 +2026,7 @@ class ContextCompressor(ContextEngine):
|
||||
self._cooldown_persist_failed = False
|
||||
self._last_summary_error = None
|
||||
self._last_compress_aborted = False
|
||||
self._last_compress_refused_would_grow = False
|
||||
self.last_real_prompt_tokens = 0
|
||||
self.last_compression_rough_tokens = 0
|
||||
self.last_rough_tokens_when_real_prompt_fit = 0
|
||||
@@ -2167,6 +2309,7 @@ class ContextCompressor(ContextEngine):
|
||||
self._summary_failure_cooldown_until = 0.0
|
||||
self._cooldown_persist_failed = False
|
||||
self._last_compress_aborted = False
|
||||
self._last_compress_refused_would_grow = False
|
||||
self._context_probed = False
|
||||
self._context_probe_persistable = False
|
||||
self.last_real_prompt_tokens = 0
|
||||
@@ -2371,6 +2514,31 @@ class ContextCompressor(ContextEngine):
|
||||
self._ineffective_compression_count = count
|
||||
self._persist_ineffective_compression_count()
|
||||
|
||||
def record_rejected_compaction(self) -> None:
|
||||
"""Record one compaction whose result was REJECTED before committing.
|
||||
|
||||
The anti-growth guard in the commit layer (conversation_compression)
|
||||
discards a candidate that would grow the transcript and keeps the
|
||||
original. Without recording the attempt, the anti-thrash breaker
|
||||
never sees a strike, so automatic compression retries the SAME
|
||||
unchanged transcript on every turn — same summary request, same
|
||||
refusal, same user-facing warning (#88568). This counts one
|
||||
ineffective strike (persisted, so the normal >= 2 latch and its
|
||||
recovery window apply) WITHOUT arming post-compaction real-usage
|
||||
verification — nothing was committed, so there is no new compaction
|
||||
to verify — and without touching the fallback-summary streak (no
|
||||
summary was accepted).
|
||||
"""
|
||||
self._record_ineffective_compression_verdict(
|
||||
self._ineffective_compression_count + 1
|
||||
)
|
||||
if not self.quiet_mode:
|
||||
logger.warning(
|
||||
"Compaction rejected before commit (would grow the "
|
||||
"transcript); ineffective_compression_count=%d",
|
||||
self._ineffective_compression_count,
|
||||
)
|
||||
|
||||
def record_completed_compaction(
|
||||
self, *, used_fallback: bool = False, feasibility_skip: bool = False,
|
||||
) -> None:
|
||||
@@ -6927,6 +7095,7 @@ This compaction should PRIORITISE preserving all information related to the focu
|
||||
self._last_aux_model_failure_error = None
|
||||
self._last_aux_model_failure_model = None
|
||||
self._last_compress_aborted = False
|
||||
self._last_compress_refused_would_grow = False
|
||||
self._last_compression_made_progress = False
|
||||
# NOTE: do NOT reset _last_summary_auth_failure or
|
||||
# _last_summary_network_failure here. These flags are set by
|
||||
|
||||
@@ -3386,6 +3386,27 @@ def compress_context(
|
||||
# transcript stays untouched and durable.
|
||||
_rough_in = estimate_messages_tokens_rough(messages)
|
||||
_rough_out = estimate_messages_tokens_rough(compressed)
|
||||
if _rough_out > _rough_in:
|
||||
# Todo refresh and user-turn anchoring happen after the
|
||||
# compressor's own size check, so they can tip a break-even
|
||||
# candidate over. Give it one mechanical salvage pass.
|
||||
from agent.context_compressor import salvage_grown_transcript
|
||||
|
||||
_salvaged = salvage_grown_transcript(
|
||||
messages, compressed, budget=_rough_in
|
||||
)
|
||||
if _salvaged is not None:
|
||||
_salv_est = estimate_messages_tokens_rough(_salvaged)
|
||||
if _salv_est < _rough_in:
|
||||
logger.info(
|
||||
"Compression salvage recovered a shrinking "
|
||||
"transcript (session=%s, ~%s -> ~%s tokens)",
|
||||
agent.session_id or "none",
|
||||
f"{_rough_in:,}",
|
||||
f"{_salv_est:,}",
|
||||
)
|
||||
compressed = _salvaged
|
||||
_rough_out = _salv_est
|
||||
if _rough_out > _rough_in:
|
||||
logger.warning(
|
||||
"Compression refused: compressed transcript would be "
|
||||
@@ -3395,6 +3416,17 @@ def compress_context(
|
||||
f"{_rough_in:,}",
|
||||
f"{_rough_out:,}",
|
||||
)
|
||||
# Flag the refusal on the compressor state so manual
|
||||
# /compress feedback can report it honestly. Without this,
|
||||
# the CLI compared the returned list against its pre-call
|
||||
# snapshot, saw a difference (durable-snapshot adoption can
|
||||
# legitimately change the count), and printed
|
||||
# "✅ Compressed: 8 → 14 messages" directly under the
|
||||
# refusal warning (Aug 2026 full-surface CLI QA sweep).
|
||||
try:
|
||||
agent.context_compressor._last_compress_refused_would_grow = True
|
||||
except Exception:
|
||||
pass
|
||||
try:
|
||||
agent._emit_warning(
|
||||
"⚠️ Compression refused: the generated summary "
|
||||
@@ -3414,6 +3446,20 @@ def compress_context(
|
||||
split_status="aborted",
|
||||
failure_class="would_grow",
|
||||
)
|
||||
# Record the rejected attempt as an ineffective
|
||||
# compaction strike so the anti-thrash breaker latches
|
||||
# after the normal threshold. Without this, the unchanged
|
||||
# transcript stays over the compression threshold and
|
||||
# automatic compression retries the identical summary
|
||||
# request on every turn (#88568). Manual /compress keeps
|
||||
# bypassing the latch (force=True skips the guards).
|
||||
try:
|
||||
agent.context_compressor.record_rejected_compaction()
|
||||
except Exception:
|
||||
logger.debug(
|
||||
"could not record rejected-compaction strike",
|
||||
exc_info=True,
|
||||
)
|
||||
_release_lock()
|
||||
return messages, _existing_sp
|
||||
|
||||
|
||||
+141
-3
@@ -107,6 +107,64 @@ logger = logging.getLogger(__name__)
|
||||
_INTERRUPT_SCAFFOLD_MARKER = "[This response was interrupted by a user correction.]"
|
||||
|
||||
|
||||
# One-time wrap-up notice appended when a wall-clock run budget crosses its
|
||||
# 80% threshold (agent.run_budget_seconds / --run-budget). Mirrors the Codex
|
||||
# CLI budget wrap-up template: stop new work, deliver from current state.
|
||||
RUN_BUDGET_WRAPUP_NOTICE = (
|
||||
"[SYSTEM NOTICE — run time budget nearly exhausted] "
|
||||
"Run time budget nearly exhausted. Stop new discovery/verification work "
|
||||
"now. Produce the required final deliverable (answer/JSON/summary) from "
|
||||
"the state you already have, completing only mandatory writes."
|
||||
)
|
||||
|
||||
|
||||
def _maybe_inject_run_budget_wrapup(agent: Any, messages: List[Dict[str, Any]]) -> bool:
|
||||
"""Inject the one-time wall-clock wrap-up notice when past 80% of budget.
|
||||
|
||||
Cache-safe delivery: the notice is appended to the NEWEST ``role:"tool"``
|
||||
message (the same channel /steer uses) — no synthetic user message is
|
||||
inserted mid-loop and no past context is rewritten, so role alternation
|
||||
and the prompt-cache prefix survive. Latches ``_run_budget_wrapup_injected``
|
||||
only on a successful append, so a first iteration without tool results
|
||||
retries on the next iteration. Returns True when the notice was injected.
|
||||
|
||||
Dormant unless ``agent.run_budget_seconds`` is set AND the turn stamped
|
||||
``_run_budget_started_at`` (see ``turn_context.prepare_conversation_turn``).
|
||||
"""
|
||||
budget = getattr(agent, "run_budget_seconds", None)
|
||||
if not budget:
|
||||
return False
|
||||
if getattr(agent, "_run_budget_wrapup_injected", False):
|
||||
return False
|
||||
started = getattr(agent, "_run_budget_started_at", None)
|
||||
if not started:
|
||||
return False
|
||||
if (time.time() - started) < 0.8 * float(budget):
|
||||
return False
|
||||
for i in range(len(messages) - 1, -1, -1):
|
||||
msg = messages[i]
|
||||
if isinstance(msg, dict) and msg.get("role") == "tool":
|
||||
existing = msg.get("content", "")
|
||||
if isinstance(existing, str):
|
||||
msg["content"] = existing + f"\n\n{RUN_BUDGET_WRAPUP_NOTICE}"
|
||||
else:
|
||||
# Multimodal content blocks — append a text block.
|
||||
try:
|
||||
blocks = list(existing) if existing else []
|
||||
blocks.append({"type": "text", "text": RUN_BUDGET_WRAPUP_NOTICE})
|
||||
msg["content"] = blocks
|
||||
except Exception:
|
||||
return False
|
||||
agent._run_budget_wrapup_injected = True
|
||||
logger.info(
|
||||
"Run budget wrap-up notice injected (budget=%.0fs, elapsed=%.0fs)",
|
||||
float(budget),
|
||||
time.time() - started,
|
||||
)
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
def _restore_user_after_reference_handoff(
|
||||
messages: List[Dict[str, Any]], user_message: Any
|
||||
) -> bool:
|
||||
@@ -2041,6 +2099,15 @@ def run_conversation(
|
||||
existing = getattr(agent, "_pending_steer", None)
|
||||
agent._pending_steer = (existing + "\n" + _pre_api_steer) if existing else _pre_api_steer
|
||||
|
||||
# ── Wall-clock run-budget wrap-up notice ───────────────────────
|
||||
# One-shot: when a run budget (agent.run_budget_seconds /
|
||||
# --run-budget) is active and 80% of it has elapsed, ask the model
|
||||
# to wrap up and deliver from the state it already has. Same
|
||||
# cache-safe channel as /steer (appended to the newest tool
|
||||
# result); dormant when no budget is set.
|
||||
if getattr(agent, "run_budget_seconds", None):
|
||||
_maybe_inject_run_budget_wrapup(agent, messages)
|
||||
|
||||
# Prepare messages for API call
|
||||
# If we have an ephemeral system prompt, prepend it to the messages
|
||||
# Note: Reasoning is embedded in content via <think> tags for trajectory storage.
|
||||
@@ -2698,7 +2765,34 @@ def run_conversation(
|
||||
request_pressure_tokens,
|
||||
int(getattr(_compressor, "threshold_tokens", 0) or 0),
|
||||
)
|
||||
|
||||
elif not agent.compression_enabled and len(messages) > 1:
|
||||
# Uncompressed session guard (#89297): compression is disabled, so
|
||||
# nothing shrinks a growing session. Reuse the unconditionally
|
||||
# computed request estimate (zero marginal cost — this site runs
|
||||
# before every provider request, covering turn-start AND mid-turn
|
||||
# tool-result growth) and surface a deduped, actionable warning
|
||||
# when the request exceeds the model context window. The dedup is
|
||||
# re-armed by the turn-context preflight once the session is back
|
||||
# under the window (manual /compress works with compression
|
||||
# disabled), so the guard warns again on a later re-overflow.
|
||||
# context_compressor always exists (agent_init constructs it even
|
||||
# when compression is disabled) and its context_length property
|
||||
# hard-floors at a positive default — no metadata re-resolution
|
||||
# needed here.
|
||||
_ctx_len = getattr(
|
||||
getattr(agent, "context_compressor", None), "context_length", None
|
||||
)
|
||||
if (
|
||||
isinstance(_ctx_len, int)
|
||||
and _ctx_len > 0
|
||||
and request_pressure_tokens > _ctx_len
|
||||
):
|
||||
_warn_fn = getattr(
|
||||
agent, "_warn_uncompressed_context_overflow", None
|
||||
)
|
||||
if callable(_warn_fn):
|
||||
_warn_fn(request_pressure_tokens, _ctx_len)
|
||||
|
||||
# Thinking spinner for quiet mode (animated during API call)
|
||||
thinking_spinner = None
|
||||
|
||||
@@ -5237,6 +5331,21 @@ def run_conversation(
|
||||
FailoverReason.billing,
|
||||
FailoverReason.upstream_rate_limit,
|
||||
}
|
||||
# Relay-wrapped output-cap errors: some gateways wrap an
|
||||
# upstream "[400]: max_tokens (...) exceeds model's maximum
|
||||
# output tokens (...)" as HTTP 429, which classifies as
|
||||
# rate_limit. The failure is a deterministic request-shape
|
||||
# problem — falling back to another provider (or burning
|
||||
# generic retries) can't fix it, but the output-cap clamp
|
||||
# below can, in one retry (#72281). Parse once here; the
|
||||
# result gates both the eager-fallback exemption and the
|
||||
# widened is_context_length_error entry, and is reused as
|
||||
# available_out inside the handler.
|
||||
_wrapped_output_cap_budget = (
|
||||
parse_available_output_tokens_from_error(error_msg)
|
||||
if classified.reason == FailoverReason.rate_limit
|
||||
else None
|
||||
)
|
||||
_is_transport_failure = classified.reason in {
|
||||
FailoverReason.timeout,
|
||||
FailoverReason.overloaded,
|
||||
@@ -5254,7 +5363,7 @@ def run_conversation(
|
||||
if _is_zai_coding_overload:
|
||||
max_retries = max(max_retries, zai_coding_overload_retry_ceiling())
|
||||
_should_fallback = (
|
||||
is_rate_limited
|
||||
(is_rate_limited and _wrapped_output_cap_budget is None)
|
||||
or (_is_transport_failure and retry_count >= 2)
|
||||
)
|
||||
if _should_fallback and agent._fallback_index < len(agent._fallback_chain):
|
||||
@@ -5547,6 +5656,11 @@ def run_conversation(
|
||||
# server disconnect + large session pattern (#2153).
|
||||
is_context_length_error = (
|
||||
classified.reason == FailoverReason.context_overflow
|
||||
# Relay-wrapped output-cap 429s (parsed once above, where
|
||||
# the eager-fallback exemption is gated) route into the
|
||||
# output-cap clamp below instead of provider failover or
|
||||
# generic retries (#72281).
|
||||
or _wrapped_output_cap_budget is not None
|
||||
)
|
||||
|
||||
if is_context_length_error:
|
||||
@@ -7864,10 +7978,28 @@ def run_conversation(
|
||||
|
||||
from agent.agent_runtime_helpers import (
|
||||
intent_ack_continuation_mode,
|
||||
trailing_continue_intent,
|
||||
)
|
||||
|
||||
_ack_mode = intent_ack_continuation_mode(agent)
|
||||
if (
|
||||
# Said-continue-but-stopped guard (agent.stall_guards): the
|
||||
# model ended the turn with no tool calls but its short reply
|
||||
# TAILS with an announced next action ("Let me now…",
|
||||
# "I will now…"). Unlike the intent-ack detector below, this
|
||||
# fires mid-task too (after tool results), which is exactly
|
||||
# where eval traces show the stall. It reuses the SAME bounded
|
||||
# continuation path and counter (max 2 per turn), so the
|
||||
# alternation-safe interim-assistant + user-nudge mechanism —
|
||||
# not a new parallel one — carries the recovery.
|
||||
_stall_continue_intent = (
|
||||
bool(getattr(agent, "_stall_guards", True))
|
||||
and agent.valid_tool_names
|
||||
and codex_ack_continuations < 2
|
||||
and trailing_continue_intent(
|
||||
agent._strip_think_blocks(final_response or "")
|
||||
)
|
||||
)
|
||||
if _stall_continue_intent or (
|
||||
_ack_mode != "off"
|
||||
and agent.valid_tool_names
|
||||
and codex_ack_continuations < 2
|
||||
@@ -7878,6 +8010,12 @@ def run_conversation(
|
||||
require_workspace=(_ack_mode == "codex_only"),
|
||||
)
|
||||
):
|
||||
if _stall_continue_intent:
|
||||
logger.info(
|
||||
"Stall guard: turn ending on trailing continue-"
|
||||
"intent with no tool calls — re-prompting to act "
|
||||
"(%d/2)", codex_ack_continuations + 1,
|
||||
)
|
||||
codex_ack_continuations += 1
|
||||
interim_msg = agent._build_assistant_message(assistant_message, "incomplete")
|
||||
append_message(messages, interim_msg)
|
||||
|
||||
@@ -139,6 +139,18 @@ def get_active_provider() -> Optional[ImageGenProvider]:
|
||||
except Exception as exc:
|
||||
logger.debug("Could not read image_gen.provider from config: %s", exc)
|
||||
|
||||
# The managed "Nous Subscription" selection is serviced by the FAL
|
||||
# plugin through the managed fal-queue gateway (the legacy FAL pipeline
|
||||
# routes managed when the stored selection is "nous").
|
||||
if configured:
|
||||
try:
|
||||
from tools.tool_backend_helpers import NOUS_MANAGED_PROVIDER
|
||||
|
||||
if configured.lower() == NOUS_MANAGED_PROVIDER:
|
||||
configured = "fal"
|
||||
except Exception: # pragma: no cover — helpers are in-repo
|
||||
pass
|
||||
|
||||
with _lock:
|
||||
snapshot = dict(_providers)
|
||||
snapshot.update(_scoped_providers.get(hermes_home_key(), {}))
|
||||
|
||||
@@ -53,6 +53,11 @@ def summarize_manual_compression(
|
||||
compression_state is not None
|
||||
and getattr(compression_state, "_last_compress_aborted", False) is True
|
||||
)
|
||||
refused_would_grow = (
|
||||
compression_state is not None
|
||||
and getattr(compression_state, "_last_compress_refused_would_grow", False)
|
||||
is True
|
||||
)
|
||||
fallback_used = (
|
||||
compression_state is not None
|
||||
and getattr(compression_state, "_last_summary_fallback_used", False) is True
|
||||
@@ -65,7 +70,12 @@ def summarize_manual_compression(
|
||||
if not isinstance(failure_reason, str) or not failure_reason.strip():
|
||||
failure_reason = None
|
||||
|
||||
if aborted:
|
||||
if refused_would_grow:
|
||||
headline = (
|
||||
f"Compression refused (summary would grow the conversation): "
|
||||
f"{before_count} messages preserved"
|
||||
)
|
||||
elif aborted:
|
||||
headline = f"Compression aborted: {before_count} messages preserved"
|
||||
elif fallback_used:
|
||||
headline = (
|
||||
@@ -78,6 +88,8 @@ def summarize_manual_compression(
|
||||
|
||||
if noop and after_tokens == before_tokens:
|
||||
token_line = f"Approx request size: ~{before_tokens:,} tokens (unchanged)"
|
||||
elif refused_would_grow:
|
||||
token_line = f"Approx request size: ~{before_tokens:,} tokens (unchanged)"
|
||||
else:
|
||||
token_line = (
|
||||
f"Approx request size: ~{before_tokens:,} → "
|
||||
@@ -85,7 +97,12 @@ def summarize_manual_compression(
|
||||
)
|
||||
|
||||
note = None
|
||||
if aborted:
|
||||
if refused_would_grow:
|
||||
note = (
|
||||
"The generated summary was larger than what it would replace; "
|
||||
"no messages were removed."
|
||||
)
|
||||
elif aborted:
|
||||
note = "Summary generation failed; no messages were removed."
|
||||
elif fallback_used:
|
||||
dropped_count = getattr(
|
||||
@@ -113,6 +130,7 @@ def summarize_manual_compression(
|
||||
return {
|
||||
"noop": noop,
|
||||
"aborted": aborted,
|
||||
"refused_would_grow": refused_would_grow,
|
||||
"fallback_used": fallback_used,
|
||||
"headline": headline,
|
||||
"token_line": token_line,
|
||||
|
||||
@@ -1659,10 +1659,28 @@ def parse_available_output_tokens_from_error(error_msg: str) -> Optional[int]:
|
||||
# The input itself fits — this is purely an output-cap error, so reduce
|
||||
# max_tokens and retry; do NOT compress.
|
||||
"range of max_tokens should be" in error_lower
|
||||
) or (
|
||||
# OpenAI-compatible relays may reject a request whose output cap exceeds
|
||||
# the model's separate completion-token limit, e.g.
|
||||
# "max_tokens (98304) exceeds model's maximum output tokens (65536)"
|
||||
# This is independent of the input context window.
|
||||
"exceeds model" in error_lower
|
||||
and "maximum output tokens" in error_lower
|
||||
)
|
||||
if not is_output_cap_error:
|
||||
return None
|
||||
|
||||
# Generic model-output-cap form:
|
||||
# "max_tokens (98304) exceeds model's maximum output tokens (65536)"
|
||||
_m_max_output = re.search(
|
||||
r'exceeds model(?:\'s)? maximum output tokens\s*\(?\s*(\d+)\s*\)?',
|
||||
error_lower,
|
||||
)
|
||||
if _m_max_output:
|
||||
_cap = int(_m_max_output.group(1))
|
||||
if _cap >= 1:
|
||||
return _cap
|
||||
|
||||
# DashScope / Alibaba range form: "Range of max_tokens should be [1, 65536]".
|
||||
# The upper bound is the available output cap.
|
||||
_m_range = re.search(
|
||||
@@ -1726,11 +1744,28 @@ def parse_available_output_tokens_from_error(error_msg: str) -> Optional[int]:
|
||||
# Available output = window - input. When the input alone is at or over
|
||||
# the window this stays None, so the caller correctly falls through to
|
||||
# compression instead of futilely shrinking the output cap.
|
||||
#
|
||||
# Caveat: when max_tokens is the BINDING constraint, vLLM does not report
|
||||
# the real prompt size at all. It back-computes a lower bound from the
|
||||
# constraint itself -- "at least N input tokens" where
|
||||
# N == window + 1 - requested_output -- so window - N is always exactly
|
||||
# requested_output - 1. Subtracting the caller's safety margin then walks
|
||||
# the cap down ~65 tokens per retry while the reported input walks up by
|
||||
# the same amount, burning every compression attempt without ever fitting.
|
||||
# Detect that degenerate case and halve the requested cap instead: it
|
||||
# carries the same guarantee (strictly below what was rejected) and
|
||||
# converges in one or two retries.
|
||||
_m_vllm_input = re.search(
|
||||
r'prompt contains (?:at least )?(\d+)\s*input tokens', error_lower
|
||||
)
|
||||
if _m_ctx_tok and _m_vllm_input:
|
||||
_available = int(_m_ctx_tok.group(1)) - int(_m_vllm_input.group(1))
|
||||
_m_requested_out = re.search(r'requested (\d+)\s*output tokens', error_lower)
|
||||
if 'at least' in error_lower and _m_requested_out:
|
||||
_requested_out = int(_m_requested_out.group(1))
|
||||
if _available >= _requested_out - 1:
|
||||
# The budget is derived from the constraint, not measured.
|
||||
return max(1, _requested_out // 2)
|
||||
if _available >= 1:
|
||||
return _available
|
||||
|
||||
@@ -1782,6 +1817,8 @@ def is_output_cap_error(error_msg: str) -> bool:
|
||||
or "should be" in error_lower # generic "max_tokens should be <= N"
|
||||
or "less than or equal" in error_lower
|
||||
or "must be" in error_lower
|
||||
or ("exceeds model" in error_lower
|
||||
and "maximum output tokens" in error_lower)
|
||||
)
|
||||
if not output_cap_signal:
|
||||
return False
|
||||
|
||||
+67
-2
@@ -191,6 +191,21 @@ MEMORY_GUIDANCE = (
|
||||
"workflows belong in skills, not memory."
|
||||
)
|
||||
|
||||
USER_PROFILE_GUIDANCE = (
|
||||
"You have a persistent user profile across sessions. Save durable facts about "
|
||||
"the user with the memory tool (target='user'): name, role, preferences, "
|
||||
"corrections, and communication style. The profile is injected into every turn, "
|
||||
"so keep it compact and focused on facts that will still matter later.\n"
|
||||
"The built-in memory notes store is disabled — write only to the user profile "
|
||||
"(target='user'), never target='memory'.\n"
|
||||
"Prioritize what reduces future user steering — the most valuable entry is one "
|
||||
"that prevents the user from having to correct or remind you again.\n"
|
||||
"Write entries as declarative facts, not instructions to yourself. "
|
||||
"'User prefers concise responses' ✓ — 'Always respond concisely' ✗. "
|
||||
"Imperative phrasing gets re-read as a directive in later sessions and can "
|
||||
"cause repeated work or override the user's current request."
|
||||
)
|
||||
|
||||
SESSION_SEARCH_GUIDANCE = (
|
||||
"When the user references something from a past conversation or you suspect "
|
||||
"relevant cross-session context exists, use session_search to recall it before "
|
||||
@@ -358,6 +373,25 @@ TOOL_USE_ENFORCEMENT_GUIDANCE = (
|
||||
# Add new patterns here when a model family needs explicit steering.
|
||||
TOOL_USE_ENFORCEMENT_MODELS = ("gpt", "codex", "gemini", "gemma", "grok", "glm", "qwen", "deepseek")
|
||||
|
||||
# Model name substrings whose sessions receive OPENAI_MODEL_EXECUTION_GUIDANCE
|
||||
# (execution discipline: tool persistence, mandatory tool use for arithmetic,
|
||||
# external-write read-back, count reconciliation, literal preservation,
|
||||
# verification-gated completion) when agent.execution_guidance is "auto".
|
||||
#
|
||||
# gpt/codex/grok are the historical set; deepseek/kimi/qwen/glm/minimax/
|
||||
# mimo/mistral were added after Composio agentic-eval traces showed the same
|
||||
# failure modes on those families (financial math in prose, no read-back after
|
||||
# external writes, identifier "repair", completeness claims despite count
|
||||
# mismatches). GLM's tool-calls-as-plain-text stall (#53847) and MiMo (#41874)
|
||||
# are covered here too. Gemini/Gemma are excluded — they get the more specific
|
||||
# GOOGLE_MODEL_OPERATIONAL_GUIDANCE block instead. Claude is excluded because
|
||||
# it does not exhibit these failure modes; users can opt any model in via
|
||||
# config.yaml `agent.execution_guidance: true` or a substring list.
|
||||
EXECUTION_GUIDANCE_MODELS = (
|
||||
"gpt", "codex", "grok",
|
||||
"deepseek", "kimi", "qwen", "glm", "minimax", "mimo", "mistral",
|
||||
)
|
||||
|
||||
# Universal "finish the job" guidance — applied to ALL models, not gated
|
||||
# by model family. Addresses two cross-model failure modes:
|
||||
# 1. Stopping after a stub: writing a tiny file or running one command
|
||||
@@ -438,13 +472,22 @@ PARALLEL_TOOL_CALL_GUIDANCE = (
|
||||
# without tool calls, suggests workarounds instead of using existing tools,
|
||||
# replies with plans/suggestions instead of executing). The body is
|
||||
# family-agnostic; the OPENAI_ prefix reflects origin, not exclusivity.
|
||||
#
|
||||
# As of the Composio agentic-eval follow-up, the block is no longer fenced to
|
||||
# gpt/codex/grok: eval traces showed DeepSeek/Kimi doing financial math in
|
||||
# prose, skipping read-back verification after external writes, "repairing"
|
||||
# malformed identifiers, and claiming completeness despite count mismatches —
|
||||
# exactly the failure modes this block targets. The injection gate lives in
|
||||
# agent/system_prompt.py and is controlled by config.yaml
|
||||
# ``agent.execution_guidance`` (auto/true/false/list); "auto" matches the
|
||||
# EXECUTION_GUIDANCE_MODELS substring tuple below.
|
||||
OPENAI_MODEL_EXECUTION_GUIDANCE = (
|
||||
"# Execution discipline\n"
|
||||
"<tool_persistence>\n"
|
||||
"- Use tools whenever they improve correctness, completeness, or grounding.\n"
|
||||
"- Do not stop early when another tool call would materially improve the result.\n"
|
||||
"- If a tool returns empty or partial results, retry with a different query or "
|
||||
"strategy before giving up.\n"
|
||||
"- If a tool returns empty, partial, or suspiciously narrow results, retry "
|
||||
"with a broader or different query or strategy before concluding.\n"
|
||||
"- Keep calling tools until: (1) the task is complete, AND (2) you have verified "
|
||||
"the result.\n"
|
||||
"</tool_persistence>\n"
|
||||
@@ -487,8 +530,30 @@ OPENAI_MODEL_EXECUTION_GUIDANCE = (
|
||||
"- Formatting: does the output match the requested format or schema?\n"
|
||||
"- Safety: if the next step has side effects (file writes, commands, API calls), "
|
||||
"confirm scope before executing.\n"
|
||||
"- Completion: 'done' means every named acceptance criterion is verified — "
|
||||
"never a plausible subset. Completing your plan is not itself the answer; "
|
||||
"the requested output must appear in your response.\n"
|
||||
"</verification>\n"
|
||||
"\n"
|
||||
"<external_state_verification>\n"
|
||||
"- After any state-changing write to an external system (API call, message "
|
||||
"post, record update), verify the effect by reading back the exact target "
|
||||
"before claiming success — a successful tool call is not a successful task. "
|
||||
"Do NOT re-verify internal file edits a tool already confirmed.\n"
|
||||
"- Declared totals in responses (total, reply_count, has_more, '...N more') "
|
||||
"are hard assertions. If your enumerated count disagrees, re-fetch or parse "
|
||||
"programmatically — never finalize on 'go with what I have'.\n"
|
||||
"- When building write payloads, set fields explicitly rather than relying "
|
||||
"on provider defaults that could contradict intent.\n"
|
||||
"</external_state_verification>\n"
|
||||
"\n"
|
||||
"<literal_preservation>\n"
|
||||
"- Preserve identifiers, commands, and values exactly as given — never "
|
||||
"'repair' or normalize a token that fails a stated format. A successful "
|
||||
"lookup does not validate a malformed source token; validate format first, "
|
||||
"then look up.\n"
|
||||
"</literal_preservation>\n"
|
||||
"\n"
|
||||
"<missing_context>\n"
|
||||
"- If required context is missing, do NOT guess or hallucinate an answer.\n"
|
||||
"- Use the appropriate lookup tool when missing information is retrievable "
|
||||
|
||||
@@ -0,0 +1,213 @@
|
||||
"""Canonical reasoning-effort vocabulary and wire clamping.
|
||||
|
||||
Hermes' internal effort ladder (``hermes_constants.VALID_REASONING_EFFORTS``
|
||||
plus the ``none`` disable level) is wider than what any single provider wire
|
||||
accepts. Historically every transport and provider profile hand-rolled its own
|
||||
translation map, and the class of bugs that produced was constant: a new
|
||||
internal level (``ultra``) leaking to a wire that rejects it with HTTP 400
|
||||
(#89503, #70058), or an unknown level being dropped to a weak default so the
|
||||
strongest ask resolved *weaker* than an explicit ``high`` — a ladder
|
||||
inversion (#74295, #87279).
|
||||
|
||||
This module is the single source of truth both kinds of code use instead:
|
||||
|
||||
- :data:`EFFORT_LADDER` — canonical low→high ordering.
|
||||
- :func:`clamp_effort` — the one clamping policy: keep a supported level
|
||||
verbatim, otherwise take the **nearest weaker** supported level (never
|
||||
silently escalate cost above what was asked), and only when nothing weaker
|
||||
exists take the weakest supported level (a provider whose minimum thinking
|
||||
level is ``high`` serves ``high`` for a ``low`` ask — GLM-5.2's shape).
|
||||
- Named wire-vocabulary constants for the common OpenAI-compatible surfaces,
|
||||
so call sites declare *data* ("this route accepts these levels") rather
|
||||
than logic.
|
||||
|
||||
Rules for call sites:
|
||||
|
||||
1. **Wire shape stays local.** Whether a route wants ``extra_body.reasoning``,
|
||||
a top-level ``reasoning_effort`` string, or a ``thinking`` toggle is the
|
||||
caller's business. Only the *vocabulary math* lives here.
|
||||
2. **Unset stays unset.** ``clamp_effort`` translates an explicit request; it
|
||||
does not invent one. When the user expressed no effort, prefer omitting
|
||||
the field so the server default applies.
|
||||
3. **Never patch a predicate.** When a provider rejects a level, fix its
|
||||
declared supported set (data), never add another vendor-name special case
|
||||
at the call site.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import re
|
||||
from typing import Optional, Sequence
|
||||
|
||||
#: K3 slug detector — matches ``k3`` as a delimited token (``k3``,
|
||||
#: ``k3-256k``, ``kimi-k3``, ``kimi-k3-cot``) without matching K2-era names
|
||||
#: (``kimi-k2.6``). From #76427 by @ruizanthony.
|
||||
_KIMI_K3_SLUG_RE = re.compile(r"(?:^|[^a-z0-9])k3(?:[^a-z0-9]|$)")
|
||||
|
||||
# Canonical low→high ordering used for nearest-level clamping. Superset of
|
||||
# hermes_constants.VALID_REASONING_EFFORTS ("none" included so an explicit
|
||||
# disable can be clamped too when a provider publishes it as a level).
|
||||
EFFORT_LADDER: tuple[str, ...] = (
|
||||
"none", "minimal", "low", "medium", "high", "xhigh", "max", "ultra",
|
||||
)
|
||||
|
||||
# ``ultra`` is Hermes-internal ladder vocabulary (the Codex product tier); no
|
||||
# provider wire accepts it verbatim anywhere. Every declared wire set below
|
||||
# therefore stops at ``max`` — ``ultra`` always clamps down.
|
||||
|
||||
#: The widest OpenAI-compatible wire vocabulary (OpenRouter, Nous Portal):
|
||||
#: exactly max|xhigh|high|medium|low|minimal|none.
|
||||
OPENAI_COMPAT_WIRE_EFFORTS: tuple[str, ...] = (
|
||||
"none", "minimal", "low", "medium", "high", "xhigh", "max",
|
||||
)
|
||||
|
||||
#: OpenAI/Codex Responses backend — per-model vocabulary, live-verified
|
||||
#: (Aug 2026): ``minimal`` is rejected by both generations (clamps to low);
|
||||
#: ``max`` is gpt-5.6-only — gpt-5.5 rejects it with "Supported values are:
|
||||
#: 'none', 'low', 'medium', 'high', 'xhigh'" (#68365's premise, confirmed).
|
||||
CODEX_GPT56_EFFORTS: tuple[str, ...] = (
|
||||
"none", "low", "medium", "high", "xhigh", "max",
|
||||
)
|
||||
CODEX_LEGACY_EFFORTS: tuple[str, ...] = (
|
||||
"none", "low", "medium", "high", "xhigh",
|
||||
)
|
||||
|
||||
|
||||
def codex_supported_efforts(model: Optional[str]) -> tuple[str, ...]:
|
||||
"""Supported effort set for an OpenAI/Codex Responses model."""
|
||||
if "gpt-5.6" in (model or "").lower():
|
||||
return CODEX_GPT56_EFFORTS
|
||||
return CODEX_LEGACY_EFFORTS
|
||||
|
||||
|
||||
#: Backward-compat alias (pre-#68365-verification name).
|
||||
CODEX_RESPONSES_EFFORTS: tuple[str, ...] = CODEX_GPT56_EFFORTS
|
||||
|
||||
#: xAI Responses — Grok 4.6+ accepts xhigh; older Grok tops out at high.
|
||||
XAI_GROK46_EFFORTS: tuple[str, ...] = ("low", "medium", "high", "xhigh")
|
||||
XAI_LEGACY_EFFORTS: tuple[str, ...] = ("low", "medium", "high")
|
||||
|
||||
#: Actual Computer relays (SGLang/vLLM): none/low/medium/high/max.
|
||||
ACTUAL_RELAY_EFFORTS: tuple[str, ...] = ("none", "low", "medium", "high", "max")
|
||||
|
||||
#: Moonshot/Kimi K3: low/high/max (server default high).
|
||||
KIMI_K3_EFFORTS: tuple[str, ...] = ("low", "high", "max")
|
||||
#: Moonshot/Kimi K2-era models: low/medium/high.
|
||||
KIMI_K2_EFFORTS: tuple[str, ...] = ("low", "medium", "high")
|
||||
|
||||
#: Tencent TokenHub: low/medium/high.
|
||||
TOKENHUB_EFFORTS: tuple[str, ...] = ("low", "medium", "high")
|
||||
|
||||
#: Kimi K3's vendor-documented translation quirks (platform.kimi.ai
|
||||
#: thinking-model guide): ``high`` is K3's positional middle AND server
|
||||
#: default, so ``medium`` rounds to it rather than down to ``low``; ``xhigh``
|
||||
#: rounds up to ``max`` (K3's top tier), matching the kimi-coding plugin.
|
||||
KIMI_K3_OVERRIDES: dict[str, str] = {"medium": "high", "xhigh": "max"}
|
||||
|
||||
#: GLM-5.2 native reasoning_effort knob: exactly two enabled levels,
|
||||
#: ``high`` (its minimum thinking level) and ``max`` (per Z.AI/BigModel
|
||||
#: docs). ``xhigh`` requests the top tier, not the floor.
|
||||
GLM52_EFFORTS: tuple[str, ...] = ("high", "max")
|
||||
GLM52_OVERRIDES: dict[str, str] = {"xhigh": "max"}
|
||||
|
||||
#: DeepSeek V4 OpenAI-compat endpoint: low/medium/high/max; ``xhigh``
|
||||
#: requests the top tier (matches the shipped profile mapping).
|
||||
DEEPSEEK_V4_EFFORTS: tuple[str, ...] = ("low", "medium", "high", "max")
|
||||
DEEPSEEK_V4_OVERRIDES: dict[str, str] = {"xhigh": "max"}
|
||||
|
||||
#: Ollama Cloud /v1/chat/completions: accepts {none, low, medium, high, max};
|
||||
#: rejects ``minimal`` with HTTP 400. ``xhigh`` requests the top tier.
|
||||
OLLAMA_CLOUD_EFFORTS: tuple[str, ...] = ("none", "low", "medium", "high", "max")
|
||||
OLLAMA_CLOUD_OVERRIDES: dict[str, str] = {"xhigh": "max"}
|
||||
|
||||
#: Meta Model API (Muse): minimal..xhigh; rejects ``none``.
|
||||
META_AI_EFFORTS: tuple[str, ...] = ("minimal", "low", "medium", "high", "xhigh")
|
||||
|
||||
#: Upstage Solar Pro/Open: low/medium/high.
|
||||
SOLAR_EFFORTS: tuple[str, ...] = ("low", "medium", "high")
|
||||
|
||||
|
||||
def kimi_supported_efforts(model: Optional[str]) -> tuple[str, ...]:
|
||||
"""Supported effort set for a Moonshot/Kimi model slug.
|
||||
|
||||
K3 is served as the bare slug ``k3``, plan variants like ``k3-256k``,
|
||||
and the ``kimi-k3*`` aliases; its documented set is low/high/max.
|
||||
Everything earlier speaks low/medium/high. Boundary-matched so K2-era
|
||||
names (``kimi-k2.6``) never match (detection regex from #76427 by
|
||||
@ruizanthony).
|
||||
"""
|
||||
m = (model or "").strip().lower().split("/")[-1]
|
||||
if _KIMI_K3_SLUG_RE.search(m):
|
||||
return KIMI_K3_EFFORTS
|
||||
return KIMI_K2_EFFORTS
|
||||
|
||||
|
||||
def clamp_effort(
|
||||
effort: Optional[str],
|
||||
supported: Optional[Sequence[str]],
|
||||
overrides: Optional[dict[str, str]] = None,
|
||||
) -> Optional[str]:
|
||||
"""Clamp a requested reasoning effort onto a wire's supported levels.
|
||||
|
||||
``overrides`` is an optional declared mapping consulted first, for routes
|
||||
whose vendor documents a translation that differs from nearest-weaker
|
||||
(Kimi K3 documents ``medium → high``: high is its positional middle and
|
||||
server default). Overrides are data, not logic — a call site never adds
|
||||
vendor ``if``\\ s around this function.
|
||||
|
||||
Otherwise: returns the requested effort unchanged when it is supported,
|
||||
when the supported set is unknown (``None``/empty), or when the effort
|
||||
isn't a recognized ladder level (custom providers may use bespoke names —
|
||||
pass through rather than guess). Otherwise returns the **nearest weaker**
|
||||
supported level, so a clamp never silently escalates cost; when nothing
|
||||
weaker exists, the weakest supported level is returned (the caller asked
|
||||
for *some* thinking and the provider's floor is the closest honest match).
|
||||
|
||||
The policy is monotonic: a stronger request never resolves to a weaker
|
||||
wire level than a weaker request would.
|
||||
"""
|
||||
requested = str(effort or "").strip().lower()
|
||||
if not requested or not supported:
|
||||
return effort
|
||||
supported_norm = [
|
||||
str(level).strip().lower()
|
||||
for level in supported
|
||||
if str(level).strip().lower() in EFFORT_LADDER
|
||||
]
|
||||
if not supported_norm or requested in supported_norm:
|
||||
return effort
|
||||
if overrides:
|
||||
mapped = overrides.get(requested)
|
||||
if mapped in supported_norm:
|
||||
return mapped
|
||||
if requested not in EFFORT_LADDER:
|
||||
return effort
|
||||
# "none" disables reasoning — it is never a *degradation target* for an
|
||||
# enabled ask (clamping "minimal" to "none" would silently switch
|
||||
# thinking off). It still passes through verbatim when requested.
|
||||
candidates = [level for level in supported_norm if level != "none"]
|
||||
if not candidates:
|
||||
return effort
|
||||
requested_idx = EFFORT_LADDER.index(requested)
|
||||
below = [
|
||||
level for level in candidates
|
||||
if EFFORT_LADDER.index(level) < requested_idx
|
||||
]
|
||||
if below:
|
||||
return max(below, key=EFFORT_LADDER.index)
|
||||
return min(candidates, key=EFFORT_LADDER.index)
|
||||
|
||||
|
||||
def requested_effort(reasoning_config: Optional[dict]) -> Optional[str]:
|
||||
"""Extract the user's explicit effort from a reasoning config, or None.
|
||||
|
||||
Returns ``None`` when the config is absent, malformed, carries no effort,
|
||||
or reasoning is explicitly disabled — callers should then omit the wire
|
||||
field entirely so the server default applies (rule 2 above).
|
||||
"""
|
||||
if not isinstance(reasoning_config, dict):
|
||||
return None
|
||||
if reasoning_config.get("enabled") is False:
|
||||
return None
|
||||
effort = str(reasoning_config.get("effort") or "").strip().lower()
|
||||
return effort or None
|
||||
+100
-70
@@ -434,6 +434,7 @@ class ManagedLlmStream(Iterator[Any]):
|
||||
self._stream: Any = None
|
||||
self._raw_stream_resource: Any = None
|
||||
self._closed = False
|
||||
self._runtime_lease: relay_runtime.RelayOperationLease | None = None
|
||||
self._close_error: BaseException | None = None
|
||||
self._callback_error: BaseException | None = None
|
||||
self._logical: tuple[relay_runtime.RelayTurnContext, Any, str] | None = None
|
||||
@@ -573,7 +574,12 @@ class ManagedLlmStream(Iterator[Any]):
|
||||
self._callback_error = exc
|
||||
raise
|
||||
|
||||
loop = asyncio.new_event_loop()
|
||||
self._runtime_lease = runtime.acquire_operation_lease()
|
||||
try:
|
||||
loop = asyncio.new_event_loop()
|
||||
except BaseException:
|
||||
self._release_runtime_lease()
|
||||
raise
|
||||
self._loop = loop
|
||||
self._relay_observes_chunks = True
|
||||
try:
|
||||
@@ -613,10 +619,14 @@ class ManagedLlmStream(Iterator[Any]):
|
||||
model_name=self._logical_model_name,
|
||||
provider_name=self._logical_provider_name,
|
||||
response_model_name=self._logical_response_model_name,
|
||||
operation_lease=self._runtime_lease,
|
||||
)
|
||||
self._logical = None
|
||||
loop.close()
|
||||
self._loop = None
|
||||
try:
|
||||
loop.close()
|
||||
finally:
|
||||
self._loop = None
|
||||
self._release_runtime_lease()
|
||||
raise
|
||||
|
||||
def __iter__(self) -> "ManagedLlmStream":
|
||||
@@ -662,6 +672,7 @@ class ManagedLlmStream(Iterator[Any]):
|
||||
model_name=self._logical_model_name,
|
||||
provider_name=self._logical_provider_name,
|
||||
response_model_name=self._logical_response_model_name,
|
||||
operation_lease=self._runtime_lease,
|
||||
)
|
||||
self._logical = None
|
||||
self._close(logical_outcome="cancelled")
|
||||
@@ -719,8 +730,75 @@ class ManagedLlmStream(Iterator[Any]):
|
||||
self._stream = iter(pending)
|
||||
self._raw_stream_resource = None
|
||||
self._accept_chunk = None
|
||||
if loop is not None:
|
||||
close = getattr(relay_stream, "aclose", None)
|
||||
try:
|
||||
if loop is not None:
|
||||
close = getattr(relay_stream, "aclose", None)
|
||||
if callable(close):
|
||||
|
||||
async def close_stream() -> None:
|
||||
await close()
|
||||
|
||||
try:
|
||||
loop.run_until_complete(close_stream())
|
||||
except Exception:
|
||||
logger.debug(
|
||||
"Relay stream cleanup failed during provider fallback",
|
||||
exc_info=True,
|
||||
)
|
||||
loop.close()
|
||||
if not self._defer_logical_completion:
|
||||
_complete_logical(
|
||||
self._logical,
|
||||
outcome="success",
|
||||
model_name=self._logical_model_name,
|
||||
provider_name=self._logical_provider_name,
|
||||
response_model_name=self._logical_response_model_name,
|
||||
operation_lease=self._runtime_lease,
|
||||
)
|
||||
self._logical = None
|
||||
finally:
|
||||
self._release_runtime_lease()
|
||||
|
||||
def _close(self, *, logical_outcome: str) -> None:
|
||||
if self._closed:
|
||||
return
|
||||
self._closed = True
|
||||
self._prefetched_chunks.clear()
|
||||
try:
|
||||
loop = self._loop
|
||||
self._loop = None
|
||||
if loop is None:
|
||||
resources = (self._stream, self._raw_stream_resource)
|
||||
self._stream = None
|
||||
self._raw_stream_resource = None
|
||||
closed_ids: set[int] = set()
|
||||
for resource in resources:
|
||||
if resource is None or id(resource) in closed_ids:
|
||||
continue
|
||||
closed_ids.add(id(resource))
|
||||
close = getattr(resource, "close", None)
|
||||
if callable(close):
|
||||
try:
|
||||
close()
|
||||
except Exception as exc:
|
||||
if self._close_error is None:
|
||||
self._close_error = exc
|
||||
logger.debug(
|
||||
"Provider stream cleanup failed",
|
||||
exc_info=True,
|
||||
)
|
||||
if not self._defer_logical_completion:
|
||||
_complete_logical(
|
||||
self._logical,
|
||||
outcome=logical_outcome,
|
||||
model_name=self._logical_model_name,
|
||||
provider_name=self._logical_provider_name,
|
||||
response_model_name=self._logical_response_model_name,
|
||||
operation_lease=self._runtime_lease,
|
||||
)
|
||||
self._logical = None
|
||||
return
|
||||
close = getattr(self._stream, "aclose", None)
|
||||
if callable(close):
|
||||
|
||||
async def close_stream() -> None:
|
||||
@@ -728,49 +806,9 @@ class ManagedLlmStream(Iterator[Any]):
|
||||
|
||||
try:
|
||||
loop.run_until_complete(close_stream())
|
||||
except Exception:
|
||||
logger.debug(
|
||||
"Relay stream cleanup failed during provider fallback",
|
||||
exc_info=True,
|
||||
)
|
||||
loop.close()
|
||||
if not self._defer_logical_completion:
|
||||
_complete_logical(
|
||||
self._logical,
|
||||
outcome="success",
|
||||
model_name=self._logical_model_name,
|
||||
provider_name=self._logical_provider_name,
|
||||
response_model_name=self._logical_response_model_name,
|
||||
)
|
||||
self._logical = None
|
||||
|
||||
def _close(self, *, logical_outcome: str) -> None:
|
||||
if self._closed:
|
||||
return
|
||||
self._closed = True
|
||||
self._prefetched_chunks.clear()
|
||||
loop = self._loop
|
||||
self._loop = None
|
||||
if loop is None:
|
||||
resources = (self._stream, self._raw_stream_resource)
|
||||
self._stream = None
|
||||
self._raw_stream_resource = None
|
||||
closed_ids: set[int] = set()
|
||||
for resource in resources:
|
||||
if resource is None or id(resource) in closed_ids:
|
||||
continue
|
||||
closed_ids.add(id(resource))
|
||||
close = getattr(resource, "close", None)
|
||||
if callable(close):
|
||||
try:
|
||||
close()
|
||||
except Exception as exc:
|
||||
if self._close_error is None:
|
||||
self._close_error = exc
|
||||
logger.debug(
|
||||
"Provider stream cleanup failed",
|
||||
exc_info=True,
|
||||
)
|
||||
except Exception as exc:
|
||||
if self._close_error is None:
|
||||
self._close_error = exc
|
||||
if not self._defer_logical_completion:
|
||||
_complete_logical(
|
||||
self._logical,
|
||||
@@ -778,30 +816,18 @@ class ManagedLlmStream(Iterator[Any]):
|
||||
model_name=self._logical_model_name,
|
||||
provider_name=self._logical_provider_name,
|
||||
response_model_name=self._logical_response_model_name,
|
||||
operation_lease=self._runtime_lease,
|
||||
)
|
||||
self._logical = None
|
||||
return
|
||||
close = getattr(self._stream, "aclose", None)
|
||||
if callable(close):
|
||||
loop.close()
|
||||
finally:
|
||||
self._release_runtime_lease()
|
||||
|
||||
async def close_stream() -> None:
|
||||
await close()
|
||||
|
||||
try:
|
||||
loop.run_until_complete(close_stream())
|
||||
except Exception as exc:
|
||||
if self._close_error is None:
|
||||
self._close_error = exc
|
||||
if not self._defer_logical_completion:
|
||||
_complete_logical(
|
||||
self._logical,
|
||||
outcome=logical_outcome,
|
||||
model_name=self._logical_model_name,
|
||||
provider_name=self._logical_provider_name,
|
||||
response_model_name=self._logical_response_model_name,
|
||||
)
|
||||
self._logical = None
|
||||
loop.close()
|
||||
def _release_runtime_lease(self) -> None:
|
||||
lease = self._runtime_lease
|
||||
self._runtime_lease = None
|
||||
if lease is not None:
|
||||
lease.release()
|
||||
|
||||
def __del__(self) -> None:
|
||||
self._close(logical_outcome="cancelled")
|
||||
@@ -941,6 +967,7 @@ def _complete_logical(
|
||||
model_name: str | None = None,
|
||||
provider_name: str | None = None,
|
||||
response_model_name: str | None = None,
|
||||
operation_lease: relay_runtime.RelayOperationLease | None = None,
|
||||
) -> None:
|
||||
if logical is None:
|
||||
return
|
||||
@@ -960,7 +987,10 @@ def _complete_logical(
|
||||
output.update({"model": model_name, "provider": provider_name})
|
||||
if response_model_name is not None:
|
||||
output["response_model"] = response_model_name
|
||||
lease.host.run_in_session(
|
||||
callback = lease.host.run_in_session
|
||||
if operation_lease is not None:
|
||||
callback = operation_lease.run_in_session
|
||||
callback(
|
||||
lease.session,
|
||||
relay_runtime.pop_relay_scope,
|
||||
lease.host.relay,
|
||||
|
||||
+492
-41
@@ -8,13 +8,21 @@ import contextvars
|
||||
import importlib
|
||||
import inspect
|
||||
import logging
|
||||
import os
|
||||
import threading
|
||||
import tomllib
|
||||
import uuid
|
||||
from concurrent.futures import TimeoutError as FuturesTimeoutError
|
||||
from dataclasses import dataclass, field
|
||||
from enum import Enum, auto
|
||||
from pathlib import Path
|
||||
from typing import Any, Callable
|
||||
|
||||
from hermes_constants import get_hermes_home
|
||||
from hermes_cli.relay_plugin_cutover import (
|
||||
RELAY_PLUGINS_CONFIG_ENV,
|
||||
configured_legacy_relay_env_vars,
|
||||
)
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
@@ -24,6 +32,7 @@ LOGICAL_LLM_SCOPE = "hermes.logical_llm_call"
|
||||
RUNTIME_SCHEMA_KEY = "hermes.relay.schema_version"
|
||||
RUNTIME_SCHEMA_VERSION = "hermes.relay.runtime.v1"
|
||||
RUNTIME_INSTANCE_KEY = "hermes.relay.runtime_instance"
|
||||
RELAY_PLUGINS_EXECUTION_CONSUMER = "hermes.nemo_relay.plugins"
|
||||
_PROFILE_KEY_CACHE: dict[str, str] = {}
|
||||
|
||||
# Bound for native scope lifecycle operations (push/pop/flush) that gate
|
||||
@@ -128,6 +137,20 @@ def pop_relay_scope(
|
||||
return pop(handle, **kwargs)
|
||||
|
||||
|
||||
class _RelayPluginConfigurationState(Enum):
|
||||
"""Process-wide result shared by every currently hosted profile."""
|
||||
|
||||
UNINITIALIZED = auto()
|
||||
DISABLED = auto()
|
||||
ACTIVE = auto()
|
||||
FOREIGN = auto()
|
||||
FAILED = auto()
|
||||
|
||||
|
||||
class _RelayPluginConfigurationLoadError(RuntimeError):
|
||||
"""An explicitly selected Relay plugin configuration could not be loaded."""
|
||||
|
||||
|
||||
@dataclass
|
||||
class RelaySession:
|
||||
"""One isolated Relay scope stack owned by a Hermes session."""
|
||||
@@ -199,8 +222,232 @@ def _reset_segments_config_for_tests() -> None:
|
||||
_SEGMENTS_CONFIG = None
|
||||
|
||||
|
||||
class RelayOperationLease:
|
||||
"""Keep process-wide Relay plugins alive across a deferred operation."""
|
||||
|
||||
def __init__(self, runtime: "RelayRuntime") -> None:
|
||||
self._lock = threading.Lock()
|
||||
self._runtime: RelayRuntime | None = runtime
|
||||
|
||||
def run_in_session(
|
||||
self,
|
||||
session: RelaySession,
|
||||
callback: Callable[..., Any],
|
||||
*args: Any,
|
||||
**kwargs: Any,
|
||||
) -> Any:
|
||||
"""Run cleanup while this lease still owns the runtime lifetime."""
|
||||
with self._lock:
|
||||
runtime = self._runtime
|
||||
if runtime is None:
|
||||
raise RuntimeError("Hermes Relay operation lease is released")
|
||||
return runtime._run_in_session_untracked(
|
||||
session,
|
||||
callback,
|
||||
*args,
|
||||
**kwargs,
|
||||
)
|
||||
|
||||
def release(self) -> None:
|
||||
"""Release this lease exactly once."""
|
||||
with self._lock:
|
||||
runtime = self._runtime
|
||||
self._runtime = None
|
||||
if runtime is not None:
|
||||
runtime._end_operation()
|
||||
|
||||
|
||||
class _ProcessRelayPluginConfiguration:
|
||||
"""Own one Relay plugin configuration across profile-scoped hosts."""
|
||||
|
||||
def __init__(self) -> None:
|
||||
self._lock = threading.RLock()
|
||||
self._owners: set[int] = set()
|
||||
self._state = _RelayPluginConfigurationState.UNINITIALIZED
|
||||
self._active = False
|
||||
self._relay: Any = None
|
||||
self._activation: Any = None
|
||||
|
||||
def acquire(
|
||||
self,
|
||||
owner: Any,
|
||||
relay: Any,
|
||||
) -> _RelayPluginConfigurationState:
|
||||
"""Join the process configuration, initializing it for the first host."""
|
||||
owner_id = id(owner)
|
||||
with self._lock:
|
||||
if owner_id in self._owners:
|
||||
return self._state
|
||||
if self._owners:
|
||||
self._owners.add(owner_id)
|
||||
return self._state
|
||||
if self._active and not self._clear_active():
|
||||
logger.warning(
|
||||
"Hermes Relay plugin cleanup is still pending; refusing to "
|
||||
"replace the process-global configuration"
|
||||
)
|
||||
return self._remember(
|
||||
owner_id,
|
||||
_RelayPluginConfigurationState.FAILED,
|
||||
)
|
||||
|
||||
try:
|
||||
existing_report = relay.plugin.report()
|
||||
except Exception:
|
||||
logger.warning(
|
||||
"Hermes could not determine whether a process-global Relay "
|
||||
"plugin configuration is already active; refusing to replace it",
|
||||
exc_info=True,
|
||||
)
|
||||
return self._remember(
|
||||
owner_id,
|
||||
_RelayPluginConfigurationState.FAILED,
|
||||
)
|
||||
if existing_report is not None:
|
||||
logger.warning(
|
||||
"A process-global Relay plugin configuration is already active "
|
||||
"outside Hermes native ownership; leaving it unchanged and "
|
||||
"disabling Hermes-managed Relay middleware for this process"
|
||||
)
|
||||
return self._remember(
|
||||
owner_id,
|
||||
_RelayPluginConfigurationState.FOREIGN,
|
||||
)
|
||||
|
||||
try:
|
||||
configured_inputs = _configured_plugin_inputs(relay)
|
||||
if configured_inputs is None:
|
||||
return self._remember(
|
||||
owner_id,
|
||||
_RelayPluginConfigurationState.DISABLED,
|
||||
)
|
||||
plugin_config, dynamic_plugins = configured_inputs
|
||||
if dynamic_plugins:
|
||||
try:
|
||||
activation = _resolve_plugin_awaitable(
|
||||
relay.plugin.initialize_with_dynamic_plugins(
|
||||
plugin_config,
|
||||
dynamic_plugins,
|
||||
)
|
||||
)
|
||||
if activation is None:
|
||||
raise RuntimeError(
|
||||
"NeMo Relay dynamic plugin initialization "
|
||||
"returned no activation handle"
|
||||
)
|
||||
self._activation = activation
|
||||
except Exception as exc:
|
||||
raise RuntimeError(
|
||||
"Hermes Relay dynamic plugin activation failed"
|
||||
) from exc
|
||||
|
||||
if self._activation is None:
|
||||
# Hermes only enters Relay's initialization path after an
|
||||
# explicit opt-in. Relay currently owns any subsequent ambient
|
||||
# layering; a future discovery=False API can make this exact.
|
||||
_resolve_plugin_awaitable(relay.plugin.initialize(plugin_config))
|
||||
except Exception as exc:
|
||||
self._activation = None
|
||||
logger.warning(
|
||||
"Hermes Relay plugin initialization failed: %s",
|
||||
exc,
|
||||
exc_info=True,
|
||||
)
|
||||
return self._remember(
|
||||
owner_id,
|
||||
_RelayPluginConfigurationState.FAILED,
|
||||
)
|
||||
|
||||
self._active = True
|
||||
self._relay = relay
|
||||
state = self._remember(
|
||||
owner_id,
|
||||
_RelayPluginConfigurationState.ACTIVE,
|
||||
)
|
||||
logger.info(
|
||||
"Relay plugins are active process-wide and apply to all profiles "
|
||||
"hosted by this Hermes process."
|
||||
)
|
||||
return state
|
||||
|
||||
def _remember(
|
||||
self,
|
||||
owner_id: int,
|
||||
state: _RelayPluginConfigurationState,
|
||||
) -> _RelayPluginConfigurationState:
|
||||
"""Retain one process decision for all concurrently hosted profiles."""
|
||||
self._owners.add(owner_id)
|
||||
self._state = state
|
||||
return state
|
||||
|
||||
def release(self, owner: Any) -> None:
|
||||
"""Release one host and clear Relay after the final host exits."""
|
||||
owner_id = id(owner)
|
||||
with self._lock:
|
||||
if owner_id not in self._owners:
|
||||
return
|
||||
self._owners.remove(owner_id)
|
||||
if self._owners:
|
||||
return
|
||||
if self._clear_active():
|
||||
self._state = _RelayPluginConfigurationState.UNINITIALIZED
|
||||
|
||||
def reset_for_tests(self) -> None:
|
||||
"""Clear process-global state left by directly constructed test hosts."""
|
||||
with self._lock:
|
||||
self._owners.clear()
|
||||
if self._clear_active():
|
||||
self._state = _RelayPluginConfigurationState.UNINITIALIZED
|
||||
|
||||
def retry_pending_cleanup(self) -> None:
|
||||
"""Retry a failed final cleanup without disrupting live owners."""
|
||||
with self._lock:
|
||||
if not self._owners:
|
||||
if self._clear_active():
|
||||
self._state = _RelayPluginConfigurationState.UNINITIALIZED
|
||||
|
||||
def _clear_active(self) -> bool:
|
||||
relay = self._relay
|
||||
activation = self._activation
|
||||
active = self._active
|
||||
if not active or relay is None:
|
||||
return True
|
||||
try:
|
||||
_flush_relay_subscribers(relay)
|
||||
except Exception:
|
||||
logger.warning(
|
||||
"Hermes Relay plugin subscriber flush failed",
|
||||
exc_info=True,
|
||||
)
|
||||
return False
|
||||
try:
|
||||
if activation is not None:
|
||||
close = getattr(activation, "close", None)
|
||||
if not callable(close):
|
||||
raise RuntimeError(
|
||||
"NeMo Relay dynamic plugin activation has no close method"
|
||||
)
|
||||
_resolve_plugin_awaitable(close())
|
||||
else:
|
||||
_clear_relay_plugins(relay)
|
||||
except Exception:
|
||||
logger.warning(
|
||||
"Hermes Relay plugin configuration cleanup failed",
|
||||
exc_info=True,
|
||||
)
|
||||
return False
|
||||
self._active = False
|
||||
self._relay = None
|
||||
self._activation = None
|
||||
return True
|
||||
|
||||
|
||||
_PLUGIN_CONFIGURATION = _ProcessRelayPluginConfiguration()
|
||||
atexit.register(_PLUGIN_CONFIGURATION.retry_pending_cleanup)
|
||||
|
||||
|
||||
class RelayRuntime:
|
||||
"""Own Relay session scopes independently of any exporter or plugin."""
|
||||
"""Own Relay session scopes and optional process plugin configuration."""
|
||||
|
||||
def __init__(self, relay: Any = None, *, profile_key: str | None = None) -> None:
|
||||
self.relay = relay or _load_nemo_relay()
|
||||
@@ -210,8 +457,24 @@ class RelayRuntime:
|
||||
self._sessions: dict[str, RelaySession] = {}
|
||||
self._subagent_parents: dict[str, str] = {}
|
||||
self._subagent_parent_handles: dict[str, Any] = {}
|
||||
self._closing = False
|
||||
self._shutdown_started = False
|
||||
self._shutdown_complete = threading.Event()
|
||||
self._operations_idle = threading.Event()
|
||||
self._operations_idle.set()
|
||||
self._active_operations = 0
|
||||
self._execution_consumers_lock = threading.RLock()
|
||||
self._execution_consumers: set[str] = set()
|
||||
self._plugin_configuration_state = _PLUGIN_CONFIGURATION.acquire(
|
||||
self,
|
||||
self.relay,
|
||||
)
|
||||
self._plugin_configuration_registered = True
|
||||
if (
|
||||
self._plugin_configuration_state
|
||||
is _RelayPluginConfigurationState.ACTIVE
|
||||
):
|
||||
self.retain_managed_execution(RELAY_PLUGINS_EXECUTION_CONSUMER)
|
||||
self._shutdown_registered = True
|
||||
atexit.register(self.shutdown)
|
||||
|
||||
@@ -244,6 +507,8 @@ class RelayRuntime:
|
||||
if not session_id:
|
||||
return None
|
||||
with self._sessions_lock:
|
||||
if self._closing:
|
||||
return None
|
||||
session = self._sessions.get(session_id)
|
||||
if session is None:
|
||||
parent_session_id = self._subagent_parents.get(session_id, "")
|
||||
@@ -404,6 +669,8 @@ class RelayRuntime:
|
||||
):
|
||||
parent_handle = turn.handle
|
||||
with self._sessions_lock:
|
||||
if self._closing:
|
||||
return None
|
||||
self._subagent_parents[child_session_id] = parent_session_id
|
||||
if parent_handle is not None:
|
||||
self._subagent_parent_handles[child_session_id] = parent_handle
|
||||
@@ -425,6 +692,8 @@ class RelayRuntime:
|
||||
def get_session(self, session_id: str) -> RelaySession | None:
|
||||
"""Return an active Hermes Relay session without creating one."""
|
||||
with self._sessions_lock:
|
||||
if self._closing:
|
||||
return None
|
||||
session = self._sessions.get(str(session_id or ""))
|
||||
if session is None:
|
||||
return None
|
||||
@@ -458,6 +727,29 @@ class RelayRuntime:
|
||||
span, never the agent. The abandoned daemon worker cannot block
|
||||
process exit (tools.daemon_pool contract).
|
||||
"""
|
||||
self._begin_operation()
|
||||
try:
|
||||
return self._run_in_session_untracked(
|
||||
session,
|
||||
callback,
|
||||
*args,
|
||||
allow_closing=allow_closing,
|
||||
timeout=timeout,
|
||||
**kwargs,
|
||||
)
|
||||
finally:
|
||||
self._end_operation()
|
||||
|
||||
def _run_in_session_untracked(
|
||||
self,
|
||||
session: RelaySession,
|
||||
callback: Callable[..., Any],
|
||||
*args: Any,
|
||||
allow_closing: bool = False,
|
||||
timeout: float | None = None,
|
||||
**kwargs: Any,
|
||||
) -> Any:
|
||||
"""Run inside a session whose host-level lifetime is already held."""
|
||||
with session.lock:
|
||||
if session.closing and not allow_closing:
|
||||
raise RuntimeError("Hermes Relay session is closing")
|
||||
@@ -506,26 +798,49 @@ class RelayRuntime:
|
||||
**kwargs: Any,
|
||||
) -> Any:
|
||||
"""Create and await an operation inside the session's saved context."""
|
||||
with session.lock:
|
||||
if session.closing and not allow_closing:
|
||||
raise RuntimeError("Hermes Relay session is closing")
|
||||
if session.context is None or session.handle is None:
|
||||
raise RuntimeError("Hermes Relay session context is unavailable")
|
||||
relay_context = session.context.copy()
|
||||
self._begin_operation()
|
||||
try:
|
||||
with session.lock:
|
||||
if session.closing and not allow_closing:
|
||||
raise RuntimeError("Hermes Relay session is closing")
|
||||
if session.context is None or session.handle is None:
|
||||
raise RuntimeError("Hermes Relay session context is unavailable")
|
||||
relay_context = session.context.copy()
|
||||
|
||||
context = contextvars.copy_context()
|
||||
for variable, value in relay_context.items():
|
||||
context.run(variable.set, value)
|
||||
context = contextvars.copy_context()
|
||||
for variable, value in relay_context.items():
|
||||
context.run(variable.set, value)
|
||||
|
||||
async def invoke() -> Any:
|
||||
self.relay.get_scope_stack()
|
||||
result = callback(*args, **kwargs)
|
||||
if inspect.isawaitable(result):
|
||||
return await result
|
||||
return result
|
||||
async def invoke() -> Any:
|
||||
self.relay.get_scope_stack()
|
||||
result = callback(*args, **kwargs)
|
||||
if inspect.isawaitable(result):
|
||||
return await result
|
||||
return result
|
||||
|
||||
task = context.run(asyncio.create_task, invoke())
|
||||
return await task
|
||||
task = context.run(asyncio.create_task, invoke())
|
||||
return await task
|
||||
finally:
|
||||
self._end_operation()
|
||||
|
||||
def _begin_operation(self) -> None:
|
||||
"""Admit one Relay call while keeping process plugins alive."""
|
||||
with self._sessions_lock:
|
||||
if self._closing:
|
||||
raise RuntimeError("Hermes Relay runtime is shutting down")
|
||||
self._active_operations += 1
|
||||
self._operations_idle.clear()
|
||||
|
||||
def _end_operation(self) -> None:
|
||||
with self._sessions_lock:
|
||||
self._active_operations -= 1
|
||||
if self._active_operations == 0:
|
||||
self._operations_idle.set()
|
||||
|
||||
def acquire_operation_lease(self) -> RelayOperationLease:
|
||||
"""Retain plugin lifetime for work that outlives one Relay await."""
|
||||
self._begin_operation()
|
||||
return RelayOperationLease(self)
|
||||
|
||||
def emit_mark(
|
||||
self,
|
||||
@@ -586,6 +901,7 @@ class RelayRuntime:
|
||||
allow_closing: bool = False,
|
||||
failure_label: str = "scope close failed",
|
||||
drain_limit: int = 32,
|
||||
operation_already_held: bool = False,
|
||||
) -> str | None:
|
||||
"""Pop ``handle``, draining orphaned children in the same session context.
|
||||
|
||||
@@ -702,7 +1018,12 @@ class RelayRuntime:
|
||||
error_holder["retry"] = retry_exc
|
||||
|
||||
try:
|
||||
self.run_in_session(
|
||||
run_in_session = (
|
||||
self._run_in_session_untracked
|
||||
if operation_already_held
|
||||
else self.run_in_session
|
||||
)
|
||||
run_in_session(
|
||||
session,
|
||||
close_with_drain,
|
||||
allow_closing=allow_closing,
|
||||
@@ -721,6 +1042,17 @@ class RelayRuntime:
|
||||
|
||||
def close_session(self, event: dict[str, Any]) -> None:
|
||||
"""Close one session scope and remove it from the core registry."""
|
||||
try:
|
||||
self._begin_operation()
|
||||
except RuntimeError:
|
||||
return
|
||||
try:
|
||||
self._close_session(event)
|
||||
finally:
|
||||
self._end_operation()
|
||||
|
||||
def _close_session(self, event: dict[str, Any]) -> None:
|
||||
"""Close one session already admitted by the host lifecycle gate."""
|
||||
session_id = _session_id(event)
|
||||
with self._sessions_lock:
|
||||
session = self._sessions.get(session_id)
|
||||
@@ -741,23 +1073,13 @@ class RelayRuntime:
|
||||
output={},
|
||||
allow_closing=True,
|
||||
failure_label="session scope close failed",
|
||||
operation_already_held=True,
|
||||
)
|
||||
if failure:
|
||||
failures.append(failure)
|
||||
try:
|
||||
try:
|
||||
_scope_op_executor().submit(
|
||||
self.relay.subscribers.flush
|
||||
).result(timeout=_SCOPE_OP_TIMEOUT)
|
||||
except RuntimeError:
|
||||
# Interpreter shutdown: executor refuses new futures; flush
|
||||
# on a bounded exit thread so a wedged pipeline cannot
|
||||
# block process exit.
|
||||
_run_bounded_on_exit_thread(
|
||||
self.relay.subscribers.flush, _SCOPE_OP_TIMEOUT
|
||||
)
|
||||
except Exception as exc:
|
||||
failures.append(f"subscriber flush failed: {exc}")
|
||||
# Subscriber flushing is process-wide and may wait for publications
|
||||
# owned by other sessions. Final plugin teardown flushes once after all
|
||||
# tracked operations drain; doing it here can deadlock an asyncio loop.
|
||||
with self._sessions_lock:
|
||||
if self._sessions.get(session_id) is session:
|
||||
self._sessions.pop(session_id, None)
|
||||
@@ -771,17 +1093,64 @@ class RelayRuntime:
|
||||
)
|
||||
|
||||
def shutdown(self) -> None:
|
||||
"""Close all core-owned Relay session scopes."""
|
||||
"""Close core scopes and release process plugin configuration."""
|
||||
with self._sessions_lock:
|
||||
session_ids = list(self._sessions)
|
||||
for session_id in session_ids:
|
||||
self._safe(self.close_session, {"session_id": session_id})
|
||||
if self._shutdown_registered:
|
||||
if self._shutdown_started:
|
||||
return
|
||||
self._shutdown_started = True
|
||||
self._closing = True
|
||||
has_active_operations = self._active_operations > 0
|
||||
if has_active_operations:
|
||||
thread = threading.Thread(
|
||||
target=self._finish_shutdown_after_operations,
|
||||
name=f"hermes-nemo-relay-shutdown-{self.runtime_id[:8]}",
|
||||
daemon=True,
|
||||
)
|
||||
try:
|
||||
atexit.unregister(self.shutdown)
|
||||
thread.start()
|
||||
except Exception:
|
||||
pass
|
||||
self._shutdown_registered = False
|
||||
with self._sessions_lock:
|
||||
self._shutdown_started = False
|
||||
logger.warning(
|
||||
"Hermes Relay deferred shutdown could not start",
|
||||
exc_info=True,
|
||||
)
|
||||
return
|
||||
self._finish_shutdown()
|
||||
|
||||
def _finish_shutdown_after_operations(self) -> None:
|
||||
self._operations_idle.wait()
|
||||
self._finish_shutdown()
|
||||
|
||||
def _finish_shutdown(self) -> None:
|
||||
try:
|
||||
with self._sessions_lock:
|
||||
session_ids = list(self._sessions)
|
||||
for session_id in session_ids:
|
||||
self._safe(self._close_session, {"session_id": session_id})
|
||||
if self._plugin_configuration_registered:
|
||||
if (
|
||||
self._plugin_configuration_state
|
||||
is _RelayPluginConfigurationState.ACTIVE
|
||||
):
|
||||
self.release_managed_execution(
|
||||
RELAY_PLUGINS_EXECUTION_CONSUMER
|
||||
)
|
||||
_PLUGIN_CONFIGURATION.release(self)
|
||||
self._plugin_configuration_registered = False
|
||||
if self._shutdown_registered:
|
||||
try:
|
||||
atexit.unregister(self.shutdown)
|
||||
except Exception:
|
||||
pass
|
||||
self._shutdown_registered = False
|
||||
except Exception:
|
||||
with self._sessions_lock:
|
||||
self._shutdown_started = False
|
||||
logger.warning("Hermes Relay shutdown failed", exc_info=True)
|
||||
return
|
||||
with self._sessions_lock:
|
||||
self._shutdown_complete.set()
|
||||
|
||||
@staticmethod
|
||||
def _safe(callback: Callable[..., Any], *args: Any, **kwargs: Any) -> Any:
|
||||
@@ -1611,6 +1980,87 @@ def _load_nemo_relay() -> Any:
|
||||
return importlib.import_module("nemo_relay")
|
||||
|
||||
|
||||
def _configured_plugin_inputs(
|
||||
relay: Any,
|
||||
) -> tuple[dict[str, Any], list[Any]] | None:
|
||||
"""Load selected plugin inputs, or return ``None`` when none were selected."""
|
||||
configured = os.environ.get(RELAY_PLUGINS_CONFIG_ENV, "").strip()
|
||||
if not configured:
|
||||
legacy_vars = configured_legacy_relay_env_vars(os.environ)
|
||||
if legacy_vars:
|
||||
logger.warning(
|
||||
"Legacy NeMo Relay exporter variables are set but no %s was "
|
||||
"provided. %s no longer activate Relay exporters; migrate the "
|
||||
"exporter configuration to a Relay plugins.toml file.",
|
||||
RELAY_PLUGINS_CONFIG_ENV,
|
||||
", ".join(legacy_vars),
|
||||
)
|
||||
return None
|
||||
|
||||
config_path = Path(configured).expanduser()
|
||||
try:
|
||||
with config_path.open("rb") as config_file:
|
||||
config = tomllib.load(config_file)
|
||||
if "dynamic_plugins" in config:
|
||||
raise ValueError(
|
||||
"Hermes [[dynamic_plugins]] records are unsupported; use Relay "
|
||||
"[[plugins.dynamic]] records"
|
||||
)
|
||||
dynamic_plugins: list[Any] = []
|
||||
if "plugins" in config:
|
||||
dynamic_plugins = relay.plugin.load_dynamic_plugin_activation_specs(
|
||||
config_path
|
||||
)
|
||||
plugin_config = dict(config)
|
||||
plugin_config.pop("plugins", None)
|
||||
return plugin_config, dynamic_plugins
|
||||
except Exception as exc:
|
||||
raise _RelayPluginConfigurationLoadError(
|
||||
"Hermes Relay plugin configuration could not be loaded from "
|
||||
f"{config_path}; continuing without Relay plugins"
|
||||
) from exc
|
||||
|
||||
|
||||
def _flush_relay_subscribers(relay: Any) -> None:
|
||||
"""Flush Relay without blocking an asyncio event-loop thread."""
|
||||
_resolve_plugin_awaitable(relay.subscribers.flush_async())
|
||||
|
||||
|
||||
def _clear_relay_plugins(relay: Any) -> None:
|
||||
"""Clear Relay plugins without blocking an asyncio event-loop thread."""
|
||||
_resolve_plugin_awaitable(relay.plugin.clear_async())
|
||||
|
||||
|
||||
def _resolve_plugin_awaitable(value: Any) -> Any:
|
||||
"""Resolve Relay's async plugin API from synchronous host construction."""
|
||||
if not inspect.isawaitable(value):
|
||||
return value
|
||||
try:
|
||||
asyncio.get_running_loop()
|
||||
except RuntimeError:
|
||||
return asyncio.run(value)
|
||||
|
||||
result: dict[str, Any] = {}
|
||||
error: dict[str, BaseException] = {}
|
||||
|
||||
def _runner() -> None:
|
||||
try:
|
||||
result["value"] = asyncio.run(value)
|
||||
except BaseException as exc: # pragma: no cover - re-raised below
|
||||
error["exc"] = exc
|
||||
|
||||
thread = threading.Thread(
|
||||
target=_runner,
|
||||
name="hermes-nemo-relay-plugin-lifecycle",
|
||||
daemon=True,
|
||||
)
|
||||
thread.start()
|
||||
thread.join()
|
||||
if "exc" in error:
|
||||
raise error["exc"]
|
||||
return result.get("value")
|
||||
|
||||
|
||||
def _session_id(event: dict[str, Any]) -> str:
|
||||
return str(event.get("session_id") or "")
|
||||
|
||||
@@ -1619,4 +2069,5 @@ def _reset_for_tests() -> None:
|
||||
"""Reset all profile-scoped Relay hosts for isolated tests."""
|
||||
SESSION_COORDINATOR._reset_active_turns_for_tests()
|
||||
HOST_REGISTRY.shutdown_all()
|
||||
_PLUGIN_CONFIGURATION.reset_for_tests()
|
||||
_PROFILE_KEY_CACHE.clear()
|
||||
|
||||
+45
-14
@@ -8,6 +8,7 @@ import json
|
||||
import logging
|
||||
import os
|
||||
import re
|
||||
import threading
|
||||
from pathlib import Path
|
||||
from typing import Any, Dict, Optional
|
||||
|
||||
@@ -24,6 +25,10 @@ logger = logging.getLogger(__name__)
|
||||
_skill_commands: Dict[str, Dict[str, Any]] = {}
|
||||
_skill_commands_platform: Optional[str] = None
|
||||
_skill_commands_home: Optional[str] = None
|
||||
# Guards the (map, platform-tag, home-tag) triple so publication and the
|
||||
# freshness lookup always see a consistent snapshot. Scanning itself stays
|
||||
# outside this lock.
|
||||
_publish_lock = threading.Lock()
|
||||
# Patterns for sanitizing skill names into clean hyphen-separated slugs.
|
||||
_SKILL_INVALID_CHARS = re.compile(r"[^a-z0-9-]")
|
||||
_SKILL_MULTI_HYPHEN = re.compile(r"-{2,}")
|
||||
@@ -423,9 +428,15 @@ def scan_skill_commands() -> Dict[str, Dict[str, Any]]:
|
||||
Dict mapping "/skill-name" to {name, description, skill_md_path, skill_dir}.
|
||||
"""
|
||||
global _skill_commands, _skill_commands_platform, _skill_commands_home
|
||||
_skill_commands_platform = _resolve_skill_commands_platform()
|
||||
_skill_commands_home = _resolve_skill_commands_home()
|
||||
_skill_commands = {}
|
||||
platform = _resolve_skill_commands_platform()
|
||||
home = _resolve_skill_commands_home()
|
||||
# Build into a local map and publish once, at the end. Writing straight
|
||||
# into the global made a scan's partial results visible to everything
|
||||
# else in the process: a second, overlapping scan deduped against its own
|
||||
# (empty) ``seen_names`` but collided against the first scan's already-
|
||||
# published slugs, logging one bogus "already claimed" warning per skill —
|
||||
# each naming the same skill as its own incumbent (#74574).
|
||||
commands: Dict[str, Dict[str, Any]] = {}
|
||||
try:
|
||||
from tools.skills_tool import SKILLS_DIR, _parse_frontmatter, skill_matches_platform, skill_matches_environment, _get_disabled_skill_names
|
||||
from agent.skill_utils import (
|
||||
@@ -505,14 +516,14 @@ def scan_skill_commands() -> Dict[str, Dict[str, Any]]:
|
||||
# slug (e.g. "git_helper" vs "git-helper"). First-wins
|
||||
# preserves local-before-external precedence.
|
||||
cmd_key = f"/{cmd_name}"
|
||||
if cmd_key in _skill_commands:
|
||||
if cmd_key in commands:
|
||||
logger.warning(
|
||||
"Skill %r maps to slash command %s already claimed "
|
||||
"by %r; keeping the first and skipping this one.",
|
||||
name, cmd_key, _skill_commands[cmd_key]["name"],
|
||||
name, cmd_key, commands[cmd_key]["name"],
|
||||
)
|
||||
continue
|
||||
_skill_commands[cmd_key] = {
|
||||
commands[cmd_key] = {
|
||||
"name": name,
|
||||
"description": description or f"Invoke the {name} skill",
|
||||
"skill_md_path": str(skill_md),
|
||||
@@ -522,7 +533,18 @@ def scan_skill_commands() -> Dict[str, Dict[str, Any]]:
|
||||
continue
|
||||
except Exception:
|
||||
pass
|
||||
return _skill_commands
|
||||
# Publish the finished map and the platform/home it was scanned for as
|
||||
# ONE step. Bare assignments are not atomic together: a reader landing
|
||||
# between them sees the NEW map still carrying the OLD platform tag, and
|
||||
# if that stale tag happens to match its own platform it accepts the map
|
||||
# without rescanning — serving another platform's disabled-skill view,
|
||||
# exactly the leak #14536 closed. Only the publish/lookup pair is locked;
|
||||
# the scan above (file I/O, deferred imports) stays outside it.
|
||||
with _publish_lock:
|
||||
_skill_commands = commands
|
||||
_skill_commands_platform = platform
|
||||
_skill_commands_home = home
|
||||
return commands
|
||||
|
||||
|
||||
def get_skill_commands() -> Dict[str, Dict[str, Any]]:
|
||||
@@ -534,13 +556,22 @@ def get_skill_commands() -> Dict[str, Dict[str, Any]]:
|
||||
active profile's Hermes home changes (e.g. Desktop switching profiles
|
||||
mid-session) so each profile sees its own ``skills.external_dirs`` (#88023).
|
||||
"""
|
||||
if (
|
||||
not _skill_commands
|
||||
or _skill_commands_platform != _resolve_skill_commands_platform()
|
||||
or _skill_commands_home != _resolve_skill_commands_home()
|
||||
):
|
||||
scan_skill_commands()
|
||||
return _skill_commands
|
||||
current_platform = _resolve_skill_commands_platform()
|
||||
current_home = _resolve_skill_commands_home()
|
||||
# Read the map and its tags under the same lock that publishes them, so
|
||||
# the freshness decision is made against a consistent snapshot.
|
||||
with _publish_lock:
|
||||
commands = _skill_commands
|
||||
is_fresh = (
|
||||
bool(commands)
|
||||
and _skill_commands_platform == current_platform
|
||||
and _skill_commands_home == current_home
|
||||
)
|
||||
if is_fresh:
|
||||
return commands
|
||||
# Scan outside the lock — it does file I/O and deferred imports, and
|
||||
# concurrent scans are already safe (each builds its own map).
|
||||
return scan_skill_commands()
|
||||
|
||||
|
||||
def reload_skills() -> Dict[str, Any]:
|
||||
|
||||
+46
-8
@@ -33,10 +33,12 @@ from typing import Any, Dict, List, Optional
|
||||
|
||||
from agent.prompt_builder import (
|
||||
DEFAULT_AGENT_IDENTITY,
|
||||
EXECUTION_GUIDANCE_MODELS,
|
||||
GOOGLE_MODEL_OPERATIONAL_GUIDANCE,
|
||||
HERMES_AGENT_HELP_GUIDANCE,
|
||||
KANBAN_GUIDANCE,
|
||||
MEMORY_GUIDANCE,
|
||||
USER_PROFILE_GUIDANCE,
|
||||
OPENAI_MODEL_EXECUTION_GUIDANCE,
|
||||
PARALLEL_TOOL_CALL_GUIDANCE,
|
||||
PLATFORM_HINTS,
|
||||
@@ -414,8 +416,21 @@ def build_system_prompt_parts(agent: Any, system_message: Optional[str] = None)
|
||||
|
||||
# Tool-aware behavioral guidance: only inject when the tools are loaded
|
||||
tool_guidance = []
|
||||
# MEMORY_GUIDANCE instructs the model to save facts to the built-in
|
||||
# MEMORY.md/USER.md stores. With both disabled in config no store is built,
|
||||
# so the guidance would steer the model at a tool whose every call returns
|
||||
# "Memory is not available". Defaults to True for the rare code paths that
|
||||
# build an agent view without going through agent_init.
|
||||
# When only the user profile store is enabled, the narrower
|
||||
# USER_PROFILE_GUIDANCE is injected instead — the full block instructs the
|
||||
# model to write notes to a MEMORY.md store that does not exist.
|
||||
_mem_enabled = getattr(agent, "_memory_enabled", True)
|
||||
_profile_enabled = getattr(agent, "_user_profile_enabled", True)
|
||||
if "memory" in agent.valid_tool_names:
|
||||
tool_guidance.append(MEMORY_GUIDANCE)
|
||||
if _mem_enabled:
|
||||
tool_guidance.append(MEMORY_GUIDANCE)
|
||||
elif _profile_enabled:
|
||||
tool_guidance.append(USER_PROFILE_GUIDANCE)
|
||||
if "session_search" in agent.valid_tool_names:
|
||||
tool_guidance.append(SESSION_SEARCH_GUIDANCE)
|
||||
if "skill_manage" in agent.valid_tool_names:
|
||||
@@ -477,13 +492,36 @@ def build_system_prompt_parts(agent: Any, system_message: Optional[str] = None)
|
||||
# paths, parallel tool calls, verify-before-edit, etc.)
|
||||
if "gemini" in _model_lower or "gemma" in _model_lower:
|
||||
stable_parts.append(GOOGLE_MODEL_OPERATIONAL_GUIDANCE)
|
||||
# OpenAI GPT/Codex execution discipline (tool persistence,
|
||||
# prerequisite checks, verification, anti-hallucination).
|
||||
# Also applied to xAI Grok — same failure modes (claims completion
|
||||
# without tool calls, suggests workarounds instead of using
|
||||
# existing tools, replies with plans instead of executing).
|
||||
if "gpt" in _model_lower or "codex" in _model_lower or "grok" in _model_lower:
|
||||
stable_parts.append(OPENAI_MODEL_EXECUTION_GUIDANCE)
|
||||
|
||||
# Execution-discipline guidance (tool persistence, mandatory tool use
|
||||
# for arithmetic, external-write read-back, count reconciliation,
|
||||
# literal preservation, verification-gated completion). Historically
|
||||
# nested inside the tool-use-enforcement branch and fenced to
|
||||
# gpt/codex/grok; now an independent gate so DeepSeek/Kimi/Qwen-class
|
||||
# models receive it even when tool_use_enforcement is off. Controlled
|
||||
# by config.yaml agent.execution_guidance:
|
||||
# "auto" (default) — matches EXECUTION_GUIDANCE_MODELS
|
||||
# true — always inject (all models)
|
||||
# false — never inject
|
||||
# list — custom model-name substrings to match
|
||||
# Resolved once at session start keyed on the (fixed) model name, so
|
||||
# the system prompt stays byte-stable for the life of the conversation.
|
||||
if agent.valid_tool_names:
|
||||
_exec_guidance = getattr(agent, "_execution_guidance", "auto")
|
||||
_exec_inject = False
|
||||
if _exec_guidance is True or (isinstance(_exec_guidance, str) and _exec_guidance.lower() in {"true", "always", "yes", "on"}):
|
||||
_exec_inject = True
|
||||
elif _exec_guidance is False or (isinstance(_exec_guidance, str) and _exec_guidance.lower() in {"false", "never", "no", "off"}):
|
||||
_exec_inject = False
|
||||
elif isinstance(_exec_guidance, list):
|
||||
model_lower = (agent.model or "").lower()
|
||||
_exec_inject = any(p.lower() in model_lower for p in _exec_guidance if isinstance(p, str))
|
||||
else:
|
||||
# "auto" or any unrecognised value — use hardcoded defaults
|
||||
model_lower = (agent.model or "").lower()
|
||||
_exec_inject = any(p in model_lower for p in EXECUTION_GUIDANCE_MODELS)
|
||||
if _exec_inject:
|
||||
stable_parts.append(OPENAI_MODEL_EXECUTION_GUIDANCE)
|
||||
|
||||
has_skills_tools = any(name in agent.valid_tool_names for name in ['skills_list', 'skill_view', 'skill_manage'])
|
||||
if has_skills_tools:
|
||||
|
||||
@@ -557,7 +557,11 @@ def make_tool_result_message(
|
||||
The outer list itself is rebuilt rather than returned by identity, so
|
||||
callers should compare by value, not by ``is``.
|
||||
"""
|
||||
wrapped = _maybe_wrap_untrusted(name, content)
|
||||
# Order matters: detect provider-side elision on the RAW content and
|
||||
# append the notice first, THEN wrap — so the notice lives inside the
|
||||
# untrusted block next to the data it describes, appended exactly once
|
||||
# at construction time (cache-safe).
|
||||
wrapped = _maybe_wrap_untrusted(name, _maybe_append_elision_notice(name, content))
|
||||
message = stamp_message_timestamp({
|
||||
"role": "tool",
|
||||
"name": name,
|
||||
@@ -608,6 +612,70 @@ def _is_untrusted_tool(name: Optional[str]) -> bool:
|
||||
return any(name.startswith(p) for p in _UNTRUSTED_TOOL_PREFIXES)
|
||||
|
||||
|
||||
# --- Upstream-elision detection --------------------------------------------
|
||||
#
|
||||
# Some MCP servers elide data SERVER-SIDE and mark the elision inside the
|
||||
# payload itself (e.g. Composio: '...13 more items' inside a JSON array,
|
||||
# '"has_more": true', 'Complete response was large (N tokens). Full data
|
||||
# saved to sandbox in /mnt/files/...', 'data_preview' envelopes). Because the
|
||||
# result looks structurally complete, models treat the visible slice as the
|
||||
# whole dataset and falsely claim completeness. When one of these markers is
|
||||
# present, we append ONE compact notice at result-construction time — before
|
||||
# the message enters history, never mutated later, so prompt caching is safe.
|
||||
|
||||
# Conservative patterns only: each one is an explicit provider-side "there is
|
||||
# more data than what you can see" signal, not a generic truncation heuristic.
|
||||
_UPSTREAM_ELISION_PATTERNS = (
|
||||
re.compile(r"\.\.\.\s*\d+\s+more\s+items?", re.IGNORECASE),
|
||||
re.compile(r'"has_more"\s*:\s*true', re.IGNORECASE),
|
||||
re.compile(r"saved to sandbox", re.IGNORECASE),
|
||||
re.compile(r"data_preview", re.IGNORECASE),
|
||||
)
|
||||
|
||||
# Results smaller than this can't meaningfully hide an elided enumeration —
|
||||
# skip the scan entirely so tiny results pay nothing.
|
||||
_ELISION_SCAN_MIN_CHARS = 1_000
|
||||
|
||||
# Bound the regex scan: markers appear near the elided structure, which for
|
||||
# the payload sizes that matter (20-50K) is always inside the first 64KB.
|
||||
_ELISION_SCAN_MAX_CHARS = 65_536
|
||||
|
||||
_UPSTREAM_ELISION_NOTICE = (
|
||||
'\n[hermes note: this result contains provider-side elision markers '
|
||||
'(e.g. "...N more items" / has_more:true). The data shown is INCOMPLETE '
|
||||
'— page/fetch the remainder before treating any enumeration as complete.]'
|
||||
)
|
||||
|
||||
|
||||
def _detect_upstream_elision(content: Any) -> bool:
|
||||
"""True when a string tool result carries provider-side elision markers.
|
||||
|
||||
Cheap and safe by construction: non-string content is never scanned,
|
||||
results under ``_ELISION_SCAN_MIN_CHARS`` short-circuit, and the regex
|
||||
scan is capped at the first ``_ELISION_SCAN_MAX_CHARS`` chars.
|
||||
"""
|
||||
if not isinstance(content, str):
|
||||
return False
|
||||
if len(content) < _ELISION_SCAN_MIN_CHARS:
|
||||
return False
|
||||
window = content[:_ELISION_SCAN_MAX_CHARS]
|
||||
return any(p.search(window) for p in _UPSTREAM_ELISION_PATTERNS)
|
||||
|
||||
|
||||
def _maybe_append_elision_notice(name: str, content: Any) -> Any:
|
||||
"""Append the incompleteness notice to untrusted string results that
|
||||
embed upstream elision markers. Returns ``content`` unchanged otherwise.
|
||||
|
||||
Runs on the RAW result before untrusted-wrapping so the notice sits with
|
||||
the data it describes, and only at result-construction time (cache-safe).
|
||||
"""
|
||||
if not _is_untrusted_tool(name):
|
||||
return content
|
||||
if _detect_upstream_elision(content):
|
||||
return content + _UPSTREAM_ELISION_NOTICE
|
||||
return content
|
||||
|
||||
|
||||
def _tool_output_risk_metadata(name: str, content: Any) -> Optional[Dict[str, Any]]:
|
||||
"""Classify textual attacker-controlled output without retaining a copy.
|
||||
|
||||
@@ -729,5 +797,7 @@ __all__ = [
|
||||
"_extract_landed_file_mutation_paths",
|
||||
"_extract_error_preview",
|
||||
"_trajectory_normalize_msg",
|
||||
"_detect_upstream_elision",
|
||||
"_maybe_append_elision_notice",
|
||||
"make_tool_result_message",
|
||||
]
|
||||
|
||||
+78
-1
@@ -48,12 +48,31 @@ from tools.thread_context import propagate_context_to_thread
|
||||
from tools.tool_result_storage import (
|
||||
maybe_persist_tool_result,
|
||||
enforce_turn_budget,
|
||||
extract_persisted_path,
|
||||
)
|
||||
from tools.budget_config import BudgetConfig, DEFAULT_BUDGET, budget_for_context_window
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
def _record_persisted_path_for_stub(agent, tool_call_id: str, function_result) -> None:
|
||||
"""Tell the stall guards where a persisted result's full content lives.
|
||||
|
||||
When a large result is spilled to disk (<persisted-output> preview), a
|
||||
later result-reference stub pointing at that first occurrence must carry
|
||||
the spillover file path so the reference can't dangle. Best-effort: never
|
||||
lets bookkeeping break tool execution.
|
||||
"""
|
||||
try:
|
||||
if not isinstance(function_result, str):
|
||||
return
|
||||
path = extract_persisted_path(function_result)
|
||||
if path:
|
||||
agent._tool_guardrails.record_persisted_result(tool_call_id, path)
|
||||
except Exception as exc:
|
||||
logger.debug("persisted-path record for result stub failed: %s", exc)
|
||||
|
||||
|
||||
def _ensure_file_checkpoint(
|
||||
agent,
|
||||
function_name: str,
|
||||
@@ -87,7 +106,10 @@ def _budget_for_agent(agent) -> BudgetConfig:
|
||||
"""
|
||||
try:
|
||||
ctx = getattr(getattr(agent, "context_compressor", None), "context_length", None)
|
||||
return budget_for_context_window(int(ctx)) if ctx else DEFAULT_BUDGET
|
||||
# budget_for_context_window(None) (rather than DEFAULT_BUDGET) so the
|
||||
# config-driven MCP threshold override still applies when the context
|
||||
# length isn't resolvable.
|
||||
return budget_for_context_window(int(ctx) if ctx else None)
|
||||
except Exception:
|
||||
return DEFAULT_BUDGET
|
||||
|
||||
@@ -1730,6 +1752,7 @@ def execute_tool_calls_concurrent(agent, assistant_message, messages: list, effe
|
||||
function_args,
|
||||
function_result,
|
||||
failed=is_error,
|
||||
tool_call_id=getattr(tc, "id", "") or "",
|
||||
)
|
||||
|
||||
if is_error:
|
||||
@@ -1764,6 +1787,7 @@ def execute_tool_calls_concurrent(agent, assistant_message, messages: list, effe
|
||||
env=get_active_env(effective_task_id),
|
||||
config=_tool_budget,
|
||||
) if not _is_multimodal_tool_result(function_result) else function_result
|
||||
_record_persisted_path_for_stub(agent, tc.id, function_result)
|
||||
|
||||
subdir_hints = agent._subdirectory_hints.check_tool_call(name, args)
|
||||
if subdir_hints:
|
||||
@@ -2178,6 +2202,57 @@ def execute_tool_calls_sequential(agent, assistant_message, messages: list, effe
|
||||
tool_duration = time.time() - tool_start_time
|
||||
if agent._should_emit_quiet_tool_messages():
|
||||
agent._vprint(f" {_get_cute_tool_message_impl('read_preview', function_args, tool_duration, result=function_result)}")
|
||||
elif function_name == "drive_preview":
|
||||
def _execute(next_args: dict) -> Any:
|
||||
from tools.drive_preview_tool import drive_preview_tool as _drive_preview_tool
|
||||
return _drive_preview_tool(
|
||||
action=next_args.get("action", ""),
|
||||
ref=next_args.get("ref"),
|
||||
selector=next_args.get("selector"),
|
||||
text=next_args.get("text"),
|
||||
key=next_args.get("key"),
|
||||
submit=next_args.get("submit"),
|
||||
amount=next_args.get("amount"),
|
||||
to=next_args.get("to"),
|
||||
limit=next_args.get("max"),
|
||||
callback=getattr(agent, "drive_preview_callback", None),
|
||||
)
|
||||
function_result, function_args, middleware_trace, _execution_blocked, _execution_dispatched = _managed_values(_run_agent_tool_execution_middleware(
|
||||
agent,
|
||||
function_name=function_name,
|
||||
function_args=function_args,
|
||||
effective_task_id=effective_task_id,
|
||||
tool_call_id=getattr(tool_call, "id", "") or "",
|
||||
execute=_execute,
|
||||
scope_block=_ts_scope_block,
|
||||
display_index=i,
|
||||
))
|
||||
tool_duration = time.time() - tool_start_time
|
||||
if agent._should_emit_quiet_tool_messages():
|
||||
agent._vprint(f" {_get_cute_tool_message_impl('drive_preview', function_args, tool_duration, result=function_result)}")
|
||||
elif function_name == "annotate_preview":
|
||||
def _execute(next_args: dict) -> Any:
|
||||
from tools.annotate_preview_tool import annotate_preview_tool as _annotate_preview_tool
|
||||
return _annotate_preview_tool(
|
||||
action=next_args.get("action", "add"),
|
||||
ref=next_args.get("ref"),
|
||||
selector=next_args.get("selector"),
|
||||
label=next_args.get("label"),
|
||||
callback=getattr(agent, "drive_preview_callback", None),
|
||||
)
|
||||
function_result, function_args, middleware_trace, _execution_blocked, _execution_dispatched = _managed_values(_run_agent_tool_execution_middleware(
|
||||
agent,
|
||||
function_name=function_name,
|
||||
function_args=function_args,
|
||||
effective_task_id=effective_task_id,
|
||||
tool_call_id=getattr(tool_call, "id", "") or "",
|
||||
execute=_execute,
|
||||
scope_block=_ts_scope_block,
|
||||
display_index=i,
|
||||
))
|
||||
tool_duration = time.time() - tool_start_time
|
||||
if agent._should_emit_quiet_tool_messages():
|
||||
agent._vprint(f" {_get_cute_tool_message_impl('annotate_preview', function_args, tool_duration, result=function_result)}")
|
||||
elif function_name == "read_window_below":
|
||||
def _execute(next_args: dict) -> Any:
|
||||
from tools.read_window_tool import read_window_below_tool as _read_window_below_tool
|
||||
@@ -2569,6 +2644,7 @@ def execute_tool_calls_sequential(agent, assistant_message, messages: list, effe
|
||||
function_args,
|
||||
function_result,
|
||||
failed=_is_error_result,
|
||||
tool_call_id=getattr(tool_call, "id", "") or "",
|
||||
)
|
||||
result_preview = function_result if agent.verbose_logging else (
|
||||
function_result[:200] if len(function_result) > 200 else function_result
|
||||
@@ -2607,6 +2683,7 @@ def execute_tool_calls_sequential(agent, assistant_message, messages: list, effe
|
||||
env=get_active_env(effective_task_id),
|
||||
config=_tool_budget,
|
||||
) if not _is_multimodal_tool_result(function_result) else function_result
|
||||
_record_persisted_path_for_stub(agent, tool_call.id, function_result)
|
||||
|
||||
# Discover subdirectory context files from tool arguments
|
||||
subdir_hints = agent._subdirectory_hints.check_tool_call(function_name, function_args)
|
||||
|
||||
@@ -59,6 +59,52 @@ MUTATING_TOOL_NAMES = frozenset(
|
||||
}
|
||||
)
|
||||
|
||||
# Tools that are legitimately re-invoked with identical arguments and may
|
||||
# legitimately return an unchanged result while waiting on external progress —
|
||||
# background-process management and job pollers. The identical-call loop
|
||||
# notice (agent.stall_guards) never fires for these, so polling patterns like
|
||||
# ``process(action="poll")`` or repeatedly checking a generation job stay
|
||||
# unannotated.
|
||||
STALL_GUARD_REPEATABLE_TOOLS = frozenset(
|
||||
{
|
||||
"process",
|
||||
"bfl_flux3_get_result",
|
||||
}
|
||||
)
|
||||
|
||||
# Poller naming conventions (e.g. ``<vendor>_get_result``) used by generated /
|
||||
# MCP tool surfaces. Matched as suffixes so vendor-prefixed pollers are exempt
|
||||
# without enumerating every vendor.
|
||||
_STALL_GUARD_REPEATABLE_SUFFIXES = (
|
||||
"_get_result",
|
||||
"_poll",
|
||||
)
|
||||
|
||||
# The notice fires on the Nth consecutive identical call (same tool, same
|
||||
# canonical args, same result). 3 tolerates one legitimate double-check while
|
||||
# catching the observed re-issue loops (3x/4x identical calls in eval traces).
|
||||
STALL_GUARD_IDENTICAL_CALL_THRESHOLD = 3
|
||||
|
||||
# Result-reference stubbing (agent.stall_guards): from the 2nd consecutive
|
||||
# identical call whose FRESH result is byte-identical to the previous one,
|
||||
# the duplicate payload is replaced in context by a short reference stub.
|
||||
# Results under this size aren't worth stubbing (the stub itself plus the
|
||||
# lost locality outweigh the savings), and error results are never stubbed
|
||||
# (the model must see every fresh error verbatim).
|
||||
IDENTICAL_RESULT_STUB_MIN_CHARS = 512
|
||||
|
||||
# How much of the canonical args JSON the stub carries so the model still
|
||||
# knows WHAT the referenced call was even if context compression later
|
||||
# evicts the referenced result (cheap dangling-reference mitigation).
|
||||
_RESULT_STUB_ARGS_PREVIEW_CHARS = 120
|
||||
|
||||
|
||||
def is_stall_guard_repeatable(tool_name: str) -> bool:
|
||||
"""Whether a tool is exempt from the identical-call loop notice."""
|
||||
if tool_name in STALL_GUARD_REPEATABLE_TOOLS:
|
||||
return True
|
||||
return tool_name.endswith(_STALL_GUARD_REPEATABLE_SUFFIXES)
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class ToolCallGuardrailConfig:
|
||||
@@ -173,6 +219,21 @@ class LoopCapConfig:
|
||||
)
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class IdenticalCallObservation:
|
||||
"""Outcome of observing one completed tool call for the stall guards.
|
||||
|
||||
``notice`` is the identical-call loop-breaker notice (appended after the
|
||||
result). ``stub`` is the result-reference replacement for a byte-identical
|
||||
duplicate result (replaces the result content). Both may be set on the
|
||||
same call (3rd+ identical call): the stub replaces the payload and the
|
||||
notice is appended after it.
|
||||
"""
|
||||
|
||||
notice: str | None = None
|
||||
stub: str | None = None
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class ToolCallSignature:
|
||||
"""Stable, non-reversible identity for a tool name plus canonical args."""
|
||||
@@ -282,6 +343,26 @@ class ToolCallGuardrailController:
|
||||
self._same_tool_failure_counts: dict[str, int] = {}
|
||||
self._no_progress: dict[ToolCallSignature, tuple[str, int]] = {}
|
||||
self._halt_decision: ToolGuardrailDecision | None = None
|
||||
# Identical-call loop-breaker state (agent.stall_guards): tracks the
|
||||
# CONSECUTIVE streak of identical (tool, canonical args) calls whose
|
||||
# results were also identical. Any different call — or a different
|
||||
# result — resets the streak, so legitimate re-reads after edits and
|
||||
# varied polling are never flagged. Per-turn, like everything else here.
|
||||
# NOTE: open PR #85352 (patrykkopycinski) tracks no-progress loops
|
||||
# ACROSS turns via a detection window — a different mechanism from
|
||||
# this per-turn consecutive streak. Coordinate future work there.
|
||||
self._identical_streak_sig: ToolCallSignature | None = None
|
||||
self._identical_streak_result_hash: str = ""
|
||||
self._identical_streak_count: int = 0
|
||||
# tool_call_id of the FIRST call in the current streak, so a
|
||||
# result-reference stub can point at the message that carries the
|
||||
# full payload.
|
||||
self._identical_streak_first_call_id: str = ""
|
||||
# tool_call_id -> spillover file path for results that were persisted
|
||||
# out of context (persisted-output preview). Lets a reference stub
|
||||
# carry the file path so the reference can't dangle when the first
|
||||
# occurrence entered context as a preview.
|
||||
self._persisted_result_paths: dict[str, str] = {}
|
||||
# Per-turn runaway-loop cap counters. Reset every turn (this method
|
||||
# runs at the start of each run_conversation), so the caps bound a
|
||||
# single agent loop rather than accumulating across the session.
|
||||
@@ -444,6 +525,138 @@ class ToolCallGuardrailController:
|
||||
return False
|
||||
return tool_name in self.config.idempotent_tools
|
||||
|
||||
def observe_identical_call(
|
||||
self,
|
||||
tool_name: str,
|
||||
args: Mapping[str, Any] | None,
|
||||
result: str | None,
|
||||
) -> str | None:
|
||||
"""Track consecutive identical calls; return a loop-breaker notice or None.
|
||||
|
||||
Back-compat wrapper around :meth:`observe_call` for callers that only
|
||||
care about the loop-breaker notice.
|
||||
"""
|
||||
return self.observe_call(tool_name, args, result).notice
|
||||
|
||||
def observe_call(
|
||||
self,
|
||||
tool_name: str,
|
||||
args: Mapping[str, Any] | None,
|
||||
result: str | None,
|
||||
*,
|
||||
tool_call_id: str = "",
|
||||
failed: bool = False,
|
||||
) -> "IdenticalCallObservation":
|
||||
"""Track consecutive identical calls; return notice + dedupe stub info.
|
||||
|
||||
Two independent outputs from the same consecutive-streak tracker:
|
||||
|
||||
- ``notice``: the compact loop-breaker notice, fired when the SAME
|
||||
tool is called with identical canonical arguments AND returns an
|
||||
identical result for the ``STALL_GUARD_IDENTICAL_CALL_THRESHOLD``-th
|
||||
(and every subsequent) consecutive time within the turn. Purely
|
||||
observational — never blocks the call. Allowlisted pollers
|
||||
(``is_stall_guard_repeatable``) are exempt from the NOTICE.
|
||||
- ``stub``: a short reference replacement for the CURRENT result,
|
||||
produced from the 2nd consecutive identical call whose fresh result
|
||||
is byte-identical to the previous one. The tool still executed —
|
||||
only the context representation is deduplicated, so polling
|
||||
semantics are preserved (a changed result flows through whole and
|
||||
resets the streak). Pollers are NOT exempt from stubbing: for a
|
||||
poller, an identical result means nothing changed, which is exactly
|
||||
when the stub saves the most context and loses nothing. Results
|
||||
under ``IDENTICAL_RESULT_STUB_MIN_CHARS`` and failed/error results
|
||||
are never stubbed, and only plain-string results are considered.
|
||||
|
||||
Any intervening different call or changed result resets the streak.
|
||||
Callers substitute/append at tool RESULT construction time, which is
|
||||
cache-safe: tool results are append-only and never mutate
|
||||
already-sent context.
|
||||
"""
|
||||
is_plain_str = isinstance(result, str)
|
||||
signature = ToolCallSignature.from_call(tool_name, _coerce_args(args))
|
||||
result_hash = _result_hash(result) if is_plain_str else ""
|
||||
|
||||
if (
|
||||
is_plain_str
|
||||
and self._identical_streak_sig == signature
|
||||
and self._identical_streak_result_hash == result_hash
|
||||
):
|
||||
self._identical_streak_count += 1
|
||||
else:
|
||||
# New streak (or non-string result, which never forms a streak —
|
||||
# multimodal content lists pass through untouched).
|
||||
self._identical_streak_sig = signature if is_plain_str else None
|
||||
self._identical_streak_result_hash = result_hash
|
||||
self._identical_streak_count = 1 if is_plain_str else 0
|
||||
self._identical_streak_first_call_id = tool_call_id or ""
|
||||
|
||||
count = self._identical_streak_count
|
||||
|
||||
notice = None
|
||||
if (
|
||||
not is_stall_guard_repeatable(tool_name)
|
||||
and count >= STALL_GUARD_IDENTICAL_CALL_THRESHOLD
|
||||
):
|
||||
ordinal = f"{count}{'th' if 11 <= count % 100 <= 13 else {1: 'st', 2: 'nd', 3: 'rd'}.get(count % 10, 'th')}"
|
||||
notice = (
|
||||
f"[hermes note: this is the {ordinal} consecutive identical call to "
|
||||
f"{tool_name} with identical arguments returning the same result. "
|
||||
"Do not repeat it — change arguments, use a different tool, or "
|
||||
"proceed with what you have.]"
|
||||
)
|
||||
|
||||
stub = None
|
||||
if (
|
||||
is_plain_str
|
||||
and count >= 2
|
||||
and not failed
|
||||
and len(result) >= IDENTICAL_RESULT_STUB_MIN_CHARS
|
||||
):
|
||||
stub = self._build_result_reference_stub(tool_name, args)
|
||||
|
||||
return IdenticalCallObservation(notice=notice, stub=stub)
|
||||
|
||||
def record_persisted_result(self, tool_call_id: str, file_path: str) -> None:
|
||||
"""Remember the spillover path a persisted result was saved to.
|
||||
|
||||
When the first occurrence of a result entered context as a
|
||||
persisted-output preview, a later reference stub must carry the
|
||||
spillover file path so the reference can't dangle.
|
||||
"""
|
||||
if tool_call_id and file_path:
|
||||
self._persisted_result_paths[tool_call_id] = file_path
|
||||
|
||||
def _build_result_reference_stub(
|
||||
self, tool_name: str, args: Mapping[str, Any] | None
|
||||
) -> str:
|
||||
"""Build the reference stub replacing a byte-identical duplicate result.
|
||||
|
||||
Carries the tool name + a canonical-args preview so that even if
|
||||
context compression later evicts the referenced result, the model
|
||||
still knows WHAT the call was (cheap dangling-reference mitigation).
|
||||
"""
|
||||
try:
|
||||
args_preview = canonical_tool_args(_coerce_args(args))
|
||||
except TypeError:
|
||||
args_preview = "{}"
|
||||
if len(args_preview) > _RESULT_STUB_ARGS_PREVIEW_CHARS:
|
||||
args_preview = args_preview[:_RESULT_STUB_ARGS_PREVIEW_CHARS] + "…"
|
||||
first_id = self._identical_streak_first_call_id
|
||||
ref = f" (tool_call_id {first_id})" if first_id else ""
|
||||
stub = (
|
||||
f"[hermes note: this result is byte-identical to the {tool_name} "
|
||||
f"result earlier this turn{ref}. Refer to that result; it has not "
|
||||
f"changed. Args: {args_preview}]"
|
||||
)
|
||||
spill_path = self._persisted_result_paths.get(first_id) if first_id else None
|
||||
if spill_path:
|
||||
stub += (
|
||||
f"\n[The referenced result was persisted to: {spill_path} — "
|
||||
"page through it with read_file if you need the full content.]"
|
||||
)
|
||||
return stub
|
||||
|
||||
def _check_loop_cap(
|
||||
self,
|
||||
tool_name: str,
|
||||
|
||||
@@ -13,6 +13,15 @@ import json
|
||||
from typing import Any, Dict
|
||||
|
||||
from agent.lmstudio_reasoning import resolve_lmstudio_effort
|
||||
from agent.reasoning_effort import (
|
||||
KIMI_K3_EFFORTS,
|
||||
KIMI_K3_OVERRIDES,
|
||||
OPENAI_COMPAT_WIRE_EFFORTS,
|
||||
TOKENHUB_EFFORTS,
|
||||
clamp_effort,
|
||||
kimi_supported_efforts,
|
||||
requested_effort,
|
||||
)
|
||||
from agent.moonshot_schema import is_moonshot_model, sanitize_moonshot_tools
|
||||
from agent.prompt_builder import DEVELOPER_ROLE_MODELS
|
||||
from agent.transports.base import ProviderTransport
|
||||
@@ -84,15 +93,25 @@ def _add_prompt_cache_key(
|
||||
|
||||
|
||||
def _reasoning_config_for_model(model: str, reasoning_config: dict | None) -> dict | None:
|
||||
"""Return the model's wire-compatible reasoning config."""
|
||||
"""Return the model's wire-compatible reasoning config.
|
||||
|
||||
Hermes' internal effort set extends the wire vocabulary with ``ultra``
|
||||
(the /reasoning command documents none..xhigh|max|ultra). OpenAI-
|
||||
compatible wires — OpenRouter chief among them — accept exactly
|
||||
max|xhigh|high|medium|low|minimal|none and reject the extension with
|
||||
HTTP 400 (#89503). Clamp against the declared wire vocabulary via the
|
||||
shared policy in ``agent.reasoning_effort``; provider profiles with
|
||||
narrower sets clamp again downstream.
|
||||
"""
|
||||
if not isinstance(reasoning_config, dict):
|
||||
return reasoning_config
|
||||
if (
|
||||
"gpt-5.6" in (model or "").lower()
|
||||
and str(reasoning_config.get("effort") or "").strip().lower() == "ultra"
|
||||
):
|
||||
effort = str(reasoning_config.get("effort") or "").strip().lower()
|
||||
if not effort:
|
||||
return reasoning_config
|
||||
clamped = clamp_effort(effort, OPENAI_COMPAT_WIRE_EFFORTS)
|
||||
if clamped != effort:
|
||||
normalized = dict(reasoning_config)
|
||||
normalized["effort"] = "max"
|
||||
normalized["effort"] = clamped
|
||||
return normalized
|
||||
return reasoning_config
|
||||
|
||||
@@ -559,11 +578,22 @@ class ChatCompletionsTransport(ProviderTransport):
|
||||
and reasoning_config.get("enabled") is False
|
||||
)
|
||||
if not _kimi_thinking_off:
|
||||
_kimi_effort = "medium"
|
||||
if reasoning_config and isinstance(reasoning_config, dict):
|
||||
_e = (reasoning_config.get("effort") or "").strip().lower()
|
||||
if _e in {"low", "medium", "high"}:
|
||||
_kimi_effort = _e
|
||||
# Kimi vocabularies are declared in agent.reasoning_effort:
|
||||
# K3 = low/high/max (with the vendor-documented medium→high,
|
||||
# xhigh→max rounding), K2-era = low/medium/high. Default when
|
||||
# no effort was requested: K3's server default is high,
|
||||
# K2-era's is medium.
|
||||
_supported = kimi_supported_efforts(model)
|
||||
_overrides = (
|
||||
KIMI_K3_OVERRIDES if _supported is KIMI_K3_EFFORTS else None
|
||||
)
|
||||
_e = requested_effort(reasoning_config)
|
||||
if _e is None:
|
||||
_kimi_effort = (
|
||||
"high" if _supported is KIMI_K3_EFFORTS else "medium"
|
||||
)
|
||||
else:
|
||||
_kimi_effort = clamp_effort(_e, _supported, _overrides)
|
||||
api_kwargs["reasoning_effort"] = _kimi_effort
|
||||
|
||||
# Tencent TokenHub: top-level reasoning_effort (unless thinking disabled)
|
||||
@@ -574,11 +604,13 @@ class ChatCompletionsTransport(ProviderTransport):
|
||||
and reasoning_config.get("enabled") is False
|
||||
)
|
||||
if not _tokenhub_thinking_off:
|
||||
_tokenhub_effort = "high"
|
||||
if reasoning_config and isinstance(reasoning_config, dict):
|
||||
_e = (reasoning_config.get("effort") or "").strip().lower()
|
||||
if _e in {"low", "medium", "high"}:
|
||||
_tokenhub_effort = _e
|
||||
# TokenHub accepts low/medium/high (declared in
|
||||
# agent.reasoning_effort); default high when no effort was
|
||||
# requested.
|
||||
_e = requested_effort(reasoning_config)
|
||||
_tokenhub_effort = (
|
||||
"high" if _e is None else clamp_effort(_e, TOKENHUB_EFFORTS)
|
||||
)
|
||||
api_kwargs["reasoning_effort"] = _tokenhub_effort
|
||||
|
||||
# LM Studio: top-level reasoning_effort. Only emit when the model
|
||||
|
||||
+29
-21
@@ -27,6 +27,13 @@ def _cache_scope_from_session_id(session_id: Optional[str]) -> str:
|
||||
match = _CRON_SESSION_ID_RE.match(sid)
|
||||
return match.group(1) if match else sid
|
||||
|
||||
from agent.reasoning_effort import (
|
||||
ACTUAL_RELAY_EFFORTS,
|
||||
XAI_GROK46_EFFORTS,
|
||||
XAI_LEGACY_EFFORTS,
|
||||
clamp_effort,
|
||||
codex_supported_efforts,
|
||||
)
|
||||
from agent.transports.base import ProviderTransport
|
||||
from agent.transports.types import NormalizedResponse, ToolCall
|
||||
|
||||
@@ -432,30 +439,31 @@ class ResponsesApiTransport(ProviderTransport):
|
||||
elif reasoning_config.get("effort"):
|
||||
reasoning_effort = reasoning_config["effort"]
|
||||
|
||||
_effort_clamp = {"minimal": "low"}
|
||||
if "gpt-5.6" in (model or "").lower():
|
||||
# Ultra is the Codex product tier; the Responses API wire value is max.
|
||||
_effort_clamp["ultra"] = "max"
|
||||
# Wire vocabularies are declared in agent.reasoning_effort; the shared
|
||||
# clamp policy (nearest weaker supported level, never escalate,
|
||||
# never invert the ladder) replaces the per-backend hand maps that
|
||||
# repeatedly leaked internal levels like "ultra" to the wire
|
||||
# (#89503 class) or clamped one rung below a model's real ceiling
|
||||
# (#87279).
|
||||
if params.get("is_xai_responses", False):
|
||||
from agent.model_metadata import is_grok_46_family
|
||||
|
||||
# Grok 4.6 accepts xhigh as a wire value; older Grok models top
|
||||
# out at high. max/ultra are Hermes ladder aliases for "this
|
||||
# model's ceiling", so they clamp to the strongest level the
|
||||
# model actually accepts — xhigh on grok-4.6, high elsewhere —
|
||||
# never one rung below it (#87279).
|
||||
if is_grok_46_family(model):
|
||||
_effort_clamp.update({"max": "xhigh", "ultra": "xhigh"})
|
||||
else:
|
||||
_effort_clamp["xhigh"] = "high"
|
||||
_effort_clamp.update({"max": "high", "ultra": "high"})
|
||||
if (params.get("provider") or "").strip().lower() == "actual":
|
||||
# Actual Computer relays to SGLang/vLLM backends that accept only
|
||||
# none/low/medium/high/max for reasoning effort — a forwarded
|
||||
# xhigh/ultra fails with a wrapped HTTP 400 ("Expecting value:
|
||||
# line 1 column 1"). Clamp Hermes' wider set to the supported one.
|
||||
_effort_clamp.update({"xhigh": "high", "ultra": "max"})
|
||||
reasoning_effort = _effort_clamp.get(reasoning_effort, reasoning_effort)
|
||||
# Grok 4.6 accepts xhigh as a wire value; older Grok tops out
|
||||
# at high.
|
||||
_supported = (
|
||||
XAI_GROK46_EFFORTS if is_grok_46_family(model)
|
||||
else XAI_LEGACY_EFFORTS
|
||||
)
|
||||
elif (params.get("provider") or "").strip().lower() == "actual":
|
||||
# Actual Computer relays to SGLang/vLLM backends:
|
||||
# none/low/medium/high/max.
|
||||
_supported = ACTUAL_RELAY_EFFORTS
|
||||
else:
|
||||
# OpenAI/Codex Responses backend — per-model vocabulary
|
||||
# (live-verified: "max" is gpt-5.6-only, "minimal" always
|
||||
# rejected). #68365 premise confirmed.
|
||||
_supported = codex_supported_efforts(model)
|
||||
reasoning_effort = clamp_effort(reasoning_effort, _supported)
|
||||
|
||||
response_tools = _responses_tools(tools)
|
||||
|
||||
|
||||
@@ -605,6 +605,15 @@ def build_turn_context(
|
||||
# NOTE: _turns_since_memory and _iters_since_skill are NOT reset here.
|
||||
agent.iteration_budget = IterationBudget(agent.max_iterations)
|
||||
|
||||
# Wall-clock run budget: per-run_conversation clock. Only stamped when a
|
||||
# budget is configured so the default path stays clock-free; the wrap-up
|
||||
# latch resets each turn (one notice per run, not per session).
|
||||
if getattr(agent, "run_budget_seconds", None):
|
||||
agent._run_budget_started_at = time.time()
|
||||
else:
|
||||
agent._run_budget_started_at = None
|
||||
agent._run_budget_wrapup_injected = False
|
||||
|
||||
# Log conversation turn start for debugging/observability.
|
||||
_preview_text = summarize_user_message_for_log(user_message)
|
||||
_msg_preview = (_preview_text[:80] + "...") if len(_preview_text) > 80 else _preview_text
|
||||
@@ -1154,6 +1163,57 @@ def build_turn_context(
|
||||
agent._last_content_with_tools = None
|
||||
agent._last_content_tools_all_housekeeping = False
|
||||
agent._mute_post_response = False
|
||||
elif not agent.compression_enabled:
|
||||
# Uncompressed session guard (#89297): when compression is explicitly
|
||||
# disabled, sessions can grow past the model's context window across
|
||||
# hundreds of messages with nothing to shrink them. The warning itself
|
||||
# fires from the conversation loop's pre-API site, which reuses the
|
||||
# unconditionally computed request estimate at zero marginal cost and
|
||||
# covers both turn-start and mid-turn growth (every provider request
|
||||
# passes through it). Here we only RE-ARM the dedup once the session
|
||||
# is back under the window, so the guard can warn again after the
|
||||
# user compacts (/compress with force=True works with compression
|
||||
# disabled) and the context later regrows past the limit.
|
||||
_ctx_len = getattr(
|
||||
getattr(agent, "context_compressor", None), "context_length", None
|
||||
)
|
||||
if isinstance(_ctx_len, int) and _ctx_len > 0:
|
||||
_raw_chars = 0
|
||||
for _m in messages:
|
||||
if not isinstance(_m, dict):
|
||||
continue
|
||||
_c = _m.get("content")
|
||||
if isinstance(_c, str):
|
||||
_raw_chars += len(_c)
|
||||
elif _c:
|
||||
# Non-string, non-empty content (multimodal part lists,
|
||||
# dict payloads) defeats a char count — force the real
|
||||
# estimate by treating it as over-gate. None/"" (routine
|
||||
# assistant tool-call rows) contribute nothing.
|
||||
_raw_chars = _ctx_len + 1
|
||||
break
|
||||
# Cheap gate: a session whose raw text is under ~1/4 of the
|
||||
# window (4 chars/token upper bound) cannot be over it — skip
|
||||
# the estimator. Non-string (multimodal) content defeats a char
|
||||
# count, so any such message forces the real estimate.
|
||||
if _raw_chars <= _ctx_len:
|
||||
_clear_warn = getattr(
|
||||
agent, "_clear_context_overflow_warn", None
|
||||
)
|
||||
if callable(_clear_warn):
|
||||
_clear_warn()
|
||||
else:
|
||||
_uncompressed_tokens = estimate_request_tokens_rough(
|
||||
messages,
|
||||
system_prompt=active_system_prompt or "",
|
||||
tools=agent.tools or None,
|
||||
)
|
||||
if _uncompressed_tokens <= _ctx_len:
|
||||
_clear_warn = getattr(
|
||||
agent, "_clear_context_overflow_warn", None
|
||||
)
|
||||
if callable(_clear_warn):
|
||||
_clear_warn()
|
||||
|
||||
if _preflight_compressed:
|
||||
# Compression rebuilt the list (tail messages are fresh compaction
|
||||
|
||||
@@ -132,6 +132,18 @@ def get_active_provider() -> Optional[VideoGenProvider]:
|
||||
except Exception as exc:
|
||||
logger.debug("Could not read video_gen.provider from config: %s", exc)
|
||||
|
||||
# The managed "Nous Subscription" selection is serviced by the FAL
|
||||
# plugin through the managed fal-queue gateway (the plugin's resolver
|
||||
# routes managed when the stored selection is "nous").
|
||||
if configured:
|
||||
try:
|
||||
from tools.tool_backend_helpers import NOUS_MANAGED_PROVIDER
|
||||
|
||||
if configured.lower() == NOUS_MANAGED_PROVIDER:
|
||||
configured = "fal"
|
||||
except Exception: # pragma: no cover — helpers are in-repo
|
||||
pass
|
||||
|
||||
with _lock:
|
||||
snapshot = dict(_providers)
|
||||
snapshot.update(_scoped_providers.get(hermes_home_key(), {}))
|
||||
|
||||
@@ -126,6 +126,22 @@ class WebSearchProvider(abc.ABC):
|
||||
"""Return True if this provider implements :meth:`search`."""
|
||||
return True
|
||||
|
||||
def is_keyless_available(self) -> bool:
|
||||
"""Return True when this provider can serve calls WITHOUT credentials.
|
||||
|
||||
A separate, weaker tier than :meth:`is_available`: providers with a
|
||||
public anonymous free tier (Exa / Parallel MCP endpoints) return
|
||||
True here so the registry can fall back to them when NO provider is
|
||||
configured or keyed — and only then. Keyless availability must never
|
||||
make :meth:`is_available` return True, or the legacy preference walk
|
||||
would route users with real credentials for a lower-priority backend
|
||||
onto the free tier of a higher-priority one.
|
||||
|
||||
Like :meth:`is_available`, this must be cheap and must NOT make
|
||||
network calls. Default: False.
|
||||
"""
|
||||
return False
|
||||
|
||||
def supports_extract(self) -> bool:
|
||||
"""Return True if this provider implements :meth:`extract`.
|
||||
|
||||
|
||||
@@ -166,6 +166,44 @@ _LEGACY_PREFERENCE = (
|
||||
"ddgs",
|
||||
)
|
||||
|
||||
# Keyless free-tier walk — strictly LAST-resort, tried only after the
|
||||
# availability-filtered legacy walk finds nothing (i.e. the user has zero
|
||||
# web credentials and no importable ddgs). All five vendors expose public
|
||||
# anonymous free tiers (see plugins/web/keyless_mcp.py). Unpinned keyless
|
||||
# traffic round-robins across the ring per request (the ring cursor lives
|
||||
# in keyless_mcp; an explicit `hermes tools` pick bypasses this walk
|
||||
# entirely, and rate-limited requests fail over to the next ring vendor).
|
||||
# Disable the tier with ``web.keyless_fallback: false``.
|
||||
_KEYLESS_PREFERENCE = (
|
||||
"exa",
|
||||
"parallel",
|
||||
"tavily",
|
||||
"firecrawl",
|
||||
"keenable",
|
||||
)
|
||||
|
||||
|
||||
def _keyless_preference() -> tuple:
|
||||
"""Return the keyless walk order for resolution.
|
||||
|
||||
Delegates the entry-vendor choice to the ring cursor in
|
||||
:mod:`plugins.web.keyless_mcp` (round-robin per request, seeded by the
|
||||
per-process random session id) so resolution and dispatch agree on
|
||||
which vendor a fresh install starts at. The remaining vendors follow
|
||||
in ring order as fallbacks for registration gaps.
|
||||
"""
|
||||
try:
|
||||
from plugins.web.keyless_mcp import _KEYLESS_RING, _ring_cursor
|
||||
|
||||
start = _ring_cursor % len(_KEYLESS_RING)
|
||||
return tuple(
|
||||
_KEYLESS_RING[(start + i) % len(_KEYLESS_RING)]
|
||||
for i in range(len(_KEYLESS_RING))
|
||||
)
|
||||
except Exception as exc: # noqa: BLE001 — ring optional in stripped envs
|
||||
logger.debug("keyless ring order unavailable: %s", exc)
|
||||
return _KEYLESS_PREFERENCE
|
||||
|
||||
|
||||
def _resolve(configured: Optional[str], *, capability: str) -> Optional[WebSearchProvider]:
|
||||
"""Resolve the active provider for a capability ("search" | "extract").
|
||||
@@ -254,9 +292,39 @@ def _resolve(configured: Optional[str], *, capability: str) -> Optional[WebSearc
|
||||
):
|
||||
return provider
|
||||
|
||||
# 4. Keyless free-tier walk — the user has NO credentialed/importable
|
||||
# backend at all. Fall back to providers that can serve anonymously
|
||||
# (public MCP free tiers), unless disabled via
|
||||
# ``web.keyless_fallback: false``. This tier never pre-empts a keyed
|
||||
# setup: it is only reachable when the legacy walk found nothing.
|
||||
if _keyless_tier_enabled():
|
||||
for name in _keyless_preference():
|
||||
provider = snapshot.get(name)
|
||||
if provider is None or not _capable(provider):
|
||||
continue
|
||||
try:
|
||||
if provider.is_keyless_available():
|
||||
return provider
|
||||
except Exception as exc: # noqa: BLE001 — buggy provider skipped
|
||||
logger.debug(
|
||||
"provider %s.is_keyless_available() raised %s", name, exc
|
||||
)
|
||||
|
||||
return None
|
||||
|
||||
|
||||
def _keyless_tier_enabled() -> bool:
|
||||
"""Read ``web.keyless_fallback`` from config.yaml (default: enabled)."""
|
||||
try:
|
||||
from hermes_cli.config import load_config
|
||||
|
||||
web_cfg = load_config().get("web") or {}
|
||||
return bool(web_cfg.get("keyless_fallback", True))
|
||||
except Exception as exc: # noqa: BLE001 — config layer optional
|
||||
logger.debug("keyless_fallback config read failed: %s", exc)
|
||||
return True
|
||||
|
||||
|
||||
def _disabled_web_plugin_for(configured: Optional[str] = None, *, capability: Optional[str] = None) -> Optional[str]:
|
||||
"""Return the plugin key of a *disabled* bundled web plugin that would
|
||||
have provided the configured backend, or None.
|
||||
|
||||
+17
-1
@@ -151,6 +151,12 @@ Notes:
|
||||
- SVGs inherit `size-3.5` (`size-3` at `xs`). Don't re-set icon size.
|
||||
- Polymorph with `asChild` when the button must render as a link/Slot.
|
||||
|
||||
## Badges — one component
|
||||
|
||||
`src/components/ui/badge.tsx`. Variants: `default` (tinted primary), `muted`,
|
||||
`warn`, `destructive`, `outline`, `solid` (primary fill — icon-corner counts).
|
||||
Sizes: `default`, `xs`, `overlay` (titlebar glyph counts).
|
||||
|
||||
## Form controls
|
||||
|
||||
- **`controlVariants`** (`src/components/ui/control.ts`) is the shared shape for
|
||||
@@ -190,6 +196,15 @@ Notes:
|
||||
- **Empty:** `EmptyState` for plain page bodies; `PanelEmpty` for overlay
|
||||
master/detail empties with an icon and action. Don't hand-roll a third
|
||||
centered empty.
|
||||
- **Confirmation:** `ConfirmDialog` is the only way we ask "are you sure". It
|
||||
opens focused on Confirm, so `Enter` confirms and `Esc` cancels, and it owns
|
||||
the pending → done → close beat and the inline error — a call site passes an
|
||||
async `onConfirm` and nothing else. A third way out (e.g. "Remove from
|
||||
sidebar" beside "Delete worktree") goes in the one `secondaryAction` slot.
|
||||
Never `window.confirm`: it's an unstyled blocking Chromium modal. A handler
|
||||
that wants the answer inline instead of a mounted dialog calls `confirm()`
|
||||
from `src/store/confirm.ts`, which renders this same primitive through the
|
||||
single `ConfirmHost` at the shell — the way `notify()` backs notifications.
|
||||
|
||||
## Chat, tools & boot surfaces
|
||||
|
||||
@@ -315,7 +330,8 @@ The detailed state contract lives in the scoped
|
||||
## Before you add something — checklist
|
||||
|
||||
- [ ] Reuse a primitive (`Button`, `SearchField`, `SegmentedControl`,
|
||||
`ListRow`, `Loader`, `ErrorState`, `LogView`) instead of forking one?
|
||||
`ListRow`, `Loader`, `ErrorState`, `LogView`, `ConfirmDialog`) instead of
|
||||
forking one?
|
||||
- [ ] Tokens (`--ui-*`, `shadow-nous`, `--stroke-nous`) — zero raw colors /
|
||||
one-off shadows?
|
||||
- [ ] No `className` overriding a primitive's padding / size / radius / chrome?
|
||||
|
||||
@@ -284,3 +284,72 @@ test('shutdown coordinator returns one promise and awaits teardown exactly once'
|
||||
assert.equal(finished, true)
|
||||
assert.equal(coordinator.run(), first)
|
||||
})
|
||||
|
||||
// #89298: a corrupt ownership file must never be silently rewritten as [] —
|
||||
// that permanently erases the only record of still-running backends. The reap
|
||||
// sweep quarantines the file and skips; a later healthy write recreates it.
|
||||
test('reapOrphans on a corrupt file quarantines and does not rewrite', async () => {
|
||||
let contents = '{ this is not json'
|
||||
let quarantined = 0
|
||||
const writes: string[] = []
|
||||
const stopped: number[] = []
|
||||
|
||||
const store = {
|
||||
read: () => contents,
|
||||
value: () => contents,
|
||||
write: (next: string) => {
|
||||
writes.push(next)
|
||||
contents = next
|
||||
},
|
||||
quarantine: () => {
|
||||
quarantined += 1
|
||||
}
|
||||
}
|
||||
|
||||
const ownership = createOwnership(store, {
|
||||
stop: identityArg => {
|
||||
stopped.push(identityArg.pid)
|
||||
}
|
||||
})
|
||||
|
||||
assert.deepEqual(await ownership.reapOrphans(), [])
|
||||
assert.equal(quarantined, 1)
|
||||
assert.deepEqual(writes, [])
|
||||
assert.deepEqual(stopped, [])
|
||||
})
|
||||
|
||||
test('reapOrphans on a corrupt file without a quarantine hook still skips the rewrite', async () => {
|
||||
const writes: string[] = []
|
||||
|
||||
const store = {
|
||||
read: () => 'garbage{{{',
|
||||
value: () => 'garbage{{{',
|
||||
write: (next: string) => {
|
||||
writes.push(next)
|
||||
}
|
||||
}
|
||||
|
||||
const ownership = createOwnership(store)
|
||||
|
||||
assert.deepEqual(await ownership.reapOrphans(), [])
|
||||
assert.deepEqual(writes, [])
|
||||
})
|
||||
|
||||
test('an empty or missing ownership file is NOT corrupt — reap sweeps normally', async () => {
|
||||
const writes: string[] = []
|
||||
|
||||
const store = {
|
||||
read: () => '',
|
||||
value: () => '',
|
||||
write: (next: string) => {
|
||||
writes.push(next)
|
||||
},
|
||||
quarantine: () => assert.fail('empty file must not be quarantined')
|
||||
}
|
||||
|
||||
const ownership = createOwnership(store)
|
||||
|
||||
assert.deepEqual(await ownership.reapOrphans(), [])
|
||||
// Empty roster: rewriting [] is harmless and keeps the legacy behavior.
|
||||
assert.equal(writes.length, 1)
|
||||
})
|
||||
|
||||
@@ -16,6 +16,10 @@ export interface BackendOwnershipEntry extends BackendIdentity {
|
||||
export interface BackendOwnershipStore {
|
||||
read: () => string | null
|
||||
write: (contents: string) => void
|
||||
/** Move an unreadable ownership file aside (e.g. rename to `.corrupt`) so
|
||||
* its contents survive for inspection instead of being rewritten away.
|
||||
* Optional: stores that can't quarantine simply skip the sweep. */
|
||||
quarantine?: () => void
|
||||
}
|
||||
|
||||
export interface BackendOwnershipDeps {
|
||||
@@ -62,12 +66,30 @@ function identitiesMatch(left: BackendIdentity, right: BackendIdentity): boolean
|
||||
}
|
||||
|
||||
export function parseBackendOwnership(contents: unknown): BackendOwnershipEntry[] {
|
||||
return parseBackendOwnershipDetailed(contents).entries
|
||||
}
|
||||
|
||||
/** Parse result that distinguishes "empty/valid" from "unreadable". A corrupt
|
||||
* ownership file must NOT read as an empty roster: `reapOrphans` rewrites the
|
||||
* file with its survivors, so treating garbage as `[]` permanently erased the
|
||||
* records of still-running backends — the exact shape of the #89298 report
|
||||
* (ownership file gone, 28 leaked serve processes nothing will ever reap). */
|
||||
export function parseBackendOwnershipDetailed(contents: unknown): {
|
||||
corrupt: boolean
|
||||
entries: BackendOwnershipEntry[]
|
||||
} {
|
||||
const text = String(contents ?? '')
|
||||
|
||||
if (!text.trim()) {
|
||||
return { corrupt: false, entries: [] }
|
||||
}
|
||||
|
||||
let parsed: unknown
|
||||
|
||||
try {
|
||||
parsed = JSON.parse(String(contents ?? ''))
|
||||
parsed = JSON.parse(text)
|
||||
} catch {
|
||||
return []
|
||||
return { corrupt: true, entries: [] }
|
||||
}
|
||||
|
||||
const values = Array.isArray(parsed)
|
||||
@@ -109,7 +131,7 @@ export function parseBackendOwnership(contents: unknown): BackendOwnershipEntry[
|
||||
}
|
||||
}
|
||||
|
||||
return entries
|
||||
return { corrupt: false, entries }
|
||||
}
|
||||
|
||||
export function serializeBackendOwnership(entries: BackendOwnershipEntry[]): string {
|
||||
@@ -123,7 +145,8 @@ export function serializeBackendOwnership(entries: BackendOwnershipEntry[]): str
|
||||
* cleanup before reporting failure to the caller.
|
||||
*/
|
||||
export function createBackendOwnership(deps: BackendOwnershipDeps) {
|
||||
const read = () => parseBackendOwnership(deps.store.read())
|
||||
const readDetailed = () => parseBackendOwnershipDetailed(deps.store.read())
|
||||
const read = () => readDetailed().entries
|
||||
const write = (entries: BackendOwnershipEntry[]) => deps.store.write(serializeBackendOwnership(entries))
|
||||
|
||||
return {
|
||||
@@ -181,7 +204,22 @@ export function createBackendOwnership(deps: BackendOwnershipDeps) {
|
||||
},
|
||||
|
||||
async reapOrphans(): Promise<number[]> {
|
||||
const entries = read()
|
||||
const { corrupt, entries } = readDetailed()
|
||||
|
||||
// An unreadable ownership file yields zero parsed entries — rewriting
|
||||
// survivors ([]) here would DESTROY the only record of any backends the
|
||||
// corrupt file described, guaranteeing they leak forever (#89298).
|
||||
// Preserve the evidence for inspection and skip the sweep.
|
||||
if (corrupt) {
|
||||
try {
|
||||
deps.store.quarantine?.()
|
||||
} catch {
|
||||
// Quarantine is best-effort; the important part is not rewriting.
|
||||
}
|
||||
|
||||
return []
|
||||
}
|
||||
|
||||
const survivors: BackendOwnershipEntry[] = []
|
||||
const reaped: number[] = []
|
||||
|
||||
|
||||
@@ -3,8 +3,10 @@ import assert from 'node:assert/strict'
|
||||
import { test } from 'vitest'
|
||||
|
||||
import {
|
||||
isHostKeyChangedBootFailure,
|
||||
isRetryableRemoteBootFailure,
|
||||
shouldLatchBackendStartFailure,
|
||||
shouldLatchHostKeyChangedFailure,
|
||||
shouldLatchRemoteReauthFailure
|
||||
} from './backend-start-failure'
|
||||
|
||||
@@ -81,3 +83,53 @@ test('retryable and reauth-latch are mutually exclusive for remote failures', ()
|
||||
assert.equal(retry !== latch, true, `remote failure with reauth=${isReauth} must pick exactly one path`)
|
||||
}
|
||||
})
|
||||
|
||||
test('FIX host-key change: classified from the kind tag and from stringified ssh banners', () => {
|
||||
// classifySshError tags the Error it built; errors that crossed an IPC or
|
||||
// string boundary only keep the message. Both shapes must classify.
|
||||
const tagged = Object.assign(new Error('SSH refused to connect.'), { kind: 'host-key-changed' })
|
||||
assert.equal(isHostKeyChangedBootFailure(tagged), true)
|
||||
assert.equal(
|
||||
isHostKeyChangedBootFailure(new Error('@@@@ WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED! @@@@')),
|
||||
true
|
||||
)
|
||||
assert.equal(isHostKeyChangedBootFailure(new Error('Host key verification failed.')), true)
|
||||
assert.equal(
|
||||
isHostKeyChangedBootFailure(new Error('The host key for root@203.0.113.7 has CHANGED since you last connected.')),
|
||||
true
|
||||
)
|
||||
assert.equal(isHostKeyChangedBootFailure(new Error('Connection refused')), false)
|
||||
assert.equal(isHostKeyChangedBootFailure(null), false)
|
||||
})
|
||||
|
||||
test('FIX host-key change: latches and is never auto-retried (157-failure loop, Aug 2026 bundle)', () => {
|
||||
// SSH fails closed on a changed host key: every retry re-drives the same
|
||||
// doomed boot until the user clears known_hosts. Terminal, like reauth.
|
||||
const context = { attemptedRemote: true, isReauth: false, isHostKeyChanged: true }
|
||||
assert.equal(shouldLatchHostKeyChangedFailure(context), true)
|
||||
assert.equal(isRetryableRemoteBootFailure(context), false)
|
||||
})
|
||||
|
||||
test('host-key latch never fires for local failures or ordinary remote faults', () => {
|
||||
assert.equal(
|
||||
shouldLatchHostKeyChangedFailure({ attemptedRemote: false, isReauth: false, isHostKeyChanged: true }),
|
||||
false
|
||||
)
|
||||
assert.equal(
|
||||
shouldLatchHostKeyChangedFailure({ attemptedRemote: true, isReauth: false, isHostKeyChanged: false }),
|
||||
false
|
||||
)
|
||||
assert.equal(shouldLatchHostKeyChangedFailure({ attemptedRemote: true, isReauth: false }), false)
|
||||
})
|
||||
|
||||
test('every remote failure picks exactly one path: retry, reauth latch, or host-key latch', () => {
|
||||
for (const isReauth of [true, false]) {
|
||||
for (const isHostKeyChanged of [true, false]) {
|
||||
const retry = isRetryableRemoteBootFailure({ attemptedRemote: true, isReauth, isHostKeyChanged })
|
||||
const reauth = shouldLatchRemoteReauthFailure({ attemptedRemote: true, isReauth })
|
||||
const hostKey = shouldLatchHostKeyChangedFailure({ attemptedRemote: true, isReauth, isHostKeyChanged })
|
||||
const picked = [retry, reauth, hostKey].filter(Boolean).length
|
||||
assert.ok(picked >= 1, `remote failure reauth=${isReauth} hostKey=${isHostKeyChanged} fell through every path`)
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
@@ -79,6 +79,44 @@ export interface RemoteBootRetryContext {
|
||||
* never self-heal without the user signing in again.
|
||||
*/
|
||||
isReauth: boolean
|
||||
/**
|
||||
* True when SSH refused to connect because the host's key CHANGED
|
||||
* (StrictHostKeyChecking fails closed). Retrying cannot succeed until the
|
||||
* user verifies the change and removes the stale known_hosts entry, so this
|
||||
* is terminal like a reauth rejection — not connectivity.
|
||||
*/
|
||||
isHostKeyChanged?: boolean
|
||||
}
|
||||
|
||||
/**
|
||||
* A host-key-change refusal is identifiable both by the `kind` tag
|
||||
* classifySshError puts on the error and — for errors that crossed a
|
||||
* stringifying boundary — by the stable phrases ssh/our own message carry.
|
||||
* One user hit 157 consecutive boot-retry failures over 2.5h against a
|
||||
* reinstalled VPS (Aug 2026 bundle) because this was classified as transient.
|
||||
*/
|
||||
export function isHostKeyChangedBootFailure(error: unknown): boolean {
|
||||
if ((error as { kind?: string } | null | undefined)?.kind === 'host-key-changed') {
|
||||
return true
|
||||
}
|
||||
|
||||
const message = error instanceof Error ? error.message : String(error ?? '')
|
||||
|
||||
return /REMOTE HOST IDENTIFICATION HAS CHANGED|Host key verification failed|host key for .+ has CHANGED/i.test(
|
||||
message
|
||||
)
|
||||
}
|
||||
|
||||
/**
|
||||
* Whether a failed remote boot should latch (into `backendStartFailure`)
|
||||
* because the host key changed. Same rationale as the reauth latch: the
|
||||
* failure cannot self-heal, and an unlatched terminal failure makes every
|
||||
* recovery surface re-drive the identical doomed boot. The latch is released
|
||||
* by the existing reset/repair/apply-config paths once the user has run
|
||||
* `ssh-keygen -R <host>`.
|
||||
*/
|
||||
export function shouldLatchHostKeyChangedFailure(context: RemoteBootRetryContext): boolean {
|
||||
return context.attemptedRemote && context.isHostKeyChanged === true
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -93,9 +131,10 @@ export interface RemoteBootRetryContext {
|
||||
* only arms after a completed boot, so the app sat on "Desktop boot failed"
|
||||
* until the user manually re-entered the same connection details (which just
|
||||
* forced a fresh bootstrap). A missing capability differs from a transient
|
||||
* failure: confirmed reauth rejections and local failures stay out of the
|
||||
* retry path; everything else remote is connectivity and should retry.
|
||||
* failure: confirmed reauth rejections, host-key changes, and local failures
|
||||
* stay out of the retry path; everything else remote is connectivity and
|
||||
* should retry.
|
||||
*/
|
||||
export function isRetryableRemoteBootFailure(context: RemoteBootRetryContext): boolean {
|
||||
return context.attemptedRemote && !context.isReauth
|
||||
return context.attemptedRemote && !context.isReauth && context.isHostKeyChanged !== true
|
||||
}
|
||||
|
||||
@@ -271,6 +271,28 @@ test('rememberSshEnumeration: live list wins, cache then seed default', () => {
|
||||
})
|
||||
})
|
||||
|
||||
test('rememberSshEnumeration: a bounced remote source keeps its last-known roster (4-bots-show-as-2)', () => {
|
||||
// A VPS restart makes the remote source unreachable for a few polls. The
|
||||
// last successful enumeration must keep painting so the roster does not
|
||||
// silently drop that source's bots mid-outage.
|
||||
assert.deepEqual(
|
||||
rememberSshEnumeration({ profiles: null, error: 'unreachable' }, ['default', 'ceo', 'accounter'], 'remote'),
|
||||
{ profiles: ['default', 'ceo', 'accounter'], error: 'unreachable' }
|
||||
)
|
||||
// Never-seen remote source: no seed — an unreachable URL is not evidence a
|
||||
// backend exists there.
|
||||
assert.deepEqual(rememberSshEnumeration({ profiles: null, error: 'unreachable' }, null, 'remote'), {
|
||||
profiles: null,
|
||||
error: 'unreachable'
|
||||
})
|
||||
// Local enumeration failures never reuse a cache (the local runtime answers
|
||||
// authoritatively or not at all).
|
||||
assert.deepEqual(rememberSshEnumeration({ profiles: null, error: 'boom' }, ['default'], 'local'), {
|
||||
profiles: null,
|
||||
error: 'boom'
|
||||
})
|
||||
})
|
||||
|
||||
test('shouldRetrySshInventory: first try, cooldown, then retry; cache never retries', () => {
|
||||
assert.equal(shouldRetrySshInventory(false, null, 1_000), true)
|
||||
assert.equal(shouldRetrySshInventory(false, 1_000, 30_000, 60_000), false)
|
||||
|
||||
@@ -341,10 +341,15 @@ export interface RosterAgent {
|
||||
}
|
||||
|
||||
/**
|
||||
* SSH roster enumeration skips undialed sources (connect-on-demand). Reuse the
|
||||
* last successful profile list so Bot Mode does not go empty the moment the
|
||||
* window switches back to local. Never-seen SSH sources still get a `default`
|
||||
* seed so the device is clickable.
|
||||
* Roster enumeration skips undialed sources (connect-on-demand) and reports
|
||||
* unreachable ones with `profiles: null`. Reuse the last successful profile
|
||||
* list so Bot Mode does not go empty (or drop to a partial roster) the moment
|
||||
* a source is briefly unreachable — SSH tunnels drop on sleep/wake, and a
|
||||
* remote gateway bounce (VPS restart) otherwise erased its bots from the
|
||||
* roster until the next successful enumeration ("my 4 bots show as 2", Aug
|
||||
* 2026 bundle). Never-seen SSH sources still get a `default` seed so the
|
||||
* device is clickable; never-seen remote sources stay empty (no seed) since
|
||||
* an unreachable URL is not evidence a backend exists there.
|
||||
*/
|
||||
export function rememberSshEnumeration(
|
||||
enumeration: Pick<ConnectionAgents, 'error' | 'profiles'>,
|
||||
@@ -355,7 +360,7 @@ export function rememberSshEnumeration(
|
||||
return enumeration
|
||||
}
|
||||
|
||||
if (kind !== 'ssh') {
|
||||
if (kind === 'local') {
|
||||
return enumeration
|
||||
}
|
||||
|
||||
@@ -363,7 +368,7 @@ export function rememberSshEnumeration(
|
||||
return { profiles: cached, error: enumeration.error }
|
||||
}
|
||||
|
||||
if (enumeration.error === 'connect-on-demand') {
|
||||
if (kind === 'ssh' && enumeration.error === 'connect-on-demand') {
|
||||
return { profiles: ['default'], error: 'connect-on-demand' }
|
||||
}
|
||||
|
||||
|
||||
@@ -4,15 +4,84 @@
|
||||
// latch when handing the session back to the app window.
|
||||
import { type BrowserWindow, ipcMain } from 'electron'
|
||||
|
||||
import { hudFrostFor, type TranslucencyState } from './translucency'
|
||||
|
||||
export interface HudIpcDeps {
|
||||
isMac: boolean
|
||||
isWindows: boolean
|
||||
glassSupported: boolean
|
||||
/** Main's authoritative translucency state (Settings → Appearance). */
|
||||
getTranslucencyState: () => TranslucencyState
|
||||
getHudWindow: () => BrowserWindow | null
|
||||
openHudWindow: (sessionId: null | string, profile: null | string) => void
|
||||
closeHudWindow: () => void
|
||||
setHudSessionId: (sessionId: null | string) => void
|
||||
}
|
||||
|
||||
export function registerHudIpc({ isMac, getHudWindow, openHudWindow, closeHudWindow, setHudSessionId }: HudIpcDeps) {
|
||||
export function registerHudIpc({
|
||||
isMac,
|
||||
isWindows,
|
||||
glassSupported,
|
||||
getTranslucencyState,
|
||||
getHudWindow,
|
||||
openHudWindow,
|
||||
closeHudWindow,
|
||||
setHudSessionId
|
||||
}: HudIpcDeps) {
|
||||
// Whether the band currently covers the window below the bar. The renderer
|
||||
// is the only party that can know this (it measures the transcript), and it
|
||||
// is half of the frost decision — the other half is the user's setting,
|
||||
// which main owns. Latched so a Settings change can re-decide without
|
||||
// waiting for the HUD to report again.
|
||||
let bandShowing = false
|
||||
let applied: null | string = null
|
||||
let appliedTo: BrowserWindow | null = null
|
||||
|
||||
// Real frosted glass behind the band — the thing CSS backdrop-filter cannot do,
|
||||
// because Chromium composites a transparent window's page against nothing and
|
||||
// the desktop is not in its backdrop root. The material IS the window's content
|
||||
// view, so it frosts the whole rectangle; the HUD's layout leaves no dead
|
||||
// margins for that reason, and it only turns on while the band is showing
|
||||
// (idle HUD mode must be the bar and nothing else).
|
||||
//
|
||||
// Diffed before issuing: `setVibrancy` carries a 150ms animation that restarts
|
||||
// if re-issued, so a repeated call would keep the material from ever settling
|
||||
// (the same churn the chat windows' native-diff contract exists to prevent).
|
||||
//
|
||||
// The diff is keyed to the WINDOW as well as the value. A HUD respawn (the
|
||||
// profile switch in openHudWindow destroys and rebuilds it) hands back a
|
||||
// fresh window carrying no material, and a latch that only remembered the
|
||||
// value would recognise its own last answer and skip — leaving the new HUD
|
||||
// unfrosted until something else happened to change the signature.
|
||||
const applyHudFrost = () => {
|
||||
const hudWindow = getHudWindow()
|
||||
|
||||
if (!hudWindow || hudWindow.isDestroyed()) {
|
||||
applied = null
|
||||
appliedTo = null
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
const frost = hudFrostFor(getTranslucencyState(), bandShowing)
|
||||
const signature = `${frost.vibrancy ?? 'off'}:${frost.backgroundMaterial}`
|
||||
|
||||
if (applied === signature && appliedTo === hudWindow) {
|
||||
return
|
||||
}
|
||||
|
||||
applied = signature
|
||||
appliedTo = hudWindow
|
||||
|
||||
if (isMac && typeof hudWindow.setVibrancy === 'function') {
|
||||
hudWindow.setVibrancy(frost.vibrancy)
|
||||
}
|
||||
|
||||
if (isWindows && glassSupported && typeof hudWindow.setBackgroundMaterial === 'function') {
|
||||
hudWindow.setBackgroundMaterial(frost.backgroundMaterial)
|
||||
}
|
||||
}
|
||||
|
||||
ipcMain.handle('hermes:hud:open', async (_event, request) => {
|
||||
openHudWindow(
|
||||
typeof request?.sessionId === 'string' ? request.sessionId : null,
|
||||
@@ -22,18 +91,9 @@ export function registerHudIpc({ isMac, getHudWindow, openHudWindow, closeHudWin
|
||||
return { ok: true }
|
||||
})
|
||||
|
||||
// Real frosted glass behind the band — the thing CSS backdrop-filter cannot do,
|
||||
// because Chromium composites a transparent window's page against nothing and
|
||||
// the desktop is not in its backdrop root. Vibrancy IS the window's content
|
||||
// view, so it frosts the whole rectangle; the HUD's layout leaves no dead
|
||||
// margins for that reason, and the renderer only turns it on while the band is
|
||||
// showing (idle HUD mode must be the bar and nothing else).
|
||||
ipcMain.handle('hermes:hud:vibrancy', (_event, on) => {
|
||||
const hudWindow = getHudWindow()
|
||||
|
||||
if (hudWindow && !hudWindow.isDestroyed() && isMac) {
|
||||
hudWindow.setVibrancy(on ? 'hud' : null)
|
||||
}
|
||||
ipcMain.handle('hermes:hud:frost', (_event, showing) => {
|
||||
bandShowing = Boolean(showing)
|
||||
applyHudFrost()
|
||||
|
||||
return { ok: true }
|
||||
})
|
||||
@@ -125,4 +185,8 @@ export function registerHudIpc({ isMac, getHudWindow, openHudWindow, closeHudWin
|
||||
|
||||
return { ok: true }
|
||||
})
|
||||
|
||||
// Main re-applies the frost when the translucency SETTING changes, since the
|
||||
// band's own report only fires when the band itself moves.
|
||||
return { applyHudFrost }
|
||||
}
|
||||
|
||||
+205
-57
@@ -46,8 +46,10 @@ import {
|
||||
} from './backend-probes'
|
||||
import { waitForDashboardPortAnnouncement } from './backend-ready'
|
||||
import {
|
||||
isHostKeyChangedBootFailure,
|
||||
isRetryableRemoteBootFailure,
|
||||
shouldLatchBackendStartFailure,
|
||||
shouldLatchHostKeyChangedFailure,
|
||||
shouldLatchRemoteReauthFailure
|
||||
} from './backend-start-failure'
|
||||
import {
|
||||
@@ -188,6 +190,7 @@ import { createMediaProtocolHandler, MEDIA_PROTOCOL } from './media-protocol'
|
||||
import {
|
||||
oauthGuardMayHardFail,
|
||||
oauthSessionIsLive,
|
||||
resolveGatedDownloadAuth,
|
||||
resolveJsonBody,
|
||||
resolveOauthRestAuth,
|
||||
resolveReadinessProbeAuth
|
||||
@@ -256,6 +259,7 @@ import {
|
||||
import { missingRendererAssets } from './renderer-bundle'
|
||||
import { attachRendererConsoleCapture, formatRendererBoundaryReport } from './renderer-log'
|
||||
import {
|
||||
buildInstanceWindowUrl,
|
||||
buildSessionWindowUrl,
|
||||
chatWindowWebPreferences,
|
||||
createSessionWindowRegistry,
|
||||
@@ -272,6 +276,7 @@ import { registerTerminalIpc } from './terminal-ipc'
|
||||
import { nativeOverlayWidth as computeNativeOverlayWidth, macTitleBarOverlayHeight } from './titlebar-overlay-width'
|
||||
import {
|
||||
backgroundMaterialFor,
|
||||
defaultTranslucencyState,
|
||||
glassActive,
|
||||
glassSupportedOn,
|
||||
normalizeState as normalizeTranslucency,
|
||||
@@ -877,7 +882,12 @@ function readPersistedTranslucency() {
|
||||
try {
|
||||
return normalizeTranslucency(JSON.parse(fs.readFileSync(TRANSLUCENCY_CONFIG_PATH, 'utf8')), GLASS_SUPPORTED)
|
||||
} catch {
|
||||
return normalizeTranslucency(null, GLASS_SUPPORTED)
|
||||
// Nothing persisted yet — a first launch. Glass ships on, so the FIRST
|
||||
// window has to be created with the glass backing already: a window born
|
||||
// opaque cannot reliably be swapped to glass afterwards (see
|
||||
// windowBackingOptions). nativeTheme is the only appearance signal main
|
||||
// has this early; the renderer's first resolved send corrects it.
|
||||
return defaultTranslucencyState(nativeTheme.shouldUseDarkColors ? 'dark' : 'light', GLASS_SUPPORTED, IS_WINDOWS)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -3260,7 +3270,20 @@ const backendOwnership = createBackendOwnership({
|
||||
return null
|
||||
}
|
||||
},
|
||||
write: writeBackendOwnership
|
||||
write: writeBackendOwnership,
|
||||
// A corrupt ownership file is moved aside instead of being rewritten
|
||||
// away by the reap sweep — its records are the only pointer to any
|
||||
// still-running backends it described (#89298).
|
||||
quarantine: () => {
|
||||
const parked = `${DESKTOP_BACKEND_OWNERSHIP_PATH}.corrupt`
|
||||
|
||||
try {
|
||||
fs.renameSync(DESKTOP_BACKEND_OWNERSHIP_PATH, parked)
|
||||
rememberLog(`Backend ownership file was unreadable; moved to ${parked}`)
|
||||
} catch {
|
||||
// Nothing to move (or no permission) — the sweep already skipped.
|
||||
}
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
@@ -4859,7 +4882,8 @@ function fetchJson(url, token, options: any = {}) {
|
||||
// Token-auth download that streams the response body straight to a
|
||||
// user-selected destination (via finalizeGatewayDownload) instead of buffering
|
||||
// the whole file in memory. The connect timeout is cleared once headers arrive
|
||||
// so a slow save dialog or a large stream doesn't trip it.
|
||||
// so a slow save dialog or a large stream doesn't trip it. `options.bearer`
|
||||
// switches the header to Authorization (RFC 8252 native flow), matching fetchJson.
|
||||
function downloadViaTokenToFile(url, token, ctx, options: any = {}) {
|
||||
return new Promise((resolve, reject) => {
|
||||
let parsed
|
||||
@@ -4885,9 +4909,7 @@ function downloadViaTokenToFile(url, token, ctx, options: any = {}) {
|
||||
parsed,
|
||||
{
|
||||
method: 'GET',
|
||||
headers: {
|
||||
'X-Hermes-Session-Token': token
|
||||
}
|
||||
headers: options.bearer ? { Authorization: `Bearer ${options.bearer}` } : { 'X-Hermes-Session-Token': token }
|
||||
},
|
||||
res => {
|
||||
// Headers arrived — the connection phase is done. Drop the idle timeout
|
||||
@@ -7251,6 +7273,13 @@ function readGatewayErrorText(res): Promise<string> {
|
||||
})
|
||||
}
|
||||
|
||||
async function gatedFileAuth(connection) {
|
||||
const nativeAt =
|
||||
connection.authMode === 'oauth' ? await ensureNativeAccessToken(connection.baseUrl).catch(() => null) : null
|
||||
|
||||
return resolveGatedDownloadAuth(connection.authMode, nativeAt, connection.token)
|
||||
}
|
||||
|
||||
async function saveGatewayFile(payload: any = {}) {
|
||||
const filePath = gatewayFilePath(payload.path)
|
||||
|
||||
@@ -7273,9 +7302,17 @@ async function saveGatewayFile(payload: any = {}) {
|
||||
const url = `${connection.baseUrl}${requestPath}`
|
||||
|
||||
try {
|
||||
return await (connection.authMode === 'oauth'
|
||||
? downloadViaOauthSessionToFile(url, ctx)
|
||||
: downloadViaTokenToFile(url, connection.token, ctx))
|
||||
const auth = await gatedFileAuth(connection)
|
||||
|
||||
if (auth.kind === 'bearer') {
|
||||
return await downloadViaTokenToFile(url, auth.token, ctx, { bearer: auth.token })
|
||||
}
|
||||
|
||||
if (auth.kind === 'cookie') {
|
||||
return await downloadViaOauthSessionToFile(url, ctx)
|
||||
}
|
||||
|
||||
return await downloadViaTokenToFile(url, auth.token, ctx)
|
||||
} catch (error) {
|
||||
// Desktop and the remote gateway update independently. A gateway predating
|
||||
// /api/fs/download 404s here; fall back (ONLY on 404) to the older capped
|
||||
@@ -7300,10 +7337,16 @@ async function saveGatewayFileViaDataUrl(connection, profile, filePath, ctx: any
|
||||
)
|
||||
|
||||
const url = `${connection.baseUrl}${requestPath}`
|
||||
const auth = await gatedFileAuth(connection)
|
||||
let json: any
|
||||
|
||||
const json = (
|
||||
connection.authMode === 'oauth' ? await fetchJsonViaOauthSession(url) : await fetchJson(url, connection.token)
|
||||
) as any
|
||||
if (auth.kind === 'bearer') {
|
||||
json = await fetchJson(url, null, { bearer: auth.token })
|
||||
} else if (auth.kind === 'cookie') {
|
||||
json = await fetchJsonViaOauthSession(url)
|
||||
} else {
|
||||
json = await fetchJson(url, auth.token)
|
||||
}
|
||||
|
||||
const dataUrl = json?.dataUrl
|
||||
|
||||
@@ -9716,6 +9759,13 @@ async function ensureBackend(profile) {
|
||||
}
|
||||
|
||||
entry.connectionPromise = spawnPoolBackend(key, entry).catch(async error => {
|
||||
// Land the failure in desktop.log: without this a spawn that dies before
|
||||
// its child exists (guard rejection, runtime resolution) leaves no trace
|
||||
// beyond renderer-side rejections users never see in a bundle.
|
||||
rememberLog(
|
||||
`Hermes backend for profile "${key}" failed to start: ${error instanceof Error ? error.message : String(error)}`
|
||||
)
|
||||
|
||||
if (backendPool.get(key) === entry) {
|
||||
backendPool.delete(key)
|
||||
}
|
||||
@@ -9798,6 +9848,12 @@ async function ensureRegistryBackend(connectionId, profile) {
|
||||
forceLocal: true,
|
||||
poolKey: localRoute.poolKey
|
||||
}).catch(async error => {
|
||||
// Same trace rule as the v1 pool path: a forced-local child whose spawn
|
||||
// rejects before the child exists must still land in desktop.log.
|
||||
rememberLog(
|
||||
`Hermes backend for profile "${profileKey}" (forced-local) failed to start: ${error instanceof Error ? error.message : String(error)}`
|
||||
)
|
||||
|
||||
if (backendPool.get(localRoute.poolKey) === localEntry) {
|
||||
backendPool.delete(localRoute.poolKey)
|
||||
}
|
||||
@@ -10079,12 +10135,18 @@ async function spawnPoolBackend(profile, entry, opts: { forceLocal?: boolean; po
|
||||
const webDist = resolveWebDist()
|
||||
const readyFile = backend.readyFile ? makeDashboardReadyFile() : null
|
||||
|
||||
rememberLog(`Starting Hermes backend for profile "${profile}" via ${backend.label}`)
|
||||
|
||||
const parentStartMarker = await desktopParentStartMarker()
|
||||
// Guard BEFORE the "Starting" line: a profile that only exists on a remote
|
||||
// backend (remote-primary desktop asked for a forced-local child) rejects
|
||||
// here, and logging "Starting" first left an orphaned line with no READY
|
||||
// and no exit — the exact undiagnosable burst signature in remote-gateway
|
||||
// user bundles (Aug 2026, Dash's report).
|
||||
assertLocalProfileCanStart(profile, profileDeletionGate, key =>
|
||||
directoryExists(path.join(HERMES_HOME, 'profiles', key))
|
||||
)
|
||||
|
||||
rememberLog(`Starting Hermes backend for profile "${profile}" via ${backend.label}`)
|
||||
|
||||
const parentStartMarker = await desktopParentStartMarker()
|
||||
const backendNonce = crypto.randomBytes(16).toString('hex')
|
||||
const parentIdentityEnv = parentWatchdogEnv(process.pid, parentStartMarker, backendNonce)
|
||||
|
||||
@@ -10630,6 +10692,7 @@ async function startHermes() {
|
||||
}
|
||||
|
||||
const message = error instanceof Error ? error.message : String(error)
|
||||
const hostKeyChanged = isHostKeyChangedBootFailure(error)
|
||||
|
||||
// Only latch LOCAL boot failures. A remote failure (lapsed session / mint
|
||||
// timeout / host briefly unreachable across sleep) is transient and has no
|
||||
@@ -10640,6 +10703,16 @@ async function startHermes() {
|
||||
backendStartFailure = error instanceof Error ? error : new Error(message)
|
||||
}
|
||||
|
||||
// A host-key CHANGE is the terminal exception among remote failures: SSH
|
||||
// fails closed until the user verifies the change and clears the stale
|
||||
// known_hosts entry, so retrying re-drives the identical doomed boot (one
|
||||
// bundle showed 157 consecutive failures over 2.5h). Latch it like a local
|
||||
// failure — reset/repair/apply-config clear the latch after the user fixes
|
||||
// known_hosts.
|
||||
if (shouldLatchHostKeyChangedFailure({ attemptedRemote, isReauth: false, isHostKeyChanged: hostKeyChanged })) {
|
||||
backendStartFailure = error instanceof Error ? error : new Error(message)
|
||||
}
|
||||
|
||||
// A confirmed reauth rejection latches separately: it can't self-heal, and
|
||||
// leaving it unlatched hides the overlay's "Sign in" button on every retry.
|
||||
if (shouldLatchRemoteReauthFailure({ attemptedRemote, isReauth: isReauthRequiredError(error) })) {
|
||||
@@ -10654,9 +10727,14 @@ async function startHermes() {
|
||||
// Renderer contract for the self-heal loop (#82679): a transient
|
||||
// REMOTE failure (dropped SSH/HTTP registered connection, mint
|
||||
// timeout) is retryable — the renderer re-attempts the boot with
|
||||
// bounded backoff. Local failures and confirmed reauth rejections
|
||||
// are not: those end in the recovery overlay / sign-in affordance.
|
||||
retryable: isRetryableRemoteBootFailure({ attemptedRemote, isReauth: isReauthRequiredError(error) }),
|
||||
// bounded backoff. Local failures, confirmed reauth rejections, and
|
||||
// host-key changes are not: those end in the recovery overlay /
|
||||
// sign-in affordance.
|
||||
retryable: isRetryableRemoteBootFailure({
|
||||
attemptedRemote,
|
||||
isReauth: isReauthRequiredError(error),
|
||||
isHostKeyChanged: hostKeyChanged
|
||||
}),
|
||||
running: false
|
||||
},
|
||||
{ allowDecrease: true }
|
||||
@@ -10850,8 +10928,10 @@ function createSessionWindow(sessionId, { watch = false } = {}) {
|
||||
// Additional full "instance" windows — peers of the primary that render the
|
||||
// COMPLETE app (sidebar, routing, its own draft) against the shared backend, so
|
||||
// a user can run multiple GUI windows at once (⌘⇧N / the "New Window" palette
|
||||
// command). Unlike the compact session windows they carry no `?win` flag. The
|
||||
// primary mainWindow stays the notification / deep-link / pet-overlay anchor and
|
||||
// command). Unlike the compact session windows they carry no `?win` flag; a
|
||||
// separate `peer=1` marker prevents them from replaying app-launch source
|
||||
// restoration after joining that shared backend. The primary mainWindow stays
|
||||
// the notification / deep-link / pet-overlay anchor and
|
||||
// is NOT tracked here. The set holds a strong reference so an open peer isn't
|
||||
// garbage-collected, and drops it on close.
|
||||
const instanceWindows = new Set<any>()
|
||||
@@ -10931,7 +11011,14 @@ function createInstanceWindow() {
|
||||
})
|
||||
|
||||
attachRendererConsoleCapture(win, 'instance', rememberLog)
|
||||
loadWindowUrl(win, DEV_SERVER || pathToFileURL(resolveRendererIndex()).toString(), 'Instance window')
|
||||
loadWindowUrl(
|
||||
win,
|
||||
buildInstanceWindowUrl({
|
||||
devServer: DEV_SERVER,
|
||||
rendererIndexPath: DEV_SERVER ? undefined : resolveRendererIndex()
|
||||
}),
|
||||
'Instance window'
|
||||
)
|
||||
|
||||
return win
|
||||
}
|
||||
@@ -12137,8 +12224,11 @@ registerPetOverlayIpc({
|
||||
})
|
||||
|
||||
// --- HUD mode (chrome-free floating chat) — see hud-ipc.ts. ---------------
|
||||
registerHudIpc({
|
||||
const hudIpc = registerHudIpc({
|
||||
isMac: IS_MAC,
|
||||
isWindows: IS_WINDOWS,
|
||||
glassSupported: GLASS_SUPPORTED,
|
||||
getTranslucencyState: () => translucencyState,
|
||||
getHudWindow: () => hudWindow,
|
||||
openHudWindow,
|
||||
closeHudWindow,
|
||||
@@ -12146,6 +12236,7 @@ registerHudIpc({
|
||||
hudSessionId = value
|
||||
}
|
||||
})
|
||||
|
||||
ipcMain.handle('hermes:bootstrap:reset', async () => {
|
||||
// Renderer's "Reload and retry" path. Clear the latched failure and
|
||||
// reset connection state so the next startHermes() call restarts the
|
||||
@@ -12584,6 +12675,31 @@ async function probeSshProfileInventory(connection) {
|
||||
}
|
||||
|
||||
async function enumerateRegistryAgentSources(registry = readDesktopConnectionsRegistry()) {
|
||||
// One dead source must not wedge the whole roster: ensureRegistryBackend on
|
||||
// an unreachable remote can block up to the 45s readiness timeout, and the
|
||||
// Bot Mode poll runs every 5s — each poll queued behind the dead dial, so
|
||||
// the renderer painted stale rows for the entire outage (and the roster IPC
|
||||
// hung >30s in live repro). Bound each source's enumeration; a timeout is
|
||||
// reported like any other unreachable source and retried on the next poll.
|
||||
const perSourceTimeoutMs = 10_000
|
||||
|
||||
const withEnumerationDeadline = async <T>(work: Promise<T>): Promise<T> => {
|
||||
let timer: ReturnType<typeof setTimeout> | null = null
|
||||
|
||||
try {
|
||||
return await Promise.race([
|
||||
work,
|
||||
new Promise<never>((_resolve, reject) => {
|
||||
timer = setTimeout(() => reject(new Error('roster enumeration timed out')), perSourceTimeoutMs)
|
||||
})
|
||||
])
|
||||
} finally {
|
||||
if (timer !== null) {
|
||||
clearTimeout(timer)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return Promise.all(
|
||||
registry.connections.map(async connection => {
|
||||
let raw: { connection: typeof connection; error?: string; installId?: string; profiles: null | string[] }
|
||||
@@ -12617,7 +12733,10 @@ async function enumerateRegistryAgentSources(registry = readDesktopConnectionsRe
|
||||
}
|
||||
}
|
||||
|
||||
const descriptor: any = await ensureRegistryBackend(connection.id, null)
|
||||
const descriptor: any = await withEnumerationDeadline(
|
||||
Promise.resolve(ensureRegistryBackend(connection.id, null))
|
||||
)
|
||||
|
||||
const body: any = await getJsonForBackend(descriptor, '/api/profiles', { timeoutMs: 8_000 })
|
||||
|
||||
// Cached with a TTL, so the 5s roster poll usually pays zero extra
|
||||
@@ -12703,42 +12822,59 @@ ipcMain.handle('hermes:gateway:ws-url-for', async (_event, payload) => {
|
||||
// app's own update pipeline; remote/ssh POST the backend's own
|
||||
// /api/hermes/update endpoint (the dashboard updater), which runs
|
||||
// `hermes update` on THAT machine.
|
||||
ipcMain.handle('hermes:connections:update-all', async () => {
|
||||
ipcMain.handle('hermes:connections:update-all', async (_event, payload) => {
|
||||
const registry = readDesktopConnectionsRegistry()
|
||||
|
||||
// Optional renderer-side exclusions: the everything-update flow dispatches
|
||||
// the ACTIVE backend through its own detailed-progress path and chains the
|
||||
// local client apply LAST (it relaunches the app), so it excludes those ids
|
||||
// here to avoid double-dispatch. No payload keeps the Settings button's
|
||||
// original all-rows behavior byte-identical.
|
||||
const excludeIds = new Set<string>(
|
||||
Array.isArray((payload as any)?.excludeIds) ? (payload as any).excludeIds.map((id: unknown) => String(id)) : []
|
||||
)
|
||||
|
||||
const results = await Promise.all(
|
||||
registry.connections.map(async connection => {
|
||||
const base = { connectionId: connection.id, label: connection.label, kind: connection.kind }
|
||||
const eligibility = updateEligibility(connection)
|
||||
registry.connections
|
||||
.filter(connection => !excludeIds.has(connection.id))
|
||||
.map(async connection => {
|
||||
const base = { connectionId: connection.id, label: connection.label, kind: connection.kind }
|
||||
const eligibility = updateEligibility(connection)
|
||||
|
||||
if (!eligibility.eligible) {
|
||||
return { ...base, ok: false, skipped: true, reason: eligibility.reason }
|
||||
}
|
||||
|
||||
try {
|
||||
if (connection.kind === 'local') {
|
||||
// The app-managed runtime updates through the same pipeline as the
|
||||
// Settings → Updates button (marker + venv gate + relaunch flow).
|
||||
const result: any = await applyUpdates({})
|
||||
|
||||
return { ...base, ok: result?.ok !== false, detail: result?.message || 'update started' }
|
||||
if (!eligibility.eligible) {
|
||||
return { ...base, ok: false, skipped: true, reason: eligibility.reason }
|
||||
}
|
||||
|
||||
const descriptor: any = await ensureRegistryBackend(connection.id, null)
|
||||
try {
|
||||
if (connection.kind === 'local') {
|
||||
// The app-managed runtime updates through the same pipeline as the
|
||||
// Settings → Updates button (marker + venv gate + relaunch flow).
|
||||
const result: any = await applyUpdates({})
|
||||
|
||||
const body: any = await postJsonForBackend(descriptor, '/api/hermes/update', {}, { timeoutMs: 15_000 })
|
||||
return { ...base, ok: result?.ok !== false, detail: result?.message || 'update started' }
|
||||
}
|
||||
|
||||
if (body?.ok === false) {
|
||||
// The backend refused (docker/nix/externally-managed installs) —
|
||||
// surface ITS message, per-row, instead of failing the batch.
|
||||
return { ...base, ok: false, skipped: true, reason: body?.error || 'backend-refused', detail: body?.message }
|
||||
const descriptor: any = await ensureRegistryBackend(connection.id, null)
|
||||
|
||||
const body: any = await postJsonForBackend(descriptor, '/api/hermes/update', {}, { timeoutMs: 15_000 })
|
||||
|
||||
if (body?.ok === false) {
|
||||
// The backend refused (docker/nix/externally-managed installs) —
|
||||
// surface ITS message, per-row, instead of failing the batch.
|
||||
return {
|
||||
...base,
|
||||
ok: false,
|
||||
skipped: true,
|
||||
reason: body?.error || 'backend-refused',
|
||||
detail: body?.message
|
||||
}
|
||||
}
|
||||
|
||||
return { ...base, ok: true, detail: body?.message || 'update started' }
|
||||
} catch (error: any) {
|
||||
return { ...base, ok: false, error: String(error?.message || error) }
|
||||
}
|
||||
|
||||
return { ...base, ok: true, detail: body?.message || 'update started' }
|
||||
} catch (error: any) {
|
||||
return { ...base, ok: false, error: String(error?.message || error) }
|
||||
}
|
||||
})
|
||||
})
|
||||
)
|
||||
|
||||
return { ok: true, results }
|
||||
@@ -13283,12 +13419,17 @@ async function pooledRegistrySessionSources(): Promise<RegistrySessionSource[]>
|
||||
return sources
|
||||
}
|
||||
|
||||
async function dispatchRegistryApiRequest(request, registryConnectionId, routeProfile = request?.profile) {
|
||||
async function dispatchRegistryApiRequest(
|
||||
request,
|
||||
registryConnectionId,
|
||||
routeProfile = request?.profile,
|
||||
requestProfile = request?.profile
|
||||
) {
|
||||
const connection: any = await ensureRegistryBackend(registryConnectionId, routeProfile)
|
||||
|
||||
const requestPath = connection.sharedRemote
|
||||
? pathWithProfileScope(request.path, request?.profile)
|
||||
: translateSelfProfileQuery(request.path, request?.profile, connection.remoteProfile)
|
||||
? pathWithProfileScope(request.path, requestProfile)
|
||||
: translateSelfProfileQuery(request.path, requestProfile, connection.remoteProfile)
|
||||
|
||||
return fetchJsonForBackend(connection, requestPath, {
|
||||
method: request?.method,
|
||||
@@ -13309,8 +13450,8 @@ function registryConnectionKind(connectionId) {
|
||||
return source.kind
|
||||
}
|
||||
|
||||
async function teardownConnectionScopedProfileBackend(connectionId, profile, request) {
|
||||
const key = backendScopeKey(connectionId, request?.profile || profile)
|
||||
async function teardownConnectionScopedProfileBackend(connectionId, profile) {
|
||||
const key = backendScopeKey(connectionId, profile)
|
||||
await Promise.all([
|
||||
poolStopper.stop(key),
|
||||
sshBootstrapCoordinator.cancelAndWait(key).then(() => teardownSshConnection(key))
|
||||
@@ -13446,12 +13587,13 @@ ipcMain.handle('hermes:api', async (_event, request) => {
|
||||
return dispatchConnectionScopedProfileDelete(request, {
|
||||
acquire: profile => profileDeletionGate.acquire(profile),
|
||||
connectionKind: connectionId => registryConnectionKind(connectionId),
|
||||
dispatch: routeProfile => dispatchRegistryApiRequest(request, registryConnectionId, routeProfile),
|
||||
dispatch: routeProfile =>
|
||||
dispatchRegistryApiRequest(request, registryConnectionId, routeProfile, deletingProfile),
|
||||
isDefaultProfile: profile => profile === 'default',
|
||||
isValidProfileName: profile => PROFILE_NAME_RE.test(profile),
|
||||
prepareLocal: localRequest => prepareProfileDeleteRequest(localRequest).then(() => undefined),
|
||||
teardownConnection: (connectionId, profile) =>
|
||||
teardownConnectionScopedProfileBackend(connectionId, profile, request)
|
||||
teardownConnectionScopedProfileBackend(connectionId, profile)
|
||||
})
|
||||
}
|
||||
|
||||
@@ -13931,6 +14073,12 @@ ipcMain.on('hermes:translucency', (_event, payload) => {
|
||||
|
||||
scheduleTranslucencyWrite()
|
||||
|
||||
// The HUD's frost reads the same setting but answers on its own terms (see
|
||||
// hudFrostFor) — and it is a transparent window, so it is deliberately not
|
||||
// in the chat fan-out below. It self-diffs, so an unrelated change costs
|
||||
// nothing native.
|
||||
hudIpc.applyHudFrost()
|
||||
|
||||
if (changed.backing || changed.material || changed.opacity) {
|
||||
for (const win of BrowserWindow.getAllWindows()) {
|
||||
applyWindowTranslucency(win, changed)
|
||||
|
||||
@@ -13,6 +13,7 @@ import { test } from 'vitest'
|
||||
import {
|
||||
oauthGuardMayHardFail,
|
||||
oauthSessionIsLive,
|
||||
resolveGatedDownloadAuth,
|
||||
resolveJsonBody,
|
||||
resolveOauthRestAuth,
|
||||
resolveReadinessProbeAuth
|
||||
@@ -130,3 +131,20 @@ test('oauthGuardMayHardFail keeps the strict guard when the list is unusable', (
|
||||
assert.equal(oauthGuardMayHardFail('nonsense' as any), true)
|
||||
assert.equal(oauthGuardMayHardFail([{ supportsPassword: true }]), true)
|
||||
})
|
||||
|
||||
// --- 6. gated download auth (guards the Files-panel 401 on cookieless native) ---
|
||||
|
||||
test('resolveGatedDownloadAuth matches oauth REST: bearer first, then cookie', () => {
|
||||
assert.deepEqual(resolveGatedDownloadAuth('oauth', 'native-at'), { kind: 'bearer', token: 'native-at' })
|
||||
assert.deepEqual(resolveGatedDownloadAuth('oauth', null), { kind: 'cookie' })
|
||||
assert.deepEqual(resolveGatedDownloadAuth('oauth', ''), { kind: 'cookie' })
|
||||
})
|
||||
|
||||
test('resolveGatedDownloadAuth uses the session token for token and local modes', () => {
|
||||
assert.deepEqual(resolveGatedDownloadAuth('token', 'native-at', 'session-token'), {
|
||||
kind: 'token',
|
||||
token: 'session-token'
|
||||
})
|
||||
assert.deepEqual(resolveGatedDownloadAuth('local', null, 'sess'), { kind: 'token', token: 'sess' })
|
||||
assert.deepEqual(resolveGatedDownloadAuth(undefined, null, null), { kind: 'token', token: null })
|
||||
})
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
* native-auth-decisions.ts
|
||||
*
|
||||
* Pure decision helpers extracted from main.ts for the RFC 8252 native-app
|
||||
* auth flow. These encode three choices that were each the site of a real
|
||||
* auth flow. These encode six choices that were each the site of a real
|
||||
* runtime bug — invisible to the mocked flow tests because the tests never
|
||||
* exercised the real main.ts internals. Keeping them pure + unit-tested here
|
||||
* prevents silent regressions:
|
||||
@@ -31,7 +31,12 @@
|
||||
* can satisfy neither the native-bearer nor the OAuth-partition-cookie
|
||||
* check by design, so the pre-flight guard must not hard-fail it.
|
||||
*
|
||||
* All five are trivial once named; the value is the test that pins the
|
||||
* 6. resolveGatedDownloadAuth — file save/read must present the SAME
|
||||
* credentials as oauth REST. `saveGatewayFile` used to always ride the
|
||||
* OAuth cookie partition, so a cookieless native (or native-password)
|
||||
* session could list files via `hermes:api` and still 401 on Download.
|
||||
*
|
||||
* All six are trivial once named; the value is the test that pins the
|
||||
* contract so the god-file call sites can't drift back to the buggy shape.
|
||||
*/
|
||||
|
||||
@@ -106,6 +111,28 @@ export function resolveReadinessProbeAuth(
|
||||
return { kind: 'public' }
|
||||
}
|
||||
|
||||
export type GatedDownloadAuth = OauthRestAuth | { kind: 'token'; token: string | null }
|
||||
|
||||
/**
|
||||
* Decide how a gated file download authenticates.
|
||||
*
|
||||
* Must match oauth REST (`resolveOauthRestAuth`): native bearer when present,
|
||||
* else the OAuth cookie partition. Token/local connections keep the static
|
||||
* session-token header. A cookie-only download against a cookieless native
|
||||
* session is the #88987 401 — Files panel listing works, Download does not.
|
||||
*/
|
||||
export function resolveGatedDownloadAuth(
|
||||
authMode: string | null | undefined,
|
||||
nativeAccessToken?: string | null,
|
||||
connectionToken?: string | null
|
||||
): GatedDownloadAuth {
|
||||
if (authMode === 'oauth') {
|
||||
return resolveOauthRestAuth(nativeAccessToken)
|
||||
}
|
||||
|
||||
return { kind: 'token', token: connectionToken ?? null }
|
||||
}
|
||||
|
||||
export interface AdvertisedAuthProvider {
|
||||
name?: string
|
||||
supportsPassword?: boolean
|
||||
|
||||
@@ -5,7 +5,8 @@ import { test, vi } from 'vitest'
|
||||
import {
|
||||
createParentStartMarkerResolver,
|
||||
electronProcessStartMarker,
|
||||
parentWatchdogEnv
|
||||
parentWatchdogEnv,
|
||||
spawnTag
|
||||
} from './parent-process-identity'
|
||||
|
||||
test('electronProcessStartMarker uses Electron creation time only for its own PID', () => {
|
||||
@@ -60,14 +61,26 @@ test('parentWatchdogEnv emits an exact identity when the marker is available', (
|
||||
assert.deepEqual(parentWatchdogEnv(42, 'winms:1723456789123', 'nonce-1'), {
|
||||
HERMES_PARENT_NONCE: 'nonce-1',
|
||||
HERMES_PARENT_PID: '42',
|
||||
HERMES_PARENT_START_MARKER: 'winms:1723456789123'
|
||||
HERMES_PARENT_START_MARKER: 'winms:1723456789123',
|
||||
// Spawn tag mirrored by hermes_cli/process_identity.py — spawner create
|
||||
// time in seconds derived from the same winms marker.
|
||||
HERMES_SPAWN: 'v1:-:serve:42:1723456789.123'
|
||||
})
|
||||
})
|
||||
|
||||
test('parentWatchdogEnv atomically falls back to PID-only identity', () => {
|
||||
assert.deepEqual(parentWatchdogEnv(42, null, 'unused-nonce'), {
|
||||
HERMES_PARENT_PID: '42'
|
||||
HERMES_PARENT_PID: '42',
|
||||
// Marker probe failed → spawn tag still present, create time unknown.
|
||||
HERMES_SPAWN: 'v1:-:serve:42:-'
|
||||
})
|
||||
assert.throws(() => parentWatchdogEnv(42, '', 'nonce-1'), /marker and nonce must be non-empty/)
|
||||
assert.throws(() => parentWatchdogEnv(42, 'winms:1723456789123', ''), /marker and nonce must be non-empty/)
|
||||
})
|
||||
|
||||
test('spawnTag derives seconds from a winms marker and dashes without one', () => {
|
||||
assert.equal(spawnTag(42, 'winms:1723456789123'), 'v1:-:serve:42:1723456789.123')
|
||||
assert.equal(spawnTag(42, null), 'v1:-:serve:42:-')
|
||||
assert.equal(spawnTag(42, 'win:638908765432100000'), 'v1:-:serve:42:-')
|
||||
assert.equal(spawnTag(42, 'winms:garbage'), 'v1:-:serve:42:-')
|
||||
})
|
||||
|
||||
@@ -2,6 +2,10 @@ export type ParentWatchdogEnv = {
|
||||
HERMES_PARENT_PID: string
|
||||
HERMES_PARENT_START_MARKER?: string
|
||||
HERMES_PARENT_NONCE?: string
|
||||
/** Spawn tag consumed by hermes_cli.process_identity (`v1:<install>:<purpose>:<spawner_pid>:<spawner_create_s>`).
|
||||
* Install is `-` (unknown) from the Desktop — the Python side scopes by
|
||||
* venv membership, so the tag only needs lineage, not install identity. */
|
||||
HERMES_SPAWN?: string
|
||||
}
|
||||
|
||||
export interface ParentStartMarkerResolverOptions {
|
||||
@@ -69,6 +73,7 @@ export function parentWatchdogEnv(pid: number, startMarker: string | null, nonce
|
||||
}
|
||||
|
||||
const env: ParentWatchdogEnv = { HERMES_PARENT_PID: String(pid) }
|
||||
env.HERMES_SPAWN = spawnTag(pid, startMarker)
|
||||
|
||||
if (startMarker === null) {
|
||||
return env
|
||||
@@ -83,3 +88,21 @@ export function parentWatchdogEnv(pid: number, startMarker: string | null, nonce
|
||||
|
||||
return env
|
||||
}
|
||||
|
||||
/** Build the `HERMES_SPAWN` tag mirrored by hermes_cli/process_identity.py.
|
||||
* The Desktop only ever spawns backend servers, so purpose is `serve`; the
|
||||
* spawner create-time is derived from the same `winms:` marker the parent
|
||||
* watchdog uses (seconds, 3 decimals), `-` when the marker probe failed. */
|
||||
export function spawnTag(pid: number, startMarker: string | null): string {
|
||||
let createPart = '-'
|
||||
|
||||
if (startMarker?.startsWith('winms:')) {
|
||||
const ms = Number(startMarker.slice('winms:'.length))
|
||||
|
||||
if (Number.isFinite(ms) && ms > 0) {
|
||||
createPart = (ms / 1000).toFixed(3)
|
||||
}
|
||||
}
|
||||
|
||||
return `v1:-:serve:${pid}:${createPart}`
|
||||
}
|
||||
|
||||
@@ -75,7 +75,10 @@ contextBridge.exposeInMainWorld('hermesDesktop', {
|
||||
setIgnoreMouse: ignore => ipcRenderer.send('hermes:hud:ignore-mouse', ignore),
|
||||
moveBy: delta => ipcRenderer.send('hermes:hud:move-by', delta),
|
||||
setBounds: bounds => ipcRenderer.send('hermes:hud:set-bounds', bounds),
|
||||
setVibrancy: on => ipcRenderer.invoke('hermes:hud:vibrancy', on),
|
||||
// Whether the band covers the window below the bar. Main pairs it with the
|
||||
// user's translucency setting to decide the native frost (macOS vibrancy /
|
||||
// Windows 11 DWM backdrop) — see hudFrostFor.
|
||||
setFrost: showing => ipcRenderer.invoke('hermes:hud:frost', showing),
|
||||
// The HUD tells main which session it is on; main hands that back to the
|
||||
// app window when the HUD closes, so the app can re-home onto it.
|
||||
setSession: sessionId => ipcRenderer.send('hermes:hud:session', sessionId),
|
||||
@@ -152,7 +155,8 @@ contextBridge.exposeInMainWorld('hermesDesktop', {
|
||||
setLastUsed: id => ipcRenderer.invoke('hermes:connections:set-last-used', id),
|
||||
test: id => ipcRenderer.invoke('hermes:connections:test', id),
|
||||
// Fan out `hermes update` to every eligible registered connection.
|
||||
updateAll: () => ipcRenderer.invoke('hermes:connections:update-all'),
|
||||
// Optional excludeIds skips rows the caller updates through another path.
|
||||
updateAll: options => ipcRenderer.invoke('hermes:connections:update-all', options),
|
||||
// Registry lifecycle push (main → renderer): a connection was removed or
|
||||
// materially edited, so secondaries scoped to it must be disposed (and,
|
||||
// for edits, re-dialed at the new target).
|
||||
|
||||
@@ -222,6 +222,41 @@ test('explicit registered SSH DELETE tears down its source backend before dispat
|
||||
])
|
||||
})
|
||||
|
||||
test('non-identity connection DELETE tears down the logical pool and deletes the backend target', async () => {
|
||||
const events: string[] = []
|
||||
const request = {
|
||||
connectionId: 'source-a',
|
||||
method: 'DELETE',
|
||||
path: '/api/profiles/backend-worker',
|
||||
profile: 'worker'
|
||||
}
|
||||
|
||||
await dispatchConnectionScopedProfileDelete(request, {
|
||||
...deps,
|
||||
acquire: profile => {
|
||||
events.push(`gate:${profile}`)
|
||||
return () => events.push(`release:${profile}`)
|
||||
},
|
||||
connectionKind: () => 'ssh',
|
||||
dispatch: async routeProfile => {
|
||||
events.push(`delete:${request.path}:${routeProfile ?? 'primary'}`)
|
||||
return 'deleted'
|
||||
},
|
||||
prepareLocal: async () => assert.fail('remote deletion must not use local profile teardown'),
|
||||
teardownConnection: async (connectionId, profile) => {
|
||||
events.push(`teardown:${connectionId}:${profile}`)
|
||||
assert.notEqual(profile, 'backend-worker', 'must not stop the backend-target pool')
|
||||
}
|
||||
})
|
||||
|
||||
assert.deepEqual(events, [
|
||||
'gate:backend-worker',
|
||||
'teardown:source-a:worker',
|
||||
'delete:/api/profiles/backend-worker:primary',
|
||||
'release:backend-worker'
|
||||
])
|
||||
})
|
||||
|
||||
test('connection-scoped default DELETE rejects before gate, preparation, teardown, or dispatch', async () => {
|
||||
const events: string[] = []
|
||||
|
||||
|
||||
@@ -88,28 +88,29 @@ export async function dispatchConnectionScopedProfileDelete<T>(
|
||||
request: ConnectionScopedProfileDeleteRequest,
|
||||
deps: ConnectionScopedProfileDeleteDeps<T>
|
||||
): Promise<T> {
|
||||
const profile = profileNameFromDeleteRequest(request)
|
||||
const targetProfile = profileNameFromDeleteRequest(request)
|
||||
const logicalProfile = String(request.profile ?? '').trim() || targetProfile || ''
|
||||
const connectionId = String(request.connectionId ?? '').trim()
|
||||
|
||||
if (!profile || !connectionId) {
|
||||
if (!targetProfile || !connectionId) {
|
||||
throw new Error('Connection-scoped profile deletion requires a connection and profile.')
|
||||
}
|
||||
|
||||
if (deps.isDefaultProfile(profile)) {
|
||||
if (deps.isDefaultProfile(targetProfile)) {
|
||||
throw new Error('The default profile cannot be deleted.')
|
||||
}
|
||||
|
||||
if (!deps.isValidProfileName(profile)) {
|
||||
throw new Error(`Invalid profile name: ${profile}`)
|
||||
if (!deps.isValidProfileName(targetProfile)) {
|
||||
throw new Error(`Invalid profile name: ${targetProfile}`)
|
||||
}
|
||||
|
||||
const release = deps.acquire(profile)
|
||||
const release = deps.acquire(targetProfile)
|
||||
|
||||
try {
|
||||
if (deps.connectionKind(connectionId) === 'local') {
|
||||
await deps.prepareLocal(request)
|
||||
} else {
|
||||
await deps.teardownConnection(connectionId, profile)
|
||||
await deps.teardownConnection(connectionId, logicalProfile)
|
||||
}
|
||||
|
||||
return await deps.dispatch(null)
|
||||
|
||||
@@ -3,6 +3,7 @@ import assert from 'node:assert/strict'
|
||||
import { test } from 'vitest'
|
||||
|
||||
import {
|
||||
buildInstanceWindowUrl,
|
||||
buildSessionWindowUrl,
|
||||
chatWindowWebPreferences,
|
||||
createSessionWindowRegistry,
|
||||
@@ -88,6 +89,19 @@ test('buildSessionWindowUrl adds the watch flag for spectator windows, before th
|
||||
assert.equal(url, 'http://localhost:5173/?win=secondary&watch=1#/abc')
|
||||
})
|
||||
|
||||
test('buildInstanceWindowUrl marks a full peer without selecting a specialized renderer', () => {
|
||||
const url = buildInstanceWindowUrl({ devServer: 'http://localhost:5173/' })
|
||||
|
||||
assert.equal(url, 'http://localhost:5173/?peer=1')
|
||||
assert.ok(!url.includes('win='))
|
||||
})
|
||||
|
||||
test('buildInstanceWindowUrl marks a packaged full peer', () => {
|
||||
const url = buildInstanceWindowUrl({ rendererIndexPath: '/opt/app/index.html' })
|
||||
|
||||
assert.match(url, /^file:\/\/.*index\.html\?peer=1$/)
|
||||
})
|
||||
|
||||
test('instanceWindowBounds cascades a new window off its source bounds', () => {
|
||||
const bounds = instanceWindowBounds({ x: 100, y: 120, width: 1400, height: 900 }, { width: 1, height: 1 })
|
||||
|
||||
|
||||
@@ -77,6 +77,23 @@ function buildSessionWindowUrl(sessionId: string, { devServer, rendererIndexPath
|
||||
return `${pathToFileURL(rendererIndexPath).toString()}${query}${route}`
|
||||
}
|
||||
|
||||
// Full peer windows render the ordinary app shell, so they deliberately do
|
||||
// not use the `win` query parameter that selects a specialized renderer. The
|
||||
// separate marker lets the renderer distinguish a peer from the one primary
|
||||
// app window: app-launch source restoration belongs to the primary only, while
|
||||
// a peer keeps the already-running backend it joined during boot.
|
||||
function buildInstanceWindowUrl({ devServer, rendererIndexPath }: any = {}) {
|
||||
const query = '?peer=1'
|
||||
|
||||
if (devServer) {
|
||||
const base = devServer.endsWith('/') ? devServer.slice(0, -1) : devServer
|
||||
|
||||
return `${base}/${query}`
|
||||
}
|
||||
|
||||
return `${pathToFileURL(rendererIndexPath).toString()}${query}`
|
||||
}
|
||||
|
||||
// Full "instance" windows (⌘⇧N / the "New Window" command) open a complete app
|
||||
// peer, not a compact chat. Cascade each one off its source window's bounds so a
|
||||
// new window doesn't land exactly on top of the one it was spawned from. Pure so
|
||||
@@ -160,6 +177,7 @@ function createSessionWindowRegistry() {
|
||||
}
|
||||
|
||||
export {
|
||||
buildInstanceWindowUrl,
|
||||
buildSessionWindowUrl,
|
||||
chatWindowWebPreferences,
|
||||
createSessionWindowRegistry,
|
||||
|
||||
@@ -15,6 +15,8 @@ import {
|
||||
clampIntensity,
|
||||
DEFAULT_GLASS_MATERIAL,
|
||||
DEFAULT_GLASS_SCOPE,
|
||||
defaultTranslucencyState,
|
||||
defaultTranslucencyValues,
|
||||
GLASS_MATERIALS,
|
||||
GLASS_SCOPES,
|
||||
glassActive,
|
||||
@@ -23,10 +25,14 @@ import {
|
||||
glassMaterialsFor,
|
||||
glassSupportedOn,
|
||||
glassSurfaceKeep,
|
||||
hudFrostFor,
|
||||
normalizeBook,
|
||||
normalizeMaterial,
|
||||
normalizeMode,
|
||||
normalizeScope,
|
||||
normalizeState,
|
||||
resolveTranslucency,
|
||||
setTranslucencyValues,
|
||||
TRANSLUCENCY_CURVE,
|
||||
TRANSLUCENCY_MAX,
|
||||
TRANSLUCENCY_MIN,
|
||||
@@ -183,7 +189,7 @@ describe('windowOpacityFor', () => {
|
||||
it('fades a glass window only through its own lever, on the ramp clear uses', () => {
|
||||
expect(windowOpacityFor(glass(60, DEFAULT_GLASS_MATERIAL, 0))).toBe(1)
|
||||
expect(windowOpacityFor(glass(60, DEFAULT_GLASS_MATERIAL, 40))).toBe(windowOpacityFor(clear(40)))
|
||||
expect(windowOpacityFor(glass(0, DEFAULT_GLASS_MATERIAL, 100))).toBe(windowOpacityFor(clear(100)))
|
||||
expect(windowOpacityFor(glass(100, DEFAULT_GLASS_MATERIAL, 100))).toBe(windowOpacityFor(clear(100)))
|
||||
})
|
||||
|
||||
it('leaves fade inert under clear, where the intensity lever already is the opacity', () => {
|
||||
@@ -245,6 +251,53 @@ describe('vibrancyFor', () => {
|
||||
})
|
||||
})
|
||||
|
||||
// The HUD is a transparent window, so its frost has no opaque page to hide
|
||||
// behind: every state that isn't "frost wanted" has to resolve to no material
|
||||
// at all, or the band leaves a grey slab hanging over another app.
|
||||
describe('hudFrostFor', () => {
|
||||
it('wears the chosen frost on both platforms while the band is showing', () => {
|
||||
expect(hudFrostFor(glass(60, 'header'), true)).toEqual({ vibrancy: 'header', backgroundMaterial: 'mica' })
|
||||
expect(hudFrostFor(glass(60, 'under-window'), true)).toEqual({
|
||||
vibrancy: 'under-window',
|
||||
backgroundMaterial: 'acrylic'
|
||||
})
|
||||
})
|
||||
|
||||
// The material is the whole window rectangle and nothing on the page can
|
||||
// clip it, so a hidden band must mean no frost — this is the veto that keeps
|
||||
// idle HUD mode the bar and nothing else.
|
||||
it('is off whenever the band is not covering the window', () => {
|
||||
expect(hudFrostFor(glass(60, 'header'), false)).toEqual({ vibrancy: null, backgroundMaterial: 'none' })
|
||||
})
|
||||
|
||||
// ...and the setting is the other veto: Glass off, or the tint at zero,
|
||||
// means the HUD never frosts however engaged the band is.
|
||||
it('is off whenever glass itself is off', () => {
|
||||
expect(hudFrostFor(clear(60), true)).toEqual({ vibrancy: null, backgroundMaterial: 'none' })
|
||||
expect(hudFrostFor(glass(0, 'header'), true)).toEqual({ vibrancy: null, backgroundMaterial: 'none' })
|
||||
})
|
||||
|
||||
// Unlike a chat window, which keeps 'sidebar' under its titlebar band in
|
||||
// every non-glass state. Pinning this is what stops someone "fixing" the
|
||||
// null into a resting material and painting the slab back.
|
||||
it('resolves off to no material at all, not to a resting one', () => {
|
||||
expect(hudFrostFor(clear(60), true).vibrancy).toBeNull()
|
||||
expect(vibrancyFor(clear(60))).toBe('sidebar')
|
||||
})
|
||||
|
||||
// The tint is painted by the renderer, exactly as it is for a chat window —
|
||||
// dragging it must not re-issue setVibrancy, whose 150ms animation restarts
|
||||
// on every call and never lets the material settle.
|
||||
it('does not move any native property as the tint slider is dragged', () => {
|
||||
for (let intensity = 1; intensity <= 100; intensity += 1) {
|
||||
expect(hudFrostFor(glass(intensity, 'popover'), true)).toEqual({
|
||||
vibrancy: 'popover',
|
||||
backgroundMaterial: 'tabbed'
|
||||
})
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
describe('glassSupportedOn', () => {
|
||||
it('is on for macOS regardless of kernel version', () => {
|
||||
expect(glassSupportedOn('darwin')).toBe(true)
|
||||
@@ -499,4 +552,133 @@ describe('what an update actually changes natively', () => {
|
||||
it('is everything when switching between the two modes', () => {
|
||||
expect(nativeDiff(clear(60), glass(60))).toEqual({ backing: true, material: true, opacity: true })
|
||||
})
|
||||
|
||||
it('leaves a window alone when glass is selected but off', () => {
|
||||
// The light default carries one point of fade. Someone who dragged the
|
||||
// tint to zero asked for an opaque window, and that point must not follow
|
||||
// them there — off has to mean exactly 1, not 0.9999.
|
||||
expect(windowOpacityFor({ ...glass(0), fade: 1 })).toBe(1)
|
||||
expect(windowOpacityFor({ ...glass(0), fade: 40 })).toBe(1)
|
||||
})
|
||||
|
||||
it('still fades a window whose glass is actually on', () => {
|
||||
expect(windowOpacityFor({ ...glass(66), fade: 40 })).toBeLessThan(1)
|
||||
})
|
||||
})
|
||||
|
||||
/**
|
||||
* The shipped defaults, per platform. These are the numbers a fresh profile
|
||||
* gets before anyone opens Settings, so they are the ones most people will
|
||||
* ever see — and they differ by platform because the lever means different
|
||||
* things behind macOS vibrancy and Windows acrylic.
|
||||
*/
|
||||
describe('the defaults a fresh profile lands on', () => {
|
||||
const mac = (appearance: 'dark' | 'light') => defaultTranslucencyValues(appearance, false)
|
||||
const win = (appearance: 'dark' | 'light') => defaultTranslucencyValues(appearance, true)
|
||||
|
||||
it('ships glass on, not a lever resting at zero', () => {
|
||||
for (const values of [mac('light'), mac('dark'), win('light'), win('dark')]) {
|
||||
expect(values.intensity).toBeGreaterThan(0)
|
||||
expect(glassActive({ ...values, mode: 'glass' })).toBe(true)
|
||||
}
|
||||
|
||||
for (const appearance of ['light', 'dark'] as const) {
|
||||
expect(defaultTranslucencyState(appearance, true, false).mode).toBe('glass')
|
||||
expect(defaultTranslucencyState(appearance, true, true).mode).toBe('glass')
|
||||
}
|
||||
})
|
||||
|
||||
it('falls back to clear where no native material exists', () => {
|
||||
expect(defaultTranslucencyState('dark', false, false).mode).toBe('clear')
|
||||
})
|
||||
|
||||
it('tints light more heavily than dark, on both platforms', () => {
|
||||
// A dark field already separates from what is behind it; a bright one
|
||||
// needs real thinning before the desktop reads as a layer underneath.
|
||||
expect(mac('light').intensity).toBeGreaterThan(mac('dark').intensity)
|
||||
expect(win('light').intensity).toBeGreaterThan(win('dark').intensity)
|
||||
})
|
||||
|
||||
it('asks far less of Windows, which composites its own tint in DWM', () => {
|
||||
expect(win('light').intensity).toBeLessThan(mac('light').intensity)
|
||||
expect(win('dark').intensity).toBeLessThan(mac('dark').intensity)
|
||||
})
|
||||
|
||||
it('never fades a Windows window — setOpacity dims the composited backdrop', () => {
|
||||
expect(win('light').fade).toBe(0)
|
||||
expect(win('dark').fade).toBe(0)
|
||||
})
|
||||
|
||||
it('defaults each platform onto a frost that platform can actually render', () => {
|
||||
for (const appearance of ['light', 'dark'] as const) {
|
||||
expect(glassMaterialsFor(true)).toContain(win(appearance).material)
|
||||
expect(glassMaterialsFor(false)).toContain(mac(appearance).material)
|
||||
}
|
||||
})
|
||||
|
||||
it('opens the whole window, not just the sidebar rail', () => {
|
||||
for (const values of [mac('light'), mac('dark'), win('light'), win('dark')]) {
|
||||
expect(values.scope).toBe('window')
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
/**
|
||||
* The per-appearance ladder: appearance slot → base → platform default, per
|
||||
* key. This is what makes tuning light mode stay in light mode while an
|
||||
* untouched dark keeps inheriting.
|
||||
*/
|
||||
describe('resolving the book for the painted appearance', () => {
|
||||
const empty = normalizeBook(null, true)
|
||||
|
||||
it('falls all the way through to the platform default', () => {
|
||||
expect(resolveTranslucency(empty, 'dark', false).intensity).toBe(defaultTranslucencyValues('dark', false).intensity)
|
||||
expect(resolveTranslucency(empty, 'dark', true).intensity).toBe(defaultTranslucencyValues('dark', true).intensity)
|
||||
})
|
||||
|
||||
it('scopes an edit to the appearance it was made in', () => {
|
||||
const book = setTranslucencyValues(empty, 'light', { intensity: 90 })
|
||||
|
||||
expect(resolveTranslucency(book, 'light', false).intensity).toBe(90)
|
||||
expect(resolveTranslucency(book, 'dark', false).intensity).toBe(defaultTranslucencyValues('dark', false).intensity)
|
||||
})
|
||||
|
||||
it('carries a v1 state into BOTH appearances via base', () => {
|
||||
// Someone who tuned a window before appearances were split keeps exactly
|
||||
// what was on screen, in either appearance, until they edit one of them.
|
||||
const migrated = normalizeBook({ intensity: 40, mode: 'glass' }, true)
|
||||
|
||||
expect(migrated.base.intensity).toBe(40)
|
||||
expect(resolveTranslucency(migrated, 'light', false).intensity).toBe(40)
|
||||
expect(resolveTranslucency(migrated, 'dark', false).intensity).toBe(40)
|
||||
})
|
||||
|
||||
it('lets an appearance override base without disturbing the other', () => {
|
||||
const tuned = setTranslucencyValues(normalizeBook({ intensity: 40, mode: 'glass' }, true), 'dark', {
|
||||
intensity: 10
|
||||
})
|
||||
|
||||
expect(resolveTranslucency(tuned, 'dark', false).intensity).toBe(10)
|
||||
expect(resolveTranslucency(tuned, 'light', false).intensity).toBe(40)
|
||||
})
|
||||
|
||||
it('inherits per KEY, not per appearance', () => {
|
||||
// Editing only the tint in dark must leave dark's material still tracking
|
||||
// base — a partial edit is not a full snapshot of the appearance.
|
||||
const book = setTranslucencyValues(normalizeBook({ material: 'popover', mode: 'glass' }, true), 'dark', {
|
||||
intensity: 33
|
||||
})
|
||||
|
||||
const resolved = resolveTranslucency(book, 'dark', false)
|
||||
|
||||
expect(resolved.intensity).toBe(33)
|
||||
expect(resolved.material).toBe('popover')
|
||||
})
|
||||
|
||||
it('keeps mode global — clear vs glass is about the window, not the palette', () => {
|
||||
const book = setTranslucencyValues({ ...empty, mode: 'clear' }, 'light', { intensity: 50 })
|
||||
|
||||
expect(resolveTranslucency(book, 'light', false).mode).toBe('clear')
|
||||
expect(resolveTranslucency(book, 'dark', false).mode).toBe('clear')
|
||||
})
|
||||
})
|
||||
|
||||
@@ -18,6 +18,8 @@ export {
|
||||
clampIntensity,
|
||||
DEFAULT_GLASS_MATERIAL,
|
||||
DEFAULT_GLASS_SCOPE,
|
||||
defaultTranslucencyState,
|
||||
defaultTranslucencyValues,
|
||||
GLASS_MATERIALS,
|
||||
GLASS_SCOPES,
|
||||
glassActive,
|
||||
@@ -26,10 +28,14 @@ export {
|
||||
glassMaterialsFor,
|
||||
glassSupportedOn,
|
||||
glassSurfaceKeep,
|
||||
hudFrostFor,
|
||||
normalizeBook,
|
||||
normalizeMaterial,
|
||||
normalizeMode,
|
||||
normalizeScope,
|
||||
normalizeState,
|
||||
resolveTranslucency,
|
||||
setTranslucencyValues,
|
||||
TRANSLUCENCY_CURVE,
|
||||
TRANSLUCENCY_MAX,
|
||||
TRANSLUCENCY_MIN,
|
||||
|
||||
@@ -22,6 +22,24 @@ export const COMPOSER_STACK_BREAKPOINT_PX = 320
|
||||
// chevron frees is spent keeping the row single for another stretch.
|
||||
export const COMPOSER_COMPACT_PILL_PX = 560
|
||||
|
||||
// The ladder keeps going below the stack breakpoint — a pane can be far
|
||||
// narrower than even the stacked controls row. Both rungs are budgeted
|
||||
// against that row's real cost: menu ~24 + surface padding 16 + the cluster
|
||||
// (~190; ~218 mid-turn with the queue button).
|
||||
//
|
||||
// At 260 the three voice toggles fold into the one menu HUD mode already
|
||||
// uses, clearing the mid-turn worst case with margin. Each stage sits clear
|
||||
// of the floor below it rather than arriving the instant the previous one
|
||||
// gives out — the mistake COMPOSER_COMPACT_PILL_PX documents.
|
||||
export const COMPOSER_FOLD_VOICE_PX = 260
|
||||
|
||||
// Type and send, nothing else. A pane can be dragged to MIN_PANE_PX (80), and
|
||||
// even with voice folded the row still costs ~150, so the last rung drops the
|
||||
// pill AND the voice menu. Both stay reachable — the model by hotkey and the
|
||||
// full picker, dictation from any wider pane — and Send fits with room to
|
||||
// spare at any width the layout tree allows (~74 all-in).
|
||||
export const COMPOSER_MINIMAL_PX = 180
|
||||
|
||||
// A single editor line is ~28px (--composer-input-min-height 1.625rem + 0.5rem
|
||||
// vertical padding). Anything taller means the text wrapped to a second line,
|
||||
// which is when the composer should expand to the stacked layout.
|
||||
|
||||
@@ -0,0 +1,25 @@
|
||||
import { cn } from '@/lib/utils'
|
||||
|
||||
// Shared class names for the composer's control row, in a module of their own
|
||||
// so both the row (`controls.tsx`) and the menus it renders can wear them
|
||||
// without importing each other in a cycle.
|
||||
|
||||
export const ICON_BTN = 'size-(--composer-control-size) shrink-0 rounded-md'
|
||||
|
||||
export const GHOST_ICON_BTN = cn(
|
||||
ICON_BTN,
|
||||
'text-(--ui-text-tertiary) hover:bg-(--chrome-action-hover) hover:text-foreground'
|
||||
)
|
||||
|
||||
// Send/voice-conversation primary: solid foreground-on-background circle
|
||||
// (reads as black-on-white in light mode, white-on-black in dark mode) to
|
||||
// match the reference composer's high-contrast CTA. Keeps the pill itself
|
||||
// neutral and lets the action visually dominate the row.
|
||||
export const PRIMARY_ICON_BTN = cn(
|
||||
'size-(--composer-control-primary-size,var(--composer-control-size)) shrink-0 rounded-full p-0',
|
||||
'bg-foreground text-background hover:bg-foreground/90',
|
||||
'disabled:bg-foreground/30 disabled:text-background disabled:opacity-100'
|
||||
)
|
||||
|
||||
/** A toggle that is currently ON — dictation, spoken replies, the wake word. */
|
||||
export const ACTIVE_ICON_BTN = 'bg-primary/10 text-primary hover:bg-primary/15 hover:text-primary'
|
||||
@@ -3,6 +3,7 @@ import { afterEach, describe, expect, it, vi } from 'vitest'
|
||||
|
||||
import type { ChatBarState } from '@/app/chat/composer/types'
|
||||
import { I18nProvider } from '@/i18n'
|
||||
import { $hudMode } from '@/store/hud'
|
||||
import { applyWakeStartResult, applyWakeStatus, resetWakeWordState } from '@/store/wake-word'
|
||||
|
||||
import { ComposerControls } from './controls'
|
||||
@@ -57,6 +58,75 @@ async function expectShortcutTooltip(label: string, shortcut: string) {
|
||||
|
||||
afterEach(() => {
|
||||
cleanup()
|
||||
$hudMode.set(false)
|
||||
})
|
||||
|
||||
// The HUD is a Spotlight bar a few hundred pixels wide: the four voice
|
||||
// controls fold into one menu there, and the way out of HUD mode joins the
|
||||
// row instead of floating above the bar in a reserved strip. The docked
|
||||
// composer keeps every control inline and shows no exit.
|
||||
describe('HUD mode', () => {
|
||||
it('keeps the voice controls inline and offers no exit in the docked composer', () => {
|
||||
renderControls()
|
||||
|
||||
expect(screen.getByLabelText('Voice dictation')).toBeTruthy()
|
||||
expect(screen.getByLabelText('Read replies aloud')).toBeTruthy()
|
||||
expect(screen.queryByLabelText('Exit HUD mode')).toBeNull()
|
||||
expect(screen.queryByLabelText('Voice')).toBeNull()
|
||||
})
|
||||
|
||||
it('folds them into one menu and offers the way out in the HUD', () => {
|
||||
$hudMode.set(true)
|
||||
renderControls()
|
||||
|
||||
expect(screen.getByLabelText('Voice')).toBeTruthy()
|
||||
expect(screen.getByLabelText('Exit HUD mode')).toBeTruthy()
|
||||
|
||||
// Folded away, not duplicated — the whole point is the row's width back.
|
||||
expect(screen.queryByLabelText('Voice dictation')).toBeNull()
|
||||
expect(screen.queryByLabelText('Read replies aloud')).toBeNull()
|
||||
})
|
||||
|
||||
// A collapsed menu that looked idle while the mic was open would be a worse
|
||||
// trade than the space it saves, so the trigger reports the live state.
|
||||
it('reports a live voice state on the collapsed trigger', () => {
|
||||
$hudMode.set(true)
|
||||
renderControls({ voiceStatus: 'recording' })
|
||||
|
||||
expect(screen.getByLabelText('Stop dictation')).toBeTruthy()
|
||||
expect(screen.queryByLabelText('Voice')).toBeNull()
|
||||
})
|
||||
})
|
||||
|
||||
// A tile can be narrower than the controls cost, and the row is inside an
|
||||
// overflow-hidden surface — so anything that doesn't fold gets clipped off the
|
||||
// right edge, send button first. The ladder keeps going past `stacked`: voice
|
||||
// folds into the same menu the HUD uses, then the model pill drops. Send is
|
||||
// the last thing standing.
|
||||
describe('narrow tiles', () => {
|
||||
it('folds the voice controls into one menu without entering HUD mode', () => {
|
||||
renderControls({ foldVoice: true })
|
||||
|
||||
expect(screen.getByLabelText('Voice')).toBeTruthy()
|
||||
expect(screen.queryByLabelText('Voice dictation')).toBeNull()
|
||||
expect(screen.queryByLabelText('Read replies aloud')).toBeNull()
|
||||
|
||||
// Folding is a width decision, not the HUD: no exit affordance appears.
|
||||
expect(screen.queryByLabelText('Exit HUD mode')).toBeNull()
|
||||
})
|
||||
|
||||
it('keeps Send at the tightest width, with everything else dropped', () => {
|
||||
renderControls({ foldVoice: true, minimal: true })
|
||||
|
||||
expect(screen.getByLabelText('Send')).toBeTruthy()
|
||||
expect(screen.queryByLabelText('Voice')).toBeNull()
|
||||
})
|
||||
|
||||
it('keeps Stop reachable mid-turn at the tightest width', () => {
|
||||
renderControls({ busy: true, busyAction: 'stop', foldVoice: true, hasComposerPayload: false, minimal: true })
|
||||
|
||||
expect(screen.getByLabelText('Stop')).toBeTruthy()
|
||||
})
|
||||
})
|
||||
|
||||
describe('ComposerControls shortcut tooltips', () => {
|
||||
|
||||
@@ -7,26 +7,18 @@ import { useI18n } from '@/i18n'
|
||||
import { triggerHaptic } from '@/lib/haptics'
|
||||
import { AudioLines, Ear, EarOff, iconSize, Layers3, Loader2, Square, Volume2, VolumeX } from '@/lib/icons'
|
||||
import { cn } from '@/lib/utils'
|
||||
import { $hudMode, closeHud } from '@/store/hud'
|
||||
import { $wakeWord, toggleWakeWord } from '@/store/wake-word'
|
||||
|
||||
import { ACTIVE_ICON_BTN, GHOST_ICON_BTN, PRIMARY_ICON_BTN } from './control-classes'
|
||||
import type { ConversationStatus } from './hooks/use-voice-conversation'
|
||||
import { ModelPill } from './model-pill'
|
||||
import type { ChatBarState, VoiceStatus } from './types'
|
||||
import { VoiceMenu } from './voice-menu'
|
||||
|
||||
export const ICON_BTN = 'size-(--composer-control-size) shrink-0 rounded-md'
|
||||
export const GHOST_ICON_BTN = cn(
|
||||
ICON_BTN,
|
||||
'text-(--ui-text-tertiary) hover:bg-(--chrome-action-hover) hover:text-foreground'
|
||||
)
|
||||
// Send/voice-conversation primary: solid foreground-on-background circle
|
||||
// (reads as black-on-white in light mode, white-on-black in dark mode) to
|
||||
// match the reference composer's high-contrast CTA. Keeps the pill itself
|
||||
// neutral and lets the action visually dominate the row.
|
||||
export const PRIMARY_ICON_BTN = cn(
|
||||
'size-(--composer-control-primary-size,var(--composer-control-size)) shrink-0 rounded-full p-0',
|
||||
'bg-foreground text-background hover:bg-foreground/90',
|
||||
'disabled:bg-foreground/30 disabled:text-background disabled:opacity-100'
|
||||
)
|
||||
// Re-exported: `context-menu.tsx` and other row neighbours have always reached
|
||||
// for these here, and the row is where they read as belonging.
|
||||
export { ACTIVE_ICON_BTN, GHOST_ICON_BTN, ICON_BTN, PRIMARY_ICON_BTN } from './control-classes'
|
||||
|
||||
interface ConversationProps {
|
||||
active: boolean
|
||||
@@ -47,7 +39,9 @@ export function ComposerControls({
|
||||
compactModelPill = false,
|
||||
conversation,
|
||||
disabled,
|
||||
foldVoice = false,
|
||||
hasComposerPayload,
|
||||
minimal = false,
|
||||
state,
|
||||
voiceStatus,
|
||||
onDictate,
|
||||
@@ -61,7 +55,9 @@ export function ComposerControls({
|
||||
compactModelPill?: boolean
|
||||
conversation: ConversationProps
|
||||
disabled: boolean
|
||||
foldVoice?: boolean
|
||||
hasComposerPayload: boolean
|
||||
minimal?: boolean
|
||||
state: ChatBarState
|
||||
voiceStatus: VoiceStatus
|
||||
onDictate: () => void
|
||||
@@ -70,6 +66,7 @@ export function ComposerControls({
|
||||
}) {
|
||||
const { t } = useI18n()
|
||||
const c = t.composer
|
||||
const hudMode = useStore($hudMode)
|
||||
|
||||
if (conversation.active) {
|
||||
return <ConversationPill {...conversation} disabled={disabled} />
|
||||
@@ -80,13 +77,40 @@ export function ComposerControls({
|
||||
// only when the composer is empty and a turn is running.
|
||||
const showStop = busy && !hasComposerPayload
|
||||
const showQueueButton = busyAction !== 'stop' && hasComposerPayload
|
||||
// The HUD is a Spotlight bar a few hundred pixels wide, so the four separate
|
||||
// voice toggles fold into one menu there and leave the row to the input. A
|
||||
// narrow tile hits the same wall from the other direction and folds for the
|
||||
// same reason — same controls, same state, different budget. Below that
|
||||
// even the menu goes: at `minimal` the row is the send button and nothing
|
||||
// else, which is the one thing that must survive every width.
|
||||
const foldedVoice = hudMode || foldVoice
|
||||
|
||||
return (
|
||||
<div className="ml-auto flex shrink-0 items-center gap-(--composer-control-gap)">
|
||||
<ModelPill compact={compactModelPill} disabled={disabled} model={state.model} />
|
||||
const voiceControls = foldedVoice ? (
|
||||
<VoiceMenu
|
||||
autoSpeak={autoSpeak}
|
||||
disabled={disabled}
|
||||
onDictate={onDictate}
|
||||
onStartConversation={conversation.onStart}
|
||||
onToggleAutoSpeak={onToggleAutoSpeak}
|
||||
state={state}
|
||||
voiceStatus={voiceStatus}
|
||||
/>
|
||||
) : (
|
||||
<>
|
||||
<DictationButton disabled={disabled} onToggle={onDictate} state={state.voice} status={voiceStatus} />
|
||||
<AutoSpeakButton active={autoSpeak} disabled={disabled} onToggle={onToggleAutoSpeak} />
|
||||
<WakeWordButton disabled={disabled} />
|
||||
</>
|
||||
)
|
||||
|
||||
return (
|
||||
<div className="ml-auto flex min-w-0 shrink items-center gap-(--composer-control-gap)">
|
||||
{minimal ? null : (
|
||||
<>
|
||||
<ModelPill compact={compactModelPill} disabled={disabled} model={state.model} />
|
||||
{voiceControls}
|
||||
</>
|
||||
)}
|
||||
{showQueueButton ? (
|
||||
<Tip label={<TipKeybindLabel actionId="composer.queue" text={c.queueMessage} />}>
|
||||
<Button
|
||||
@@ -142,10 +166,37 @@ export function ComposerControls({
|
||||
</Button>
|
||||
</Tip>
|
||||
)}
|
||||
{/* The way out of HUD mode, riding the controls row rather than floating
|
||||
above the bar. The old chip lived in a 26px transparent strip reserved
|
||||
over the composer (--hud-chip-strip), which under glass is bare
|
||||
untinted material with a hidden button in it — a band of chrome above
|
||||
the surface, paid for in every state, for a control that is invisible
|
||||
until hovered. Here it costs no reserved space and sits with the other
|
||||
things you can press. */}
|
||||
{hudMode ? <ExitHudButton /> : null}
|
||||
</div>
|
||||
)
|
||||
}
|
||||
|
||||
function ExitHudButton() {
|
||||
const { t } = useI18n()
|
||||
|
||||
return (
|
||||
<Tip label={t.titlebar.exitHud}>
|
||||
<Button
|
||||
aria-label={t.titlebar.exitHud}
|
||||
className={cn(GHOST_ICON_BTN, 'p-0')}
|
||||
onClick={closeHud}
|
||||
size="icon"
|
||||
type="button"
|
||||
variant="ghost"
|
||||
>
|
||||
<Codicon name="screen-normal" size="0.875rem" />
|
||||
</Button>
|
||||
</Tip>
|
||||
)
|
||||
}
|
||||
|
||||
function ConversationPill({
|
||||
disabled,
|
||||
level,
|
||||
@@ -269,11 +320,7 @@ function AutoSpeakButton({ active, disabled, onToggle }: { active: boolean; disa
|
||||
<Button
|
||||
aria-label={label}
|
||||
aria-pressed={active}
|
||||
className={cn(
|
||||
GHOST_ICON_BTN,
|
||||
'p-0',
|
||||
active && 'bg-primary/10 text-primary hover:bg-primary/15 hover:text-primary'
|
||||
)}
|
||||
className={cn(GHOST_ICON_BTN, 'p-0', active && ACTIVE_ICON_BTN)}
|
||||
disabled={disabled}
|
||||
onClick={() => {
|
||||
triggerHaptic(active ? 'close' : 'open')
|
||||
@@ -318,11 +365,7 @@ function WakeWordButton({ disabled, pausedForVoice = false }: { disabled: boolea
|
||||
<Button
|
||||
aria-label={label}
|
||||
aria-pressed={wake.listening && !pausedForVoice}
|
||||
className={cn(
|
||||
GHOST_ICON_BTN,
|
||||
'p-0',
|
||||
wake.listening && !pausedForVoice && 'bg-primary/10 text-primary hover:bg-primary/15 hover:text-primary'
|
||||
)}
|
||||
className={cn(GHOST_ICON_BTN, 'p-0', wake.listening && !pausedForVoice && ACTIVE_ICON_BTN)}
|
||||
disabled={disabled || pausedForVoice || wake.pending}
|
||||
onClick={() => {
|
||||
triggerHaptic(wake.listening ? 'close' : 'open')
|
||||
@@ -365,7 +408,7 @@ function DictationButton({
|
||||
GHOST_ICON_BTN,
|
||||
'p-0',
|
||||
'data-[active=true]:bg-accent data-[active=true]:text-foreground',
|
||||
status === 'recording' && 'bg-primary/10 text-primary hover:bg-primary/15 hover:text-primary',
|
||||
status === 'recording' && ACTIVE_ICON_BTN,
|
||||
status === 'transcribing' && 'bg-primary/10 text-primary'
|
||||
)}
|
||||
data-active={active}
|
||||
|
||||
@@ -10,7 +10,13 @@ import {
|
||||
} from '@/app/chat/surface-vars'
|
||||
import { useResizeObserver } from '@/hooks/use-resize-observer'
|
||||
|
||||
import { COMPOSER_COMPACT_PILL_PX, COMPOSER_SINGLE_LINE_MAX_PX, COMPOSER_STACK_BREAKPOINT_PX } from '../composer-utils'
|
||||
import {
|
||||
COMPOSER_COMPACT_PILL_PX,
|
||||
COMPOSER_FOLD_VOICE_PX,
|
||||
COMPOSER_MINIMAL_PX,
|
||||
COMPOSER_SINGLE_LINE_MAX_PX,
|
||||
COMPOSER_STACK_BREAKPOINT_PX
|
||||
} from '../composer-utils'
|
||||
|
||||
interface UseComposerMetricsArgs {
|
||||
composerDockRef: RefObject<HTMLDivElement | null>
|
||||
@@ -20,13 +26,36 @@ interface UseComposerMetricsArgs {
|
||||
poppedOut: boolean
|
||||
}
|
||||
|
||||
/** Every width-driven collapse stage, resolved from the composer's own width. */
|
||||
export interface ComposerFit {
|
||||
compactPill: boolean
|
||||
foldVoice: boolean
|
||||
minimal: boolean
|
||||
tight: boolean
|
||||
}
|
||||
|
||||
const ROOMY: ComposerFit = { compactPill: false, foldVoice: false, minimal: false, tight: false }
|
||||
|
||||
const fitForWidth = (width: number): ComposerFit => ({
|
||||
compactPill: width < COMPOSER_COMPACT_PILL_PX,
|
||||
foldVoice: width < COMPOSER_FOLD_VOICE_PX,
|
||||
minimal: width < COMPOSER_MINIMAL_PX,
|
||||
tight: width < COMPOSER_STACK_BREAKPOINT_PX
|
||||
})
|
||||
|
||||
const sameFit = (a: ComposerFit, b: ComposerFit) =>
|
||||
a.compactPill === b.compactPill && a.foldVoice === b.foldVoice && a.minimal === b.minimal && a.tight === b.tight
|
||||
|
||||
interface UseComposerMetricsResult extends ComposerFit {
|
||||
stacked: boolean
|
||||
}
|
||||
|
||||
/**
|
||||
* Owns the composer's *sizing* engine: the stacked-vs-inline layout decision
|
||||
* and the measured-height CSS vars the thread reads for bottom clearance. All
|
||||
* work is edge-gated — the ResizeObserver only fires on real size changes, the
|
||||
* height vars are 8px-bucketed so per-keystroke growth never invalidates the
|
||||
* tree's computed style, and `tight` only flips when it crosses the breakpoint.
|
||||
* Returns `stacked` (the only value the render needs).
|
||||
* tree's computed style, and the fit only re-renders when it crosses a stage.
|
||||
*/
|
||||
export function useComposerMetrics({
|
||||
composerDockRef,
|
||||
@@ -34,14 +63,9 @@ export function useComposerMetrics({
|
||||
composerSurfaceRef,
|
||||
editorRef,
|
||||
poppedOut
|
||||
}: UseComposerMetricsArgs): {
|
||||
compactPill: boolean
|
||||
stacked: boolean
|
||||
} {
|
||||
}: UseComposerMetricsArgs): UseComposerMetricsResult {
|
||||
const [expanded, setExpanded] = useState(false)
|
||||
const [tight, setTight] = useState(false)
|
||||
// Wider than `tight`: the pill goes icon-only before the row has to stack.
|
||||
const [compactPill, setCompactPill] = useState(false)
|
||||
const [fit, setFit] = useState<ComposerFit>(ROOMY)
|
||||
|
||||
// Edge signals, not the live text: these only re-render when emptiness / the
|
||||
// presence of a non-trailing newline actually flips, so typing within a line
|
||||
@@ -84,8 +108,7 @@ export function useComposerMetrics({
|
||||
// until a wrap or row change actually happens.
|
||||
const lastBucketedHeightRef = useRef(0)
|
||||
const lastBucketedSurfaceHeightRef = useRef(0)
|
||||
const lastTightRef = useRef<boolean | null>(null)
|
||||
const lastCompactPillRef = useRef<boolean | null>(null)
|
||||
const lastFitRef = useRef(ROOMY)
|
||||
// Mirrored into a ref so `syncComposerMetrics` stays referentially stable —
|
||||
// it's the shared ResizeObserver's handler, and a new identity every render
|
||||
// would re-register the observation.
|
||||
@@ -121,18 +144,11 @@ export function useComposerMetrics({
|
||||
const surfaceHeight = composerSurfaceRef.current?.getBoundingClientRect().height
|
||||
|
||||
if (width > 0) {
|
||||
const nextTight = width < COMPOSER_STACK_BREAKPOINT_PX
|
||||
const nextFit = fitForWidth(width)
|
||||
|
||||
if (nextTight !== lastTightRef.current) {
|
||||
lastTightRef.current = nextTight
|
||||
setTight(nextTight)
|
||||
}
|
||||
|
||||
const nextCompactPill = width < COMPOSER_COMPACT_PILL_PX
|
||||
|
||||
if (nextCompactPill !== lastCompactPillRef.current) {
|
||||
lastCompactPillRef.current = nextCompactPill
|
||||
setCompactPill(nextCompactPill)
|
||||
if (!sameFit(nextFit, lastFitRef.current)) {
|
||||
lastFitRef.current = nextFit
|
||||
setFit(nextFit)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -189,7 +205,7 @@ export function useComposerMetrics({
|
||||
}
|
||||
}, [composerRef])
|
||||
|
||||
// Both decisions come from the composer's OWN measured width, never the
|
||||
// Every decision comes from the composer's OWN measured width, never the
|
||||
// viewport's. There used to be a `(max-width: 30rem)` media query in here as
|
||||
// well, and it quietly outranked everything: any window under 480px stacked
|
||||
// the row AND compacted the pill in the same instant, regardless of how much
|
||||
@@ -199,7 +215,14 @@ export function useComposerMetrics({
|
||||
// stack) by 160px. The ResizeObserver knows the real width; the viewport is
|
||||
// not a proxy for it.
|
||||
//
|
||||
// The pill still compacts whenever the row stacks, so the controls row can't
|
||||
// over-run once it has the width to itself.
|
||||
return { compactPill: compactPill || tight, stacked: expanded || tight }
|
||||
// The ladder is monotonic: each stage implies the ones above it, so the pill
|
||||
// is always compact by the time the row stacks, and the voice controls are
|
||||
// always folded before minimal drops them.
|
||||
return {
|
||||
compactPill: fit.compactPill || fit.tight,
|
||||
foldVoice: fit.foldVoice || fit.minimal,
|
||||
minimal: fit.minimal,
|
||||
stacked: expanded || fit.tight,
|
||||
tight: fit.tight
|
||||
}
|
||||
}
|
||||
|
||||
@@ -321,7 +321,7 @@ export function ChatBar({
|
||||
return onCancel()
|
||||
}, [activeQueueSessionKeyRef, onCancel])
|
||||
|
||||
const { compactPill, stacked } = useComposerMetrics({
|
||||
const { compactPill, foldVoice, minimal, stacked } = useComposerMetrics({
|
||||
composerDockRef,
|
||||
composerRef,
|
||||
composerSurfaceRef,
|
||||
@@ -984,7 +984,9 @@ export function ChatBar({
|
||||
status: conversation.status
|
||||
}}
|
||||
disabled={disabled}
|
||||
foldVoice={foldVoice}
|
||||
hasComposerPayload={hasComposerPayload}
|
||||
minimal={minimal}
|
||||
onDictate={dictate}
|
||||
onQueue={queueDraft}
|
||||
onToggleAutoSpeak={handleToggleAutoSpeak}
|
||||
@@ -1242,7 +1244,13 @@ export function ChatBar({
|
||||
{hudMode && busy && <span aria-hidden className="arc-border arc-composer" />}
|
||||
<div
|
||||
className={cn(
|
||||
'group/composer-surface relative z-4 isolate grid grid-rows-[auto_1fr] overflow-hidden rounded-[inherit] border border-[color-mix(in_srgb,var(--dt-composer-ring)_calc(18%*var(--composer-ring-strength)),var(--dt-input))]',
|
||||
// grid-cols-[minmax(0,1fr)]: the implicit `auto` column sized
|
||||
// itself to its items' min-content, so a status row whose
|
||||
// content out-measured a narrow pane silently widened the
|
||||
// track past the surface — and every `w-full` child (the fade,
|
||||
// the input/controls row) laid out against that phantom width
|
||||
// and got clipped by overflow-hidden, send button first.
|
||||
'group/composer-surface relative z-4 isolate grid grid-cols-[minmax(0,1fr)] grid-rows-[auto_1fr] overflow-hidden rounded-[inherit] border border-[color-mix(in_srgb,var(--dt-composer-ring)_calc(18%*var(--composer-ring-strength)),var(--dt-input))]',
|
||||
COMPOSER_DROP_FADE_CLASS,
|
||||
dragActive && COMPOSER_DROP_ACTIVE_CLASS
|
||||
)}
|
||||
@@ -1322,7 +1330,7 @@ export function ChatBar({
|
||||
<ContribSlot area={COMPOSER_AREAS.leading} />
|
||||
</div>
|
||||
<div className="min-w-0 [grid-area:input]">{input}</div>
|
||||
<div className="flex items-center justify-end gap-(--composer-control-gap) [grid-area:controls]">
|
||||
<div className="flex min-w-0 items-center justify-end gap-(--composer-control-gap) [grid-area:controls]">
|
||||
<ContribSlot area={COMPOSER_AREAS.actions} />
|
||||
{controls}
|
||||
</div>
|
||||
|
||||
@@ -18,8 +18,11 @@ import { onComposerModelMenuRequest } from './focus'
|
||||
import { useComposerScope } from './scope'
|
||||
import type { ChatBarState } from './types'
|
||||
|
||||
// `shrink` (not `shrink-0`) with a truncating label: the pill is the one
|
||||
// control in the row that can give width back continuously, so it absorbs the
|
||||
// squeeze between collapse stages instead of pushing Send past the edge.
|
||||
const PILL = cn(
|
||||
'h-(--composer-control-size) max-w-40 shrink-0 gap-1 rounded-md px-2 text-xs font-normal',
|
||||
'h-(--composer-control-size) min-w-0 max-w-40 shrink gap-1 rounded-md px-2 text-xs font-normal',
|
||||
'text-(--ui-text-tertiary) hover:bg-(--chrome-action-hover) hover:text-foreground'
|
||||
)
|
||||
|
||||
|
||||
@@ -0,0 +1,162 @@
|
||||
import { useStore } from '@nanostores/react'
|
||||
|
||||
import { Button } from '@/components/ui/button'
|
||||
import { Codicon } from '@/components/ui/codicon'
|
||||
import {
|
||||
DropdownMenu,
|
||||
DropdownMenuCheckboxItem,
|
||||
DropdownMenuContent,
|
||||
DropdownMenuItem,
|
||||
dropdownMenuRow,
|
||||
DropdownMenuSeparator,
|
||||
DropdownMenuTrigger
|
||||
} from '@/components/ui/dropdown-menu'
|
||||
import { Tip } from '@/components/ui/tooltip'
|
||||
import { useI18n } from '@/i18n'
|
||||
import { triggerHaptic } from '@/lib/haptics'
|
||||
import { AudioLines, Ear, EarOff, iconSize, Loader2, Square, Volume2, VolumeX } from '@/lib/icons'
|
||||
import { cn } from '@/lib/utils'
|
||||
import { $wakeWord, toggleWakeWord } from '@/store/wake-word'
|
||||
|
||||
import { ACTIVE_ICON_BTN, GHOST_ICON_BTN } from './control-classes'
|
||||
import type { ChatBarState, VoiceStatus } from './types'
|
||||
|
||||
export interface VoiceMenuProps {
|
||||
autoSpeak: boolean
|
||||
disabled: boolean
|
||||
state: ChatBarState
|
||||
voiceStatus: VoiceStatus
|
||||
onDictate: () => void
|
||||
onStartConversation: () => void
|
||||
onToggleAutoSpeak: () => void
|
||||
}
|
||||
|
||||
/**
|
||||
* Every voice control behind one trigger: dictation, spoken replies, the
|
||||
* "hey hermes" wake word, and starting a full conversation.
|
||||
*
|
||||
* The bar carried four separate icon buttons — mic, speaker, ear, and the
|
||||
* voice-conversation primary — which is most of a Spotlight-width composer
|
||||
* spent on toggles that are set once and rarely touched. Collapsing them costs
|
||||
* one click on the rare change and gives the row back to the input.
|
||||
*
|
||||
* The trigger is not a static glyph: it REPORTS the loudest live voice state
|
||||
* (recording, transcribing, listening for the wake word, speaking replies), so
|
||||
* folding the controls away never hides the fact that something is listening.
|
||||
* A collapsed menu that looked idle while the mic was hot would be a worse
|
||||
* trade than the space it saves.
|
||||
*/
|
||||
export function VoiceMenu({
|
||||
autoSpeak,
|
||||
disabled,
|
||||
state,
|
||||
voiceStatus,
|
||||
onDictate,
|
||||
onStartConversation,
|
||||
onToggleAutoSpeak
|
||||
}: VoiceMenuProps) {
|
||||
const { t } = useI18n()
|
||||
const c = t.composer
|
||||
const wake = useStore($wakeWord)
|
||||
|
||||
const phrase = wake.phrase || 'hey hermes'
|
||||
const dictating = state.voice.active || voiceStatus !== 'idle'
|
||||
const wakeListening = wake.listening
|
||||
// Anything live keeps the trigger lit, so a folded menu can never look idle
|
||||
// while the mic is open.
|
||||
const active = dictating || wakeListening || autoSpeak
|
||||
|
||||
const dictationLabel =
|
||||
voiceStatus === 'recording'
|
||||
? c.stopDictation
|
||||
: voiceStatus === 'transcribing'
|
||||
? c.transcribingDictation
|
||||
: c.voiceDictation
|
||||
|
||||
const wakeLabel = wakeListening ? c.wakeWordListening(phrase) : c.wakeWordOff(phrase)
|
||||
const triggerLabel = dictating ? dictationLabel : wakeListening ? wakeLabel : c.voiceControls
|
||||
|
||||
return (
|
||||
<DropdownMenu>
|
||||
<Tip label={wake.notice && !dictating ? `${triggerLabel} — ${wake.notice}` : triggerLabel}>
|
||||
<DropdownMenuTrigger asChild>
|
||||
<Button
|
||||
aria-label={triggerLabel}
|
||||
className={cn(GHOST_ICON_BTN, 'p-0', active && ACTIVE_ICON_BTN)}
|
||||
disabled={disabled}
|
||||
size="icon"
|
||||
type="button"
|
||||
variant="ghost"
|
||||
>
|
||||
{voiceStatus === 'recording' ? (
|
||||
<Square className={cn('fill-current', iconSize.xs)} />
|
||||
) : voiceStatus === 'transcribing' ? (
|
||||
<Loader2 className={cn('animate-spin', iconSize.sm)} />
|
||||
) : wakeListening ? (
|
||||
<Ear className={iconSize.sm} />
|
||||
) : (
|
||||
<Codicon name="mic" size="0.875rem" />
|
||||
)}
|
||||
</Button>
|
||||
</DropdownMenuTrigger>
|
||||
</Tip>
|
||||
<DropdownMenuContent align="end" className="min-w-52">
|
||||
<DropdownMenuItem
|
||||
className={dropdownMenuRow}
|
||||
disabled={disabled}
|
||||
onSelect={() => {
|
||||
triggerHaptic('open')
|
||||
onStartConversation()
|
||||
}}
|
||||
>
|
||||
<AudioLines className={iconSize.sm} />
|
||||
{c.startVoice}
|
||||
</DropdownMenuItem>
|
||||
<DropdownMenuSeparator />
|
||||
{/* Checkbox items, because all three are toggles the user is reading
|
||||
the CURRENT state of — the reason they were pressed-state buttons
|
||||
before. A plain row would fold that state away with the menu. */}
|
||||
<DropdownMenuCheckboxItem
|
||||
checked={dictating}
|
||||
className={dropdownMenuRow}
|
||||
disabled={disabled || !state.voice.enabled || voiceStatus === 'transcribing'}
|
||||
onSelect={event => {
|
||||
// Keep the menu open: dictation is a mode you watch, and closing
|
||||
// on select hides the recording state the trigger just entered.
|
||||
event.preventDefault()
|
||||
triggerHaptic(dictating ? 'close' : 'open')
|
||||
onDictate()
|
||||
}}
|
||||
>
|
||||
{dictationLabel}
|
||||
</DropdownMenuCheckboxItem>
|
||||
<DropdownMenuCheckboxItem
|
||||
checked={autoSpeak}
|
||||
className={dropdownMenuRow}
|
||||
disabled={disabled}
|
||||
onSelect={event => {
|
||||
event.preventDefault()
|
||||
triggerHaptic(autoSpeak ? 'close' : 'open')
|
||||
onToggleAutoSpeak()
|
||||
}}
|
||||
>
|
||||
{autoSpeak ? <Volume2 className={iconSize.sm} /> : <VolumeX className={iconSize.sm} />}
|
||||
{autoSpeak ? c.stopSpeakingReplies : c.speakReplies}
|
||||
</DropdownMenuCheckboxItem>
|
||||
<DropdownMenuCheckboxItem
|
||||
checked={wakeListening}
|
||||
className={dropdownMenuRow}
|
||||
disabled={disabled || wake.pending}
|
||||
onSelect={event => {
|
||||
event.preventDefault()
|
||||
triggerHaptic(wakeListening ? 'close' : 'open')
|
||||
void toggleWakeWord()
|
||||
}}
|
||||
>
|
||||
{wakeListening ? <Ear className={iconSize.sm} /> : <EarOff className={iconSize.sm} />}
|
||||
{wakeLabel}
|
||||
</DropdownMenuCheckboxItem>
|
||||
</DropdownMenuContent>
|
||||
</DropdownMenu>
|
||||
)
|
||||
}
|
||||
@@ -23,6 +23,7 @@ import type { ChatMessage } from '@/lib/chat-messages'
|
||||
import { NEW_SESSION_TITLE, quickModelOptions, sessionTitle } from '@/lib/chat-runtime'
|
||||
import { useIncrementalExternalStoreRuntime } from '@/lib/incremental-external-store-runtime'
|
||||
import { modelOptionsQueryKey, requestModelOptions } from '@/lib/model-options'
|
||||
import { useStoreSelector } from '@/lib/use-session-slice'
|
||||
import { cn } from '@/lib/utils'
|
||||
import { migrateSessionDraft } from '@/store/composer'
|
||||
import { migrateQueuedPrompts, parkQueuedPrompts } from '@/store/composer-queue'
|
||||
@@ -46,7 +47,7 @@ import {
|
||||
sessionPinId,
|
||||
shouldMigrateComposerScope
|
||||
} from '@/store/session'
|
||||
import { sessionTileDelegate } from '@/store/session-states'
|
||||
import { $focusedStoredSessionId, sessionTileDelegate } from '@/store/session-states'
|
||||
import { $transcriptTailBySessionId, transcriptTailState } from '@/store/transcript-tail'
|
||||
import { isAuxiliaryWindow, isWatchWindow } from '@/store/windows'
|
||||
import type { ModelOptionsResponse } from '@/types/hermes'
|
||||
@@ -389,6 +390,13 @@ const ChatViewContent = memo(function ChatViewContent({
|
||||
const isPrimary = view.kind === 'primary'
|
||||
const activeSessionId = useStore(view.$runtimeId)
|
||||
const storedId = useStore(view.$storedId)
|
||||
// Multi-pane dimming: only the focused surface paints at full strength, so
|
||||
// two sessions side by side read as "this one, and that one over there".
|
||||
// A selector, not a plain useStore — the focused id changes on click, and a
|
||||
// boolean bails every other surface out of the re-render. Sole surface ⇒
|
||||
// always focused (the atom falls back to the primary's selection), so a
|
||||
// single-pane workspace never dims.
|
||||
const surfaceFocused = useStoreSelector($focusedStoredSessionId, focused => focused === storedId)
|
||||
// Dock anchor for a session drop onto this surface: the workspace pane for the
|
||||
// primary, this tile's pane id for a tile. Read by the session-drop bridge.
|
||||
const sessionAnchor = isPrimary ? 'workspace' : `session-tile:${storedId ?? ''}`
|
||||
@@ -593,6 +601,7 @@ const ChatViewContent = memo(function ChatViewContent({
|
||||
className
|
||||
)}
|
||||
data-chat-surface=""
|
||||
data-chat-unfocused={surfaceFocused ? undefined : ''}
|
||||
data-composer-surface-id={composerSurfaceId}
|
||||
data-composer-target={composerScope.target}
|
||||
data-session-anchor={sessionAnchor}
|
||||
|
||||
@@ -0,0 +1,316 @@
|
||||
import { beforeEach, describe, expect, it, vi } from 'vitest'
|
||||
|
||||
import { $rightRailActiveTabId } from '@/store/layout'
|
||||
import { closeRightRail, openPreview, type PreviewTarget } from '@/store/preview'
|
||||
|
||||
import { actOnActivePreview } from './preview-act'
|
||||
import { registerPreviewInput } from './preview-input'
|
||||
import { registerPreviewNav } from './preview-nav'
|
||||
import { registerPreviewScriptRunner } from './preview-script-runner'
|
||||
|
||||
function urlTarget(url: string): PreviewTarget {
|
||||
return { kind: 'url', label: 'Browser', source: url, url }
|
||||
}
|
||||
|
||||
describe('actOnActivePreview (drive_preview tool)', () => {
|
||||
// URL targets share the singleton Browser tab id, so anything a test
|
||||
// registers would answer the next one.
|
||||
let cleanups: Array<() => void> = []
|
||||
|
||||
const openBrowserTab = () => {
|
||||
openPreview(urlTarget('https://example.com'), 'tool-result')
|
||||
|
||||
return $rightRailActiveTabId.get()!
|
||||
}
|
||||
|
||||
const withRunner = (runner: (code: string) => Promise<unknown>) =>
|
||||
cleanups.push(registerPreviewScriptRunner(openBrowserTab(), runner))
|
||||
|
||||
beforeEach(() => {
|
||||
vi.useRealTimers()
|
||||
|
||||
for (const cleanup of cleanups) {
|
||||
cleanup()
|
||||
}
|
||||
|
||||
cleanups = []
|
||||
closeRightRail()
|
||||
window.localStorage.clear()
|
||||
})
|
||||
|
||||
it('tells the agent to open a page when no live pane is behind the tab', async () => {
|
||||
const result = await actOnActivePreview({ kind: 'elements' })
|
||||
|
||||
expect(result.success).toBe(false)
|
||||
expect(result.error).toContain('open_preview')
|
||||
})
|
||||
|
||||
it('injects the engine and returns the page’s answer', async () => {
|
||||
let injected = ''
|
||||
|
||||
withRunner(async code => {
|
||||
injected = code
|
||||
|
||||
return JSON.stringify({ acted: 'clicked button "Save"', success: true })
|
||||
})
|
||||
|
||||
const result = await actOnActivePreview({ kind: 'click', ref: '@e1' })
|
||||
|
||||
expect(result).toMatchObject({ acted: 'clicked button "Save"', success: true })
|
||||
// Self-contained payload: the engine source and the action travel together,
|
||||
// and the holder keeps refs alive across calls on the same page.
|
||||
expect(injected).toContain('__hermesActHolder')
|
||||
expect(injected).toContain('"ref":"@e1"')
|
||||
})
|
||||
|
||||
it('re-inventories after a mutating action so the next ref is current', async () => {
|
||||
const actions: string[] = []
|
||||
|
||||
withRunner(code => {
|
||||
// Stand in for the guest page: run the script's own settle/rescan shape
|
||||
// by answering each act() call in order.
|
||||
actions.push(...(code.match(/"kind":"(\w+)"/g) ?? []))
|
||||
|
||||
return Promise.resolve(
|
||||
JSON.stringify({
|
||||
acted: 'clicked',
|
||||
elements: [{ label: 'Log out', ref: '@e1', role: 'button', selector: '#out' }],
|
||||
success: true,
|
||||
url: 'https://example.com/app'
|
||||
})
|
||||
)
|
||||
})
|
||||
|
||||
const result = await actOnActivePreview({ kind: 'click', ref: '@e1' })
|
||||
|
||||
expect(result.elements?.[0].label).toBe('Log out')
|
||||
expect(result.url).toBe('https://example.com/app')
|
||||
})
|
||||
|
||||
it('does not pay the settle delay for a plain inventory', async () => {
|
||||
let injected = ''
|
||||
withRunner(async code => {
|
||||
injected = code
|
||||
|
||||
return JSON.stringify({ elements: [], success: true })
|
||||
})
|
||||
|
||||
await actOnActivePreview({ kind: 'elements' })
|
||||
|
||||
expect(injected).toContain('0 <= 0')
|
||||
})
|
||||
|
||||
it('reports a page that answers with nothing', async () => {
|
||||
withRunner(async () => '')
|
||||
|
||||
expect((await actOnActivePreview({ kind: 'click', ref: '@e1' })).error).toContain('did not answer')
|
||||
})
|
||||
|
||||
/** A pane that answers the locate trip with a fixed on-screen point, and the
|
||||
* read-back trip with an empty inventory. Returns the input spy. */
|
||||
const withDrivenPane = () => {
|
||||
const tabId = openBrowserTab()
|
||||
const send = vi.fn()
|
||||
|
||||
cleanups.push(
|
||||
registerPreviewScriptRunner(tabId, async code =>
|
||||
code.includes('"kind":"locate"')
|
||||
? JSON.stringify({ acted: 'looking at button "Save"', point: { x: 120, y: 80 }, success: true })
|
||||
: // `hit` is the page's witness that the real pointerdown arrived.
|
||||
JSON.stringify({ elements: [], hit: { tag: 'BUTTON', trusted: true }, success: true })
|
||||
)
|
||||
)
|
||||
cleanups.push(registerPreviewInput(tabId, { focus: vi.fn(), send }))
|
||||
|
||||
return send
|
||||
}
|
||||
|
||||
const sentTypes = (send: ReturnType<typeof vi.fn>) => send.mock.calls.map(([event]) => event.type)
|
||||
|
||||
it('clicks with real input, walking the pointer to where the page said', async () => {
|
||||
const send = withDrivenPane()
|
||||
|
||||
const result = await actOnActivePreview({ kind: 'click', ref: '@e1' })
|
||||
const types = sentTypes(send)
|
||||
|
||||
// Stepped rather than teleported: a page learns it is hovered from a stream
|
||||
// of moves, and one jump to the target skips everything in between.
|
||||
expect(types.filter(type => type === 'mouseMove').length).toBeGreaterThan(1)
|
||||
expect(types).toContain('mouseDown')
|
||||
expect(types).toContain('mouseUp')
|
||||
expect(send.mock.calls.map(([event]) => event).find(event => event.type === 'mouseDown')).toMatchObject({
|
||||
x: 120,
|
||||
y: 80
|
||||
})
|
||||
expect(result.acted).toBe('clicked button "Save"')
|
||||
})
|
||||
|
||||
it('types by pressing keys, after selecting whatever the field held', async () => {
|
||||
const send = withDrivenPane()
|
||||
|
||||
await actOnActivePreview({ kind: 'type', ref: '@e1', submit: true, text: 'hi' })
|
||||
|
||||
const events = send.mock.calls.map(([event]) => event)
|
||||
const chars = events.filter(event => event.type === 'char').map(event => event.keyCode)
|
||||
|
||||
// One click to focus, then select-all by keyboard — NOT the triple-click
|
||||
// this used to do. A triple-click is a pointer gesture, so it grabs the
|
||||
// paragraph under the cursor whenever the target turns out not to be a
|
||||
// field, and the agent was leaving pages with their body text highlighted.
|
||||
expect(events.filter(event => event.type === 'mouseDown').map(event => event.clickCount)).toEqual([1])
|
||||
expect(events.filter(event => event.type === 'keyDown' && event.keyCode === 'a')[0]).toMatchObject({
|
||||
modifiers: ['control', 'meta']
|
||||
})
|
||||
// The chord must not send a `char` phase, or select-all types a literal 'a'.
|
||||
expect(chars).toEqual(['h', 'i', 'Enter'])
|
||||
})
|
||||
|
||||
it('hovers by walking the pointer over and leaving it there', async () => {
|
||||
const send = withDrivenPane()
|
||||
|
||||
const result = await actOnActivePreview({ kind: 'hover', ref: '@e1' })
|
||||
const types = sentTypes(send)
|
||||
|
||||
expect(types).toContain('mouseMove')
|
||||
// The whole request is "be on it" — a click here would open the dropdown the
|
||||
// agent was trying to reveal, or worse, activate it.
|
||||
expect(types).not.toContain('mouseDown')
|
||||
expect(result.acted).toBe('hovered over button "Save"')
|
||||
})
|
||||
|
||||
// The witness only speaks for verbs that put the button down. Demanding one
|
||||
// from a key press reported every press as a failure.
|
||||
it('does not expect a click witness from a verb that never clicks', async () => {
|
||||
const tabId = openBrowserTab()
|
||||
|
||||
cleanups.push(
|
||||
registerPreviewScriptRunner(tabId, async code =>
|
||||
code.includes('"kind":"locate"')
|
||||
? JSON.stringify({ acted: 'looking at textbox "Search"', point: { x: 40, y: 20 }, success: true })
|
||||
: JSON.stringify({ elements: [], hit: null, success: true })
|
||||
)
|
||||
)
|
||||
cleanups.push(registerPreviewInput(tabId, { focus: vi.fn(), send: vi.fn() }))
|
||||
|
||||
for (const action of [
|
||||
{ key: 'Escape', kind: 'press', ref: '@e1' },
|
||||
{ kind: 'hover', ref: '@e1' }
|
||||
]) {
|
||||
expect(await actOnActivePreview(action)).toMatchObject({ success: true })
|
||||
}
|
||||
})
|
||||
|
||||
it('scrolls by wheeling for real, not by scripting the page', async () => {
|
||||
const tabId = openBrowserTab()
|
||||
const send = vi.fn()
|
||||
let scripted = false
|
||||
|
||||
cleanups.push(
|
||||
registerPreviewScriptRunner(tabId, async code => {
|
||||
scripted ||= code.includes('"kind":"scroll"')
|
||||
|
||||
return code.includes('scrollHeight')
|
||||
? JSON.stringify({ page: 700, point: { x: 500, y: 400 }, span: 4_000, success: true })
|
||||
: JSON.stringify({ elements: [], success: true })
|
||||
})
|
||||
)
|
||||
cleanups.push(registerPreviewInput(tabId, { focus: vi.fn(), send }))
|
||||
|
||||
await actOnActivePreview({ kind: 'scroll' })
|
||||
|
||||
const wheels = send.mock.calls.map(([event]) => event).filter(event => event.type === 'mouseWheel')
|
||||
|
||||
// A stream of notches, not one delta: scroll-linked headers and lazy loaders
|
||||
// only react to the events, so a scripted scrollBy leaves them asleep.
|
||||
expect(wheels.length).toBeGreaterThan(1)
|
||||
// Electron's wheel delta is wheelDelta-signed, so scrolling DOWN is negative.
|
||||
expect(wheels.every(event => event.deltaY < 0)).toBe(true)
|
||||
expect(scripted).toBe(false)
|
||||
})
|
||||
|
||||
it('says so plainly when the page has nothing to scroll', async () => {
|
||||
const tabId = openBrowserTab()
|
||||
|
||||
cleanups.push(
|
||||
registerPreviewScriptRunner(tabId, async () =>
|
||||
JSON.stringify({ page: 700, point: { x: 500, y: 400 }, span: 0, success: true })
|
||||
)
|
||||
)
|
||||
cleanups.push(registerPreviewInput(tabId, { focus: vi.fn(), send: vi.fn() }))
|
||||
|
||||
expect(await actOnActivePreview({ kind: 'scroll' })).toMatchObject({
|
||||
note: expect.stringContaining('nothing to scroll')
|
||||
})
|
||||
})
|
||||
|
||||
it('fails loudly when the pointer input never reaches the page', async () => {
|
||||
const tabId = openBrowserTab()
|
||||
|
||||
cleanups.push(
|
||||
registerPreviewScriptRunner(tabId, async code =>
|
||||
code.includes('"kind":"locate"')
|
||||
? JSON.stringify({ acted: 'looking at button "Save"', point: { x: 12, y: 8 }, success: true })
|
||||
: JSON.stringify({ elements: [], hit: null, success: true })
|
||||
)
|
||||
)
|
||||
cleanups.push(registerPreviewInput(tabId, { focus: vi.fn(), send: vi.fn() }))
|
||||
|
||||
const result = await actOnActivePreview({ kind: 'click', ref: '@e1' })
|
||||
|
||||
// Everything else about this action travels on the script channel and would
|
||||
// report success whether or not a single event landed.
|
||||
expect(result.success).toBe(false)
|
||||
expect(result.error).toContain('never reached the page')
|
||||
})
|
||||
|
||||
it('says so when the overlay itself swallowed the click', async () => {
|
||||
const tabId = openBrowserTab()
|
||||
|
||||
cleanups.push(
|
||||
registerPreviewScriptRunner(tabId, async code =>
|
||||
code.includes('"kind":"locate"')
|
||||
? JSON.stringify({ acted: 'looking at button "Save"', point: { x: 12, y: 8 }, success: true })
|
||||
: JSON.stringify({ elements: [], hit: { tag: 'HERMES-WATCH', trusted: true }, success: true })
|
||||
)
|
||||
)
|
||||
cleanups.push(registerPreviewInput(tabId, { focus: vi.fn(), send: vi.fn() }))
|
||||
|
||||
expect((await actOnActivePreview({ kind: 'click', ref: '@e1' })).note).toContain('overlay intercepted')
|
||||
})
|
||||
|
||||
it('falls back to scripted events when the pane exposes no input channel', async () => {
|
||||
let injected = ''
|
||||
|
||||
withRunner(async code => {
|
||||
injected = code
|
||||
|
||||
return JSON.stringify({ acted: 'clicked', success: true })
|
||||
})
|
||||
|
||||
await actOnActivePreview({ kind: 'click', ref: '@e1' })
|
||||
|
||||
// The one-trip shape: the engine both acts and re-reads, no locate handshake.
|
||||
expect(injected).toContain('"kind":"click"')
|
||||
expect(injected).not.toContain('"kind":"locate"')
|
||||
})
|
||||
|
||||
it('routes history verbs to the pane instead of the guest page', async () => {
|
||||
const back = vi.fn()
|
||||
const runner = vi.fn()
|
||||
|
||||
const tabId = openBrowserTab()
|
||||
cleanups.push(registerPreviewNav(tabId, { back, forward: vi.fn(), reload: vi.fn() }))
|
||||
cleanups.push(registerPreviewScriptRunner(tabId, runner))
|
||||
|
||||
const result = await actOnActivePreview({ kind: 'back' })
|
||||
|
||||
expect(back).toHaveBeenCalledOnce()
|
||||
expect(runner).not.toHaveBeenCalled()
|
||||
expect(result.success).toBe(true)
|
||||
expect(result.note).toContain('elements')
|
||||
})
|
||||
|
||||
it('reports history verbs with no pane to drive', async () => {
|
||||
expect((await actOnActivePreview({ kind: 'reload' })).error).toContain('open_preview')
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,567 @@
|
||||
/**
|
||||
* PREVIEW ACT — performs the agent's interactions inside the preview pane's
|
||||
* guest page, so `drive_preview` drives whatever web app is open in the in-app
|
||||
* browser.
|
||||
*
|
||||
* The guest page is out-of-process; nothing here can touch its DOM directly.
|
||||
* Two separate channels reach it, and the split matters:
|
||||
*
|
||||
* - `executeJavaScript` injects the engine SOURCE (see
|
||||
* lib/preview-act/act-in-page.ts's self-containment contract) to RESOLVE
|
||||
* and READ — turn 'btn-sign-in' into a node, measure it, inventory the
|
||||
* page. It is parked on a window global alongside the book of handles so
|
||||
* they survive between calls, and it vanishes with the page, so a
|
||||
* navigation retires them and the engine reports that instead of acting on
|
||||
* the wrong node.
|
||||
* - `sendInputEvent` (preview-drive.ts) does the ACTING, as real Chromium
|
||||
* input. Script can only dispatch synthetic events, which the page can tell
|
||||
* apart and which never move the browser's own hover or focus target.
|
||||
*
|
||||
* Panes with no input channel — a remote HTML preview — fall back to the
|
||||
* engine's synthetic events, which is worse but still works.
|
||||
*
|
||||
* A mutating action settles briefly and returns a fresh inventory, so the
|
||||
* click → re-read → click loop costs one round trip instead of two.
|
||||
*
|
||||
* Dynamic-imported by the gateway event handler so the engine payload stays
|
||||
* out of the boot path.
|
||||
*/
|
||||
|
||||
import { actEngineSource, type PreviewActAction, type PreviewActResult } from '@/lib/preview-act/act-in-page'
|
||||
import { watchInPage } from '@/lib/preview-act/watch-in-page'
|
||||
|
||||
import { clickAt, glideTo, pointerPlaced, pressKey, selectAll, typeText, wheelBy } from './preview-drive'
|
||||
import { activePreviewInput, type PreviewInputHandle } from './preview-input'
|
||||
import { activePreviewNav, type PreviewNavHandle } from './preview-nav'
|
||||
import { activePreviewScriptRunner, type PreviewScriptRunner } from './preview-script-runner'
|
||||
|
||||
/** Verbs the pane owns; a guest page cannot drive its own history. */
|
||||
const NAV_ACTIONS: readonly (keyof PreviewNavHandle)[] = ['back', 'forward', 'reload']
|
||||
|
||||
/** How long a click/type is given to land before the page is re-inventoried.
|
||||
* Long enough for a framework re-render, short enough not to stall the turn.
|
||||
* A render that misses this window is not lost — the NEXT action re-reads the
|
||||
* page anyway, so the cost of being early is a slightly stale inventory, not a
|
||||
* wrong one. That trade is worth several hundred ms on every single step. */
|
||||
const SETTLE_MS = 220
|
||||
|
||||
/** Cap on one round trip into the guest page. A click that starts a navigation
|
||||
* tears the document down mid-settle, so the injected promise dies with it and
|
||||
* `executeJavaScript` never settles — without this the tool eats its whole
|
||||
* 45s bridge deadline for what was actually a successful click. */
|
||||
const ACT_TIMEOUT_MS = 8_000
|
||||
|
||||
/** Verbs that get the look-then-act treatment: locate the target, walk the
|
||||
* pointer there, then send real input. Actions with no single target (scroll,
|
||||
* elements) are absent and skip it. */
|
||||
const DRIVEN: readonly string[] = ['click', 'hover', 'press', 'type']
|
||||
|
||||
/** Verbs that put the mouse button down, and so are the only ones the pointerdown
|
||||
* witness can speak to. `press` and `hover` never click, so demanding a witness
|
||||
* from them would report every one of them as a failure. */
|
||||
const CLICKS: readonly string[] = ['click', 'type']
|
||||
|
||||
const NOTHING_OPEN = 'No live page is open in the in-app browser — open one with open_preview first.'
|
||||
|
||||
const NAVIGATED =
|
||||
'The page stopped answering right after — it is probably navigating. Call elements to see where you landed.'
|
||||
|
||||
/** A fingerprint of the overlay's source, so the guest page can tell that the
|
||||
* code it is running has changed underneath it.
|
||||
*
|
||||
* It needs one because the overlay memoizes its own chrome: the cursor, the
|
||||
* lock frame and the scan line are built ONCE per page and then reused, so an
|
||||
* edit to any of their styles lands in the injected source, gets injected, and
|
||||
* changes nothing — the layers it would have styled were built by the previous
|
||||
* version and are still on the page. In dev that reads as "HMR didn't pick up
|
||||
* my CSS"; in production it is a long-lived tab pinned to whichever build first
|
||||
* touched it, across an app upgrade.
|
||||
*
|
||||
* Content-addressed rather than a length or a version literal: the change that
|
||||
* exposed this was one hex colour for another, which is byte-for-byte the same
|
||||
* length, and a hand-maintained version is a step someone forgets. */
|
||||
const WATCH_TAG = (() => {
|
||||
const source = watchInPage.toString()
|
||||
let hash = 5381
|
||||
|
||||
for (let i = 0; i < source.length; i++) {
|
||||
hash = ((hash << 5) + hash + source.charCodeAt(i)) | 0
|
||||
}
|
||||
|
||||
return hash
|
||||
})()
|
||||
|
||||
/** Injected once per page: the engine, the overlay, and the two helpers every
|
||||
* script below shares. Idempotent — re-running it on a live page is a no-op. */
|
||||
const preamble = () => ` var w = window;
|
||||
// Reassigned on every trip rather than cached behind a guard: the source is in
|
||||
// this payload either way, so the guard saved nothing and pinned a long-lived
|
||||
// tab to whichever build first touched it. The holder is the exception — it
|
||||
// carries the aimed element from the locate trip to the act trip.
|
||||
w.__hermesActHolder = w.__hermesActHolder || {};
|
||||
w.__hermesAct = ${actEngineSource()};
|
||||
w.__hermesWatch_fn = (${watchInPage.toString()});
|
||||
w.__hermesWatchTag = ${WATCH_TAG};
|
||||
var holder = w.__hermesActHolder;
|
||||
var act = function (a) { return w.__hermesAct(document, holder, a); };
|
||||
var watch = function (stage, label) {
|
||||
try { w.__hermesWatch_fn(document, holder, stage, label); } catch (err) {}
|
||||
};
|
||||
var wait = function (ms) { return new Promise(function (resolve) { setTimeout(resolve, ms); }); };
|
||||
// Sit out a smooth scroll so the pointer is aimed at a target that has stopped
|
||||
// moving. A scroll that never started fires no scrollend, so only wait on one
|
||||
// we can actually see happening; capture catches nested scrollers, whose
|
||||
// scrollend does not bubble.
|
||||
var restAfterScroll = function () {
|
||||
return new Promise(function (resolve) {
|
||||
var sc = document.scrollingElement || document.documentElement;
|
||||
var x0 = sc ? sc.scrollLeft : 0;
|
||||
var y0 = sc ? sc.scrollTop : 0;
|
||||
requestAnimationFrame(function () {
|
||||
if (!sc || (sc.scrollLeft === x0 && sc.scrollTop === y0)) { return resolve(); }
|
||||
var done = false;
|
||||
var finish = function () {
|
||||
if (done) { return; }
|
||||
done = true;
|
||||
document.removeEventListener('scrollend', finish, true);
|
||||
clearTimeout(timer);
|
||||
resolve();
|
||||
};
|
||||
var timer = setTimeout(finish, 350);
|
||||
document.addEventListener('scrollend', finish, true);
|
||||
});
|
||||
});
|
||||
};`
|
||||
|
||||
/** Bring the target on screen, mark it, and report where it came to rest. */
|
||||
function buildLocateScript(action: PreviewActAction, focus: boolean): string {
|
||||
const locate = { focus, kind: 'locate', ref: action.ref, selector: action.selector }
|
||||
|
||||
return `(function () {
|
||||
${preamble()}
|
||||
var locate = ${JSON.stringify(locate)};
|
||||
var found = act(locate);
|
||||
if (!found.success) { return Promise.resolve(JSON.stringify(found)); }
|
||||
watch('aim');
|
||||
// Arm a witness for the real input that is about to arrive. Without it a
|
||||
// click that never reached the page is indistinguishable from one the page
|
||||
// ignored, and the agent would report success either way.
|
||||
w.__hermesHit = null;
|
||||
document.addEventListener('pointerdown', function (e) {
|
||||
w.__hermesHit = { tag: e.target ? e.target.tagName : '?', trusted: e.isTrusted === true };
|
||||
}, { capture: true, once: true });
|
||||
// Measure again once the scroll has stopped: real input is aimed at a fixed
|
||||
// viewport coordinate, so it has to be where the target ENDS UP.
|
||||
return restAfterScroll().then(function () {
|
||||
var settled = act(locate);
|
||||
var best = settled.success ? settled : found;
|
||||
var at = best.point;
|
||||
// Last line of defence before the pointer is sent somewhere real. An element
|
||||
// that is still outside the viewport after we scrolled to it is hidden, not
|
||||
// placed, and aiming at it would drive the cursor off into a corner and
|
||||
// click whatever happens to be under that coordinate.
|
||||
if (at && (at.x < 0 || at.y < 0 || at.x > window.innerWidth || at.y > window.innerHeight)) {
|
||||
return JSON.stringify({
|
||||
error: 'That element is still off-screen after scrolling to it, so it is hidden rather than clickable. Call elements again for what is really on the page.',
|
||||
success: false
|
||||
});
|
||||
}
|
||||
return JSON.stringify(best);
|
||||
});
|
||||
})()`
|
||||
}
|
||||
|
||||
/** Put up a mark that outlives the action that made it. Every other cue on the
|
||||
* overlay retires on a timer, which is right for narrating a click and no use
|
||||
* at all for holding a finding on screen while the agent keeps working. */
|
||||
function buildPinScript(action: PreviewActAction, label: string): string {
|
||||
const locate = { kind: 'locate', ref: action.ref, selector: action.selector }
|
||||
|
||||
return `(function () {
|
||||
${preamble()}
|
||||
var found = act(${JSON.stringify(locate)});
|
||||
if (!found.success) { return JSON.stringify(found); }
|
||||
watch('pin', ${JSON.stringify(label)});
|
||||
return JSON.stringify({ acted: 'pinned ' + String(found.acted || 'it').replace(/^looking at /, ''), success: true });
|
||||
})()`
|
||||
}
|
||||
|
||||
/** Freeze the whole visible field as marks. Needs a fresh inventory first, so
|
||||
* the overlay has both the field to draw and the refs to number it by. */
|
||||
function buildHoldScript(): string {
|
||||
return `(function () {
|
||||
${preamble()}
|
||||
var found = act({ kind: 'elements' });
|
||||
if (!found.success) { return JSON.stringify(found); }
|
||||
watch('hold');
|
||||
found.acted = 'held the field';
|
||||
return JSON.stringify(found);
|
||||
})()`
|
||||
}
|
||||
|
||||
/** Rattle through the field one box at a time. Needs a fresh inventory for the
|
||||
* overlay to pick from, and nothing else — the page is never touched. */
|
||||
function buildStrobeScript(): string {
|
||||
return `(function () {
|
||||
${preamble()}
|
||||
var found = act({ kind: 'elements' });
|
||||
if (!found.success) { return JSON.stringify(found); }
|
||||
watch('strobe');
|
||||
found.acted = 'strobed the field';
|
||||
return JSON.stringify(found);
|
||||
})()`
|
||||
}
|
||||
|
||||
/** Take one mark down, or — with nothing to aim at — all of them. */
|
||||
function buildUnpinScript(action: PreviewActAction): string {
|
||||
const locate = { kind: 'locate', ref: action.ref, selector: action.selector }
|
||||
const one = !!(action.ref || action.selector)
|
||||
|
||||
return `(function () {
|
||||
${preamble()}
|
||||
${
|
||||
one
|
||||
? ` var found = act(${JSON.stringify(locate)});
|
||||
if (!found.success) { return JSON.stringify(found); }
|
||||
var gone = 'unpinned ' + String(found.acted || 'it').replace(/^looking at /, '');`
|
||||
: ` holder.aimed = null;
|
||||
var gone = 'cleared every pin';`
|
||||
}
|
||||
watch('unpin');
|
||||
return JSON.stringify({ acted: gone, success: true });
|
||||
})()`
|
||||
}
|
||||
|
||||
/** Mark the hit, let the page react, and hand back a fresh inventory. */
|
||||
function buildFinishScript(settleMs: number): string {
|
||||
return `(function () {
|
||||
${preamble()}
|
||||
watch('strike');
|
||||
return wait(${settleMs}).then(function () {
|
||||
// A rescan that throws must still answer — an unresolved promise here costs
|
||||
// the whole bridge deadline.
|
||||
try {
|
||||
var out = act({ kind: 'elements' });
|
||||
watch('sweep');
|
||||
out.hit = w.__hermesHit || null;
|
||||
return JSON.stringify(out);
|
||||
} catch (err) {
|
||||
return JSON.stringify({ note: 'The page changed before it could be re-read: ' + err, success: true });
|
||||
}
|
||||
});
|
||||
})()`
|
||||
}
|
||||
|
||||
/** The no-real-input fallback: the engine both acts and reads, in one trip.
|
||||
* Both reads mark the field — the explicit `elements` call and the re-read
|
||||
* every other verb does on its way out — so the page is marked after every
|
||||
* single action rather than only when the agent asks for an inventory outright.
|
||||
* They mark it differently, though, and the difference is what each one MEANS:
|
||||
* an outright `elements` is the agent reading the whole page, which is the
|
||||
* moment worth showing, so it strobes. The re-read after a click is
|
||||
* housekeeping, and strobing there would put five seconds of noise between
|
||||
* every step of a task, so it sweeps. The two never collide: an `elements` call
|
||||
* settles in 0ms and returns before the re-read. */
|
||||
function buildScriptedScript(action: PreviewActAction, settleMs: number): string {
|
||||
return `(function () {
|
||||
${preamble()}
|
||||
var result = act(${JSON.stringify(action)});
|
||||
${action.kind === 'elements' ? "if (result.success) { watch('strobe'); }" : ''}
|
||||
if (!result.success || ${settleMs} <= 0) { return Promise.resolve(JSON.stringify(result)); }
|
||||
return wait(${settleMs}).then(function () {
|
||||
try {
|
||||
var after = act({ kind: 'elements' });
|
||||
watch('sweep');
|
||||
// One or the other, never both: a re-read answers with the whole
|
||||
// inventory only when it is the first look at this page.
|
||||
result.elements = after.elements;
|
||||
result.delta = after.delta;
|
||||
result.url = after.url;
|
||||
result.title = after.title;
|
||||
} catch (err) {
|
||||
result.note = 'The page changed before it could be re-read: ' + err;
|
||||
}
|
||||
return JSON.stringify(result);
|
||||
});
|
||||
})()`
|
||||
}
|
||||
|
||||
/** The outcome of one round trip into the page. `silent` is its own case on
|
||||
* purpose: a page that stops answering mid-action is navigating, whereas one
|
||||
* that answers with nothing is broken, and the agent needs to hear the
|
||||
* difference. */
|
||||
type Trip = { error: string; kind: 'failed' } | { kind: 'answered'; result: PreviewActResult } | { kind: 'silent' }
|
||||
|
||||
async function runJson(run: PreviewScriptRunner, code: string): Promise<Trip> {
|
||||
const raw = await Promise.race([
|
||||
run(code).catch((error: unknown) => new Error(String(error))),
|
||||
new Promise<undefined>(resolve => setTimeout(resolve, ACT_TIMEOUT_MS))
|
||||
])
|
||||
|
||||
if (raw === undefined) {
|
||||
return { kind: 'silent' }
|
||||
}
|
||||
|
||||
if (raw instanceof Error) {
|
||||
return { error: 'The page rejected the action: ' + raw.message, kind: 'failed' }
|
||||
}
|
||||
|
||||
if (typeof raw !== 'string' || !raw) {
|
||||
return { error: 'The page did not answer the action.', kind: 'failed' }
|
||||
}
|
||||
|
||||
return { kind: 'answered', result: JSON.parse(raw) as PreviewActResult }
|
||||
}
|
||||
|
||||
/** Past tense of the verb the agent asked for, against what it actually hit. */
|
||||
function describeDone(action: PreviewActAction, target: string): string {
|
||||
if (action.kind === 'type') {
|
||||
return 'typed into ' + target + (action.submit ? ' and submitted' : '')
|
||||
}
|
||||
|
||||
if (action.kind === 'press') {
|
||||
return 'pressed ' + (action.key || '') + ' on ' + target
|
||||
}
|
||||
|
||||
if (action.kind === 'hover') {
|
||||
return 'hovered over ' + target
|
||||
}
|
||||
|
||||
return 'clicked ' + target
|
||||
}
|
||||
|
||||
/** Look at the target, walk the pointer over, and act on it for real. */
|
||||
async function driveAction(
|
||||
run: PreviewScriptRunner,
|
||||
input: PreviewInputHandle,
|
||||
action: PreviewActAction
|
||||
): Promise<PreviewActResult> {
|
||||
// A key press must not be preceded by a click — that would activate the
|
||||
// control rather than type into it — so the page hands it focus instead.
|
||||
const trip = await runJson(run, buildLocateScript(action, action.kind === 'press'))
|
||||
|
||||
if (trip.kind === 'failed') {
|
||||
return { error: trip.error, success: false }
|
||||
}
|
||||
|
||||
if (trip.kind === 'silent') {
|
||||
return { acted: action.kind, note: NAVIGATED, success: true }
|
||||
}
|
||||
|
||||
const found = trip.result
|
||||
|
||||
if (!found.success) {
|
||||
return found
|
||||
}
|
||||
|
||||
if (!found.point) {
|
||||
return { error: 'Could not work out where that element is on screen.', success: false }
|
||||
}
|
||||
|
||||
await glideTo(input, found.point)
|
||||
|
||||
if (action.kind === 'click') {
|
||||
await clickAt(input)
|
||||
} else if (action.kind === 'type') {
|
||||
if (found.typable === false) {
|
||||
return {
|
||||
error: `${String(found.acted || 'That').replace(/^looking at /, '')} is not a text field, so typing into it would only select the text under the pointer. Click it if it opens one, then type into that.`,
|
||||
success: false
|
||||
}
|
||||
}
|
||||
|
||||
input.focus()
|
||||
await clickAt(input)
|
||||
// Select-all inside the now-focused field, so typing replaces what is there
|
||||
// the way it would for a person. NOT a triple-click: that is a pointer
|
||||
// gesture and selects the paragraph under the cursor whenever the target
|
||||
// turns out not to be a field.
|
||||
await selectAll(input)
|
||||
await typeText(input, action.text ?? '')
|
||||
|
||||
if (action.submit) {
|
||||
await pressKey(input, 'Enter')
|
||||
}
|
||||
} else if (action.kind === 'press') {
|
||||
input.focus()
|
||||
await pressKey(input, action.key || 'Enter')
|
||||
}
|
||||
// hover is the glide and nothing else — the pointer is already sitting on the
|
||||
// target, which is the whole request.
|
||||
|
||||
const target = String(found.acted || '').replace(/^looking at /, '')
|
||||
const after = await runJson(run, buildFinishScript(SETTLE_MS))
|
||||
const acted = describeDone(action, target)
|
||||
|
||||
// The action itself already happened as real input, so a page that will not
|
||||
// answer the read-back is a page that navigated — never a failed click.
|
||||
if (after.kind !== 'answered') {
|
||||
return { acted, note: NAVIGATED, success: true }
|
||||
}
|
||||
|
||||
const { hit, ...result } = after.result as PreviewActResult & { hit?: { tag: string; trusted: boolean } | null }
|
||||
|
||||
// The witness the locate trip armed. No record means the input never reached
|
||||
// the document, which the agent must hear about — every other signal here
|
||||
// travels on the script channel and would report success regardless.
|
||||
if (!hit && CLICKS.indexOf(action.kind) !== -1) {
|
||||
return {
|
||||
...result,
|
||||
error: 'The pointer input never reached the page, so nothing was ' + acted.split(' ')[0] + '.',
|
||||
success: false
|
||||
}
|
||||
}
|
||||
|
||||
return { ...result, acted, note: hitNote(hit), success: true }
|
||||
}
|
||||
|
||||
/** Flag a click the overlay intercepted, which would otherwise look like a page
|
||||
* that simply ignored it. */
|
||||
function hitNote(hit?: { tag: string; trusted: boolean } | null): string | undefined {
|
||||
return hit && hit.tag === 'HERMES-WATCH' ? 'The action overlay intercepted the click instead of the page.' : undefined
|
||||
}
|
||||
|
||||
/** How far a screenful is, whether there is anywhere to go, and a spot to wheel
|
||||
* over — the renderer cannot see the guest viewport to work any of it out. */
|
||||
function buildScrollAnchorScript(): string {
|
||||
return `(function () {
|
||||
${preamble()}
|
||||
var sc = document.scrollingElement || document.documentElement;
|
||||
var track = sc.clientHeight || window.innerHeight;
|
||||
return Promise.resolve(JSON.stringify({
|
||||
page: Math.round(window.innerHeight * 0.9),
|
||||
point: { x: Math.round(window.innerWidth / 2), y: Math.round(track / 2) },
|
||||
span: sc.scrollHeight - track,
|
||||
success: true
|
||||
}));
|
||||
})()`
|
||||
}
|
||||
|
||||
/** Scroll the page the way a hand does — wheel it. The scripted path calls
|
||||
* `scrollBy`, which moves the page without the page ever seeing an input
|
||||
* event, so scroll-linked headers, reveal animations and infinite-scroll
|
||||
* loaders all stay asleep through a scroll that looked like it happened. */
|
||||
async function driveScroll(
|
||||
run: PreviewScriptRunner,
|
||||
input: PreviewInputHandle,
|
||||
action: PreviewActAction
|
||||
): Promise<PreviewActResult> {
|
||||
const far = action.amount ?? 0
|
||||
|
||||
const trip = await runJson(run, buildScrollAnchorScript())
|
||||
|
||||
if (trip.kind === 'failed') {
|
||||
return { error: trip.error, success: false }
|
||||
}
|
||||
|
||||
if (trip.kind === 'silent') {
|
||||
return { acted: 'scrolled', note: NAVIGATED, success: true }
|
||||
}
|
||||
|
||||
const anchor = trip.result as PreviewActResult & { page?: number; span?: number }
|
||||
|
||||
if (!anchor.span) {
|
||||
return { ...anchor, acted: 'scrolled the page', note: 'The page has nothing to scroll — it all fits already.' }
|
||||
}
|
||||
|
||||
// A person does not move the mouse to scroll; the wheel turns wherever their
|
||||
// hand already is. Only send it somewhere if it has never been anywhere.
|
||||
if (!pointerPlaced() && anchor.point) {
|
||||
await glideTo(input, anchor.point)
|
||||
}
|
||||
|
||||
await wheelBy(input, action.amount ?? anchor.page ?? 600)
|
||||
|
||||
const after = await runJson(run, buildFinishScript(SETTLE_MS))
|
||||
|
||||
if (after.kind !== 'answered') {
|
||||
return { acted: 'scrolled the page', note: NAVIGATED, success: true }
|
||||
}
|
||||
|
||||
return { ...after.result, acted: 'scrolled the page', success: true }
|
||||
}
|
||||
|
||||
/** Run one action against the ACTIVE preview tab's page. `kind` is a bare
|
||||
* string: the verb arrives off the wire, and the history ones never reach
|
||||
* the in-page engine. */
|
||||
export async function actOnActivePreview(
|
||||
action: Omit<PreviewActAction, 'kind'> & { kind: string }
|
||||
): Promise<PreviewActResult> {
|
||||
const nav = NAV_ACTIONS.find(verb => verb === action.kind)
|
||||
|
||||
if (nav) {
|
||||
const handle = activePreviewNav()
|
||||
|
||||
if (!handle) {
|
||||
return { error: NOTHING_OPEN, success: false }
|
||||
}
|
||||
|
||||
handle[nav]()
|
||||
|
||||
// Navigation is fire-and-forget through the webview; the new document has
|
||||
// its own refs, so the agent has to re-inventory either way.
|
||||
return { acted: nav, note: 'Page is loading — call elements to see what is on it.', success: true }
|
||||
}
|
||||
|
||||
const run = activePreviewScriptRunner()
|
||||
|
||||
if (!run) {
|
||||
return { error: NOTHING_OPEN, success: false }
|
||||
}
|
||||
|
||||
const typed = action as PreviewActAction
|
||||
|
||||
// Annotation, not interaction: nothing is clicked, nothing settles, and the
|
||||
// page is not re-read, so these skip the whole act-then-inventory path.
|
||||
if (typed.kind === 'pin' || typed.kind === 'unpin' || typed.kind === 'hold' || typed.kind === 'strobe') {
|
||||
const mark =
|
||||
typed.kind === 'hold'
|
||||
? buildHoldScript()
|
||||
: typed.kind === 'strobe'
|
||||
? buildStrobeScript()
|
||||
: typed.kind === 'pin'
|
||||
? buildPinScript(typed, typed.text || '')
|
||||
: buildUnpinScript(typed)
|
||||
|
||||
const trip = await runJson(run, mark)
|
||||
|
||||
if (trip.kind === 'failed') {
|
||||
return { error: trip.error, success: false }
|
||||
}
|
||||
|
||||
return trip.kind === 'answered' ? trip.result : { acted: typed.kind, note: NAVIGATED, success: true }
|
||||
}
|
||||
|
||||
const input = activePreviewInput()
|
||||
|
||||
if (input && DRIVEN.indexOf(typed.kind) !== -1) {
|
||||
return driveAction(run, input, typed)
|
||||
}
|
||||
|
||||
// A plain page scroll is a wheel gesture. Jumping to an end is not — no hand
|
||||
// wheels to the bottom of a long article — so `to` stays a scripted glide.
|
||||
const plain = typed.kind === 'scroll' && !typed.to && !typed.ref && !typed.selector
|
||||
|
||||
if (plain && input) {
|
||||
return driveScroll(run, input, typed)
|
||||
}
|
||||
|
||||
const settle = typed.kind === 'elements' ? 0 : SETTLE_MS
|
||||
const scripted = await runJson(run, buildScriptedScript(typed, settle))
|
||||
|
||||
if (scripted.kind === 'failed') {
|
||||
return { error: scripted.error, success: false }
|
||||
}
|
||||
|
||||
// The action almost certainly landed — a page that stops answering right
|
||||
// after a click is one that navigated. Say so instead of failing it.
|
||||
return scripted.kind === 'silent' ? { acted: typed.kind, note: NAVIGATED, success: true } : scripted.result
|
||||
}
|
||||
|
||||
// Self-accept so an edit here, or to the in-page sources this module
|
||||
// stringifies, doesn't reload the whole renderer out from under a live session.
|
||||
// The bridge re-requests this module per action in dev, so it picks the change
|
||||
// up without one (see loadPreviewEngine in gateway-event/desktop-bridge.ts).
|
||||
if (import.meta.hot) {
|
||||
import.meta.hot.accept()
|
||||
}
|
||||
@@ -0,0 +1,138 @@
|
||||
/**
|
||||
* PREVIEW DRIVE — the agent's hand on the mouse and keyboard.
|
||||
*
|
||||
* Everything here goes out through `sendInputEvent`, so the guest page receives
|
||||
* ordinary trusted input: the pointer really moves across it, `:hover` really
|
||||
* matches, focus really lands, and a menu that only exists while hovered is
|
||||
* actually open by the time the click arrives. That last part is the whole
|
||||
* point — a synthetic `el.click()` on a dropdown item fires at a node the page
|
||||
* never rendered, which is why script-driven clicking quietly misses.
|
||||
*
|
||||
* The pointer is walked to its target in steps rather than teleported, for the
|
||||
* same reason: a page learns it is hovered from a stream of moves, and one
|
||||
* move from nowhere to the target skips every element in between. Fourteen
|
||||
* steps over ~280ms is what Playwright's action cursor settles on too.
|
||||
*/
|
||||
|
||||
import type { PreviewInputHandle } from './preview-input'
|
||||
|
||||
export interface DrivePoint {
|
||||
x: number
|
||||
y: number
|
||||
}
|
||||
|
||||
/** The pointer JUMPS. These few steps over a couple of frames exist only so the
|
||||
* page receives a move stream at all — `:hover`, `pointerenter` and the menus
|
||||
* that hang off them need more than a single teleport to resolve — not so the
|
||||
* travel can be watched. A machine does not sweep a mouse across a screen. */
|
||||
const GLIDE_STEPS = 3
|
||||
const GLIDE_MS = 36
|
||||
|
||||
/** Gap between keystrokes. Fast enough not to pad the turn, slow enough that a
|
||||
* page debouncing its input handler still sees them as separate. */
|
||||
const KEY_MS = 7
|
||||
|
||||
/** Notches in a wheel gesture, and how long the gesture takes. Sent as a stream
|
||||
* rather than one big delta so scroll-linked effects — sticky headers, reveal
|
||||
* animations, infinite-scroll loaders — get the same series of events a hand
|
||||
* would produce, and so it looks like momentum rather than a jump cut. */
|
||||
const WHEEL_STEPS = 12
|
||||
const WHEEL_MS = 240
|
||||
|
||||
/** Where the pointer was left, so the next glide starts from there instead of
|
||||
* jumping. Module-level because the pointer is a property of the pane, not of
|
||||
* any one action. The origin is a placeholder, not a position — see below. */
|
||||
let pointer: DrivePoint = { x: 0, y: 0 }
|
||||
let placed = false
|
||||
|
||||
/** Whether the pointer has ever been sent anywhere. Until it has, its notional
|
||||
* spot is the top-left corner, which is a real coordinate a caller can wheel
|
||||
* or click at by accident — so callers that only need it to be SOMEWHERE
|
||||
* sensible have to know the difference. */
|
||||
export function pointerPlaced(): boolean {
|
||||
return placed
|
||||
}
|
||||
|
||||
const wait = (ms: number) => new Promise(resolve => setTimeout(resolve, ms))
|
||||
|
||||
/** Decelerating, like a hand arriving at a target rather than a linear sweep. */
|
||||
const easeOut = (t: number) => 1 - Math.pow(1 - t, 3)
|
||||
|
||||
/** Walk the pointer to `to`, letting the page hover everything on the way. */
|
||||
export async function glideTo(input: PreviewInputHandle, to: DrivePoint): Promise<void> {
|
||||
const from = pointer
|
||||
|
||||
for (let step = 1; step <= GLIDE_STEPS; step++) {
|
||||
const progress = easeOut(step / GLIDE_STEPS)
|
||||
|
||||
input.send({
|
||||
type: 'mouseMove',
|
||||
x: Math.round(from.x + (to.x - from.x) * progress),
|
||||
y: Math.round(from.y + (to.y - from.y) * progress)
|
||||
})
|
||||
await wait(GLIDE_MS / GLIDE_STEPS)
|
||||
}
|
||||
|
||||
pointer = to
|
||||
placed = true
|
||||
}
|
||||
|
||||
/** Press and release at the pointer's current spot. `clicks` of 3 selects the
|
||||
* text under it, which is how a field gets cleared without a modifier key. */
|
||||
export async function clickAt(input: PreviewInputHandle, clicks = 1): Promise<void> {
|
||||
for (let click = 1; click <= clicks; click++) {
|
||||
input.send({ button: 'left', clickCount: click, type: 'mouseDown', x: pointer.x, y: pointer.y })
|
||||
input.send({ button: 'left', clickCount: click, type: 'mouseUp', x: pointer.x, y: pointer.y })
|
||||
await wait(KEY_MS)
|
||||
}
|
||||
}
|
||||
|
||||
/** Wheel `down` pixels' worth of notches at the pointer's current spot; negative
|
||||
* scrolls up. Electron's wheel delta is the legacy `wheelDelta` sign — positive
|
||||
* moves the content down, i.e. scrolls UP — so it is the inverse of the number
|
||||
* a caller asks for, and of DOM `WheelEvent.deltaY`. */
|
||||
export async function wheelBy(input: PreviewInputHandle, down: number): Promise<void> {
|
||||
let sent = 0
|
||||
|
||||
for (let step = 1; step <= WHEEL_STEPS; step++) {
|
||||
const so_far = Math.round(down * easeOut(step / WHEEL_STEPS))
|
||||
const notch = so_far - sent
|
||||
|
||||
sent = so_far
|
||||
|
||||
if (notch) {
|
||||
input.send({ deltaX: 0, deltaY: -notch, type: 'mouseWheel', x: pointer.x, y: pointer.y })
|
||||
}
|
||||
|
||||
await wait(WHEEL_MS / WHEEL_STEPS)
|
||||
}
|
||||
}
|
||||
|
||||
/** Send one key the long way round, so a page watching any of the three sees it. */
|
||||
export async function pressKey(input: PreviewInputHandle, key: string): Promise<void> {
|
||||
input.send({ keyCode: key, type: 'keyDown' })
|
||||
input.send({ keyCode: key, type: 'char' })
|
||||
input.send({ keyCode: key, type: 'keyUp' })
|
||||
await wait(KEY_MS)
|
||||
}
|
||||
|
||||
/** Select-all inside whatever has focus, which for a focused field is that
|
||||
* field's own text and nothing else. This replaced a triple-click: a triple
|
||||
* click is a POINTER gesture, so it selects whatever paragraph sits under the
|
||||
* cursor whenever the target turns out not to be a field, and the agent was
|
||||
* leaving pages with their body text highlighted. There is no `char` phase —
|
||||
* a chord is not text entry, and sending one types a literal 'a'. */
|
||||
export async function selectAll(input: PreviewInputHandle): Promise<void> {
|
||||
const chord = ['control', 'meta']
|
||||
|
||||
input.send({ keyCode: 'a', modifiers: chord, type: 'keyDown' })
|
||||
input.send({ keyCode: 'a', modifiers: chord, type: 'keyUp' })
|
||||
await wait(KEY_MS)
|
||||
}
|
||||
|
||||
/** Type `text` a character at a time into whatever currently has focus. */
|
||||
export async function typeText(input: PreviewInputHandle, text: string): Promise<void> {
|
||||
for (const character of text) {
|
||||
await pressKey(input, character)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,56 @@
|
||||
/**
|
||||
* PREVIEW INPUT REGISTRY — real input into the preview pane's guest page, the
|
||||
* difference between the agent DRIVING the browser and merely poking its DOM.
|
||||
*
|
||||
* `executeJavaScript` can only ever dispatch synthetic events: `isTrusted` is
|
||||
* false, the browser's own hover target never moves, `:hover` rules never
|
||||
* match, and hover-gated menus never open — so a click lands on a dropdown item
|
||||
* that was never rendered. `sendInputEvent` goes in through Chromium's input
|
||||
* pipeline instead, producing the same events a hand on the mouse would.
|
||||
*
|
||||
* It has to be called on the `<webview>` ELEMENT. Sending to the embedder's
|
||||
* webContents does not reach a guest (electron/electron#20333), which is why
|
||||
* this is a per-pane registry rather than something main could do.
|
||||
*
|
||||
* Coordinates are relative to the webview, and the webview IS the guest
|
||||
* viewport — so a rect the act engine measured inside the page needs no
|
||||
* conversion on the way back out.
|
||||
*/
|
||||
|
||||
import { $rightRailActiveTabId } from '@/store/layout'
|
||||
import { $previewTabs } from '@/store/preview'
|
||||
|
||||
/** The subset of Electron's input events the agent needs to drive a page. */
|
||||
export type PreviewInputEvent =
|
||||
| { button: 'left'; clickCount: number; type: 'mouseDown' | 'mouseUp'; x: number; y: number }
|
||||
| { deltaX: number; deltaY: number; type: 'mouseWheel'; x: number; y: number }
|
||||
| { keyCode: string; modifiers?: string[]; type: 'char' | 'keyDown' | 'keyUp' }
|
||||
| { type: 'mouseMove'; x: number; y: number }
|
||||
|
||||
export interface PreviewInputHandle {
|
||||
/** Give the guest keyboard focus, so key events reach its active element. */
|
||||
focus: () => void
|
||||
send: (event: PreviewInputEvent) => void
|
||||
}
|
||||
|
||||
const handles = new Map<string, PreviewInputHandle>()
|
||||
|
||||
/** Register a live pane's input channel; returns an idempotent unregister. */
|
||||
export function registerPreviewInput(tabId: string, handle: PreviewInputHandle): () => void {
|
||||
handles.set(tabId, handle)
|
||||
|
||||
return () => {
|
||||
if (handles.get(tabId) === handle) {
|
||||
handles.delete(tabId)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** The ACTIVE preview tab's input channel. Null = nothing real to drive, and
|
||||
* the caller falls back to synthesizing events inside the page. */
|
||||
export function activePreviewInput(): PreviewInputHandle | null {
|
||||
const tabs = $previewTabs.get()
|
||||
const tab = tabs.find(t => t.id === $rightRailActiveTabId.get()) ?? tabs[0]
|
||||
|
||||
return (tab && handles.get(tab.id)) || null
|
||||
}
|
||||
@@ -0,0 +1,29 @@
|
||||
/**
|
||||
* IDLE PULSE — keeps the preview overlay alive while the model reasons.
|
||||
*
|
||||
* Everything else the overlay draws is narration of an action, so the pane goes
|
||||
* dark for the gap between actions — which is most of the time the agent spends
|
||||
* on a page, and the part where it is deciding what to do with what it just
|
||||
* read. A page that stops responding the moment the agent is thinking hardest
|
||||
* reads as the agent having wandered off.
|
||||
*
|
||||
* This is deliberately NOT part of the act pipeline: a turn boundary only has
|
||||
* to poke the overlay the last action left behind. See preview-nudge.ts.
|
||||
*/
|
||||
|
||||
import { $busy } from '@/store/session'
|
||||
|
||||
import { nudgeOverlay } from './preview-nudge'
|
||||
|
||||
// Module-level, matching how review.ts and coding-status.ts watch this edge. It
|
||||
// is inert without a live pane, so there is nothing to mount or tear down.
|
||||
let running = $busy.get()
|
||||
|
||||
$busy.subscribe(busy => {
|
||||
if (busy === running) {
|
||||
return
|
||||
}
|
||||
|
||||
running = busy
|
||||
nudgeOverlay(busy ? 'think' : 'rest')
|
||||
})
|
||||
@@ -9,6 +9,9 @@
|
||||
* sitting in Hermes' own DOM, where `activeElement` is authoritative.
|
||||
*/
|
||||
|
||||
import { $rightRailActiveTabId } from '@/store/layout'
|
||||
import { $previewTabs } from '@/store/preview'
|
||||
|
||||
/** Marks a live browser pane so a gesture can find the one holding focus. */
|
||||
export const PREVIEW_BROWSER_ATTR = 'data-preview-browser'
|
||||
|
||||
@@ -31,6 +34,15 @@ export function registerPreviewNav(tabId: string, handle: PreviewNavHandle): ()
|
||||
}
|
||||
}
|
||||
|
||||
/** The ACTIVE preview tab's commands, for callers with no focus to key off —
|
||||
* the agent's drive_preview, which runs while focus is in the composer. */
|
||||
export function activePreviewNav(): PreviewNavHandle | null {
|
||||
const tabs = $previewTabs.get()
|
||||
const tab = tabs.find(t => t.id === $rightRailActiveTabId.get()) ?? tabs[0]
|
||||
|
||||
return (tab && handles.get(tab.id)) || null
|
||||
}
|
||||
|
||||
/** Run `command` on the browser pane holding DOM focus. False = focus is
|
||||
* elsewhere in the app, so the caller falls back to the app-level meaning. */
|
||||
export function commandFocusedPreview(command: keyof PreviewNavHandle): boolean {
|
||||
|
||||
@@ -0,0 +1,38 @@
|
||||
/**
|
||||
* OVERLAY NUDGE — the one way to say a stage to an overlay that is ALREADY on
|
||||
* the page.
|
||||
*
|
||||
* The act pipeline (preview-act.ts) injects the whole engine because it has to:
|
||||
* it needs to resolve a ref, measure a node and read the page back. The stages
|
||||
* that only narrate — the idle pulse, the read wipe — need none of that. They
|
||||
* are one function call against something the last action already left on the
|
||||
* page, so re-shipping the engine to make it would put the payload on the wire
|
||||
* on every turn boundary.
|
||||
*
|
||||
* A page the agent has never acted on has no overlay, and the nudge is a no-op
|
||||
* there. That is the right answer rather than a gap: chrome on a page the agent
|
||||
* never touched would be a lie about what it did.
|
||||
*/
|
||||
|
||||
import type { WatchStage } from '@/lib/preview-act/watch-in-page'
|
||||
|
||||
import { activePreviewScriptRunner } from './preview-script-runner'
|
||||
|
||||
/** Run one stage against the active pane's overlay, if it has one. */
|
||||
export function nudgeOverlay(stage: WatchStage): void {
|
||||
const run = activePreviewScriptRunner()
|
||||
|
||||
if (!run) {
|
||||
return
|
||||
}
|
||||
|
||||
void run(`(function () {
|
||||
var w = window;
|
||||
var fn = w.__hermesWatch_fn;
|
||||
if (!fn) { return 'cold'; }
|
||||
try { fn(document, w.__hermesActHolder || {}, ${JSON.stringify(stage)}); } catch (err) {}
|
||||
return 'ok';
|
||||
})()`).catch(() => {
|
||||
// The page navigated out from under us. The next action re-injects.
|
||||
})
|
||||
}
|
||||
@@ -1,3 +1,7 @@
|
||||
// Side-effect import: watches the turn edge so the overlay keeps a pulse while
|
||||
// the model reasons. Lives here because the pane is what makes it reachable.
|
||||
import './preview-mind'
|
||||
|
||||
import { useStore } from '@nanostores/react'
|
||||
import type { PointerEvent as ReactPointerEvent } from 'react'
|
||||
import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
|
||||
@@ -28,9 +32,10 @@ import {
|
||||
import { type ConsoleEntry } from './preview-console-state'
|
||||
import { previewConsoleState } from './preview-console-store'
|
||||
import { LocalFilePreview, PreviewEmptyState } from './preview-file'
|
||||
import { type PreviewInputEvent, registerPreviewInput } from './preview-input'
|
||||
import { PREVIEW_BROWSER_ATTR, registerPreviewNav } from './preview-nav'
|
||||
import { registerPreviewPageReader } from './preview-reader'
|
||||
import { registerPreviewTourRunner } from './preview-tour-runner'
|
||||
import { registerPreviewScriptRunner } from './preview-script-runner'
|
||||
|
||||
type PreviewWebview = HTMLElement & {
|
||||
canGoBack?: () => boolean
|
||||
@@ -53,6 +58,7 @@ type PreviewWebview = HTMLElement & {
|
||||
reloadIgnoringCache?: () => void
|
||||
replaceMisspelling?: (word: string) => void
|
||||
selectAll?: () => void
|
||||
sendInputEvent?: (event: PreviewInputEvent) => void
|
||||
}
|
||||
|
||||
/** The raw Chromium params riding the webview tag's `context-menu` event. */
|
||||
@@ -455,15 +461,15 @@ export function PreviewPane({ embedded = false, onRestartServer, reloadRequest =
|
||||
})
|
||||
}, [isWebPreview, tabId])
|
||||
|
||||
// Publish the TOUR runner for this tab (the tour tool, surface='preview'):
|
||||
// runs injected driver.js actions inside the guest page so the agent can
|
||||
// give guided walkthroughs of whatever web app is open here.
|
||||
// Publish the SCRIPT runner for this tab: the one channel into the guest
|
||||
// page, shared by the tour tool (injected driver.js walkthroughs) and the
|
||||
// drive_preview tool (clicking, typing, scrolling the page the user sees).
|
||||
useEffect(() => {
|
||||
if (!isWebPreview || !tabId) {
|
||||
return
|
||||
}
|
||||
|
||||
return registerPreviewTourRunner(tabId, async code => {
|
||||
return registerPreviewScriptRunner(tabId, async code => {
|
||||
const webview = webviewRef.current
|
||||
|
||||
if (!webview?.executeJavaScript) {
|
||||
@@ -474,6 +480,32 @@ export function PreviewPane({ embedded = false, onRestartServer, reloadRequest =
|
||||
})
|
||||
}, [isWebPreview, tabId])
|
||||
|
||||
// Publish the INPUT channel for this tab. Same idea as the script runner, but
|
||||
// it carries real Chromium input rather than script — the agent's clicks and
|
||||
// keystrokes arrive as trusted events, so the page hovers, focuses and reacts
|
||||
// exactly as it would under a human hand.
|
||||
useEffect(() => {
|
||||
if (!isWebPreview || isRemoteHtml || !tabId) {
|
||||
return
|
||||
}
|
||||
|
||||
return registerPreviewInput(tabId, {
|
||||
focus: () => webviewRef.current?.focus?.(),
|
||||
send: event => {
|
||||
const webview = webviewRef.current
|
||||
|
||||
// Never optional-chain this call away: a missing method would make every
|
||||
// agent click a silent no-op that still reports success, because the
|
||||
// overlay and the read-back both run on the separate script channel.
|
||||
if (typeof webview?.sendInputEvent !== 'function') {
|
||||
throw new Error('preview webview cannot take input events')
|
||||
}
|
||||
|
||||
webview.sendInputEvent(event)
|
||||
}
|
||||
})
|
||||
}, [isRemoteHtml, isWebPreview, tabId])
|
||||
|
||||
// eslint-disable-next-line no-restricted-syntax -- legitimate non-atom ref write (see eslint rule comment)
|
||||
useEffect(() => {
|
||||
if (!consoleOpen) {
|
||||
|
||||
@@ -15,6 +15,8 @@
|
||||
import { $rightRailActiveTabId } from '@/store/layout'
|
||||
import { $previewTabs } from '@/store/preview'
|
||||
|
||||
import { nudgeOverlay } from './preview-nudge'
|
||||
|
||||
export interface PreviewReadOptions {
|
||||
/** Characters to return from `start` (capped at PREVIEW_READ_MAX_CHARS). */
|
||||
count?: number
|
||||
@@ -89,6 +91,13 @@ export async function readActivePreview(opts: PreviewReadOptions = {}): Promise<
|
||||
try {
|
||||
const page = await reader()
|
||||
|
||||
// Say it on the page. Reading is by far the cheapest thing the agent
|
||||
// does — a few hundredths of a second against a model round trip either
|
||||
// side of it — so a run of reads used to leave the pane dark for the
|
||||
// twenty seconds it took to page through a document, immediately after
|
||||
// the one moment that showed anything.
|
||||
nudgeOverlay('read')
|
||||
|
||||
return windowText(
|
||||
{ kind: target.kind, path: target.path, title: page.title || target.label, url: page.url || target.url },
|
||||
page.text,
|
||||
|
||||
@@ -0,0 +1,38 @@
|
||||
/**
|
||||
* PREVIEW SCRIPT RUNNER REGISTRY — the one way anything in the app reaches into
|
||||
* the preview pane's guest page, the script analog of preview-nav's handle
|
||||
* registry.
|
||||
*
|
||||
* A live browser pane registers its webview's `executeJavaScript` here, keyed
|
||||
* by tab id; `activePreviewScriptRunner` resolves the ACTIVE tab from the
|
||||
* store. Both guest-page features ride it — the tour tool (preview-tour.ts)
|
||||
* and the interaction tool (preview-act.ts) — so their heavy payloads stay out
|
||||
* of the pane component's static import graph and only load when used.
|
||||
*/
|
||||
|
||||
import { $rightRailActiveTabId } from '@/store/layout'
|
||||
import { $previewTabs } from '@/store/preview'
|
||||
|
||||
/** Runs JS source in the pane's guest page, resolving its completion value. */
|
||||
export type PreviewScriptRunner = (code: string) => Promise<unknown>
|
||||
|
||||
const runners = new Map<string, PreviewScriptRunner>()
|
||||
|
||||
/** Register a live preview's script runner; returns an idempotent unregister. */
|
||||
export function registerPreviewScriptRunner(tabId: string, runner: PreviewScriptRunner): () => void {
|
||||
runners.set(tabId, runner)
|
||||
|
||||
return () => {
|
||||
if (runners.get(tabId) === runner) {
|
||||
runners.delete(tabId)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** The ACTIVE preview tab's script runner. Null = no live page behind it. */
|
||||
export function activePreviewScriptRunner(): PreviewScriptRunner | null {
|
||||
const tabs = $previewTabs.get()
|
||||
const tab = tabs.find(t => t.id === $rightRailActiveTabId.get()) ?? tabs[0]
|
||||
|
||||
return (tab && runners.get(tab.id)) || null
|
||||
}
|
||||
@@ -1,38 +0,0 @@
|
||||
/**
|
||||
* PREVIEW TOUR RUNNER REGISTRY — the tour tool's script bridge into the
|
||||
* preview pane, the tour analog of preview-nav's handle registry.
|
||||
*
|
||||
* A live browser pane registers a script runner (its webview's
|
||||
* `executeJavaScript`) here, keyed by tab id; `activeTourRunner` resolves the
|
||||
* ACTIVE tab from the store. Kept separate from preview-tour.ts so the pane
|
||||
* component's static import stays tiny — the engine source + driver.js
|
||||
* payload only load when a tour actually runs (gateway-event dynamic-imports
|
||||
* preview-tour.ts).
|
||||
*/
|
||||
|
||||
import { $rightRailActiveTabId } from '@/store/layout'
|
||||
import { $previewTabs } from '@/store/preview'
|
||||
|
||||
/** Runs JS source in the pane's guest page, resolving its completion value. */
|
||||
export type TourScriptRunner = (code: string) => Promise<unknown>
|
||||
|
||||
const runners = new Map<string, TourScriptRunner>()
|
||||
|
||||
/** Register a live preview's script runner; returns an idempotent unregister. */
|
||||
export function registerPreviewTourRunner(tabId: string, runner: TourScriptRunner): () => void {
|
||||
runners.set(tabId, runner)
|
||||
|
||||
return () => {
|
||||
if (runners.get(tabId) === runner) {
|
||||
runners.delete(tabId)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** The ACTIVE preview tab's script runner. Null = no live page to tour. */
|
||||
export function activeTourRunner(): TourScriptRunner | null {
|
||||
const tabs = $previewTabs.get()
|
||||
const tab = tabs.find(t => t.id === $rightRailActiveTabId.get()) ?? tabs[0]
|
||||
|
||||
return (tab && runners.get(tab.id)) || null
|
||||
}
|
||||
@@ -21,7 +21,7 @@ import driverIife from 'driver.js/dist/driver.js.iife.js?raw'
|
||||
import { collectTourTargets } from '@/lib/tour/collect-targets'
|
||||
import { runTourEngine, type TourAction, type TourResult } from '@/lib/tour/engine'
|
||||
|
||||
import { activeTourRunner } from './preview-tour-runner'
|
||||
import { activePreviewScriptRunner } from './preview-script-runner'
|
||||
|
||||
/** Build the idempotent inject-and-run script for one tour action. */
|
||||
function buildTourScript(action: TourAction): string {
|
||||
@@ -51,7 +51,7 @@ function buildTourScript(action: TourAction): string {
|
||||
|
||||
/** Run one tour action in the ACTIVE preview tab's page. */
|
||||
export async function runPreviewTour(action: TourAction): Promise<TourResult> {
|
||||
const run = activeTourRunner()
|
||||
const run = activePreviewScriptRunner()
|
||||
|
||||
if (!run) {
|
||||
return { error: 'No live page is open in the preview pane — open one first.', success: false }
|
||||
|
||||
@@ -59,10 +59,13 @@ const DOT_VARIANTS: Record<SessionDotState, DotVariant> = {
|
||||
role: 'status',
|
||||
title: r => r.backgroundRunning
|
||||
},
|
||||
// Emerald — the turn finished while the user was looking elsewhere.
|
||||
// Emerald — the turn finished while the user was looking elsewhere. The
|
||||
// color is theme-derived (`--ui-success`, a success green rotated toward the
|
||||
// accent) so eight finished dots can't sit in the sidebar fighting a palette
|
||||
// they don't belong to. Under a green accent it stays emerald.
|
||||
unread: {
|
||||
ariaLabel: r => r.finishedUnread,
|
||||
className: `${DOT_BASE} bg-emerald-500`,
|
||||
className: `${DOT_BASE} bg-(--ui-success)`,
|
||||
role: 'status',
|
||||
title: r => r.finishedUnread
|
||||
},
|
||||
|
||||
@@ -40,6 +40,11 @@ vi.mock('@/store/boot', () => ({
|
||||
})
|
||||
}))
|
||||
|
||||
vi.mock('@/store/windows', () => ({
|
||||
isAuxiliaryWindow: vi.fn(() => false),
|
||||
isPeerInstanceWindow: vi.fn(() => false)
|
||||
}))
|
||||
|
||||
vi.mock('@/i18n', () => ({
|
||||
useI18n: () => ({
|
||||
t: {
|
||||
@@ -65,6 +70,7 @@ vi.mock('@/i18n', () => ({
|
||||
|
||||
const connectionStore = await import('@/store/connections')
|
||||
const bootStore = await import('@/store/boot')
|
||||
const windowStore = await import('@/store/windows')
|
||||
const $activeConnectionId = connectionStore.$activeConnectionId as ReturnType<typeof atom<null | string>>
|
||||
const $connectionsRegistry = connectionStore.$connectionsRegistry
|
||||
const $desktopBoot = bootStore.$desktopBoot
|
||||
@@ -72,6 +78,8 @@ const $pendingConnectionId = connectionStore.$pendingConnectionId
|
||||
const initializeConnectionsRegistry = vi.mocked(connectionStore.initializeConnectionsRegistry)
|
||||
const refreshConnectionsRegistry = vi.mocked(connectionStore.refreshConnectionsRegistry)
|
||||
const selectConnection = vi.mocked(connectionStore.selectConnection)
|
||||
const isAuxiliaryWindow = vi.mocked(windowStore.isAuxiliaryWindow)
|
||||
const isPeerInstanceWindow = vi.mocked(windowStore.isPeerInstanceWindow)
|
||||
const onConnect = vi.fn()
|
||||
|
||||
const connection = (id: string, label: string, kind: 'local' | 'remote' = 'remote') => ({
|
||||
@@ -106,6 +114,8 @@ afterEach(() => {
|
||||
})
|
||||
$pendingConnectionId.set(null)
|
||||
$findInPage.set({ active: false, query: '', matchOrdinal: 0, matchCount: 0 })
|
||||
isAuxiliaryWindow.mockReturnValue(false)
|
||||
isPeerInstanceWindow.mockReturnValue(false)
|
||||
})
|
||||
|
||||
describe('ConnectionSwitcher', () => {
|
||||
@@ -127,6 +137,38 @@ describe('ConnectionSwitcher', () => {
|
||||
await waitFor(() => expect(initializeConnectionsRegistry).toHaveBeenCalledTimes(1))
|
||||
})
|
||||
|
||||
it('keeps a full peer on the shared backend instead of replaying app-launch source restoration', async () => {
|
||||
isPeerInstanceWindow.mockReturnValue(true)
|
||||
$desktopBoot.set({
|
||||
...$desktopBoot.get(),
|
||||
phase: 'renderer.ready',
|
||||
progress: 100,
|
||||
running: false,
|
||||
visible: false
|
||||
})
|
||||
|
||||
render(<ConnectionSwitcher onConnect={onConnect} />)
|
||||
|
||||
await waitFor(() => expect(refreshConnectionsRegistry).toHaveBeenCalledTimes(1))
|
||||
expect(initializeConnectionsRegistry).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('keeps a secondary session window from replaying app-launch source restoration', async () => {
|
||||
isAuxiliaryWindow.mockReturnValue(true)
|
||||
$desktopBoot.set({
|
||||
...$desktopBoot.get(),
|
||||
phase: 'renderer.ready',
|
||||
progress: 100,
|
||||
running: false,
|
||||
visible: false
|
||||
})
|
||||
|
||||
render(<ConnectionSwitcher onConnect={onConnect} />)
|
||||
|
||||
await waitFor(() => expect(refreshConnectionsRegistry).toHaveBeenCalledTimes(1))
|
||||
expect(initializeConnectionsRegistry).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('adds no source chrome for a local-only setup', () => {
|
||||
$connectionsRegistry.set(registry([connection('local', 'This device', 'local')]))
|
||||
render(<ConnectionSwitcher onConnect={onConnect} />)
|
||||
|
||||
@@ -36,6 +36,7 @@ import {
|
||||
} from '@/store/connections'
|
||||
import { closeFindBar } from '@/store/find-in-page'
|
||||
import { notifyError } from '@/store/notifications'
|
||||
import { isAuxiliaryWindow, isPeerInstanceWindow } from '@/store/windows'
|
||||
|
||||
export function ConnectionSwitcher({ compact = false, onConnect }: { compact?: boolean; onConnect: () => void }) {
|
||||
const { t } = useI18n()
|
||||
@@ -64,8 +65,10 @@ export function ConnectionSwitcher({ compact = false, onConnect }: { compact?: b
|
||||
// The primary boot owns its initial config/session fetches. Restoring a
|
||||
// different source before those settle lets a late primary response repaint
|
||||
// the sidebar under the new source label. Switch only after boot completes,
|
||||
// then the normal source reset/refetch remains the final writer.
|
||||
if (!boot.running) {
|
||||
// then the normal source reset/refetch remains the final writer. Peer and
|
||||
// auxiliary windows already boot into their intended runtime; replaying the
|
||||
// primary window's app-launch preference would move them away from it.
|
||||
if (!boot.running && !isAuxiliaryWindow() && !isPeerInstanceWindow()) {
|
||||
void initializeConnectionsRegistry().catch(() => undefined)
|
||||
}
|
||||
}, [boot.running])
|
||||
|
||||
@@ -13,6 +13,7 @@ import { deleteCronJob, getCronJobRuns, pauseCronJob, resumeCronJob, type Sessio
|
||||
import { useI18n } from '@/i18n'
|
||||
import { fmtDayTime, relativeTime } from '@/lib/time'
|
||||
import { cn } from '@/lib/utils'
|
||||
import { confirm } from '@/store/confirm'
|
||||
import { updateCronJobs } from '@/store/cron'
|
||||
import { $changeEventsAvailable, $cronChangeTick } from '@/store/live-sync'
|
||||
import { notify, notifyError } from '@/store/notifications'
|
||||
@@ -259,7 +260,14 @@ function CronJobSidebarRow({
|
||||
}
|
||||
|
||||
const remove = async () => {
|
||||
if (!window.confirm(`${c.deleteDescPrefix}${label}${c.deleteDescSuffix}`)) {
|
||||
const ok = await confirm({
|
||||
confirmLabel: t.common.delete,
|
||||
description: `${c.deleteDescPrefix}${label}${c.deleteDescSuffix}`,
|
||||
destructive: true,
|
||||
title: c.deleteTitle
|
||||
})
|
||||
|
||||
if (!ok) {
|
||||
return
|
||||
}
|
||||
|
||||
|
||||
@@ -257,6 +257,16 @@ const HEADER_NAV_BTN =
|
||||
// FTS results cover sessions that aren't in the loaded page; synthesize a
|
||||
// minimal SessionInfo so they render in the same row component (resume works
|
||||
// by id; the snippet stands in for the preview).
|
||||
|
||||
// The backend's FTS layer wraps matched terms in literal '>>>' / '<<<'
|
||||
// highlight markers (sqlite snippet() delimiters — see hermes_state_search.py).
|
||||
// The sidebar renders the snippet as plain text, so the markers must be
|
||||
// stripped or a search for "foo" paints rows titled ">>>foo<<<".
|
||||
// Exported for tests.
|
||||
export function stripFtsMarkers(snippet: string): string {
|
||||
return snippet.replaceAll('>>>', '').replaceAll('<<<', '')
|
||||
}
|
||||
|
||||
function searchResultToSession(result: SessionSearchResult): SessionInfo {
|
||||
const ts = result.session_started ?? Date.now() / 1000
|
||||
|
||||
@@ -272,7 +282,7 @@ function searchResultToSession(result: SessionSearchResult): SessionInfo {
|
||||
message_count: 0,
|
||||
model: result.model ?? null,
|
||||
output_tokens: 0,
|
||||
preview: result.snippet?.trim() || null,
|
||||
preview: stripFtsMarkers(result.snippet ?? '').trim() || null,
|
||||
source: result.source ?? null,
|
||||
started_at: ts,
|
||||
title: null,
|
||||
|
||||
@@ -2,16 +2,8 @@ import { useStore } from '@nanostores/react'
|
||||
import type * as React from 'react'
|
||||
import { useMemo, useState } from 'react'
|
||||
|
||||
import { Button } from '@/components/ui/button'
|
||||
import { Codicon } from '@/components/ui/codicon'
|
||||
import {
|
||||
Dialog,
|
||||
DialogContent,
|
||||
DialogDescription,
|
||||
DialogFooter,
|
||||
DialogHeader,
|
||||
DialogTitle
|
||||
} from '@/components/ui/dialog'
|
||||
import { ConfirmDialog } from '@/components/ui/confirm-dialog'
|
||||
import type { HermesGitWorktree } from '@/global'
|
||||
import type { SessionInfo } from '@/hermes'
|
||||
import { useI18n } from '@/i18n'
|
||||
@@ -190,43 +182,26 @@ function RepoFlatSection({
|
||||
destructiveLabel: string,
|
||||
onDestructive: (group: SidebarSessionGroup) => void
|
||||
) => (
|
||||
<Dialog onOpenChange={isOpen => !isOpen && setTarget(null)} open={Boolean(target)}>
|
||||
<DialogContent>
|
||||
<DialogHeader>
|
||||
<DialogTitle>{`${s.projects.removeWorktree} "${target?.label ?? ''}"?`}</DialogTitle>
|
||||
<DialogDescription>{description}</DialogDescription>
|
||||
</DialogHeader>
|
||||
<DialogFooter>
|
||||
<Button onClick={() => setTarget(null)} variant="ghost">
|
||||
{t.common.cancel}
|
||||
</Button>
|
||||
<Button
|
||||
onClick={() => {
|
||||
if (target) {
|
||||
dismissWorktree(target.id)
|
||||
}
|
||||
|
||||
setTarget(null)
|
||||
}}
|
||||
variant="secondary"
|
||||
>
|
||||
{s.projects.removeFromSidebar}
|
||||
</Button>
|
||||
<Button
|
||||
onClick={() => {
|
||||
setTarget(null)
|
||||
|
||||
if (target) {
|
||||
onDestructive(target)
|
||||
}
|
||||
}}
|
||||
variant="destructive"
|
||||
>
|
||||
{destructiveLabel}
|
||||
</Button>
|
||||
</DialogFooter>
|
||||
</DialogContent>
|
||||
</Dialog>
|
||||
<ConfirmDialog
|
||||
confirmLabel={destructiveLabel}
|
||||
description={description}
|
||||
destructive
|
||||
// removeViaGit finishes on its own: it either dismisses the lane, escalates
|
||||
// to the force prompt, or toasts. Nothing left for the dialog to wait on.
|
||||
dismissOnConfirm
|
||||
onClose={() => setTarget(null)}
|
||||
onConfirm={() => {
|
||||
if (target) {
|
||||
onDestructive(target)
|
||||
}
|
||||
}}
|
||||
open={Boolean(target)}
|
||||
secondaryAction={{
|
||||
label: s.projects.removeFromSidebar,
|
||||
onClick: () => target && dismissWorktree(target.id)
|
||||
}}
|
||||
title={`${s.projects.removeWorktree} "${target?.label ?? ''}"?`}
|
||||
/>
|
||||
)
|
||||
|
||||
const removeDialog = (
|
||||
|
||||
@@ -247,12 +247,19 @@ describe('SessionActionsMenu', () => {
|
||||
expect(await screen.queryByRole('dialog')).toBeNull()
|
||||
expect(onDelete).not.toHaveBeenCalled()
|
||||
|
||||
// Re-open and confirm with Enter: the delete call fires.
|
||||
// Re-open and confirm with Enter at wherever focus actually is. Firing on
|
||||
// the dialog node would pass even when the menu leaves focus on the row
|
||||
// trigger — where Enter re-activates the row instead of confirming.
|
||||
fireEvent.pointerDown(trigger, { button: 0, pointerType: 'mouse' })
|
||||
fireEvent.pointerUp(trigger, { button: 0, pointerType: 'mouse' })
|
||||
fireEvent.click(trigger)
|
||||
fireEvent.click(await screen.findByRole('menuitem', { name: /delete/i }))
|
||||
fireEvent.keyDown(await screen.findByRole('dialog'), { key: 'Enter' })
|
||||
|
||||
const reopened = await screen.findByRole('dialog')
|
||||
// eslint-disable-next-line no-restricted-globals -- asserting real focus requires the live document
|
||||
await waitFor(() => expect(reopened.contains(document.activeElement)).toBe(true))
|
||||
// eslint-disable-next-line no-restricted-globals -- asserting real focus requires the live document
|
||||
fireEvent.keyDown(document.activeElement!, { key: 'Enter' })
|
||||
|
||||
expect(await screen.findByText('Session deleted')).toBeTruthy()
|
||||
expect(onDelete).toHaveBeenCalledTimes(1)
|
||||
|
||||
@@ -22,14 +22,7 @@ import { Codicon } from '@/components/ui/codicon'
|
||||
import { ColorSwatches } from '@/components/ui/color-swatches'
|
||||
import { ConfirmDialog } from '@/components/ui/confirm-dialog'
|
||||
import { CopyButton } from '@/components/ui/copy-button'
|
||||
import {
|
||||
Dialog,
|
||||
DialogContent,
|
||||
DialogFooter,
|
||||
DialogHeader,
|
||||
DialogTitle,
|
||||
preventCloseButtonAutoFocus
|
||||
} from '@/components/ui/dialog'
|
||||
import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from '@/components/ui/dialog'
|
||||
import { Input } from '@/components/ui/input'
|
||||
import { renameSession } from '@/hermes'
|
||||
import { useI18n } from '@/i18n'
|
||||
@@ -580,7 +573,6 @@ function DeleteSessionDialog({ open, onOpenChange, onConfirm, sessionTitle }: De
|
||||
doneLabel={r.deleted}
|
||||
onClose={() => onOpenChange(false)}
|
||||
onConfirm={onConfirm}
|
||||
onOpenAutoFocus={preventCloseButtonAutoFocus}
|
||||
open={open}
|
||||
title={r.deleteTitle}
|
||||
/>
|
||||
|
||||
@@ -30,6 +30,7 @@ import { $projects } from '@/store/projects'
|
||||
import { $pullRequestsByBranch, sessionPrKey } from '@/store/pull-requests'
|
||||
import { $sessionDotStateById, hasLiveTurn, showsRunningArc } from '@/store/session-dot-state'
|
||||
import { $sessionListDensity } from '@/store/session-list-density'
|
||||
import { $openStoredSessionIds } from '@/store/session-states'
|
||||
import { sessionCostUsd } from '@/store/sidebar-archive'
|
||||
import { $todoProgressBySession } from '@/store/todos'
|
||||
|
||||
@@ -173,6 +174,10 @@ function SidebarSessionRowImpl({
|
||||
// those branches should repaint.
|
||||
const prKey = sessionPrKey(session)
|
||||
const pr = useStoreSelector($pullRequestsByBranch, prs => (rowMeta.includes('pr') && prKey ? prs[prKey] : undefined))
|
||||
// Open in a pane, but not the focused one. A selector rather than a prop:
|
||||
// it reaches all four row render paths at once, the set only changes when a
|
||||
// tile opens or closes, and the boolean bails every unaffected row out.
|
||||
const openUnfocused = useStoreSelector($openStoredSessionIds, open => !isSelected && open.has(session.id))
|
||||
const totalTokens = session.input_tokens + session.output_tokens
|
||||
const cost = sessionCostUsd(session)
|
||||
|
||||
@@ -352,6 +357,10 @@ function SidebarSessionRowImpl({
|
||||
!card && density !== 'compact' && 'min-h-[2.75rem]',
|
||||
!card && density === 'detailed' && 'min-h-[3.875rem]',
|
||||
isSelected && 'bg-(--ui-row-active-background)',
|
||||
// Open in another pane: the SAME band, just weaker. Its own mixed
|
||||
// token rather than row opacity — dimming the whole row would take
|
||||
// the title and the status dot down with it.
|
||||
openUnfocused && 'bg-(--ui-row-open-background)',
|
||||
liveTurn && 'text-foreground',
|
||||
// Opaque surface while lifted so the dragged row erases what's under
|
||||
// it (translucency let the rows below bleed through). data-glass-opaque
|
||||
|
||||
@@ -0,0 +1,27 @@
|
||||
// Regression: the backend's session-search FTS layer wraps matched terms in
|
||||
// literal '>>>' / '<<<' snippet() delimiters (hermes_state_search.py). The
|
||||
// sidebar paints the snippet as plain text, so an unstripped marker renders
|
||||
// rows titled ">>>foo<<<" (Aug 2026 desktop audit).
|
||||
import { describe, expect, it } from 'vitest'
|
||||
|
||||
import { stripFtsMarkers } from './index'
|
||||
|
||||
describe('stripFtsMarkers', () => {
|
||||
it('strips highlight markers around the matched term', () => {
|
||||
expect(stripFtsMarkers('...replied with >>>MARCO<<< and nothing else...')).toBe(
|
||||
'...replied with MARCO and nothing else...'
|
||||
)
|
||||
})
|
||||
|
||||
it('strips multiple marked terms', () => {
|
||||
expect(stripFtsMarkers('>>>alpha<<< then >>>beta<<<')).toBe('alpha then beta')
|
||||
})
|
||||
|
||||
it('leaves marker-free snippets untouched', () => {
|
||||
expect(stripFtsMarkers('plain snippet text')).toBe('plain snippet text')
|
||||
})
|
||||
|
||||
it('handles empty string', () => {
|
||||
expect(stripFtsMarkers('')).toBe('')
|
||||
})
|
||||
})
|
||||
@@ -23,6 +23,7 @@ import { useI18n } from '@/i18n'
|
||||
import { AlertCircle } from '@/lib/icons'
|
||||
import { cn } from '@/lib/utils'
|
||||
import { upsertDesktopActionTask } from '@/store/activity'
|
||||
import { confirm } from '@/store/confirm'
|
||||
import { notify, notifyError } from '@/store/notifications'
|
||||
import type { ActionStatusResponse } from '@/types/hermes'
|
||||
|
||||
@@ -169,7 +170,7 @@ export function MaintenancePanel() {
|
||||
|
||||
const doResetMemory = useCallback(
|
||||
async (target: 'all' | 'memory' | 'user', label: string) => {
|
||||
if (!window.confirm(mm.resetConfirm(label))) {
|
||||
if (!(await confirm({ destructive: true, title: mm.resetConfirm(label) }))) {
|
||||
return
|
||||
}
|
||||
|
||||
|
||||
@@ -18,6 +18,7 @@ import { Command, CommandGroup, CommandInput, CommandItem, CommandList } from '@
|
||||
import { HighlightMatches } from '@/components/ui/highlight-matches'
|
||||
import { KbdCombo } from '@/components/ui/kbd'
|
||||
import { getHermesConfigRecord, listAllProfileSessions } from '@/hermes'
|
||||
import { useMediaQuery } from '@/hooks/use-media-query'
|
||||
import { useI18n } from '@/i18n'
|
||||
import { sessionTitle } from '@/lib/chat-runtime'
|
||||
import {
|
||||
@@ -248,8 +249,8 @@ const rankGroups = (groups: PaletteGroup[], search: string): PaletteGroup[] => {
|
||||
.map(entry => entry.group)
|
||||
}
|
||||
|
||||
// cmdk selection values must be unique; labels alone can repeat (the same
|
||||
// theme lists under both Light and Dark). The id suffix disambiguates.
|
||||
// cmdk selection values must be unique; labels alone can repeat (a settings
|
||||
// field and a session can share a title). The id suffix disambiguates.
|
||||
const paletteValue = (item: PaletteItem): string => `${item.label}\u0001${item.id}`
|
||||
|
||||
const EMPTY_GROUPS: PaletteGroup[] = []
|
||||
@@ -559,6 +560,16 @@ function CommandPaletteBody({ onExited }: { onExited: () => void }) {
|
||||
const { availableThemes, clearThemePreview, mode, previewTheme, resolvedMode, setMode, setTheme, themeName } =
|
||||
useTheme()
|
||||
|
||||
// Mode rows preview like theme rows do: paint the committed skin at the
|
||||
// highlighted brightness. `system` has to be resolved here — previewTheme
|
||||
// paints a concrete light/dark.
|
||||
const systemDark = useMediaQuery('(prefers-color-scheme: dark)')
|
||||
|
||||
const resolveThemeMode = useCallback(
|
||||
(target: ThemeMode): 'light' | 'dark' => (target === 'system' ? (systemDark ? 'dark' : 'light') : target),
|
||||
[systemDark]
|
||||
)
|
||||
|
||||
const [search, setSearch] = useState('')
|
||||
const [page, setPage] = useState<string | null>(null)
|
||||
const inputRef = useRef<HTMLInputElement>(null)
|
||||
@@ -1148,6 +1159,7 @@ function CommandPaletteBody({ onExited }: { onExited: () => void }) {
|
||||
keepOpen: true,
|
||||
keywords: ['appearance', 'color mode', 'brightness', entry.mode, t.settings.modeOptions[entry.mode].label],
|
||||
label: t.settings.modeOptions[entry.mode].label,
|
||||
onHighlight: () => previewTheme(themeName, resolveThemeMode(entry.mode)),
|
||||
run: () => setMode(entry.mode)
|
||||
}))
|
||||
})
|
||||
@@ -1232,6 +1244,7 @@ function CommandPaletteBody({ onExited }: { onExited: () => void }) {
|
||||
mode,
|
||||
previewTheme,
|
||||
resolvedMode,
|
||||
resolveThemeMode,
|
||||
search,
|
||||
sessions,
|
||||
setMode,
|
||||
@@ -1325,27 +1338,51 @@ function CommandPaletteBody({ onExited }: { onExited: () => void }) {
|
||||
}
|
||||
]
|
||||
},
|
||||
// Built-ins and imported families list under the mode(s) they support;
|
||||
// picking sets skin + mode at once. A multi-variant import (GitHub,
|
||||
// Solarized) appears in both groups and switches variants with the mode.
|
||||
...(['light', 'dark'] as const).map(groupMode => ({
|
||||
heading: groupMode === 'light' ? t.settings.modeOptions.light.label : t.settings.modeOptions.dark.label,
|
||||
items: availableThemes
|
||||
.filter(theme => themeSupportsMode(theme.name, groupMode))
|
||||
.map(theme => ({
|
||||
active: themeName === theme.name && resolvedMode === groupMode,
|
||||
icon: groupMode === 'light' ? Sun : Moon,
|
||||
id: `theme-${theme.name}-${groupMode}`,
|
||||
// Brightness lives with the palettes: one mode toggle for the whole
|
||||
// list instead of splitting every theme across a Light and a Dark group.
|
||||
{
|
||||
heading: t.settings.appearance.colorMode,
|
||||
items: THEME_MODES.map(entry => ({
|
||||
active: mode === entry.mode,
|
||||
icon: entry.icon,
|
||||
id: `theme-mode-${entry.mode}`,
|
||||
keepOpen: true,
|
||||
keywords: ['appearance', 'brightness', 'color mode', t.settings.modeOptions[entry.mode].label],
|
||||
label: t.settings.modeOptions[entry.mode].label,
|
||||
onHighlight: () => previewTheme(themeName, resolveThemeMode(entry.mode)),
|
||||
run: () => setMode(entry.mode)
|
||||
}))
|
||||
},
|
||||
// Every palette once, applied on top of the selected mode. An import
|
||||
// that only ships one variant (Dracula) flips the mode to the side it
|
||||
// can actually render.
|
||||
{
|
||||
heading: t.settings.appearance.themeTitle,
|
||||
items: availableThemes.map(theme => {
|
||||
const previewMode = themeSupportsMode(theme.name, resolvedMode)
|
||||
? resolvedMode
|
||||
: resolvedMode === 'dark'
|
||||
? 'light'
|
||||
: 'dark'
|
||||
|
||||
return {
|
||||
active: themeName === theme.name,
|
||||
icon: Palette,
|
||||
id: `theme-${theme.name}`,
|
||||
keepOpen: true,
|
||||
keywords: ['theme', 'appearance', 'palette', groupMode, theme.label, theme.description ?? ''],
|
||||
keywords: ['theme', 'appearance', 'palette', theme.label, theme.description ?? ''],
|
||||
label: theme.label,
|
||||
onHighlight: () => previewTheme(theme.name, groupMode),
|
||||
onHighlight: () => previewTheme(theme.name, previewMode),
|
||||
run: () => {
|
||||
setTheme(theme.name)
|
||||
setMode(groupMode)
|
||||
|
||||
if (previewMode !== resolvedMode) {
|
||||
setMode(previewMode)
|
||||
}
|
||||
}
|
||||
}))
|
||||
}))
|
||||
}
|
||||
})
|
||||
}
|
||||
]
|
||||
},
|
||||
'color-mode': {
|
||||
@@ -1361,6 +1398,7 @@ function CommandPaletteBody({ onExited }: { onExited: () => void }) {
|
||||
keepOpen: true,
|
||||
keywords: ['appearance', 'brightness', t.settings.modeOptions[entry.mode].label],
|
||||
label: t.settings.modeOptions[entry.mode].label,
|
||||
onHighlight: () => previewTheme(themeName, resolveThemeMode(entry.mode)),
|
||||
run: () => setMode(entry.mode)
|
||||
}))
|
||||
}
|
||||
@@ -1387,7 +1425,18 @@ function CommandPaletteBody({ onExited }: { onExited: () => void }) {
|
||||
groups: settingsPageGroups
|
||||
}
|
||||
}),
|
||||
[availableThemes, mode, previewTheme, resolvedMode, setMode, setTheme, settingsPageGroups, t, themeName]
|
||||
[
|
||||
availableThemes,
|
||||
mode,
|
||||
previewTheme,
|
||||
resolvedMode,
|
||||
resolveThemeMode,
|
||||
setMode,
|
||||
setTheme,
|
||||
settingsPageGroups,
|
||||
t,
|
||||
themeName
|
||||
]
|
||||
)
|
||||
|
||||
const activePage = page ? subPages[page] : null
|
||||
|
||||
@@ -3,6 +3,7 @@ import { MemoryRouter } from 'react-router'
|
||||
import { afterEach, describe, expect, it, vi } from 'vitest'
|
||||
|
||||
import { registerTerminalContextMenu } from '@/app/right-sidebar/terminal/terminal-context-menu'
|
||||
import { ContextMenu, ContextMenuTrigger, HERMES_CONTEXT_MENU_TRIGGER_ATTR } from '@/components/ui/context-menu'
|
||||
import { formatCombo } from '@/lib/keybinds/combo'
|
||||
import { $previewTabs, closeRightRail } from '@/store/preview'
|
||||
import { $connection } from '@/store/session'
|
||||
@@ -567,3 +568,20 @@ describe('AppContextMenu guest (in-app browser)', () => {
|
||||
expect(screen.queryByText('Add to dictionary')).toBeNull()
|
||||
})
|
||||
})
|
||||
|
||||
describe('ContextMenuTrigger asChild', () => {
|
||||
it('keeps the coordinator marker when the child overwrites data-slot', () => {
|
||||
render(
|
||||
<ContextMenu>
|
||||
<ContextMenuTrigger asChild>
|
||||
<footer data-slot="statusbar">bar</footer>
|
||||
</ContextMenuTrigger>
|
||||
</ContextMenu>
|
||||
)
|
||||
|
||||
const footer = screen.getByText('bar')
|
||||
|
||||
expect(footer.getAttribute('data-slot')).toBe('statusbar')
|
||||
expect(footer.hasAttribute(HERMES_CONTEXT_MENU_TRIGGER_ATTR)).toBe(true)
|
||||
})
|
||||
})
|
||||
|
||||
@@ -5,6 +5,7 @@ import { useNavigate } from 'react-router'
|
||||
|
||||
import { terminalMenuHandleFor } from '@/app/right-sidebar/terminal/terminal-context-menu'
|
||||
import { Codicon } from '@/components/ui/codicon'
|
||||
import { HERMES_CONTEXT_MENU_TRIGGER_ATTR } from '@/components/ui/context-menu'
|
||||
import { writeClipboardText } from '@/components/ui/copy-button'
|
||||
import {
|
||||
DropdownMenu,
|
||||
@@ -609,7 +610,11 @@ export function AppContextMenu() {
|
||||
const element = event.target instanceof Element ? event.target : null
|
||||
|
||||
// Surfaces with their own Radix context menu keep the whole gesture.
|
||||
if (element?.closest('[data-slot="context-menu-trigger"]')) {
|
||||
// Guard the dedicated marker first: Radix `asChild` Slot merges
|
||||
// `mergeProps(slotProps, childProps)` so the child's `data-slot` wins
|
||||
// (status bar footer is `data-slot="statusbar"`). The marker is stamped
|
||||
// after `{...props}` on ContextMenuTrigger and is not overwritten.
|
||||
if (element?.closest(`[${HERMES_CONTEXT_MENU_TRIGGER_ATTR}], [data-slot="context-menu-trigger"]`)) {
|
||||
return
|
||||
}
|
||||
|
||||
|
||||
@@ -16,6 +16,7 @@ import { useLocation, useNavigate } from 'react-router'
|
||||
import { graftRefreshedTailOntoBackfill } from '@/app/chat/transcript-backfill'
|
||||
import { formatRefValue } from '@/components/assistant-ui/directive-text'
|
||||
import { BootFailureOverlay } from '@/components/boot-failure-overlay'
|
||||
import { ConfirmHost } from '@/components/confirm-host'
|
||||
import { DesktopInstallOverlay } from '@/components/desktop-install-overlay'
|
||||
import { FindBar } from '@/components/find-bar'
|
||||
import { GatewayConnectingOverlay } from '@/components/gateway-connecting-overlay'
|
||||
@@ -62,12 +63,14 @@ import {
|
||||
$selectedStoredSessionId,
|
||||
$sessionResumeRequest,
|
||||
$sessions,
|
||||
rememberedSessionProfile,
|
||||
sessionMatchesStoredId,
|
||||
sessionPinId,
|
||||
setAwaitingResponse,
|
||||
setBusy,
|
||||
setMessages
|
||||
} from '@/store/session'
|
||||
import { requestForSessionProfile } from '@/store/session-request-router'
|
||||
import { clearSessionTodos, setSessionTodos, todosForHydration } from '@/store/todos'
|
||||
import { armWakeWord, stopClientCapture } from '@/store/wake-word'
|
||||
import { isAuxiliaryWindow, isHudWindow } from '@/store/windows'
|
||||
@@ -279,7 +282,22 @@ export function ContribWiring({ children }: { children: ReactNode }) {
|
||||
setMessages
|
||||
})
|
||||
|
||||
const { connectionRef, gateway, gatewayRef, requestGateway } = useGatewayRequest()
|
||||
const { connectionRef, gateway, gatewayRef, requestGateway: ambientRequestGateway } = useGatewayRequest()
|
||||
|
||||
// When chrome stays on the launch backend (Bot Mode / all-profiles
|
||||
// navigation), session-owned RPCs still have to hit the session's backend.
|
||||
const requestGateway = useCallback(
|
||||
<T,>(method: string, params?: Record<string, unknown>, timeoutMs?: number, signal?: AbortSignal) => {
|
||||
const owner = rememberedSessionProfile(
|
||||
$sessions.get(),
|
||||
selectedStoredSessionIdRef.current,
|
||||
$activeGatewayProfile.get()
|
||||
)
|
||||
|
||||
return requestForSessionProfile<T>(owner, ambientRequestGateway, method, params ?? {}, timeoutMs, signal)
|
||||
},
|
||||
[ambientRequestGateway]
|
||||
)
|
||||
|
||||
const { loadMoreMessagingForPlatform, loadMoreSessions, refreshCronJobs, refreshMessagingSessions, refreshSessions } =
|
||||
useSessionListActions({ profileScope })
|
||||
@@ -1160,6 +1178,9 @@ export function ContribWiring({ children }: { children: ReactNode }) {
|
||||
{/* Toasts above everything. */}
|
||||
<NotificationStack />
|
||||
|
||||
{/* Backs confirm() from @/store/confirm — renders only while one is open. */}
|
||||
<ConfirmHost />
|
||||
|
||||
{/* Petdex floating mascot — renders nothing unless installed + enabled.
|
||||
Never in the HUD: that window is the chat bar and nothing else. */}
|
||||
{!isHudWindow() && <FloatingPet />}
|
||||
|
||||
@@ -8,6 +8,7 @@ import { PageLoader } from '@/components/page-loader'
|
||||
import { Button } from '@/components/ui/button'
|
||||
import { Checkbox } from '@/components/ui/checkbox'
|
||||
import { Codicon } from '@/components/ui/codicon'
|
||||
import { ConfirmDialog } from '@/components/ui/confirm-dialog'
|
||||
import {
|
||||
Dialog,
|
||||
DialogContent,
|
||||
@@ -343,7 +344,6 @@ export function CronView({ onClose, onOpenSession, setStatusbarItemGroup: _setSt
|
||||
|
||||
const [editor, setEditor] = useState<EditorState>({ mode: 'closed' })
|
||||
const [pendingDelete, setPendingDelete] = useState<CronJob | null>(null)
|
||||
const [deleting, setDeleting] = useState(false)
|
||||
|
||||
// Jobs live per-profile on disk and the list endpoint aggregates 'all' by
|
||||
// default — scope the fetch to the sidebar's profile scope so this overlay
|
||||
@@ -533,31 +533,23 @@ export function CronView({ onClose, onOpenSession, setStatusbarItemGroup: _setSt
|
||||
}
|
||||
}
|
||||
|
||||
// Throws on failure — ConfirmDialog reports it inline and stays open.
|
||||
async function handleConfirmDelete() {
|
||||
if (!pendingDelete) {
|
||||
return
|
||||
}
|
||||
|
||||
setDeleting(true)
|
||||
const { refreshError, stale } = await mutateAndRefreshCronJobs(profile, () => deleteCronJob(pendingDelete.id))
|
||||
|
||||
try {
|
||||
const { refreshError, stale } = await mutateAndRefreshCronJobs(profile, () => deleteCronJob(pendingDelete.id))
|
||||
|
||||
if (stale) {
|
||||
return
|
||||
}
|
||||
|
||||
if (refreshError) {
|
||||
notifyError(refreshError, c.failedLoad)
|
||||
}
|
||||
|
||||
notify({ kind: 'success', title: c.deleted, message: truncate(jobTitle(pendingDelete), 60) })
|
||||
setPendingDelete(null)
|
||||
} catch (err) {
|
||||
notifyError(err, c.failedDelete)
|
||||
} finally {
|
||||
setDeleting(false)
|
||||
if (stale) {
|
||||
return
|
||||
}
|
||||
|
||||
if (refreshError) {
|
||||
notifyError(refreshError, c.failedLoad)
|
||||
}
|
||||
|
||||
notify({ kind: 'success', title: c.deleted, message: truncate(jobTitle(pendingDelete), 60) })
|
||||
}
|
||||
|
||||
async function handleEditorSave(values: EditorValues) {
|
||||
@@ -682,7 +674,9 @@ export function CronView({ onClose, onOpenSession, setStatusbarItemGroup: _setSt
|
||||
/>
|
||||
))}
|
||||
{visibleJobs.length === 0 && (
|
||||
<p className="px-2 py-4 text-center text-xs text-muted-foreground">{c.emptyTitleSearch}</p>
|
||||
<p className="px-2 py-4 text-center text-xs text-muted-foreground">
|
||||
{query.trim() ? c.emptyTitleSearch : c.emptyTitleNew}
|
||||
</p>
|
||||
)}
|
||||
<PanelAddButton label={c.newCron} onClick={() => setEditor({ mode: 'create' })} />
|
||||
{visibleBlueprints.length > 0 && (
|
||||
@@ -711,8 +705,17 @@ export function CronView({ onClose, onOpenSession, setStatusbarItemGroup: _setSt
|
||||
onPauseResume={() => void handlePauseResume(selectedJob)}
|
||||
onTrigger={() => void handleTrigger(selectedJob)}
|
||||
/>
|
||||
) : (
|
||||
) : query.trim() ? (
|
||||
// A search with no selected job: search-flavored copy is right.
|
||||
<PanelEmpty description={c.emptyDescSearch} icon="search" />
|
||||
) : (
|
||||
// No selection and no search — "Try a broader search query" here
|
||||
// just confused people staring at an empty panel with zero jobs.
|
||||
<PanelEmpty
|
||||
description={c.emptyDescNew}
|
||||
icon="watch"
|
||||
title={jobs.length === 0 ? c.emptyTitleNew : undefined}
|
||||
/>
|
||||
)}
|
||||
</PanelBody>
|
||||
)}
|
||||
@@ -724,30 +727,24 @@ export function CronView({ onClose, onOpenSession, setStatusbarItemGroup: _setSt
|
||||
onSave={handleEditorSave}
|
||||
/>
|
||||
|
||||
<Dialog onOpenChange={open => !open && !deleting && setPendingDelete(null)} open={pendingDelete !== null}>
|
||||
<DialogContent className="max-w-md">
|
||||
<DialogHeader>
|
||||
<DialogTitle>{c.deleteTitle}</DialogTitle>
|
||||
<DialogDescription>
|
||||
{pendingDelete ? (
|
||||
<>
|
||||
{c.deleteDescPrefix}
|
||||
<span className="font-medium text-foreground">{truncate(jobTitle(pendingDelete), 60)}</span>
|
||||
{c.deleteDescSuffix}
|
||||
</>
|
||||
) : null}
|
||||
</DialogDescription>
|
||||
</DialogHeader>
|
||||
<DialogFooter>
|
||||
<Button disabled={deleting} onClick={() => setPendingDelete(null)} variant="outline">
|
||||
{t.common.cancel}
|
||||
</Button>
|
||||
<Button disabled={deleting} onClick={() => void handleConfirmDelete()} variant="destructive">
|
||||
{deleting ? c.deleting : t.common.delete}
|
||||
</Button>
|
||||
</DialogFooter>
|
||||
</DialogContent>
|
||||
</Dialog>
|
||||
<ConfirmDialog
|
||||
busyLabel={c.deleting}
|
||||
confirmLabel={t.common.delete}
|
||||
description={
|
||||
pendingDelete ? (
|
||||
<>
|
||||
{c.deleteDescPrefix}
|
||||
<span className="font-medium text-foreground">{truncate(jobTitle(pendingDelete), 60)}</span>
|
||||
{c.deleteDescSuffix}
|
||||
</>
|
||||
) : null
|
||||
}
|
||||
destructive
|
||||
onClose={() => setPendingDelete(null)}
|
||||
onConfirm={handleConfirmDelete}
|
||||
open={pendingDelete !== null}
|
||||
title={c.deleteTitle}
|
||||
/>
|
||||
</Panel>
|
||||
)
|
||||
}
|
||||
|
||||
@@ -3,14 +3,18 @@ import { type RefObject, useEffect } from 'react'
|
||||
/** The caret is in the composer — see the `:has()` rules in styles.css. */
|
||||
const TYPING_SELECTOR = '[data-slot="composer-rich-input"]:focus'
|
||||
|
||||
/** An open completion list owns the surface; the band falls back behind it. */
|
||||
const DRAWER_SELECTOR = '[data-slot="composer-completion-drawer"]'
|
||||
|
||||
/**
|
||||
* Native frost behind the band.
|
||||
*
|
||||
* macOS vibrancy, not CSS — `backdrop-filter` reaches nothing here, because a
|
||||
* transparent window's backdrop root is the document and the desktop was never
|
||||
* in it. Vibrancy is composited by WindowServer BELOW the web contents, which
|
||||
* is what lets it see the desktop and also what makes it untouchable from the
|
||||
* page: no mask, clip or stacking order can shape it.
|
||||
* A platform material, not CSS — `backdrop-filter` reaches nothing here,
|
||||
* because a transparent window's backdrop root is the document and the desktop
|
||||
* was never in it. The material is composited BELOW the web contents (macOS
|
||||
* vibrancy via WindowServer, Windows 11 via the DWM backdrop), which is what
|
||||
* lets it see the desktop and also what makes it untouchable from the page: no
|
||||
* mask, clip or stacking order can shape it.
|
||||
*
|
||||
* That is survivable because the band is a flat panel. It was NOT survivable
|
||||
* while the band carried a vertical gradient — the frost stayed a slab under a
|
||||
@@ -31,38 +35,79 @@ const TYPING_SELECTOR = '[data-slot="composer-rich-input"]:focus'
|
||||
* document.activeElement, which stays put when the window is blurred and would
|
||||
* latch the frost on forever once the user had ever typed here.
|
||||
*
|
||||
* `backing` is the veto over both of those. Because the frost is the window and
|
||||
* not the sheet, it is only ever right when the sheet covers the window; short
|
||||
* of that the excess is frost over empty space. Gating the caller's `engaged`
|
||||
* alone would not do it — focus turns the frost on by itself, which is how a
|
||||
* brand new thread still frosted its whole empty window.
|
||||
* Two vetoes sit over that:
|
||||
*
|
||||
* - `backing` — because the frost is the window and not the sheet, it is only
|
||||
* ever right when the sheet covers the window; short of that the excess is
|
||||
* frost over empty space. Gating the caller's `engaged` alone would not do
|
||||
* it — focus turns the frost on by itself, which is how a brand new thread
|
||||
* still frosted its whole empty window.
|
||||
* - An open completion drawer, which drops the band to 25% and blurs it
|
||||
* (see the `composer-completion-drawer` rule in styles.css). Full-strength
|
||||
* frost behind a band that has deliberately stepped back is the same bare
|
||||
* slab in a different disguise. Observed rather than passed in: the drawer
|
||||
* mounts inside the composer subtree from three different call sites, so a
|
||||
* prop would need every one of them to remember.
|
||||
*
|
||||
* Whether the frost is wanted AT ALL is the user's translucency setting, and
|
||||
* that answer lives in main (`hudFrostFor`) next to the state it reads. This
|
||||
* hook reports what the band is doing; it does not decide the material.
|
||||
*/
|
||||
export function useHudGlass(rootRef: RefObject<HTMLElement | null>, engaged: boolean, backing: boolean): void {
|
||||
useEffect(() => {
|
||||
const root = rootRef.current
|
||||
const setVibrancy = window.hermesDesktop?.hud?.setVibrancy
|
||||
const setFrost = window.hermesDesktop?.hud?.setFrost
|
||||
|
||||
if (!root || !setVibrancy) {
|
||||
if (!root || !setFrost) {
|
||||
return
|
||||
}
|
||||
|
||||
let on: boolean | null = null
|
||||
|
||||
const apply = () => {
|
||||
const next = backing && (engaged || root.querySelector(TYPING_SELECTOR) !== null)
|
||||
const next =
|
||||
backing &&
|
||||
root.querySelector(DRAWER_SELECTOR) === null &&
|
||||
(engaged || root.querySelector(TYPING_SELECTOR) !== null)
|
||||
|
||||
if (on !== next) {
|
||||
on = next
|
||||
void setVibrancy(next)
|
||||
void setFrost(next)
|
||||
}
|
||||
}
|
||||
|
||||
// The drawer mounts and unmounts without any focus change, so neither
|
||||
// focusin/focusout nor a re-render is guaranteed to follow it. Coalesced
|
||||
// to a frame: this observes the whole shell, and a streaming reply mutates
|
||||
// the transcript tens of times a second — the drawer's state cannot change
|
||||
// more than once per paint, so re-deciding per mutation is pure churn.
|
||||
let frame: null | number = null
|
||||
|
||||
const schedule = () => {
|
||||
if (frame === null) {
|
||||
frame = requestAnimationFrame(() => {
|
||||
frame = null
|
||||
apply()
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
const observer = new MutationObserver(schedule)
|
||||
|
||||
observer.observe(root, { childList: true, subtree: true })
|
||||
|
||||
apply()
|
||||
root.addEventListener('focusin', apply)
|
||||
root.addEventListener('focusout', apply)
|
||||
|
||||
return () => {
|
||||
void setVibrancy(false)
|
||||
void setFrost(false)
|
||||
observer.disconnect()
|
||||
|
||||
if (frame !== null) {
|
||||
cancelAnimationFrame(frame)
|
||||
}
|
||||
|
||||
root.removeEventListener('focusin', apply)
|
||||
root.removeEventListener('focusout', apply)
|
||||
}
|
||||
|
||||
@@ -2,18 +2,12 @@ import { useStore } from '@nanostores/react'
|
||||
import { type CSSProperties, useCallback, useEffect, useRef, useState } from 'react'
|
||||
import { useNavigate } from 'react-router'
|
||||
|
||||
import { TitlebarIcon } from '@/app/shell/titlebar-icon'
|
||||
import { Button } from '@/components/ui/button'
|
||||
import { Tip } from '@/components/ui/tooltip'
|
||||
import { useI18n } from '@/i18n'
|
||||
import { chatMessageText } from '@/lib/chat-messages'
|
||||
import { closeHud } from '@/store/hud'
|
||||
import { $activeSessionAwaitingInput } from '@/store/prompts'
|
||||
import { $busy, $messages } from '@/store/session'
|
||||
|
||||
import { RICH_INPUT_SLOT } from '../chat/composer/rich-editor'
|
||||
import { WiredPane } from '../contrib/wiring'
|
||||
import { titlebarButtonClass } from '../shell/titlebar'
|
||||
|
||||
import { useHudClickThrough } from './click-through'
|
||||
import { useHudGlass } from './glass'
|
||||
@@ -170,7 +164,6 @@ function useHudHeld(): boolean {
|
||||
* `useRecentActivity`).
|
||||
*/
|
||||
export function HudShell() {
|
||||
const { t } = useI18n()
|
||||
const [recent, holdBand] = useRecentActivity()
|
||||
const held = useHudHeld()
|
||||
|
||||
@@ -388,22 +381,6 @@ export function HudShell() {
|
||||
|
||||
<WiredPane part="chatRoutes" />
|
||||
|
||||
{/* The way back — without it the only exits are ⌘⇧H and ⌘W, both
|
||||
invisible. Placed and revealed entirely from styles.css. */}
|
||||
<Tip label={t.titlebar.exitHud}>
|
||||
<Button
|
||||
aria-label={t.titlebar.exitHud}
|
||||
className={`${titlebarButtonClass} absolute z-20`}
|
||||
data-hud-exit=""
|
||||
onClick={closeHud}
|
||||
size="icon-titlebar"
|
||||
type="button"
|
||||
variant="ghost"
|
||||
>
|
||||
<TitlebarIcon name="screen-normal" />
|
||||
</Button>
|
||||
</Tip>
|
||||
|
||||
{/* The resize handle: bottom-right corner, the one sanctioned way to
|
||||
change the HUD's size. Invisible chrome — a hot corner, not a
|
||||
button — so it never reads as part of the surface. `data-hud-grabbing`
|
||||
|
||||
@@ -4,14 +4,7 @@ import { FileDiffPanel } from '@/components/chat/diff-lines'
|
||||
import { DiffSkeleton, TreeSkeleton } from '@/components/chat/skeletons'
|
||||
import { Button } from '@/components/ui/button'
|
||||
import { Codicon } from '@/components/ui/codicon'
|
||||
import {
|
||||
Dialog,
|
||||
DialogContent,
|
||||
DialogDescription,
|
||||
DialogFooter,
|
||||
DialogHeader,
|
||||
DialogTitle
|
||||
} from '@/components/ui/dialog'
|
||||
import { ConfirmDialog } from '@/components/ui/confirm-dialog'
|
||||
import { DiffCount } from '@/components/ui/diff-count'
|
||||
import { Tip } from '@/components/ui/tooltip'
|
||||
import { useDelayedTrue } from '@/hooks/use-delayed-true'
|
||||
@@ -209,32 +202,30 @@ export function ReviewPane() {
|
||||
|
||||
<ReviewShipBar />
|
||||
|
||||
<Dialog onOpenChange={open => !open && cancelRevert()} open={revertTarget !== undefined}>
|
||||
<DialogContent>
|
||||
<DialogHeader>
|
||||
<DialogTitle>{revertingAll ? c.revertAll : c.revert}</DialogTitle>
|
||||
<DialogDescription>
|
||||
{revertingAll ? c.revertAllConfirm : c.revertConfirm}
|
||||
{!revertingAll && revertTarget?.path && (
|
||||
<span
|
||||
className="mt-2 block truncate font-mono text-[0.7rem] text-(--ui-text-secondary)"
|
||||
title={displayPath(revertTarget.path)}
|
||||
>
|
||||
{displayPath(revertTarget.path)}
|
||||
</span>
|
||||
)}
|
||||
</DialogDescription>
|
||||
</DialogHeader>
|
||||
<DialogFooter>
|
||||
<Button onClick={cancelRevert} variant="ghost">
|
||||
{t.common.cancel}
|
||||
</Button>
|
||||
<Button onClick={() => void confirmRevert().catch(err => notifyError(err, c.revert))} variant="destructive">
|
||||
{revertingAll ? c.revertAll : c.revert}
|
||||
</Button>
|
||||
</DialogFooter>
|
||||
</DialogContent>
|
||||
</Dialog>
|
||||
<ConfirmDialog
|
||||
confirmLabel={revertingAll ? c.revertAll : c.revert}
|
||||
description={
|
||||
<>
|
||||
{revertingAll ? c.revertAllConfirm : c.revertConfirm}
|
||||
{!revertingAll && revertTarget?.path && (
|
||||
<span
|
||||
className="mt-2 block truncate font-mono text-[0.7rem] text-(--ui-text-secondary)"
|
||||
title={displayPath(revertTarget.path)}
|
||||
>
|
||||
{displayPath(revertTarget.path)}
|
||||
</span>
|
||||
)}
|
||||
</>
|
||||
}
|
||||
destructive
|
||||
// confirmRevert closes the dialog itself, then reverts in the
|
||||
// background — so the failure lands in a toast, not inline.
|
||||
dismissOnConfirm
|
||||
onClose={cancelRevert}
|
||||
onConfirm={() => confirmRevert().catch(err => void notifyError(err, c.revert))}
|
||||
open={revertTarget !== undefined}
|
||||
title={revertingAll ? c.revertAll : c.revert}
|
||||
/>
|
||||
</aside>
|
||||
)
|
||||
}
|
||||
|
||||
@@ -365,4 +365,41 @@ describe('PersistentTerminal rect tracking', () => {
|
||||
expect(overlay.style.pointerEvents).toBe('auto')
|
||||
expect(mount.container!.querySelector('[data-testid="terminal-workspace"]')).toBe(workspace)
|
||||
})
|
||||
|
||||
it('hides the overlay on a tab switch that happens while the window is unfocused', () => {
|
||||
// The trap: the terminal is a tab in the main zone and the user clicks
|
||||
// another tab without the window being focused (or right as it blurs).
|
||||
// The rect chase is paused then — but visibility is correctness, not perf,
|
||||
// so the overlay must still stand down instead of covering the chat with
|
||||
// an opaque, pointer-interactive surface until something refocuses.
|
||||
installRaf()
|
||||
vi.spyOn(HTMLElement.prototype, 'getBoundingClientRect').mockReturnValue(rect(10, 20, 200, 100))
|
||||
$terminalTakeover.set(true)
|
||||
|
||||
mount.render(<HiddenPaneHarness hidden={false} />)
|
||||
|
||||
const overlay = mount.container!.lastElementChild as HTMLElement
|
||||
|
||||
expect(overlay.style.visibility).toBe('visible')
|
||||
expect(overlay.style.pointerEvents).toBe('auto')
|
||||
|
||||
act(() => {
|
||||
vi.mocked(document.hasFocus).mockReturnValue(false)
|
||||
window.dispatchEvent(new Event('blur'))
|
||||
})
|
||||
|
||||
act(() => {
|
||||
mount.root!.render(<HiddenPaneHarness hidden />)
|
||||
})
|
||||
|
||||
act(() => {
|
||||
mutationObserverCallback?.([], {} as MutationObserver)
|
||||
})
|
||||
|
||||
expect(overlay.style.visibility).toBe('hidden')
|
||||
expect(overlay.style.opacity).toBe('0')
|
||||
expect(overlay.style.pointerEvents).toBe('none')
|
||||
// The PTY survives — only the overlay stands down.
|
||||
expect(mount.container!.querySelector('[data-testid="terminal-workspace"]')).not.toBeNull()
|
||||
})
|
||||
})
|
||||
|
||||
@@ -103,8 +103,25 @@ export function PersistentTerminal({ onAddSelectionToChat }: PersistentTerminalP
|
||||
}
|
||||
}
|
||||
|
||||
// Visibility is CORRECTNESS, not perf. The rect chase below forces layout,
|
||||
// so it stays gated on the renderer pause — but `hidden` is a cheap
|
||||
// attribute walk, and skipping it while paused strands the overlay over a
|
||||
// tab the user has already switched away from: the terminal keeps covering
|
||||
// the chat, opaque and pointer-interactive, until something refocuses the
|
||||
// window. Sample it on every wake, paused or not.
|
||||
const syncHidden = () => {
|
||||
const hidden = isElementInHiddenPane(slot)
|
||||
|
||||
if (prev && prev.hidden !== hidden) {
|
||||
prev = { ...prev, hidden }
|
||||
setRect(prev)
|
||||
}
|
||||
}
|
||||
|
||||
const measure = (reason: string): boolean => {
|
||||
if (rendererPaused()) {
|
||||
syncHidden()
|
||||
|
||||
return false
|
||||
}
|
||||
|
||||
@@ -140,7 +157,20 @@ export function PersistentTerminal({ onAddSelectionToChat }: PersistentTerminalP
|
||||
}
|
||||
|
||||
const scheduleMeasure = (reason = 'unknown') => {
|
||||
if (stopped || rendererPaused() || frame !== 0) {
|
||||
if (stopped) {
|
||||
return
|
||||
}
|
||||
|
||||
// Paused: no frame is coming (and none is wanted — the rect chase is the
|
||||
// expensive half). Still settle visibility synchronously so a tab switch
|
||||
// while the window is unfocused can't leave the overlay stranded.
|
||||
if (rendererPaused()) {
|
||||
syncHidden()
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
if (frame !== 0) {
|
||||
return
|
||||
}
|
||||
|
||||
@@ -158,6 +188,7 @@ export function PersistentTerminal({ onAddSelectionToChat }: PersistentTerminalP
|
||||
const handleVisibilityChange = () => {
|
||||
if (rendererPaused()) {
|
||||
cancelFrame()
|
||||
syncHidden()
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
@@ -81,130 +81,129 @@ describe('preview routing', () => {
|
||||
})
|
||||
|
||||
describe('open_preview', () => {
|
||||
// The rail used to hold a session-keyed singleton alongside its tabs, written
|
||||
// under one session-id rule and reconciled under another. A live session with
|
||||
// no stored id yet resolved to '' on the write side, so the target was set and
|
||||
// then immediately reconciled back to null — the pane flashed and vanished.
|
||||
it('opens a tab for a session that has no stored id yet', async () => {
|
||||
$selectedStoredSessionId.set(null)
|
||||
render(<Harness />)
|
||||
|
||||
// The rail used to hold a session-keyed singleton alongside its tabs, written
|
||||
// under one session-id rule and reconciled under another. A live session with
|
||||
// no stored id yet resolved to '' on the write side, so the target was set and
|
||||
// then immediately reconciled back to null — the pane flashed and vanished.
|
||||
it('opens a tab for a session that has no stored id yet', async () => {
|
||||
$selectedStoredSessionId.set(null)
|
||||
render(<Harness />)
|
||||
await emitPreviewOpen()
|
||||
|
||||
await emitPreviewOpen()
|
||||
|
||||
await waitFor(() => expect($previewTarget.get()?.path).toBe('/tmp/artifact-test.html'))
|
||||
expect($previewTabs.get()).toHaveLength(1)
|
||||
})
|
||||
|
||||
it('keeps the tab when the stored session id arrives afterwards', async () => {
|
||||
$selectedStoredSessionId.set(null)
|
||||
render(<Harness />)
|
||||
|
||||
await emitPreviewOpen()
|
||||
await waitFor(() => expect($previewTarget.get()?.path).toBe('/tmp/artifact-test.html'))
|
||||
|
||||
await act(async () => {
|
||||
$selectedStoredSessionId.set('stored-1')
|
||||
await waitFor(() => expect($previewTarget.get()?.path).toBe('/tmp/artifact-test.html'))
|
||||
expect($previewTabs.get()).toHaveLength(1)
|
||||
})
|
||||
|
||||
expect($previewTarget.get()?.path).toBe('/tmp/artifact-test.html')
|
||||
})
|
||||
it('keeps the tab when the stored session id arrives afterwards', async () => {
|
||||
$selectedStoredSessionId.set(null)
|
||||
render(<Harness />)
|
||||
|
||||
it('ignores an open from a session that is not the one on screen', async () => {
|
||||
render(<Harness />)
|
||||
await emitPreviewOpen()
|
||||
await waitFor(() => expect($previewTarget.get()?.path).toBe('/tmp/artifact-test.html'))
|
||||
|
||||
await act(async () => {
|
||||
handleEvent({
|
||||
payload: { url: '/tmp/other.html' },
|
||||
session_id: 'some-other-session',
|
||||
type: 'preview.open'
|
||||
} as unknown as RpcEvent)
|
||||
await act(async () => {
|
||||
$selectedStoredSessionId.set('stored-1')
|
||||
})
|
||||
|
||||
expect($previewTarget.get()?.path).toBe('/tmp/artifact-test.html')
|
||||
})
|
||||
|
||||
expect($previewTabs.get()).toHaveLength(0)
|
||||
})
|
||||
it('ignores an open from a session that is not the one on screen', async () => {
|
||||
render(<Harness />)
|
||||
|
||||
// The turn that calls open_preview is often a TILE's session while focus
|
||||
// sits on main (the user asked, then clicked elsewhere). On-screen is the
|
||||
// bar — gating on focus made an explicit "open reddit" silently vanish.
|
||||
it('honors an open from an open tile session even when main holds focus', async () => {
|
||||
const { $sessionTiles } = await import('@/store/session-states')
|
||||
const tiles = $sessionTiles.get()
|
||||
await act(async () => {
|
||||
handleEvent({
|
||||
payload: { url: '/tmp/other.html' },
|
||||
session_id: 'some-other-session',
|
||||
type: 'preview.open'
|
||||
} as unknown as RpcEvent)
|
||||
})
|
||||
|
||||
$sessionTiles.set([{ dir: 'right', runtimeId: 'tile-runtime', storedSessionId: 'stored-tile' }])
|
||||
render(<Harness />)
|
||||
|
||||
try {
|
||||
await emitPreviewOpen('/tmp/from-tile.html', 'tile-runtime')
|
||||
|
||||
await waitFor(() => expect($previewTarget.get()?.path).toBe('/tmp/from-tile.html'))
|
||||
} finally {
|
||||
$sessionTiles.set(tiles)
|
||||
}
|
||||
})
|
||||
|
||||
it('opens a second target as its own tab rather than replacing the first', async () => {
|
||||
render(<Harness />)
|
||||
|
||||
await emitPreviewOpen('/tmp/one.html')
|
||||
await waitFor(() => expect($previewTabs.get()).toHaveLength(1))
|
||||
|
||||
await emitPreviewOpen('/tmp/two.html')
|
||||
await waitFor(() => expect($previewTabs.get()).toHaveLength(2))
|
||||
|
||||
expect($previewTarget.get()?.path).toBe('/tmp/two.html')
|
||||
})
|
||||
|
||||
it('re-fronts the existing tab when the same target opens twice', async () => {
|
||||
render(<Harness />)
|
||||
|
||||
await emitPreviewOpen('/tmp/one.html')
|
||||
await emitPreviewOpen('/tmp/one.html')
|
||||
|
||||
await waitFor(() => expect($previewTabs.get()).toHaveLength(1))
|
||||
})
|
||||
|
||||
it('renders a tool-opened html file rather than showing its source', async () => {
|
||||
render(<Harness />)
|
||||
|
||||
await emitPreviewOpen()
|
||||
|
||||
await waitFor(() => expect($previewTarget.get()?.renderMode).toBe('preview'))
|
||||
})
|
||||
|
||||
// Offer, don't hijack: only an explicit open_preview call opens the rail.
|
||||
it('does not infer a preview from assistant prose', async () => {
|
||||
render(<Harness />)
|
||||
|
||||
await act(async () => {
|
||||
$messages.set([
|
||||
assistantMessage('a1', 'Preview: http://localhost:5173/'),
|
||||
assistantMessage('a2', 'Open /work/demo.html')
|
||||
])
|
||||
expect($previewTabs.get()).toHaveLength(0)
|
||||
})
|
||||
|
||||
expect($previewTabs.get()).toHaveLength(0)
|
||||
expect(window.hermesDesktop.normalizePreviewTarget).not.toHaveBeenCalled()
|
||||
})
|
||||
// The turn that calls open_preview is often a TILE's session while focus
|
||||
// sits on main (the user asked, then clicked elsewhere). On-screen is the
|
||||
// bar — gating on focus made an explicit "open reddit" silently vanish.
|
||||
it('honors an open from an open tile session even when main holds focus', async () => {
|
||||
const { $sessionTiles } = await import('@/store/session-states')
|
||||
const tiles = $sessionTiles.get()
|
||||
|
||||
it('does not open a preview off the back of a tool result', async () => {
|
||||
render(<Harness />)
|
||||
$sessionTiles.set([{ dir: 'right', runtimeId: 'tile-runtime', storedSessionId: 'stored-tile' }])
|
||||
render(<Harness />)
|
||||
|
||||
await act(async () => {
|
||||
handleEvent({
|
||||
payload: { inline_diff: 'a/preview-demo.html -> b/preview-demo.html\n' },
|
||||
session_id: RUNTIME_SESSION_ID,
|
||||
type: 'tool.complete'
|
||||
} as unknown as RpcEvent)
|
||||
handleEvent({
|
||||
payload: { path: './dist/index.html' },
|
||||
session_id: RUNTIME_SESSION_ID,
|
||||
type: 'tool.complete'
|
||||
} as unknown as RpcEvent)
|
||||
try {
|
||||
await emitPreviewOpen('/tmp/from-tile.html', 'tile-runtime')
|
||||
|
||||
await waitFor(() => expect($previewTarget.get()?.path).toBe('/tmp/from-tile.html'))
|
||||
} finally {
|
||||
$sessionTiles.set(tiles)
|
||||
}
|
||||
})
|
||||
|
||||
expect($previewTabs.get()).toHaveLength(0)
|
||||
})
|
||||
it('opens a second target as its own tab rather than replacing the first', async () => {
|
||||
render(<Harness />)
|
||||
|
||||
await emitPreviewOpen('/tmp/one.html')
|
||||
await waitFor(() => expect($previewTabs.get()).toHaveLength(1))
|
||||
|
||||
await emitPreviewOpen('/tmp/two.html')
|
||||
await waitFor(() => expect($previewTabs.get()).toHaveLength(2))
|
||||
|
||||
expect($previewTarget.get()?.path).toBe('/tmp/two.html')
|
||||
})
|
||||
|
||||
it('re-fronts the existing tab when the same target opens twice', async () => {
|
||||
render(<Harness />)
|
||||
|
||||
await emitPreviewOpen('/tmp/one.html')
|
||||
await emitPreviewOpen('/tmp/one.html')
|
||||
|
||||
await waitFor(() => expect($previewTabs.get()).toHaveLength(1))
|
||||
})
|
||||
|
||||
it('renders a tool-opened html file rather than showing its source', async () => {
|
||||
render(<Harness />)
|
||||
|
||||
await emitPreviewOpen()
|
||||
|
||||
await waitFor(() => expect($previewTarget.get()?.renderMode).toBe('preview'))
|
||||
})
|
||||
|
||||
// Offer, don't hijack: only an explicit open_preview call opens the rail.
|
||||
it('does not infer a preview from assistant prose', async () => {
|
||||
render(<Harness />)
|
||||
|
||||
await act(async () => {
|
||||
$messages.set([
|
||||
assistantMessage('a1', 'Preview: http://localhost:5173/'),
|
||||
assistantMessage('a2', 'Open /work/demo.html')
|
||||
])
|
||||
})
|
||||
|
||||
expect($previewTabs.get()).toHaveLength(0)
|
||||
expect(window.hermesDesktop.normalizePreviewTarget).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('does not open a preview off the back of a tool result', async () => {
|
||||
render(<Harness />)
|
||||
|
||||
await act(async () => {
|
||||
handleEvent({
|
||||
payload: { inline_diff: 'a/preview-demo.html -> b/preview-demo.html\n' },
|
||||
session_id: RUNTIME_SESSION_ID,
|
||||
type: 'tool.complete'
|
||||
} as unknown as RpcEvent)
|
||||
handleEvent({
|
||||
payload: { path: './dist/index.html' },
|
||||
session_id: RUNTIME_SESSION_ID,
|
||||
type: 'tool.complete'
|
||||
} as unknown as RpcEvent)
|
||||
})
|
||||
|
||||
expect($previewTabs.get()).toHaveLength(0)
|
||||
})
|
||||
})
|
||||
|
||||
describe('close_preview', () => {
|
||||
|
||||
@@ -2,6 +2,7 @@ import { readActivePreview } from '@/app/chat/right-rail/preview-reader'
|
||||
import { writeAgentTerminalChunk } from '@/app/right-sidebar/terminal/agent-terminal-stream'
|
||||
import { readActiveTerminal } from '@/app/right-sidebar/terminal/buffer'
|
||||
import { closeAgentTerminalByProc } from '@/app/right-sidebar/terminal/terminals'
|
||||
import type { PreviewActAction } from '@/lib/preview-act/act-in-page'
|
||||
import type { TourAction, TourStep } from '@/lib/tour'
|
||||
import { $gateway } from '@/store/gateway'
|
||||
import { applyDesktopLayoutPreset, revealDesktopPane } from '@/store/pane-focus'
|
||||
@@ -10,6 +11,34 @@ import { setMessages } from '@/store/session'
|
||||
|
||||
import type { GatewayEventContext } from './types'
|
||||
|
||||
/** The preview engine, loaded on demand so ~25KB of page-injectable source stays
|
||||
* off the boot path.
|
||||
*
|
||||
* In dev that lazy chunk is also a trap. The browser caches a dynamic import by
|
||||
* URL for the life of the page, so this bridge would hand every action to
|
||||
* whichever build of the engine loaded first, and no edit to it — or to the
|
||||
* overlay whose source it stringifies into the page — would reach the guest
|
||||
* until the whole window reloaded. Asking for a fresh copy is more reliable
|
||||
* than trusting hot-update propagation to reach a module nothing statically
|
||||
* imports; the dev server stamps the dependency URLs it has invalidated, so a
|
||||
* fresh engine pulls a fresh overlay down with it.
|
||||
*
|
||||
* The literal path is what a bare specifier can't be here, and it has to track
|
||||
* this module's real location — hence the fall back to the static import, which
|
||||
* is also the only branch production keeps, `import.meta.hot` being stripped
|
||||
* there along with everything it guards. */
|
||||
const loadPreviewEngine = () => {
|
||||
const stable = () => import('@/app/chat/right-rail/preview-act')
|
||||
|
||||
if (!import.meta.hot) {
|
||||
return stable().then(mod => mod.actOnActivePreview)
|
||||
}
|
||||
|
||||
return import(/* @vite-ignore */ '/src/app/chat/right-rail/preview-act.ts?hot=' + Date.now())
|
||||
.catch(stable)
|
||||
.then(mod => mod.actOnActivePreview as Awaited<ReturnType<typeof stable>>['actOnActivePreview'])
|
||||
}
|
||||
|
||||
/** Desktop-surface bridge events: read-back requests the agent blocks on
|
||||
* (terminal/preview/window), agent terminal streaming, pane reveal, and
|
||||
* message reactions. */
|
||||
@@ -55,6 +84,50 @@ export function handleDesktopBridgeEvent(ctx: GatewayEventContext): boolean {
|
||||
return true
|
||||
}
|
||||
|
||||
if (event.type === 'preview.act.request') {
|
||||
// drive_preview tool: click/type/scroll/press inside the guest page, or
|
||||
// drive the pane's history. Dynamic import keeps the injected engine off
|
||||
// the boot path. Active session only: a background turn must never reach
|
||||
// into the page the user is working in (desktop AGENTS.md: offer, don't
|
||||
// hijack).
|
||||
const requestId = typeof payload?.request_id === 'string' ? payload.request_id : ''
|
||||
|
||||
if (requestId) {
|
||||
const answer = (result: unknown) =>
|
||||
$gateway.get()?.request('preview.act.respond', {
|
||||
request_id: requestId,
|
||||
text: result ? JSON.stringify(result) : ''
|
||||
})
|
||||
|
||||
if (isActiveEvent) {
|
||||
void loadPreviewEngine()
|
||||
.then(run =>
|
||||
run({
|
||||
amount: payload?.amount,
|
||||
key: payload?.key,
|
||||
kind: payload?.action ?? '',
|
||||
max: payload?.max,
|
||||
ref: payload?.ref,
|
||||
selector: payload?.selector,
|
||||
submit: payload?.submit,
|
||||
text: payload?.text,
|
||||
to: payload?.to as PreviewActAction['to']
|
||||
})
|
||||
)
|
||||
.then(answer, error =>
|
||||
answer({ error: error instanceof Error ? error.message : String(error), success: false })
|
||||
)
|
||||
} else {
|
||||
void answer({
|
||||
error: 'The in-app browser only takes actions in the session the user is looking at.',
|
||||
success: false
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
if (event.type === 'window.read.request') {
|
||||
// read_window_below tool: main owns native window enumeration, so ask
|
||||
// it over IPC and answer. Empty text = unavailable (no bridge, or
|
||||
|
||||
@@ -121,6 +121,7 @@ export function usePreviewRouting({ baseHandleGatewayEvent, currentCwd, requestG
|
||||
|
||||
if (!target) {
|
||||
closeRightRail()
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
|
||||
@@ -163,7 +163,7 @@ describe('connection-qualified session deletion', () => {
|
||||
afterEach(() => {
|
||||
cleanup()
|
||||
setSessions([])
|
||||
vi.restoreAllMocks()
|
||||
vi.clearAllMocks()
|
||||
})
|
||||
|
||||
it('deletes a registry session through its captured connection owner', async () => {
|
||||
|
||||
@@ -13,8 +13,8 @@ import { setSessionYolo } from '@/lib/yolo-session'
|
||||
import { normalizeChoices, setClarifyRequest } from '@/store/clarify'
|
||||
import { migrateSessionDraft } from '@/store/composer'
|
||||
import { clearQueuedPrompts, migrateQueuedPrompts } from '@/store/composer-queue'
|
||||
import { openGatewayForAgent, openGatewayForProfile, requestGatewayForAgent } from '@/store/gateway'
|
||||
import { $gatewaySwitching } from '@/store/gateway-switch'
|
||||
import { requestGatewayForAgent } from '@/store/gateway'
|
||||
import { $pinnedSessionIds } from '@/store/layout'
|
||||
import { clearNotifications, notify, notifyError } from '@/store/notifications'
|
||||
import {
|
||||
@@ -22,6 +22,7 @@ import {
|
||||
$gatewaySwapTarget,
|
||||
$newChatProfile,
|
||||
$newChatRoute,
|
||||
$showAllProfiles,
|
||||
ensureGatewayAgent,
|
||||
ensureGatewayProfile,
|
||||
normalizeProfileKey
|
||||
@@ -83,6 +84,7 @@ import {
|
||||
} from '@/store/session-states'
|
||||
import { broadcastSessionsChanged } from '@/store/session-sync'
|
||||
import { forgetSessionUnread } from '@/store/session-unread'
|
||||
import { $archivedSessions } from '@/store/sidebar-archive'
|
||||
import { dropTranscriptTail, loadTranscriptTail, saveTranscriptTail } from '@/store/transcript-tail-cache'
|
||||
import { isWatchWindow } from '@/store/windows'
|
||||
import type { SessionCreateResponse, SessionMessage, SessionResumeResponse, UsageStats } from '@/types/hermes'
|
||||
@@ -776,8 +778,22 @@ export function useSessionActions({
|
||||
}
|
||||
: sessionProfile)
|
||||
|
||||
if (ownerRoute?.connectionId || storedForProfile?.connection_id) {
|
||||
await ensureGatewayAgent(ownerRoute?.connectionId || storedForProfile?.connection_id || null, sessionProfile || 'default')
|
||||
// All-profiles / plugin navigation must not steal chrome API-home:
|
||||
// dial the owning backend without moving $activeGatewayProfile.
|
||||
if ($showAllProfiles.get()) {
|
||||
if (ownerRoute?.connectionId || storedForProfile?.connection_id) {
|
||||
await openGatewayForAgent(
|
||||
ownerRoute?.connectionId || storedForProfile?.connection_id || null,
|
||||
ownerRoute?.profile || sessionProfile || 'default'
|
||||
)
|
||||
} else if (sessionProfile) {
|
||||
await openGatewayForProfile(normalizeProfileKey(sessionProfile))
|
||||
}
|
||||
} else if (ownerRoute?.connectionId || storedForProfile?.connection_id) {
|
||||
await ensureGatewayAgent(
|
||||
ownerRoute?.connectionId || storedForProfile?.connection_id || null,
|
||||
ownerRoute?.profile || sessionProfile || 'default'
|
||||
)
|
||||
} else {
|
||||
await ensureGatewayProfile(sessionProfile)
|
||||
}
|
||||
@@ -1756,7 +1772,15 @@ export function useSessionActions({
|
||||
async (storedSessionId: string) => {
|
||||
clearNotifications()
|
||||
|
||||
const removed = $sessions.get().find(session => sessionMatchesStoredId(session, storedSessionId))
|
||||
// The row may live in the main list OR the archived view's own store
|
||||
// (archived rows are excluded from $sessions by design). Resolve from
|
||||
// both so deleting from the Archived filter evicts the row instead of
|
||||
// leaving a ghost that resumes into a dead id (infinite spinner).
|
||||
const removedFromMain = $sessions.get().find(session => sessionMatchesStoredId(session, storedSessionId))
|
||||
|
||||
const removed =
|
||||
removedFromMain ?? $archivedSessions.get().find(session => sessionMatchesStoredId(session, storedSessionId))
|
||||
|
||||
const wasSelected = selectedStoredSessionId === storedSessionId
|
||||
const closingRuntimeId = wasSelected ? activeSessionId : null
|
||||
const previousMessages = $messages.get()
|
||||
@@ -1767,12 +1791,14 @@ export function useSessionActions({
|
||||
profile: removed.profile || 'default'
|
||||
}
|
||||
: removed?.profile
|
||||
const previousArchived = $archivedSessions.get()
|
||||
// Pins are keyed on the durable lineage-root id; the stored id may be the
|
||||
// live tip after compression. Drop both so the pin can't linger.
|
||||
const removedPinId = removed ? sessionPinId(removed) : storedSessionId
|
||||
const removedIds = [storedSessionId, removed?.id, removed?._lineage_root_id]
|
||||
|
||||
setSessions(prev => prev.filter(session => !sessionMatchesStoredId(session, storedSessionId)))
|
||||
$archivedSessions.set(previousArchived.filter(session => !sessionMatchesStoredId(session, storedSessionId)))
|
||||
// Evict from the project tree's optimistic layer too (the backend snapshot
|
||||
// still lists it until its next refresh), so grouped + flat views drop the
|
||||
// row in lockstep. Pin the tombstone against the projects.tree prune while
|
||||
@@ -1821,10 +1847,13 @@ export function useSessionActions({
|
||||
dropSessionState(tiledRuntimeId)
|
||||
}
|
||||
} catch (err) {
|
||||
if (removed) {
|
||||
setSessions(prev => [removed, ...prev])
|
||||
if (removedFromMain) {
|
||||
setSessions(prev => [removedFromMain, ...prev])
|
||||
}
|
||||
|
||||
// Restore the archived-view row too (no-op when it wasn't archived).
|
||||
$archivedSessions.set(previousArchived)
|
||||
|
||||
untombstoneSessions(removedIds)
|
||||
$pinnedSessionIds.set(previousPinned)
|
||||
|
||||
|
||||
+141
@@ -0,0 +1,141 @@
|
||||
// Regression: deleting a session from the Archived filter view left a ghost
|
||||
// row. Archived rows live in $archivedSessions (their own capped store —
|
||||
// they're excluded from $sessions by design), and removeSession only pruned
|
||||
// $sessions. The ghost row then resumed into a hard-deleted id: resume 404 →
|
||||
// goneSessionVerdict saw the row still listed → 'retry' → an unrecoverable
|
||||
// spinner (Aug 2026 desktop audit, F8).
|
||||
import { act, cleanup, render, waitFor } from '@testing-library/react'
|
||||
import type { MutableRefObject } from 'react'
|
||||
import { useEffect } from 'react'
|
||||
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
|
||||
|
||||
import { deleteSession, type SessionInfo } from '@/hermes'
|
||||
import { setSessions } from '@/store/session'
|
||||
import { $archivedSessions } from '@/store/sidebar-archive'
|
||||
|
||||
import type { ClientSessionState } from '../../../types'
|
||||
|
||||
import { useSessionActions } from './index'
|
||||
|
||||
vi.mock('@/hermes', async importOriginal => ({
|
||||
...(await importOriginal<Record<string, unknown>>()),
|
||||
deleteSession: vi.fn(),
|
||||
getSession: vi.fn(),
|
||||
getAllSessionMessages: vi.fn(),
|
||||
getLatestSessionMessages: vi.fn(),
|
||||
listAllProfileSessions: vi.fn(),
|
||||
setApiRequestProfile: vi.fn(),
|
||||
setSessionArchived: vi.fn()
|
||||
}))
|
||||
|
||||
vi.mock('@/store/profile', async importOriginal => ({
|
||||
...(await importOriginal<Record<string, unknown>>()),
|
||||
ensureGatewayProfile: vi.fn().mockResolvedValue(undefined)
|
||||
}))
|
||||
|
||||
function archivedSession(overrides: Partial<SessionInfo> = {}): SessionInfo {
|
||||
return {
|
||||
archived: true,
|
||||
ended_at: null,
|
||||
id: 'arch-1',
|
||||
input_tokens: 0,
|
||||
is_active: false,
|
||||
last_active: 1,
|
||||
message_count: 2,
|
||||
model: null,
|
||||
output_tokens: 0,
|
||||
preview: null,
|
||||
source: 'desktop',
|
||||
started_at: 1,
|
||||
title: 'archived ghost',
|
||||
tool_call_count: 0,
|
||||
...overrides
|
||||
} as SessionInfo
|
||||
}
|
||||
|
||||
type Handle = Pick<ReturnType<typeof useSessionActions>, 'removeSession'>
|
||||
|
||||
function Harness({ onReady }: { onReady: (handle: Handle) => void }) {
|
||||
const ref = <T,>(value: T): MutableRefObject<T> => ({ current: value })
|
||||
|
||||
const actions = useSessionActions({
|
||||
activeSessionId: null,
|
||||
activeSessionIdRef: ref<string | null>(null),
|
||||
busyRef: ref(false),
|
||||
creatingSessionRef: ref(false),
|
||||
ensureSessionState: () => ({}) as ClientSessionState,
|
||||
getRouteToken: () => 'token',
|
||||
getRoutedStoredSessionId: () => null,
|
||||
navigate: vi.fn() as never,
|
||||
requestGateway: vi.fn().mockResolvedValue(undefined),
|
||||
resetViewSync: vi.fn(),
|
||||
runtimeIdByStoredSessionIdRef: ref(new Map<string, string>()),
|
||||
selectedStoredSessionId: null,
|
||||
selectedStoredSessionIdRef: ref<string | null>(null),
|
||||
sessionStateByRuntimeIdRef: ref(new Map<string, ClientSessionState>()),
|
||||
syncSessionStateToView: vi.fn(),
|
||||
updateSessionState: () => ({}) as ClientSessionState
|
||||
})
|
||||
|
||||
useEffect(() => {
|
||||
onReady({ removeSession: actions.removeSession })
|
||||
}, [actions, onReady])
|
||||
|
||||
return null
|
||||
}
|
||||
|
||||
async function mountHarness(): Promise<Handle> {
|
||||
let handle: Handle | undefined
|
||||
render(<Harness onReady={h => (handle = h)} />)
|
||||
await waitFor(() => expect(handle).toBeDefined())
|
||||
|
||||
return handle as Handle
|
||||
}
|
||||
|
||||
describe('removeSession × archived view store', () => {
|
||||
beforeEach(() => {
|
||||
setSessions([])
|
||||
$archivedSessions.set([])
|
||||
vi.mocked(deleteSession).mockReset()
|
||||
})
|
||||
|
||||
afterEach(() => {
|
||||
cleanup()
|
||||
setSessions([])
|
||||
$archivedSessions.set([])
|
||||
})
|
||||
|
||||
it('evicts the row from $archivedSessions on successful delete', async () => {
|
||||
$archivedSessions.set([archivedSession(), archivedSession({ id: 'arch-2', title: 'keep me' })])
|
||||
vi.mocked(deleteSession).mockResolvedValue({ ok: true })
|
||||
|
||||
const handle = await mountHarness()
|
||||
|
||||
await act(() => handle.removeSession('arch-1'))
|
||||
|
||||
expect(vi.mocked(deleteSession)).toHaveBeenCalledWith('arch-1', undefined)
|
||||
expect($archivedSessions.get().map(session => session.id)).toEqual(['arch-2'])
|
||||
})
|
||||
|
||||
it('restores the archived row when the delete RPC fails', async () => {
|
||||
$archivedSessions.set([archivedSession()])
|
||||
vi.mocked(deleteSession).mockRejectedValue(new Error('backend down'))
|
||||
|
||||
const handle = await mountHarness()
|
||||
|
||||
await act(() => handle.removeSession('arch-1'))
|
||||
|
||||
expect($archivedSessions.get().map(session => session.id)).toEqual(['arch-1'])
|
||||
})
|
||||
|
||||
it('passes the archived row profile to deleteSession', async () => {
|
||||
$archivedSessions.set([archivedSession({ profile: 'sage' } as Partial<SessionInfo>)])
|
||||
vi.mocked(deleteSession).mockResolvedValue({ ok: true })
|
||||
|
||||
const handle = await mountHarness()
|
||||
|
||||
await act(() => handle.removeSession('arch-1'))
|
||||
|
||||
expect(vi.mocked(deleteSession)).toHaveBeenCalledWith('arch-1', 'sage')
|
||||
})
|
||||
})
|
||||
@@ -9,6 +9,7 @@ import { Input } from '@/components/ui/input'
|
||||
import { getElevenLabsVoices, getHermesConfigSchema, saveHermesConfig } from '@/hermes'
|
||||
import { useI18n } from '@/i18n'
|
||||
import { triggerHaptic } from '@/lib/haptics'
|
||||
import { confirm } from '@/store/confirm'
|
||||
import {
|
||||
$dataUrlReadMaxMb,
|
||||
clampDataUrlReadMaxMb,
|
||||
@@ -213,19 +214,29 @@ function ConfigSettingsInner({
|
||||
// eslint-disable-next-line react-hooks/exhaustive-deps -- copy is stable; avoid re-scheduling autosave on locale change
|
||||
}, [config, onConfigSaved, saveVersion])
|
||||
|
||||
const applyConfig = (next: HermesConfigRecord) => {
|
||||
saveVersionRef.current += 1
|
||||
setConfig(next)
|
||||
setSaveVersion(saveVersionRef.current)
|
||||
}
|
||||
|
||||
const updateConfig = (next: HermesConfigRecord) => {
|
||||
// Guard the single most destructive config edit: clearing the entire
|
||||
// "Enabled Toolsets" list silently disables memory, terminal, web search,
|
||||
// delegation, and most tools, and a stray select-all + Backspace can do it.
|
||||
// Auto-save is debounced with no undo, so confirm a non-empty → empty
|
||||
// transition before applying it. Every other edit passes through untouched.
|
||||
if (config && clearsEnabledToolsets(config, next) && !window.confirm(c.toolsetsWipeConfirm)) {
|
||||
if (config && clearsEnabledToolsets(config, next)) {
|
||||
void confirm({ destructive: true, title: c.toolsetsWipeConfirm }).then(ok => {
|
||||
if (ok) {
|
||||
applyConfig(next)
|
||||
}
|
||||
})
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
saveVersionRef.current += 1
|
||||
setConfig(next)
|
||||
setSaveVersion(saveVersionRef.current)
|
||||
applyConfig(next)
|
||||
}
|
||||
|
||||
const sectionFields = useMemo(() => {
|
||||
|
||||
@@ -13,6 +13,7 @@ import {
|
||||
import { triggerHaptic } from '@/lib/haptics'
|
||||
import { Check, Globe, Loader2, Plus, Save, Trash2, Zap } from '@/lib/icons'
|
||||
import { cn } from '@/lib/utils'
|
||||
import { confirm } from '@/store/confirm'
|
||||
import { notify, notifyError } from '@/store/notifications'
|
||||
import type { CustomEndpoint, CustomEndpointUpdate } from '@/types/hermes'
|
||||
|
||||
@@ -195,7 +196,8 @@ export function CustomEndpointsSettings({ onConfigSaved, onMainModelChanged }: C
|
||||
}
|
||||
|
||||
async function handleDelete(endpoint: CustomEndpoint) {
|
||||
if (!window.confirm(`Delete ${endpoint.name}?`)) {
|
||||
// This panel is not internationalized at all — keep the literal it had.
|
||||
if (!(await confirm({ destructive: true, title: `Delete ${endpoint.name}?` }))) {
|
||||
return
|
||||
}
|
||||
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user