| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164 |
- """The ``manage_connections`` card on the session authority: ``connection.respond``, the operation's ``status``/``wake`` and the card's Try again (``connectors.connect`` with ``reconnect``), plus the open card a resume restores (``pending_connection``).
- The operation lives in ``tools/connectors/live.py`` under the turn's session key (the live session's route) and profile, so a card can only drive its own session's operation. Account-owned calls (the Connectors page) are not the session's and stay on the legacy handlers (``tui_gateway/methods_connectors.py``). Answers and refusals share that file's code (``tools.connectors.run.respond``, ``tui_gateway/connector_refusals.py``); ``ConnectorRefusal`` carries a refusal through the authority's error path.
- """
- import asyncio
- from functools import partial
- from hermes_state_runtime import RuntimeStoreError
- METHODS = ('connection.respond', 'connectors.operation.status', 'connectors.operation.wake', 'connectors.connect')
- class ConnectorRefusal(RuntimeStoreError):
- """A refusal on the legacy connector handlers' wire shape: their code, their human message, their ``ConnectorErrorReason`` as ``data.reason``."""
- def __init__(self, code, reason, message):
- super().__init__(str(reason), detail=message)
- self.wire_code, self.wire_message = code, message
- def session_owned(params) -> bool:
- owner = params.get('owner') if isinstance(params, dict) else None
- return isinstance(owner, dict) and owner.get('type') == 'session'
- def handlers(connection):
- return {method: partial(_handle, connection, method) for method in METHODS}
- def pending_connection(authority, session_id):
- """The open operation of a live session as its ``connection.request`` payload, or None."""
- from tools.connectors import live
- operation = live.current(authority.sessions[session_id].route, profile_home=authority.profile_id)
- return operation.request_payload() if operation is not None else None
- def _request(method, params):
- """The validated envelope and, for ``connection.respond``, the answer validated on its own as the legacy handler does: a bad answer is ``INVALID_ANSWER``, not a bad envelope."""
- from pydantic import ValidationError
- from tui_gateway.connector_refusals import INVALID_ANSWER, INVALID_PARAMS
- from tui_gateway.contracts.connectors_operation import ConnectionAnswer, ConnectionOperationParams
- from tui_gateway.contracts.registry import METHODS as CONTRACTS
- respond = method == 'connection.respond'
- contract = ConnectionOperationParams if respond else CONTRACTS[method].params
- try:
- request = contract.model_validate({k: v for k, v in params.items() if not (respond and k == 'result')})
- except ValidationError as exc:
- raise ConnectorRefusal(*INVALID_PARAMS) from exc
- if not respond:
- return request, None
- try:
- return request, ConnectionAnswer.model_validate(params.get('result'))
- except ValidationError as exc:
- raise ConnectorRefusal(*INVALID_ANSWER) from exc
- def _view(operation):
- from tui_gateway.connector_payload import connector_ui_payload
- snapshot = operation.snapshot()
- return connector_ui_payload({**snapshot, 'settled': snapshot.get('settled_at') is not None})
- async def _handle(connection, method, _ref, params):
- from gateway.session_busy_controls import authorize
- from gateway.session_contract import SessionRef
- from tools.connectors import live
- from tui_gateway import connector_refusals as refusals
- request, answer = _request(method, params)
- authority = connection.authority
- ref = SessionRef(authority.profile_id, request.owner.session_id)
- # Capability before existence, as every authority verb: a refused caller learns nothing about the id.
- authorize(connection, ref, params, 'session:read' if method == 'connectors.operation.status' else 'session:control')
- if ref.session_id not in authority.sessions:
- raise RuntimeStoreError('not_found')
- route = authority.sessions[ref.session_id].route
- if method == 'connectors.connect':
- operation = live.current(route, profile_home=authority.profile_id)
- else:
- operation = live.get(route, request.op_id, profile_home=authority.profile_id)
- if operation is None:
- raise ConnectorRefusal(*refusals.UNKNOWN_OPERATION)
- if method == 'connectors.operation.status':
- return _view(operation)
- if method == 'connectors.operation.wake':
- operation.wake.set()
- return {'status': 'ok'}
- if method == 'connection.respond':
- return await asyncio.to_thread(_respond, operation, answer)
- return await asyncio.to_thread(_retry, authority, ref, operation, request)
- def _respond(operation, answer):
- from tools.connectors.operation import IllegalTransition
- from tools.connectors.run import respond
- from tui_gateway.connector_refusals import INVALID_ANSWER
- try:
- return {'status': 'ok', 'settled': respond(operation, answer.model_dump_json(exclude_none=True))}
- except IllegalTransition as exc:
- raise ConnectorRefusal(*INVALID_ANSWER) from exc
- def _retry(authority, ref, operation, request):
- """The card's Try again, under the session's own context, as the sidecar ran it for its session."""
- from tools.connectors import run
- from tools.connectors.gateway.errors import GatewayAuthError
- from tui_gateway.connector_refusals import (INVALID_PARAMS, REISSUE_REFUSALS, REISSUE_REFUSED, REQUEST_FAILED,
- UNKNOWN_TARGET_REFUSAL, auth_refusal)
- if not request.reconnect:
- raise ConnectorRefusal(*INVALID_PARAMS)
- for name in request.connectors:
- target = operation.target(name)
- # A retry naming another account must not re-mint this one.
- if target is not None and ((request.alias is not None and target.alias != request.alias)
- or request.connection_id not in (None, target.repair_id, target.connection_id)):
- raise ConnectorRefusal(*UNKNOWN_TARGET_REFUSAL)
- with _session_context(authority, ref):
- _require_connectors(authority, ref)
- try:
- reason = run.reissue(operation, request.connectors)
- except RuntimeStoreError:
- raise
- except GatewayAuthError as exc:
- raise ConnectorRefusal(*auth_refusal(exc)) from exc
- except Exception as exc: # health: allow BLE001 -- the sidecar's _connector_guard: one named failure
- raise ConnectorRefusal(*REQUEST_FAILED) from exc
- if reason is not None:
- raise ConnectorRefusal(*REISSUE_REFUSALS.get(reason, REISSUE_REFUSED))
- return _view(operation)
- def _require_connectors(authority, ref):
- """The sidecar's ``_session_connector_gate``: connectors on, and ``manage_connections`` in the session's tools."""
- import model_tools
- from tools.connectors import connectors_available
- from tui_gateway import connector_refusals as refusals
- enabled, disabled = _session_toolsets(authority, ref)
- if 'manage_connections' not in model_tools._select_tool_names(enabled, disabled, quiet_mode=True) or not connectors_available():
- raise ConnectorRefusal(*refusals.CONNECTORS_UNAVAILABLE)
- def _session_toolsets(authority, ref):
- agent = authority.agent(ref)
- if agent is not None:
- return getattr(agent, 'enabled_toolsets', None), getattr(agent, 'disabled_toolsets', None)
- from agent.skill_utils import parse_config_string_list
- from gateway.session_policy import policy_for_source
- from toolsets import session_disabled_toolsets
- policy = policy_for_source(authority.runner, authority.sessions[ref.session_id].source)
- config = policy.config(authority, secrets=False) if policy is not None else {}
- enabled = list(policy.current_toolsets(config)) if policy is not None else None
- disabled = session_disabled_toolsets(parse_config_string_list((config.get('agent') or {}).get('disabled_toolsets')) or None,
- policy.platform if policy is not None else 'cli',
- oneshot=policy is not None and policy.source == 'oneshot')
- return enabled, disabled
- def _session_context(authority, ref):
- """The session vars a turn of this session binds (``GatewayRunner._session_env_scope``), so a re-mint carries the turn's caller identity and session key."""
- from gateway.session import SessionContext
- from gateway.session_ancillary import physical_target
- live = authority.sessions[ref.session_id]
- context = SessionContext(source=live.source, connected_platforms=[], home_channels={},
- session_key=live.route, session_id=physical_target(authority, ref))
- return authority.runner._session_env_scope(context)
|