mirror of
https://github.com/NousResearch/hermes-agent.git
synced 2026-11-18 03:43:05 +03:00
c871dd3191
The worker sent its activity frame every 30 s regardless of agent.gateway_timeout, so with a 10 s timeout a live quiet tool still read as wedged between frames. The owner now sends the interval (a quarter of its own timeout, capped at 30 s) in the hydrated request it already passes, and the worker uses it. The test drives the production interval for a 1 s timeout instead of a hand-picked 0.2 s.
561 lines
29 KiB
Python
561 lines
29 KiB
Python
"""Private exec entry. No agent/config imports before adopted process authority.
|
|
|
|
stdin is the owner's bounded bootstrap/control pipe; a duplicate of stdout is
|
|
reserved for framed events before runtime imports redirect ordinary output.
|
|
Neither assignment secrets nor launch credentials appear in argv or logs.
|
|
"""
|
|
# Spawned as a bare ``sys.executable -m``: in a PM install that interpreter carries no dependencies
|
|
# until hermes_bootstrap selects the committed environment, so it must be the first import.
|
|
try:
|
|
import hermes_bootstrap
|
|
except ModuleNotFoundError as exc:
|
|
if exc.name != "hermes_bootstrap" and not "hermes_bootstrap".startswith(f"{exc.name}."):
|
|
raise
|
|
|
|
import contextlib
|
|
import json
|
|
import logging
|
|
import os
|
|
import re
|
|
from pathlib import Path
|
|
import sys
|
|
import threading
|
|
import time
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
MAX_FRAME = 4 * 1024 * 1024
|
|
BOOTSTRAP_FIELDS = {'version', 'home', 'scope', 'policy', 'api_key', 'text', 'route', 'user_id', 'chat_id',
|
|
'turn_author', 'safe_mode', 'ignore_user_config'}
|
|
# The bounded run_conversation fields a turn receipt keeps (outcome, exit reason, tokens, cost,
|
|
# model): what the in-process projection commits and ``-z --usage-file`` reads.
|
|
RESULT_FIELDS = ('final_response', 'failed', 'interrupted', 'completed', 'partial', 'error', 'turn_exit_reason',
|
|
'api_calls', 'model', 'provider', 'prompt_tokens', 'completion_tokens', 'total_tokens',
|
|
'cache_read_tokens', 'cache_write_tokens', 'reasoning_tokens',
|
|
'estimated_cost_usd', 'cost_status', 'cost_source', 'service_tier', 'failure_reason',
|
|
'session_id', 'requested_model', 'served_model', '_turn_input_tokens', '_turn_output_tokens',
|
|
'failure_retryable', 'failure_resets_at', 'billing_block', 'free_tier', 'usage_window_message',
|
|
'refused_turn_boundary_row_id')
|
|
# The structured fields and their allowed keys: ``billing_block`` (``agent/billing_links.BillingBlock``
|
|
# plus ``unverified``) and ``free_tier`` (``agent/turn_recovery._stamp_free_tier``). With
|
|
# ``failure_reason``, ``failure_retryable`` and ``failure_resets_at`` they are what
|
|
# ``agent.error_surface.build_error_surface_from_result`` reads for the owner's error card.
|
|
BILLING_FIELDS = ('provider', 'provider_label', 'model', 'billing_url', 'is_nous', 'message', 'unverified')
|
|
STRUCTURED_FIELDS = {'billing_block': BILLING_FIELDS, 'free_tier': ('kind', 'message')}
|
|
|
|
|
|
def _scalar(value):
|
|
return value is None or type(value) in (bool, int, float) or (isinstance(value, str) and len(value) <= 4096)
|
|
|
|
|
|
def _structured(key, value):
|
|
return isinstance(value, dict) and not set(value) - set(STRUCTURED_FIELDS[key]) and all(map(_scalar, value.values()))
|
|
|
|
|
|
def result_frame(result):
|
|
"""Worker side: the receipt fields of ``run_conversation``'s result, scalars only, text bounded."""
|
|
frame = {k: (v[:4096] if isinstance(v, str) and k != 'final_response' else v) for k, v in result.items()
|
|
if k in RESULT_FIELDS and k not in STRUCTURED_FIELDS and (v is None or type(v) in (bool, int, float, str))}
|
|
for key, fields in STRUCTURED_FIELDS.items():
|
|
if isinstance(block := result.get(key), dict):
|
|
frame[key] = {k: v[:4096] if isinstance(v, str) else v for k, v in block.items()
|
|
if k in fields and (v is None or type(v) in (bool, int, float, str))}
|
|
return frame
|
|
|
|
|
|
def accept_result(result):
|
|
"""Owner side of the worker's result frame: ``(result, usage)`` in the in-process turn's shape
|
|
(gateway projection: prompt/completion tokens as input/output), or ValueError."""
|
|
if (not isinstance(result, dict) or set(result) - set(RESULT_FIELDS) or not isinstance(result.get('final_response'), str)
|
|
or any(result.get(key) is not None and not _structured(key, result[key]) for key in STRUCTURED_FIELDS)
|
|
or any(not _scalar(value) for key, value in result.items()
|
|
if key != 'final_response' and key not in STRUCTURED_FIELDS)):
|
|
raise ValueError('invalid_worker_result')
|
|
accepted = dict(result)
|
|
for key in STRUCTURED_FIELDS:
|
|
if accepted.get(key) is None:
|
|
# A failure other than a billing wall or a free-tier refusal carries no block.
|
|
accepted.pop(key, None)
|
|
turn_in, turn_out = accepted.pop('_turn_input_tokens', None), accepted.pop('_turn_output_tokens', None)
|
|
if any(value is not None and (type(value) is not int or value < 0) for value in (turn_in, turn_out)):
|
|
raise ValueError('invalid_worker_result')
|
|
incoming, outgoing = accepted.pop('prompt_tokens', None), accepted.pop('completion_tokens', None)
|
|
if incoming is None and outgoing is None:
|
|
return accepted, {}
|
|
usage = {'input_tokens': incoming or 0 if turn_in is None else turn_in,
|
|
'output_tokens': outgoing or 0 if turn_out is None else turn_out}
|
|
usage['total_tokens'] = usage['input_tokens'] + usage['output_tokens']
|
|
accepted.update(input_tokens=incoming or 0, output_tokens=outgoing or 0)
|
|
return accepted, usage
|
|
|
|
|
|
def read_frame(stream):
|
|
line = stream.readline(MAX_FRAME + 1)
|
|
if not line:
|
|
raise EOFError('managed_worker_pipe_closed')
|
|
if len(line) > MAX_FRAME or not line.endswith(b'\n'):
|
|
raise ValueError('managed_worker_frame_too_large')
|
|
frame = json.loads(line)
|
|
if not isinstance(frame, dict):
|
|
raise ValueError('invalid_managed_worker_frame')
|
|
return frame
|
|
|
|
|
|
def encode_frame(frame):
|
|
data = json.dumps(frame, ensure_ascii=True, allow_nan=False, separators=(',', ':')).encode() + b'\n'
|
|
if len(data) > MAX_FRAME:
|
|
raise ValueError('managed_worker_frame_too_large')
|
|
return data
|
|
|
|
|
|
def validate_bootstrap(frame):
|
|
if set(frame) - {'attachments_v1'} != BOOTSTRAP_FIELDS or frame['version'] != 1:
|
|
raise ValueError('invalid_managed_worker_bootstrap')
|
|
scope = frame['scope']
|
|
fields = {'profile_id', 'session_id', 'execution_id', 'generation', 'pid', 'birth', 'secret', 'epoch'}
|
|
if (not isinstance(scope, dict) or set(scope) != fields or scope['pid'] != os.getpid()
|
|
or scope['profile_id'] != frame['home'] or not Path(frame['home']).is_absolute()
|
|
or not isinstance(frame['policy'], dict)
|
|
or any(not isinstance(frame[k], str) for k in ('text', 'route', 'user_id', 'chat_id'))
|
|
or type(frame['safe_mode']) is not bool or type(frame['ignore_user_config']) is not bool
|
|
or (frame['safe_mode'] and not frame['ignore_user_config'])
|
|
or (frame['api_key'] is not None and not isinstance(frame['api_key'], str))):
|
|
raise ValueError('invalid_managed_worker_bootstrap')
|
|
from agent.turn_author import parse_turn_author
|
|
if frame['turn_author'] is not None and (not isinstance(frame['turn_author'], dict)
|
|
or parse_turn_author(frame['turn_author']) is None):
|
|
raise ValueError('invalid_managed_worker_bootstrap')
|
|
return frame
|
|
|
|
|
|
def bind_worker_policy(frame):
|
|
"""Freeze the owner's assignment process-wide before any config/provider/agent import.
|
|
|
|
The session's frozen config (never the live profile file) is what every config reader in
|
|
this process returns afterwards, so a profile edit after creation cannot reshape it (MCP
|
|
server definitions included). Ordinary sessions keep plugins, MCP and hooks; bypass sessions
|
|
also bind the safe / ignore-user-config policy.
|
|
"""
|
|
config = json.loads(frame['policy']['config_json'])
|
|
if not frame['ignore_user_config']:
|
|
from agent.safe_worker_policy import _bind_worker_config
|
|
_bind_worker_config(config)
|
|
return
|
|
from agent.safe_worker_policy import _bind_safe_worker_policy
|
|
_bind_safe_worker_policy(safe_mode=frame['safe_mode'], ignore_user_config=True, config=config)
|
|
|
|
|
|
class WorkerChannel:
|
|
def __init__(self, stream):
|
|
self.stream = stream
|
|
self.lock = threading.Lock()
|
|
|
|
def send(self, kind, **payload):
|
|
data = encode_frame({'type': kind, **payload})
|
|
with self.lock:
|
|
self.stream.write(data)
|
|
self.stream.flush()
|
|
|
|
|
|
# While a turn runs, the worker tells the owner its agent is still active: a quiet tool sends no
|
|
# other frame, and the owner's restart wait reads frame silence past agent.gateway_timeout as a
|
|
# wedged turn. The owner picks the interval from that timeout (``activity_interval``).
|
|
ACTIVITY_FRAME_SECONDS = 30
|
|
ACTIVITY_FRAME = {'type': 'activity'}
|
|
|
|
|
|
def activity_interval(wedge_timeout):
|
|
"""Several frames inside one wedge window, so no gap between two of them reads as silence."""
|
|
if wedge_timeout <= 0:
|
|
return ACTIVITY_FRAME_SECONDS # wedge detection off: the frames only keep the clock fresh
|
|
return max(0.05, min(ACTIVITY_FRAME_SECONDS, wedge_timeout / 4))
|
|
|
|
|
|
def forward_activity(agent, channel, done, interval=ACTIVITY_FRAME_SECONDS):
|
|
"""Send ``ACTIVITY_FRAME`` each ``interval`` in which the agent itself recorded activity
|
|
(``_touch_activity``: tool-loop and provider-wait heartbeats), until ``done`` is set. A wedged
|
|
agent stops touching, so its frames stop too; nothing here is user-visible."""
|
|
while not done.wait(interval):
|
|
idle = agent.get_activity_summary().get('seconds_since_activity')
|
|
if idle is not None and idle < interval:
|
|
try:
|
|
channel.send(ACTIVITY_FRAME['type'])
|
|
except (OSError, ValueError):
|
|
return # the channel closed under a finishing turn
|
|
|
|
|
|
def activity_frame_interval(frame):
|
|
"""Seconds between ``ACTIVITY_FRAME``s the owner asked for in the hydrated request, or None: an
|
|
older owner rejects unknown frames, so it never asks and never receives one."""
|
|
asked = json.loads(frame['policy'].get('request_json') or '{}').get('activity_frames_v1')
|
|
if isinstance(asked, dict) and isinstance(asked.get('interval'), (int, float)) and asked['interval'] > 0:
|
|
return float(asked['interval'])
|
|
return None
|
|
|
|
|
|
_INTERRUPTED = object()
|
|
# The owner's control pipe closing under a live worker means the owner died (a closing owner
|
|
# signals the worker itself). The agent is interrupted at once; cooperative tools get this long.
|
|
ORPHAN_GRACE_SECONDS = 10
|
|
# When the owner dies, in-flight background subagents (daemon threads in this process) are about to be
|
|
# SIGKILLed with the process group. Give them a bounded drain to finish + persist a real terminal result
|
|
# first; a killed one is otherwise recovered next boot only as "outcome unknown" (recover_abandoned_delegations).
|
|
DELEGATION_DRAIN_SECONDS = 30
|
|
|
|
|
|
def _drain_background_delegations(budget):
|
|
"""Wait (bounded) for in-flight background subagents to finish + persist so an owner-death SIGKILL does
|
|
not amputate a near-done one mid-write. Best-effort and read-only; on timeout the caller's hard-exit
|
|
guarantee still fires (those get recovered next boot as outcome unknown). Returns units still in flight."""
|
|
try:
|
|
from tools.async_delegation import active_count
|
|
except Exception: # health: allow BLE001 -- best-effort on the owner-death exit path
|
|
return 0
|
|
deadline = time.monotonic() + budget
|
|
while True:
|
|
try:
|
|
remaining = active_count()
|
|
except Exception: # health: allow BLE001 -- best-effort on the owner-death exit path
|
|
return 0
|
|
if remaining <= 0:
|
|
return 0
|
|
if time.monotonic() >= deadline:
|
|
logger.warning(
|
|
"managed worker: %d background delegation(s) still in flight after %.0fs drain; "
|
|
"hard-exit will end them (recovered next boot as outcome unknown)", remaining, budget,
|
|
)
|
|
return remaining
|
|
time.sleep(0.2)
|
|
|
|
|
|
def _die_with_owner():
|
|
"""Then end this worker and, on POSIX, every descendant still in its process group: the owner
|
|
spawns it as a group leader (``start_new_session``). Tools that open their own session (the
|
|
terminal tool, background processes meant to outlive the turn) are not in it. Never a group
|
|
this process does not lead."""
|
|
def kill():
|
|
if os.name != 'nt' and os.getpgrp() == os.getpid():
|
|
import signal
|
|
os.killpg(os.getpid(), signal.SIGKILL) # windows-footgun: ok — POSIX only
|
|
os._exit(1)
|
|
threading.Timer(ORPHAN_GRACE_SECONDS, kill).start()
|
|
|
|
|
|
class WorkerControls:
|
|
def __init__(self, channel, route):
|
|
self.channel, self.route = channel, route
|
|
self.agent = None
|
|
self.stopped = threading.Event()
|
|
self.finish = threading.Event()
|
|
self.clarifications = {}
|
|
self.lock = threading.Lock()
|
|
self.reader = threading.Thread(target=self.read, name='managed-controls', daemon=True)
|
|
self.reader.start()
|
|
|
|
def stop(self):
|
|
self.stopped.set()
|
|
if self.agent is not None:
|
|
from agent.interrupt_compat import request_hard_interrupt
|
|
request_hard_interrupt(self.agent) # parity with the canonical Stop (SessionAuthority.interrupt)
|
|
with self.lock:
|
|
for state in self.clarifications.values():
|
|
state['answer'] = _INTERRUPTED
|
|
state['event'].set()
|
|
|
|
def read(self):
|
|
from tools.approval import resolve_gateway_approval
|
|
try:
|
|
while True:
|
|
frame = read_frame(sys.stdin.buffer)
|
|
if frame == {'type': 'stop'}:
|
|
self.stop()
|
|
continue
|
|
if frame == {'type': 'finish'}:
|
|
self.finish.set()
|
|
return
|
|
if (set(frame) != {'type', 'prompt_id', 'value'} or frame['type'] not in {'approval', 'clarify'}
|
|
or not isinstance(frame['prompt_id'], str) or not isinstance(frame['value'], str)
|
|
or len(frame['value']) > 16384):
|
|
raise ValueError('invalid_managed_control')
|
|
if frame['type'] == 'approval':
|
|
if frame['value'] not in {'once', 'deny', 'session', 'always'}:
|
|
raise ValueError('invalid_managed_control')
|
|
resolve_gateway_approval(self.route, frame['value'], request_id=frame['prompt_id'])
|
|
else:
|
|
with self.lock:
|
|
state = self.clarifications.get(frame['prompt_id'])
|
|
if state is not None:
|
|
state['answer'] = frame['value']
|
|
state['event'].set()
|
|
except (EOFError, OSError, ValueError) as exc:
|
|
self.stop()
|
|
# The owner is gone (EOF/OSError) — before the hard-exit SIGKILLs this process group, give
|
|
# in-flight background subagents a bounded chance to finish + persist a real result.
|
|
if not isinstance(exc, ValueError):
|
|
_drain_background_delegations(DELEGATION_DRAIN_SECONDS)
|
|
self.finish.set()
|
|
if not isinstance(exc, ValueError):
|
|
_die_with_owner()
|
|
|
|
def approval(self, data):
|
|
from tools.approval import ack_gateway_approval
|
|
fields = {'request_id', 'command', 'description', 'allow_session', 'allow_permanent', 'smart_denied', 'edit'}
|
|
self.channel.send('approval', data={k: v for k, v in data.items() if k in fields})
|
|
ack_gateway_approval(self.route, data['request_id'])
|
|
|
|
def clarify(self, questions):
|
|
"""clarify_tool's batch contract: ``callback(questions) -> {answers, outcome, notice?}``.
|
|
One owner prompt per question, stopping at the first that is interrupted or unanswered;
|
|
an empty answer is a skip (``None``), as on the other surfaces. A finite turn (``chat -q`` /
|
|
``-z``, bound by worker_turn_scope) answers headless at once: its viewer cannot answer."""
|
|
from gateway.session_finite import finite_clarify_reply, finite_turn_required
|
|
if finite_turn_required() is True:
|
|
return finite_clarify_reply()
|
|
answers = {}
|
|
reply = {'answers': answers, 'outcome': 'submitted'}
|
|
for entry in questions:
|
|
answer = self._ask(entry['question'], entry['choices'], entry['multi_select'])
|
|
if answer is _INTERRUPTED:
|
|
reply['outcome'] = 'cancelled'
|
|
break
|
|
if answer is None:
|
|
reply['outcome'] = 'timed_out'
|
|
break
|
|
answers[entry['qid']] = answer.strip() or None
|
|
return reply
|
|
|
|
def _ask(self, question, choices, multi_select):
|
|
import uuid
|
|
from tools.clarify_gateway import get_clarify_timeout
|
|
timeout = get_clarify_timeout() # the frozen worker config; <= 0 is unlimited, as on every surface
|
|
prompt_id = uuid.uuid4().hex
|
|
state = {'event': threading.Event(), 'answer': None}
|
|
with self.lock:
|
|
if self.stopped.is_set() or len(self.clarifications) >= 16:
|
|
return _INTERRUPTED
|
|
self.clarifications[prompt_id] = state
|
|
try:
|
|
self.channel.send('clarify', prompt_id=prompt_id, question=question,
|
|
choices=list(choices or []), multi_select=bool(multi_select))
|
|
state['event'].wait(timeout if timeout > 0 else None)
|
|
return state['answer']
|
|
finally:
|
|
with self.lock:
|
|
self.clarifications.pop(prompt_id, None)
|
|
self.channel.send('prompt_settled', prompt_id=prompt_id)
|
|
|
|
|
|
_OUTBOX_NAME = re.compile(r'[A-Za-z0-9_-]{1,200}')
|
|
|
|
|
|
def outbox_dir(home, execution_id):
|
|
"""execution_id is a ledger key ('admission-worker:<hex>'); ':' is not a legal Windows path
|
|
character, so the private outbox directory is a portable spelling of the same identity."""
|
|
# A legacy-imported admission id is arbitrary text; never let it name a path outside
|
|
# worker-outboxes (``../`` on POSIX, ``..\\`` or drive spellings on Windows).
|
|
name = execution_id.replace(':', '-') if isinstance(execution_id, str) else ''
|
|
if not _OUTBOX_NAME.fullmatch(name):
|
|
raise ValueError('invalid_execution_id')
|
|
return Path(home) / 'worker-outboxes' / name
|
|
|
|
|
|
def discover_profile_mcp(policy):
|
|
"""The owner's MCP registry never crosses into this fresh interpreter; connect the profile's
|
|
configured servers here, filtered to the frozen toolset selection, before tool discovery snapshots
|
|
agent.tools. Safe mode keeps its deliberate no-MCP policy (discover_mcp_tools returns [])."""
|
|
from tools.mcp_oauth import suppress_interactive_oauth
|
|
from tools.mcp_tool_discovery import discover_mcp_tools
|
|
with suppress_interactive_oauth():
|
|
discover_mcp_tools(allowed_mcp_names=list(policy.toolsets))
|
|
|
|
|
|
def retire_agent(agent):
|
|
"""A settled admission is a turn boundary, not the end of the session: the owner's
|
|
in-process agent keeps its background processes, sandbox and browser between turns
|
|
(release_clients), so the worker must too. Only memory extraction is turn-final work."""
|
|
# A boundary task queued this turn (LLM-bound extraction) would be cancelled by the
|
|
# provider shutdown's short drain; give it the same bounded head start cli_shutdown does.
|
|
manager = getattr(agent, '_memory_manager', None)
|
|
if manager is not None:
|
|
manager.flush_pending(timeout=10)
|
|
messages = getattr(agent, '_session_messages', None)
|
|
agent.shutdown_memory_provider(messages if isinstance(messages, list) else None)
|
|
agent.release_clients()
|
|
|
|
|
|
def tool_frame(call_id, name, args, *result):
|
|
"""The callback arguments an in-process turn publishes from (executor-redacted display args,
|
|
the result and its failure verdict); the owner builds the shared tool event from them."""
|
|
frame = {'tool_call_id': str(call_id or ''), 'name': str(name or 'tool'), 'args': args if isinstance(args, dict) else {}}
|
|
if result:
|
|
from agent.display import _detect_tool_failure
|
|
frame['result'] = result[0] if isinstance(result[0], str) else str(result[0])
|
|
frame['is_error'] = bool(_detect_tool_failure(frame['name'], result[0])[0])
|
|
from gateway.session_tool_events import bounded_args, bounded_result
|
|
frame['args'] = bounded_args(frame['args'])
|
|
if result:
|
|
frame['result'] = bounded_result(result[0], frame['is_error'])
|
|
return json.loads(json.dumps(frame, default=str))
|
|
|
|
|
|
def execute(frame, channel):
|
|
# The owner RPC below imports gateway/config modules (hermes_cli.config, providers,
|
|
# hermes_cli.plugins) transitively; the policy must already be frozen when they load.
|
|
bind_worker_policy(frame)
|
|
from agent.runtime_session_store import RuntimeSessionStore, WorkerRPC
|
|
scope = dict(frame['scope'])
|
|
# This process serves exactly one turn of one profile: bind it as the runtime scope. The
|
|
# profile state is this process's own (its environment names the home), so only the slot.
|
|
from hermes_scope import LOCAL_OWNER, LOCAL_TENANT, Fence, Scope, push_state
|
|
push_state(scope=Scope(LOCAL_TENANT, frame['home'], LOCAL_OWNER).for_turn(
|
|
scope['session_id'], scope['execution_id'], Fence(scope['epoch'], scope['generation'])))
|
|
rpc = WorkerRPC(frame['home'])
|
|
adopted = rpc('worker.adopt', **{k: v for k, v in scope.items() if k != 'epoch'})
|
|
if adopted['owner_epoch'] != scope['epoch']:
|
|
raise RuntimeError('stale_epoch')
|
|
store = RuntimeSessionStore(rpc, scope, outbox_dir(frame['home'], scope['execution_id']), adopted)
|
|
from gateway.session_kanban import bind_worker_context
|
|
bind_worker_context(frame)
|
|
# Background processes a previous admission of this session started outlive that worker
|
|
# (F24); adopt them so process_manage in this turn can poll and kill them.
|
|
from tools.process_registry import process_registry
|
|
process_registry.recover_from_checkpoint()
|
|
# Store construction binds the delegation ledger before tool discovery.
|
|
from gateway.session_policy import restore_policy, policy_scope, register_worker_hooks
|
|
policy = restore_policy(frame['policy'])
|
|
register_worker_hooks(policy)
|
|
discover_profile_mcp(policy)
|
|
from run_agent import AIAgent
|
|
from tools.approval import register_gateway_notify, unregister_gateway_notify
|
|
from tools.approval_context import set_current_session_key
|
|
set_current_session_key(frame['route'])
|
|
os.environ['HERMES_GATEWAY_SESSION'] = '1'
|
|
from gateway.session_worker_construct import checkpoint_agent_kwargs, construct_kwargs, routing_agent_kwargs
|
|
construct = {'ephemeral_system_prompt': policy.skills_prompt, **construct_kwargs(frame)}
|
|
controls = WorkerControls(channel, frame['route'])
|
|
register_gateway_notify(frame['route'], controls.approval)
|
|
agent = None
|
|
turn_done = threading.Event() # ends forward_activity
|
|
try:
|
|
with policy_scope(policy, home=frame['home']):
|
|
agent = _construct_agent(frame, AIAgent, policy, model=policy.model, provider=policy.provider, base_url=policy.base_url,
|
|
api_key=frame['api_key'], session_db=store, session_id=scope['session_id'],
|
|
# delegate_task stays offered: each child is reserved by the owner under this
|
|
# execution (agent/runtime_session_child.py) and retires with it.
|
|
enabled_toolsets=list(policy.toolsets), max_iterations=policy.max_turns,
|
|
reasoning_config=policy.reasoning_config,
|
|
# ``tool`` / ``oneshot`` are storage labels for a CLI-surface agent (session_policy.SURFACES).
|
|
platform=policy.platform if policy.source in ('tool', 'oneshot') else policy.source,
|
|
gateway_session_key=frame['route'], user_id=frame['user_id'], chat_id=frame['chat_id'],
|
|
skip_context_files=policy.ignore_rules, load_soul_identity=not policy.ignore_rules,
|
|
skip_memory=policy.ignore_rules, skip_background_review=True, quiet_mode=True,
|
|
pass_session_id=policy.pass_session_id,
|
|
**checkpoint_agent_kwargs(policy.config()), **construct,
|
|
**routing_agent_kwargs(policy.config(), policy.model, policy.provider, policy.base_url),
|
|
stream_delta_callback=lambda text: channel.send('delta', text=text) if text else None,
|
|
clarify_callback=controls.clarify,
|
|
tool_start_callback=lambda call_id, name, args: channel.send('tool.start', **tool_frame(call_id, name, args)),
|
|
tool_complete_callback=lambda call_id, name, args, result: channel.send('tool.complete',
|
|
**tool_frame(call_id, name, args, result)))
|
|
controls.agent = agent
|
|
interval = activity_frame_interval(frame)
|
|
if interval is not None:
|
|
from agent.memory_provider import spawn_context_thread
|
|
spawn_context_thread(forward_activity, name='managed-activity',
|
|
args=(agent, channel, turn_done, interval)).start()
|
|
if controls.stopped.is_set():
|
|
from agent.interrupt_compat import request_hard_interrupt
|
|
request_hard_interrupt(agent)
|
|
channel.send('ready', pid=os.getpid())
|
|
history = store.get_messages_as_conversation(scope['session_id'])
|
|
from gateway.session_kanban import run_worker_turns
|
|
if 'attachments_v1' in frame:
|
|
from gateway.session_ingress_media import restore_attachments
|
|
from agent.image_routing import build_native_content_parts
|
|
media = restore_attachments(frame)
|
|
content, skipped = build_native_content_parts(frame['text'], media['media_urls'])
|
|
if skipped:
|
|
raise ValueError('managed_attachment_unavailable')
|
|
frame = {**frame, 'text': content}
|
|
before = (getattr(agent, 'session_prompt_tokens', 0) or 0,
|
|
getattr(agent, 'session_completion_tokens', 0) or 0)
|
|
# Most failed results name no provider or model; the owner's error card needs the agent's.
|
|
result = {'provider': getattr(agent, 'provider', None), 'model': getattr(agent, 'model', None),
|
|
**run_worker_turns(agent, frame, history)}
|
|
turn_done.set()
|
|
result['_turn_input_tokens'] = max(0, (getattr(agent, 'session_prompt_tokens', 0) or 0) - before[0])
|
|
result['_turn_output_tokens'] = max(0, (getattr(agent, 'session_completion_tokens', 0) or 0) - before[1])
|
|
retire_agent(agent)
|
|
agent = None
|
|
# The auto-title thread bills through this store from a daemon thread; a title landing
|
|
# after execution.finish is a stale_generation write that fails the close-time flush.
|
|
from agent.title_generator import wait_for_title_upgrades
|
|
wait_for_title_upgrades()
|
|
store.flush_token_counts()
|
|
if result.get('final_response') is None and (result.get('interrupted') or result.get('failed')):
|
|
result['final_response'] = ''
|
|
channel.send('result', result=result_frame(result))
|
|
if not controls.finish.wait(30):
|
|
raise ValueError('managed_finish_timeout')
|
|
store.finish()
|
|
channel.send('finished')
|
|
finally:
|
|
turn_done.set()
|
|
unregister_gateway_notify(frame['route'])
|
|
if agent is not None:
|
|
retire_agent(agent)
|
|
try:
|
|
store.close()
|
|
finally:
|
|
with contextlib.suppress(Exception): # a failing socket close never replaces the turn's outcome
|
|
rpc.close()
|
|
|
|
|
|
def _construct_agent(frame, factory, policy, **kwargs):
|
|
"""Agent construction resolves the provider credentials; a Kanban attempt that fails here
|
|
still books the one-shot exit mapping (quota wall 75, re-login 78) before the crash."""
|
|
try:
|
|
from gateway.session_worker_construct import worker_route
|
|
return factory(**{**kwargs, **worker_route(policy, kwargs)})
|
|
except Exception as exc:
|
|
from gateway.session_kanban import record_start_failure
|
|
record_start_failure(frame, exc)
|
|
raise
|
|
|
|
|
|
def hello():
|
|
"""Identity the owner verifies before it reserves: this interpreter's pid and birth plus
|
|
the ancestor chain it observes. Launchers (uv's venv python.exe) put the owner's Popen
|
|
handle one or two hops above; the owner, never this process, decides whether they match."""
|
|
import psutil
|
|
from hermes_cli.process_identity import worker_birth
|
|
me = psutil.Process()
|
|
return {'pid': me.pid, 'birth': worker_birth(me), 'ancestors': [p.pid for p in me.parents()[:3]]}
|
|
|
|
|
|
def main():
|
|
channel = WorkerChannel(os.fdopen(os.dup(sys.stdout.fileno()), 'wb', buffering=0)) # windows-footgun: ok — binary frames
|
|
os.dup2(sys.stderr.fileno(), sys.stdout.fileno())
|
|
# This process's own stderr only, never the channel. The owner drains it into the profile's
|
|
# private managed-worker.log, redacting each line (patterns plus this worker's launch key and
|
|
# assignment secret) before it reaches disk; this process never opens a profile log itself.
|
|
if not logger.handlers:
|
|
logger.addHandler(logging.StreamHandler(sys.stderr))
|
|
logger.propagate = False
|
|
try:
|
|
channel.send('hello', **hello())
|
|
frame = validate_bootstrap(read_frame(sys.stdin.buffer))
|
|
execute(frame, channel)
|
|
except Exception:
|
|
# Runtime exceptions can contain credentials; the owner gets no raw traceback.
|
|
logger.exception('managed worker failed')
|
|
channel.send('error', reason='managed_worker_failed')
|
|
return 1
|
|
finally:
|
|
channel.stream.close()
|
|
return 0
|
|
|
|
|
|
if __name__ == '__main__':
|
|
raise SystemExit(main())
|