session_connections.py 8.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164
  1. """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``).
  2. 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.
  3. """
  4. import asyncio
  5. from functools import partial
  6. from hermes_state_runtime import RuntimeStoreError
  7. METHODS = ('connection.respond', 'connectors.operation.status', 'connectors.operation.wake', 'connectors.connect')
  8. class ConnectorRefusal(RuntimeStoreError):
  9. """A refusal on the legacy connector handlers' wire shape: their code, their human message, their ``ConnectorErrorReason`` as ``data.reason``."""
  10. def __init__(self, code, reason, message):
  11. super().__init__(str(reason), detail=message)
  12. self.wire_code, self.wire_message = code, message
  13. def session_owned(params) -> bool:
  14. owner = params.get('owner') if isinstance(params, dict) else None
  15. return isinstance(owner, dict) and owner.get('type') == 'session'
  16. def handlers(connection):
  17. return {method: partial(_handle, connection, method) for method in METHODS}
  18. def pending_connection(authority, session_id):
  19. """The open operation of a live session as its ``connection.request`` payload, or None."""
  20. from tools.connectors import live
  21. operation = live.current(authority.sessions[session_id].route, profile_home=authority.profile_id)
  22. return operation.request_payload() if operation is not None else None
  23. def _request(method, params):
  24. """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."""
  25. from pydantic import ValidationError
  26. from tui_gateway.connector_refusals import INVALID_ANSWER, INVALID_PARAMS
  27. from tui_gateway.contracts.connectors_operation import ConnectionAnswer, ConnectionOperationParams
  28. from tui_gateway.contracts.registry import METHODS as CONTRACTS
  29. respond = method == 'connection.respond'
  30. contract = ConnectionOperationParams if respond else CONTRACTS[method].params
  31. try:
  32. request = contract.model_validate({k: v for k, v in params.items() if not (respond and k == 'result')})
  33. except ValidationError as exc:
  34. raise ConnectorRefusal(*INVALID_PARAMS) from exc
  35. if not respond:
  36. return request, None
  37. try:
  38. return request, ConnectionAnswer.model_validate(params.get('result'))
  39. except ValidationError as exc:
  40. raise ConnectorRefusal(*INVALID_ANSWER) from exc
  41. def _view(operation):
  42. from tui_gateway.connector_payload import connector_ui_payload
  43. snapshot = operation.snapshot()
  44. return connector_ui_payload({**snapshot, 'settled': snapshot.get('settled_at') is not None})
  45. async def _handle(connection, method, _ref, params):
  46. from gateway.session_busy_controls import authorize
  47. from gateway.session_contract import SessionRef
  48. from tools.connectors import live
  49. from tui_gateway import connector_refusals as refusals
  50. request, answer = _request(method, params)
  51. authority = connection.authority
  52. ref = SessionRef(authority.profile_id, request.owner.session_id)
  53. # Capability before existence, as every authority verb: a refused caller learns nothing about the id.
  54. authorize(connection, ref, params, 'session:read' if method == 'connectors.operation.status' else 'session:control')
  55. if ref.session_id not in authority.sessions:
  56. raise RuntimeStoreError('not_found')
  57. route = authority.sessions[ref.session_id].route
  58. if method == 'connectors.connect':
  59. operation = live.current(route, profile_home=authority.profile_id)
  60. else:
  61. operation = live.get(route, request.op_id, profile_home=authority.profile_id)
  62. if operation is None:
  63. raise ConnectorRefusal(*refusals.UNKNOWN_OPERATION)
  64. if method == 'connectors.operation.status':
  65. return _view(operation)
  66. if method == 'connectors.operation.wake':
  67. operation.wake.set()
  68. return {'status': 'ok'}
  69. if method == 'connection.respond':
  70. return await asyncio.to_thread(_respond, operation, answer)
  71. return await asyncio.to_thread(_retry, authority, ref, operation, request)
  72. def _respond(operation, answer):
  73. from tools.connectors.operation import IllegalTransition
  74. from tools.connectors.run import respond
  75. from tui_gateway.connector_refusals import INVALID_ANSWER
  76. try:
  77. return {'status': 'ok', 'settled': respond(operation, answer.model_dump_json(exclude_none=True))}
  78. except IllegalTransition as exc:
  79. raise ConnectorRefusal(*INVALID_ANSWER) from exc
  80. def _retry(authority, ref, operation, request):
  81. """The card's Try again, under the session's own context, as the sidecar ran it for its session."""
  82. from tools.connectors import run
  83. from tools.connectors.gateway.errors import GatewayAuthError
  84. from tui_gateway.connector_refusals import (INVALID_PARAMS, REISSUE_REFUSALS, REISSUE_REFUSED, REQUEST_FAILED,
  85. UNKNOWN_TARGET_REFUSAL, auth_refusal)
  86. if not request.reconnect:
  87. raise ConnectorRefusal(*INVALID_PARAMS)
  88. for name in request.connectors:
  89. target = operation.target(name)
  90. # A retry naming another account must not re-mint this one.
  91. if target is not None and ((request.alias is not None and target.alias != request.alias)
  92. or request.connection_id not in (None, target.repair_id, target.connection_id)):
  93. raise ConnectorRefusal(*UNKNOWN_TARGET_REFUSAL)
  94. with _session_context(authority, ref):
  95. _require_connectors(authority, ref)
  96. try:
  97. reason = run.reissue(operation, request.connectors)
  98. except RuntimeStoreError:
  99. raise
  100. except GatewayAuthError as exc:
  101. raise ConnectorRefusal(*auth_refusal(exc)) from exc
  102. except Exception as exc: # health: allow BLE001 -- the sidecar's _connector_guard: one named failure
  103. raise ConnectorRefusal(*REQUEST_FAILED) from exc
  104. if reason is not None:
  105. raise ConnectorRefusal(*REISSUE_REFUSALS.get(reason, REISSUE_REFUSED))
  106. return _view(operation)
  107. def _require_connectors(authority, ref):
  108. """The sidecar's ``_session_connector_gate``: connectors on, and ``manage_connections`` in the session's tools."""
  109. import model_tools
  110. from tools.connectors import connectors_available
  111. from tui_gateway import connector_refusals as refusals
  112. enabled, disabled = _session_toolsets(authority, ref)
  113. if 'manage_connections' not in model_tools._select_tool_names(enabled, disabled, quiet_mode=True) or not connectors_available():
  114. raise ConnectorRefusal(*refusals.CONNECTORS_UNAVAILABLE)
  115. def _session_toolsets(authority, ref):
  116. agent = authority.agent(ref)
  117. if agent is not None:
  118. return getattr(agent, 'enabled_toolsets', None), getattr(agent, 'disabled_toolsets', None)
  119. from agent.skill_utils import parse_config_string_list
  120. from gateway.session_policy import policy_for_source
  121. from toolsets import session_disabled_toolsets
  122. policy = policy_for_source(authority.runner, authority.sessions[ref.session_id].source)
  123. config = policy.config(authority, secrets=False) if policy is not None else {}
  124. enabled = list(policy.current_toolsets(config)) if policy is not None else None
  125. disabled = session_disabled_toolsets(parse_config_string_list((config.get('agent') or {}).get('disabled_toolsets')) or None,
  126. policy.platform if policy is not None else 'cli',
  127. oneshot=policy is not None and policy.source == 'oneshot')
  128. return enabled, disabled
  129. def _session_context(authority, ref):
  130. """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."""
  131. from gateway.session import SessionContext
  132. from gateway.session_ancillary import physical_target
  133. live = authority.sessions[ref.session_id]
  134. context = SessionContext(source=live.source, connected_platforms=[], home_channels={},
  135. session_key=live.route, session_id=physical_target(authority, ref))
  136. return authority.runner._session_env_scope(context)