diff --git a/agent/relay_llm.py b/agent/relay_llm.py index 048735d159..df52bc269e 100644 --- a/agent/relay_llm.py +++ b/agent/relay_llm.py @@ -235,12 +235,9 @@ def stream_current( completed_response_predicate=completed_response_predicate, ) if completed_response_predicate is not None: - # Relay may defer the provider callback until the first pull; prime once so a - # completed response surfaces (a real first chunk is buffered). + # Relay may defer the provider callback until the first pull; prime once (a real first chunk is buffered). managed._prime_completed_response() - if managed.final_response is not None: - return managed.final_response - return managed + return managed.final_response if managed.final_response is not None else managed def _aclose_on_loop(loop: asyncio.AbstractEventLoop, stream: Any) -> None: @@ -421,12 +418,8 @@ class ManagedLlmStream(Iterator[Any]): if self._prefetched_chunks: return self._prefetched_chunks.pop() if self._loop is None: - try: - chunk = next(self._stream) - except StopIteration: - self._close(logical_outcome="cancelled") - raise - if self._accept_chunk is not None and not self._accept_chunk(chunk): + chunk = next(self._stream, self) # self: exhausted sentinel + if chunk is self or (self._accept_chunk is not None and not self._accept_chunk(chunk)): self._close(logical_outcome="cancelled") raise StopIteration return chunk @@ -596,10 +589,9 @@ class AnthropicStreamAccumulator: for block in blocks: partial = block.pop("_partial_json", None) if partial is not None: - try: - block["input"] = json.loads(partial) - except (TypeError, ValueError): - block["input"] = partial + with contextlib.suppress(TypeError, ValueError): + partial = json.loads(partial) + block["input"] = partial return {**self._message, "content": blocks} def response(self, base: Any = None) -> Any: @@ -788,11 +780,11 @@ def _codec_round_trip_request_body( try: encoded = codec.encode(codec.decode(relay_request), relay_request) content = getattr(encoded, "content", encoded) - if isinstance(content, dict): - return _provider_request_body(content, metadata) except Exception: logger.warning("NeMo Relay request codec baseline failed; ignoring request rewrites", exc_info=True) return None + if isinstance(content, dict): + return _provider_request_body(content, metadata) logger.warning("NeMo Relay request codec returned an unsupported baseline; ignoring request rewrites") return None @@ -809,10 +801,7 @@ def _provider_request_body(content: dict[str, Any], metadata: dict[str, Any] | N def _codec(relay: Any, metadata: dict[str, Any] | None) -> Any: protocol = _RELAY_PROTOCOL_BY_API_MODE.get(_api_mode(metadata)) - codecs = getattr(relay, "codecs", None) - if protocol is None or codecs is None: - return None - codec = getattr(codecs, protocol[1], None) + codec = getattr(getattr(relay, "codecs", None), protocol[1], None) if protocol is not None else None return codec() if callable(codec) else None diff --git a/agent/relay_runtime.py b/agent/relay_runtime.py index 1bfd01a2e3..6b709b376e 100644 --- a/agent/relay_runtime.py +++ b/agent/relay_runtime.py @@ -100,8 +100,7 @@ def pop_relay_scope(relay: Any, handle: Any, *, output: Any = None, metadata: An """Pop a Relay scope, forwarding only the kwargs the live binding accepts. ``scope.pop`` gained ``metadata`` in nemo-relay 0.4+; older wheels raise TypeError.""" pop = relay.scope.pop - candidates = (("output", output), ("metadata", metadata), ("timestamp", timestamp)) - kwargs = {key: value for key, value in candidates if value is not None} + kwargs = {k: v for k, v in (("output", output), ("metadata", metadata), ("timestamp", timestamp)) if v is not None} try: params = inspect.signature(pop).parameters except (TypeError, ValueError): @@ -180,8 +179,7 @@ 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 + self._lock, self._runtime = threading.Lock(), 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.""" @@ -406,9 +404,9 @@ class RelayRuntime: return None session = self._sessions.get(session_id) if session is None: - parent_session_id = self._subagent_parents.get(session_id, "") - session = RelaySession(session_id=session_id, parent_session_id=parent_session_id) - self._sessions[session_id] = session + session = self._sessions[session_id] = RelaySession( + session_id=session_id, parent_session_id=self._subagent_parents.get(session_id, "") + ) with session.lock: if session.closing: return None @@ -461,12 +459,8 @@ class RelayRuntime: return None parent = self.ensure_session({"session_id": parent_session_id}) parent_handle = None if parent is None else parent.handle - turn = active_turn(parent_session_id) - # active_turn() already proved liveness and, for a RelayRuntime host, an open session. - if ( - turn is not None and turn.handle is not None and turn.lease.host is self - and turn.lease.session.session_id == parent_session_id - ): + turn = active_turn(parent_session_id) # already proved liveness and (RelayRuntime host) an open session + if turn is not None and turn.handle is not None and turn.lease.host is self: parent_handle = turn.handle with self._sessions_lock: if self._closing: @@ -503,14 +497,13 @@ class RelayRuntime: return None if session.closing else session def _session_context(self, session: RelaySession, *, allow_closing: bool) -> contextvars.Context: - """Copy the current context and overlay the session's saved Relay vars.""" + """Copy the current context and overlay the session's saved Relay vars (a copy: re-entrant from callbacks).""" 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() - # A copy lets a helper inside a Relay callback re-enter the session's Context. context = contextvars.copy_context() for variable, value in relay_context.items(): context.run(variable.set, value) @@ -606,9 +599,8 @@ class RelayRuntime: def apply_tool_request_intercepts(self, *, session_id: str, tool_name: str, args: dict[str, Any]) -> dict[str, Any]: """Apply Relay request rewriting before Hermes authorizes a tool call.""" request_intercepts = getattr(getattr(self.relay, "tools", None), "request_intercepts", None) - if not self.managed_execution_enabled() or not callable(request_intercepts): - return args - session = self.ensure_session({"session_id": session_id}) + managed = self.managed_execution_enabled() and callable(request_intercepts) + session = self.ensure_session({"session_id": session_id}) if managed else None if session is None: return args result = self.run_in_session(session, request_intercepts, tool_name, args) @@ -784,8 +776,7 @@ class RelayHostRegistry: def shutdown_all(self) -> None: with self._lock: - hosts = list(self._hosts.values()) - self._hosts.clear() + hosts, self._hosts = list(self._hosts.values()), {} for host in hosts: host.shutdown() @@ -904,9 +895,7 @@ class RelaySessionCoordinator: def acquire_conversation( self, *, profile_key: str, session_id: str, platform: str, parent_session_id: str = "", model: str = "", ) -> ConversationLease: - host = self.registry.for_profile(profile_key) or NoopRelayRuntime( - profile_key, "Relay host creation was disabled" - ) + host = self.registry.for_profile(profile_key) or NoopRelayRuntime(profile_key, "Relay host creation was disabled") session = None if isinstance(host, RelayRuntime): context = { @@ -924,9 +913,8 @@ class RelaySessionCoordinator: session_id, parent_session_id = context["session_id"], context["parent_session_id"] metadata = {"hermes.execution_surface": context["platform"] or "unknown"} if parent_session_id and parent_session_id != session_id: - return host.register_subagent( - {"parent_session_id": parent_session_id, "child_session_id": session_id}, metadata=metadata, - ) + event = {"parent_session_id": parent_session_id, "child_session_id": session_id} + return host.register_subagent(event, metadata=metadata) return host.ensure_session({"session_id": session_id}, metadata=metadata) def begin_turn(self, lease: ConversationLease, *, turn_id: str, task_id: str) -> RelayTurnContext: @@ -1191,9 +1179,7 @@ def current_profile_key() -> str: home = get_hermes_home().expanduser() if not home.is_absolute(): return str(home.resolve()) - raw = str(home) - cached = _PROFILE_KEY_CACHE.get(raw) - return cached if cached is not None else _PROFILE_KEY_CACHE.setdefault(raw, str(home.resolve())) + return _PROFILE_KEY_CACHE.get(str(home)) or _PROFILE_KEY_CACHE.setdefault(str(home), str(home.resolve())) def _load_nemo_relay() -> Any: @@ -1230,11 +1216,10 @@ 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: + with contextlib.suppress(RuntimeError): asyncio.get_running_loop() - except RuntimeError: - return asyncio.run(value) - return _run_on_daemon_thread(lambda: asyncio.run(value), name="hermes-nemo-relay-plugin-lifecycle") + return _run_on_daemon_thread(lambda: asyncio.run(value), name="hermes-nemo-relay-plugin-lifecycle") + return asyncio.run(value) def _session_id(event: dict[str, Any]) -> str: