"""``@`` references of one turn: expanded once, in the session's workspace, on the text the model reads. The inbound prepare step, the classic CLI's API-only text (``cli_turn_v1.api_text``: voice prefix, model-switch and skills notes) and managed workers (``--safe-mode`` / ``--ignore-user-config``, which never pass the inbound step) all expand here. A local session's refusal is the turn's reply: its adapter delivers through settlement, so a side ``send`` would never reach the viewer. """ import logging import os from contextlib import suppress from functools import partial from gateway.config import Platform logger = logging.getLogger(__name__) async def expand_references(text, *, cwd, context_length, plugins=True): """``(text, refusal)``: the expanded text, or the refusal when the injection was refused. A failed expansion leaves the text as typed.""" from agent.i18n import t try: from agent.context_references import preprocess_context_references_async expand = partial(preprocess_context_references_async, cwd=cwd, context_length=context_length, allowed_root=cwd) result = await (expand(text) if plugins else expand(text, plugins=False)) except Exception as exc: logger.warning("@ context reference expansion failed: %s", exc, exc_info=True) return text, None if result.blocked: return text, "\n".join(result.warnings) or t("gateway.notify.context_injection_refused") return (result.message if result.expanded else text), None def _inbound_cwd(runner, source): from gateway.session_policy import policy_for_source try: from tools.terminal_scope import terminal_env except ImportError: terminal_env = os.environ.get # A local session's references resolve in ITS workspace: this runs before the turn binds # the policy scope, so TERMINAL_CWD is still the daemon's own. if (policy := policy_for_source(runner, source)) is not None: return policy.cwd return terminal_env("TERMINAL_CWD", os.path.expanduser("~")) async def inbound_references(runner, source, session_key, text): """``expand_references`` for an inbound turn: a local session's policy cwd, else the terminal cwd.""" try: cwd = _inbound_cwd(runner, source) context_length = await runner._inbound_model_context_length(source, session_key) except Exception as exc: logger.warning("@ context reference expansion failed: %s", exc, exc_info=True) return text, None return await expand_references(text, cwd=cwd, context_length=context_length) async def turn_references(runner, event, source, session_key, text): """An inbound turn's text with the references of the text the model reads expanded; None when refused. The classic CLI's committed ``api_text`` replaces ``text`` at the turn (``TurnRunner._prepare_turn_message``), so ITS references are expanded and rebound for this execution, and the returned text, the stored user row, is ``text`` with the same attached context, as a typed turn stores it: later turns still read the content. A refused local turn leaves its refusal on ``event`` for the prepare step to answer with.""" from gateway.session_cli_turn import cli_turn, rebind_api_text api_text = cli_turn(event.message_id).get('api_text') target = text if api_text is None else api_text if "@" not in target: return text if source.platform == Platform.LOCAL: expanded, refusal = await inbound_references(runner, source, session_key, target) if refusal is not None: event._gateway_turn_refusal = refusal return None elif (expanded := await runner._expand_inbound_context_references(source, session_key, target)) is None: return None if api_text is None: return expanded rebind_api_text(event.message_id, expanded) # The expansion appends its context after the message, so that tail belongs to the stored row too. head = api_text.lstrip() tail = expanded[len(head):] if expanded.startswith(head) else "" return f"{text}{tail}".strip() if tail else text async def managed_turn_text(authority, row, policy): """``(text, refusal)`` for a managed worker's admitted text, expanded against the session's workspace. Built-in kinds only for a bypass session, which loads no plugins; the context length is the frozen policy's, never the profile file a bypass session must not read. ``None`` text means the admitted text as committed.""" text = (row.get('payload') or {}).get('text') if not isinstance(text, str) or "@" not in text: return None, None try: from agent.model_metadata import get_model_context_length_async model_config = policy.config(authority).get('model') or {} pinned = model_config.get('context_length') if isinstance(model_config, dict) else None with suppress(TypeError, ValueError): pinned = int(pinned) if pinned is not None else None context_length = await get_model_context_length_async( policy.current_model(authority) or '', base_url=policy.base_url or '', api_key='', provider=policy.provider or '', config_context_length=pinned if isinstance(pinned, int) else None) except Exception as exc: logger.warning("@ context reference expansion failed: %s", exc, exc_info=True) return text, None return await expand_references(text, cwd=policy.cwd, context_length=context_length, plugins=not policy.ignore_user_config) def refused_turn_result(row, refusal): """A turn that never ran because its references were refused: the refusal is its answer, and a finite (``chat -q`` / ``-z``) prompt fails with it, as ``execute_admission`` settles a notice.""" if row['payload'].get('finite') is True: return {'final_response': '', 'messages': [], 'failed': True, 'completed': False, 'error': refusal} return {'final_response': refusal, 'messages': []}