| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115 |
- """``@`` 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': []}
|