agents-relay 0.0.1__tar.gz

agents_relay-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Lolaplex
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

agents_relay-0.0.1/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.4
+Name: agents-relay
+Version: 0.0.1
+Summary: HTTP and Telegram relay to agents-harness runner.loop (stdlib only)
+Author: Lolaplex
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Lolaplex/agents-relay
+Project-URL: Repository, https://github.com/Lolaplex/agents-relay
+Project-URL: Bug Tracker, https://github.com/Lolaplex/agents-relay/issues
+Keywords: agents,relay,gateway,telegram,http,harness,cli,coding-assistant
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Communications :: Chat
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# agents-relay
+
+Thin relay over [agents-harness](https://github.com/Lolaplex/agents-harness) `runner.loop`: one subprocess per turn, trailer parsing for session metadata. No identity store, no traces.
+
+```bash
+pip install -e .
+export RELAY_SECRET=dev
+python -m agents_relay serve
+```

agents_relay-0.0.1/README.md

@@ -0,0 +1,9 @@
+# agents-relay
+
+Thin relay over [agents-harness](https://github.com/Lolaplex/agents-harness) `runner.loop`: one subprocess per turn, trailer parsing for session metadata. No identity store, no traces.
+
+```bash
+pip install -e .
+export RELAY_SECRET=dev
+python -m agents_relay serve
+```

agents_relay-0.0.1/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "agents-relay"
+version = "0.0.1"
+description = "HTTP and Telegram relay to agents-harness runner.loop (stdlib only)"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Lolaplex" }]
+requires-python = ">=3.10"
+dependencies = []
+keywords = ["agents", "relay", "gateway", "telegram", "http", "harness", "cli", "coding-assistant"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Communications :: Chat",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+
+[project.urls]
+Homepage = "https://github.com/Lolaplex/agents-relay"
+Repository = "https://github.com/Lolaplex/agents-relay"
+"Bug Tracker" = "https://github.com/Lolaplex/agents-relay/issues"
+
+[project.scripts]
+agents-relay = "agents_relay.__main__:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

agents_relay-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

agents_relay-0.0.1/src/agents_relay/__init__.py

@@ -0,0 +1,3 @@
+"""HTTP + Telegram relay to runner.loop."""
+
+__version__ = "0.0.1"

agents_relay-0.0.1/src/agents_relay/__main__.py

@@ -0,0 +1,76 @@
+"""CLI: serve HTTP relay and optional Telegram poll."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import signal
+import sys
+
+from . import __version__
+from .config import RelayConfig
+from .http_adapter import serve_http
+from .telegram_adapter import start_telegram_thread
+
+log = logging.getLogger("agents_relay")
+
+
+def _help_json() -> dict:
+    return {
+        "name": "agents-relay",
+        "version": __version__,
+        "commands": {"serve": {"description": "Start HTTP /v1/turn and optional Telegram polling"}},
+        "flags": ["--help-json"],
+    }
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="agents-relay")
+    parser.add_argument("--help-json", action="store_true")
+    sub = parser.add_subparsers(dest="command")
+    serve_p = sub.add_parser("serve", help="Run relay")
+    serve_p.add_argument("--no-telegram", action="store_true", help="Disable Telegram polling")
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    logging.basicConfig(level=logging.INFO, format="%(levelname)s %(name)s: %(message)s")
+    args = build_parser().parse_args(argv)
+    if getattr(args, "help_json", False):
+        print(json.dumps(_help_json(), indent=2))
+        return 0
+    if args.command != "serve":
+        build_parser().print_help()
+        return 0
+
+    config = RelayConfig.from_env()
+    server = serve_http(config)
+    tg_thread = None
+    tg_stop = None
+    if not args.no_telegram and config.telegram_bot_token:
+        tg_thread, tg_stop = start_telegram_thread(config)
+
+    def _shutdown(*_sig) -> None:
+        log.info("shutting down")
+        if tg_stop is not None:
+            tg_stop.set()
+        server.shutdown()
+
+    signal.signal(signal.SIGINT, _shutdown)
+    if hasattr(signal, "SIGTERM"):
+        signal.signal(signal.SIGTERM, _shutdown)
+
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        _shutdown()
+    finally:
+        server.server_close()
+        if tg_thread is not None:
+            tg_thread.join(timeout=2)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

agents_relay-0.0.1/src/agents_relay/config.py

@@ -0,0 +1,65 @@
+"""Relay configuration from environment."""
+
+from __future__ import annotations
+
+import os
+import shlex
+from dataclasses import dataclass
+
+
+def _clean(val: str) -> str:
+    return val.strip().strip("'\"").strip()
+
+
+def _int(val: str, default: int) -> int:
+    cleaned = _clean(val)
+    if not cleaned:
+        return default
+    try:
+        return int(cleaned)
+    except ValueError:
+        return default
+
+
+def _int_list(value: str) -> tuple[int, ...]:
+    cleaned = _clean(value)
+    if not cleaned:
+        return ()
+    out: list[int] = []
+    for part in cleaned.split(","):
+        part = part.strip()
+        if part:
+            out.append(int(part))
+    return tuple(out)
+
+
+@dataclass(frozen=True)
+class RelayConfig:
+    loop_cmd: tuple[str, ...]
+    loop_provider: str
+    relay_secret: str
+    telegram_bot_token: str
+    telegram_allowed_chat_ids: tuple[int, ...]
+    relay_host: str
+    relay_port: int
+    telegram_poll_timeout: int
+
+    @classmethod
+    def from_env(cls) -> "RelayConfig":
+        raw_loop = _clean(os.environ.get("LOOP_CMD", "python -m runner.loop"))
+        loop_cmd = tuple(shlex.split(raw_loop, posix=os.name != "nt"))
+        if not loop_cmd:
+            loop_cmd = ("python", "-m", "runner.loop")
+        return cls(
+            loop_cmd=loop_cmd,
+            loop_provider=_clean(os.environ.get("LOOP_PROVIDER", "echo")) or "echo",
+            relay_secret=_clean(os.environ.get("RELAY_SECRET", os.environ.get("GATEWAY_SECRET", ""))),
+            telegram_bot_token=_clean(os.environ.get("TELEGRAM_BOT_TOKEN", "")),
+            telegram_allowed_chat_ids=_int_list(os.environ.get("TELEGRAM_ALLOWED_CHAT_IDS", "")),
+            relay_host=_clean(os.environ.get("RELAY_HOST", os.environ.get("GATEWAY_HOST", "127.0.0.1"))) or "127.0.0.1",
+            relay_port=_int(os.environ.get("RELAY_PORT", os.environ.get("GATEWAY_PORT", "8787")), 8787),
+            telegram_poll_timeout=max(1, min(50, _int(os.environ.get("TELEGRAM_POLL_TIMEOUT", "50"), 50))),
+        )
+
+
+GatewayConfig = RelayConfig

agents_relay-0.0.1/src/agents_relay/http_adapter.py

@@ -0,0 +1,133 @@
+"""stdlib HTTP server for /v1/turn."""
+
+from __future__ import annotations
+
+import json
+import logging
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from typing import Callable
+
+from .config import RelayConfig
+from .loop_client import LoopTurnResult, run_loop_turn
+
+log = logging.getLogger("agents_relay.http")
+
+
+def _check_secret(handler: BaseHTTPRequestHandler, expected: str) -> bool:
+    if not expected:
+        return True
+    got = (
+        handler.headers.get("X-Relay-Secret")
+        or handler.headers.get("Relay-Secret")
+        or handler.headers.get("X-Gateway-Secret")
+        or handler.headers.get("Gateway-Secret")
+        or ""
+    )
+    return got.strip() == expected
+
+
+class _TurnHook:
+    """Wrap a turn callable so BaseHTTPRequestHandler does not bind it as a method."""
+
+    __slots__ = ("fn",)
+
+    def __init__(self, fn: Callable[..., LoopTurnResult]) -> None:
+        self.fn = fn
+
+    def __call__(self, **kwargs) -> LoopTurnResult:
+        return self.fn(**kwargs)
+
+
+class TurnHandler(BaseHTTPRequestHandler):
+    relay_secret: str = ""
+    turn_hook: _TurnHook | None = None
+    config: RelayConfig | None = None
+
+    def log_message(self, fmt: str, *args) -> None:
+        log.info("%s - %s", self.address_string(), fmt % args)
+
+    def do_POST(self) -> None:
+        path = self.path.rstrip("/")
+        if path not in ("/v1/turn", "/v1/alert", "/webhook/alert"):
+            self.send_error(404)
+            return
+        if not _check_secret(self, self.relay_secret):
+            self.send_error(401, "unauthorized")
+            return
+        length = int(self.headers.get("Content-Length") or "0")
+        raw = self.rfile.read(length).decode("utf-8", errors="replace")
+        try:
+            body = json.loads(raw) if raw else {}
+        except json.JSONDecodeError:
+            self.send_error(400, "invalid json")
+            return
+        channel = str(body.get("channel") or ("webhook" if path != "/v1/turn" else "http"))
+        user = str(body.get("user") or ("alert" if path != "/v1/turn" else "anonymous"))
+        text = str(body.get("text") or body.get("message") or "")
+        session = str(body.get("session") or "")
+        user_id = str(body.get("user_id") or "")
+        new_session = bool(body.get("new_session"))
+        notify = bool(path in ("/v1/alert", "/webhook/alert") or body.get("notify") or body.get("broadcast"))
+
+        runner = (self.turn_hook.fn if self.turn_hook else None) or run_loop_turn
+        try:
+            result = runner(
+                channel=channel,
+                user=user,
+                message=text,
+                session=session,
+                user_id=user_id,
+                new_session=new_session,
+            )
+        except Exception as exc:
+            log.exception("turn failed")
+            self.send_error(500, str(exc))
+            return
+
+        notified = False
+        if notify and self.config and self.config.telegram_bot_token and self.config.telegram_allowed_chat_ids:
+            from .telegram_adapter import send_message
+            from .telegram_format import format_telegram_html
+            try:
+                primary_chat = self.config.telegram_allowed_chat_ids[0]
+                html = format_telegram_html(result.reply, ())
+                send_message(self.config.telegram_bot_token, primary_chat, html, parse_mode="HTML")
+                notified = True
+            except Exception as exc:
+                log.warning("failed to broadcast notification to telegram: %s", exc)
+
+        payload = {
+            "reply": result.reply,
+            "session": result.session,
+            "user_id": result.user_id,
+            "alias": result.alias,
+            "returncode": result.returncode,
+            "notified": notified,
+        }
+        data = json.dumps(payload).encode("utf-8")
+        self.send_response(200 if result.returncode == 0 else 502)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(data)))
+        self.end_headers()
+        self.wfile.write(data)
+
+    def do_GET(self) -> None:
+        if self.path.rstrip("/") in ("/health", "/"):
+            data = b'{"ok":true}'
+            self.send_response(200)
+            self.send_header("Content-Type", "application/json")
+            self.send_header("Content-Length", str(len(data)))
+            self.end_headers()
+            self.wfile.write(data)
+            return
+        self.send_error(404)
+
+
+def serve_http(config: RelayConfig, *, on_turn: Callable[..., LoopTurnResult] | None = None) -> ThreadingHTTPServer:
+    attrs: dict = {"relay_secret": config.relay_secret, "config": config}
+    if on_turn is not None:
+        attrs["turn_hook"] = _TurnHook(on_turn)
+    handler = type("ConfiguredTurnHandler", (TurnHandler,), attrs)
+    server = ThreadingHTTPServer((config.relay_host, config.relay_port), handler)
+    log.info("HTTP listening on %s:%s", config.relay_host, config.relay_port)
+    return server

agents_relay-0.0.1/src/agents_relay/loop_client.py

@@ -0,0 +1,97 @@
+"""Spawn runner.loop and parse buffered trailer."""
+
+from __future__ import annotations
+
+import json
+import subprocess
+from dataclasses import dataclass
+from typing import Any
+
+from .config import RelayConfig
+
+LOOP_TRAILER_MARKER = "---agents-loop-trailer---"
+
+
+@dataclass
+class LoopTurnResult:
+    reply: str
+    session: str
+    user_id: str
+    alias: str
+    returncode: int
+    stderr: str
+
+
+def parse_loop_stdout(stdout: str) -> dict[str, Any]:
+    """Split user reply from trailer JSON after LOOP_TRAILER_MARKER."""
+    text = stdout or ""
+    if LOOP_TRAILER_MARKER in text:
+        body, _, trailer_part = text.partition(LOOP_TRAILER_MARKER)
+        reply = body.strip()
+        trailer_line = trailer_part.strip().splitlines()[0] if trailer_part.strip() else "{}"
+        try:
+            meta = json.loads(trailer_line)
+        except json.JSONDecodeError:
+            meta = {}
+    else:
+        reply = text.strip()
+        meta = {}
+    return {
+        "reply": reply,
+        "session": str(meta.get("session") or ""),
+        "user_id": str(meta.get("user_id") or ""),
+        "alias": str(meta.get("alias") or ""),
+    }
+
+
+def run_loop_turn(
+    *,
+    channel: str,
+    user: str,
+    message: str,
+    config: RelayConfig | None = None,
+    session: str = "",
+    user_id: str = "",
+    new_session: bool = False,
+    timeout_sec: int = 600,
+) -> LoopTurnResult:
+    cfg = config or RelayConfig.from_env()
+    argv = list(cfg.loop_cmd)
+    argv.extend(
+        [
+            "--channel",
+            channel,
+            "--user",
+            user,
+            "--message",
+            message,
+            "--complete",
+            "--provider",
+            cfg.loop_provider,
+            "--deliver",
+            "buffered",
+        ]
+    )
+    if session:
+        argv.extend(["--session", session])
+    if user_id:
+        argv.extend(["--user-id", user_id])
+    if new_session:
+        argv.append("--new-session")
+
+    proc = subprocess.run(
+        argv,
+        capture_output=True,
+        text=True,
+        timeout=timeout_sec,
+        shell=False,
+    )
+    parsed = parse_loop_stdout(proc.stdout or "")
+    return LoopTurnResult(
+        reply=parsed["reply"],
+        session=parsed["session"],
+        user_id=parsed["user_id"],
+        alias=parsed["alias"],
+        returncode=int(proc.returncode),
+        stderr=proc.stderr or "",
+    )

agents_relay-0.0.1/src/agents_relay/telegram_adapter.py

@@ -0,0 +1,159 @@
+"""Telegram long-poll adapter (urllib only)."""
+
+from __future__ import annotations
+
+import json
+import logging
+import threading
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+from typing import Callable
+
+from .config import RelayConfig
+from .loop_client import LoopTurnResult, run_loop_turn
+from .telegram_format import format_telegram_html, status_html
+
+log = logging.getLogger("agents_relay.telegram")
+
+API_BASE = "https://api.telegram.org"
+
+
+def _api_url(token: str, method: str) -> str:
+    return f"{API_BASE}/bot{token}/{method}"
+
+
+def _post_json(url: str, payload: dict) -> dict:
+    data = json.dumps(payload).encode("utf-8")
+    req = urllib.request.Request(url, data=data, headers={"Content-Type": "application/json"}, method="POST")
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        return json.loads(resp.read().decode("utf-8"))
+
+
+def send_message(token: str, chat_id: int, text: str, *, parse_mode: str = "HTML") -> dict:
+    body = {
+        "chat_id": chat_id,
+        "text": text[:4096],
+        "disable_web_page_preview": True,
+    }
+    if parse_mode:
+        body["parse_mode"] = parse_mode
+    try:
+        return _post_json(_api_url(token, "sendMessage"), body)
+    except urllib.error.HTTPError as exc:
+        if parse_mode and exc.code == 400:
+            body.pop("parse_mode", None)
+            return _post_json(_api_url(token, "sendMessage"), body)
+        raise
+
+
+def edit_message(token: str, chat_id: int, message_id: int, text: str, *, parse_mode: str = "HTML") -> dict:
+    body = {
+        "chat_id": chat_id,
+        "message_id": message_id,
+        "text": text[:4096],
+        "disable_web_page_preview": True,
+    }
+    if parse_mode:
+        body["parse_mode"] = parse_mode
+    try:
+        return _post_json(_api_url(token, "editMessageText"), body)
+    except urllib.error.HTTPError as exc:
+        if parse_mode and exc.code == 400:
+            body.pop("parse_mode", None)
+            return _post_json(_api_url(token, "editMessageText"), body)
+        raise
+
+
+def _allowed(chat_id: int, allowed: tuple[int, ...]) -> bool:
+    if not allowed:
+        return True
+    return chat_id in allowed
+
+
+def process_update(
+    update: dict,
+    *,
+    config: RelayConfig,
+    on_turn: Callable[..., LoopTurnResult] | None = None,
+) -> None:
+    message = update.get("message") or update.get("edited_message")
+    if not message:
+        return
+    chat = message.get("chat") or {}
+    chat_id = int(chat.get("id") or 0)
+    if not chat_id or not _allowed(chat_id, config.telegram_allowed_chat_ids):
+        return
+    text = str(message.get("text") or "").strip()
+    if not text:
+        return
+    user = str((message.get("from") or {}).get("username") or chat_id)
+    token = config.telegram_bot_token
+    if not token:
+        return
+
+    thinking_msg = send_message(token, chat_id, status_html("thinking..."), parse_mode="HTML")
+    thinking_id = (thinking_msg.get("result") or {}).get("message_id") if isinstance(thinking_msg, dict) else None
+
+    runner = on_turn or run_loop_turn
+    result = runner(channel="telegram", user=user, message=text)
+    reply_html = format_telegram_html(result.reply, ())
+
+    if thinking_id:
+        try:
+            edit_message(token, chat_id, thinking_id, reply_html, parse_mode="HTML")
+            return
+        except Exception:
+            pass
+    send_message(token, chat_id, reply_html, parse_mode="HTML")
+
+
+def telegram_poll_loop(
+    config: RelayConfig,
+    *,
+    stop_event: threading.Event | None = None,
+    on_turn: Callable[..., LoopTurnResult] | None = None,
+) -> None:
+    token = config.telegram_bot_token
+    if not token:
+        log.warning("TELEGRAM_BOT_TOKEN not set; telegram poll disabled")
+        return
+    offset = 0
+    stop = stop_event or threading.Event()
+    while not stop.is_set():
+        params = {
+            "timeout": config.telegram_poll_timeout,
+            "offset": offset,
+            "allowed_updates": json.dumps(["message"]),
+        }
+        url = _api_url(token, "getUpdates") + "?" + urllib.parse.urlencode(params)
+        try:
+            with urllib.request.urlopen(url, timeout=config.telegram_poll_timeout + 10) as resp:
+                data = json.loads(resp.read().decode("utf-8"))
+        except Exception as exc:
+            log.warning("getUpdates failed: %s", exc)
+            time.sleep(2)
+            continue
+        for update in data.get("result") or []:
+            offset = int(update.get("update_id", offset)) + 1
+            try:
+                process_update(update, config=config, on_turn=on_turn)
+            except Exception:
+                log.exception("telegram update failed")
+
+
+def start_telegram_thread(
+    config: RelayConfig,
+    *,
+    on_turn: Callable[..., LoopTurnResult] | None = None,
+) -> tuple[threading.Thread, threading.Event]:
+    stop_event = threading.Event()
+    thread = threading.Thread(
+        target=telegram_poll_loop,
+        kwargs={"config": config, "stop_event": stop_event, "on_turn": on_turn},
+        name="telegram-poll",
+        daemon=True,
+    )
+    thread.start()
+    return thread, stop_event

agents_relay-0.0.1/src/agents_relay/telegram_format.py

@@ -0,0 +1,87 @@
+"""Telegram HTML formatting (stdlib only)."""
+
+from __future__ import annotations
+
+import html
+import re
+
+TG_LIMIT = 4096
+_BOLD_RE = re.compile(r"\*\*(.+?)\*\*")
+_CODE_RE = re.compile(r"`([^`]+)`")
+_FENCE_RE = re.compile(
+    r"```(?:json|xml|javascript|tool[\w_-]*)?\s*\n[\s\S]*?```",
+    re.IGNORECASE,
+)
+_TOOL_TAG_RE = re.compile(
+    r"<(tool_use|tool_call|tool_result|function_call|invoke|ts|clock|timestamp)\b[^>]*>[\s\S]*?</\1>",
+    re.IGNORECASE,
+)
+_BARE_TAGS_RE = re.compile(r"</?(?:ts|clock|timestamp)\b[^>]*>", re.IGNORECASE)
+_BLOB_KEYS = (
+    "tool_call",
+    "tool_calls",
+    "tool_use",
+    "function_call",
+    "tool_result",
+    '"arguments"',
+)
+
+
+def _looks_like_blob(text: str) -> bool:
+    low = text.lower()
+    return any(key in low for key in _BLOB_KEYS) or len(text) > 400
+
+
+def strip_model_dumps(text: str) -> str:
+    if not text:
+        return ""
+    out = _FENCE_RE.sub(lambda m: "" if _looks_like_blob(m.group(0)) else m.group(0), text)
+    out = _TOOL_TAG_RE.sub("", out)
+    out = _BARE_TAGS_RE.sub("", out)
+    stripped = out.strip()
+    if stripped.startswith("{") or stripped.startswith("["):
+        if _looks_like_blob(stripped):
+            return ""
+    out = re.sub(r"\n{3,}", "\n\n", out)
+    return out.strip()
+
+
+def visible_reply(text: str, traces: tuple[str, ...] = ()) -> str:
+    cleaned = strip_model_dumps(text)
+    if cleaned:
+        return cleaned
+    if traces:
+        return "Fertig."
+    return "(leere Antwort)"
+
+
+def status_html(text: str) -> str:
+    plain = re.sub(r"[*_`]", "", text or "").strip() or "..."
+    return f"<i>{html.escape(plain)}</i>"
+
+
+def format_telegram_html(answer: str, traces: tuple[str, ...] = ()) -> str:
+    body = _light_md_html(visible_reply(answer, traces))
+    extra = _traces_block(traces)
+    out = body + extra
+    if len(out) <= TG_LIMIT:
+        return out
+    budget = TG_LIMIT - len(extra) - 1
+    if budget < 80:
+        return body[: TG_LIMIT - 1] + "..."
+    return body[:budget] + "..." + extra
+
+
+def _traces_block(traces: tuple[str, ...]) -> str:
+    lines = [html.escape(line) for line in traces if str(line).strip()]
+    if not lines:
+        return ""
+    inner = "\n".join(lines)
+    return f"\n\n<blockquote expandable><b>tools</b>\n{inner}</blockquote>"
+
+
+def _light_md_html(text: str) -> str:
+    escaped = html.escape(text, quote=False)
+    escaped = _BOLD_RE.sub(r"<b>\1</b>", escaped)
+    escaped = _CODE_RE.sub(r"<code>\1</code>", escaped)
+    return escaped

agents_relay-0.0.1/src/agents_relay.egg-info/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.4
+Name: agents-relay
+Version: 0.0.1
+Summary: HTTP and Telegram relay to agents-harness runner.loop (stdlib only)
+Author: Lolaplex
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Lolaplex/agents-relay
+Project-URL: Repository, https://github.com/Lolaplex/agents-relay
+Project-URL: Bug Tracker, https://github.com/Lolaplex/agents-relay/issues
+Keywords: agents,relay,gateway,telegram,http,harness,cli,coding-assistant
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Communications :: Chat
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# agents-relay
+
+Thin relay over [agents-harness](https://github.com/Lolaplex/agents-harness) `runner.loop`: one subprocess per turn, trailer parsing for session metadata. No identity store, no traces.
+
+```bash
+pip install -e .
+export RELAY_SECRET=dev
+python -m agents_relay serve
+```

agents_relay-0.0.1/src/agents_relay.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+README.md
+pyproject.toml
+src/agents_relay/__init__.py
+src/agents_relay/__main__.py
+src/agents_relay/config.py
+src/agents_relay/http_adapter.py
+src/agents_relay/loop_client.py
+src/agents_relay/telegram_adapter.py
+src/agents_relay/telegram_format.py
+src/agents_relay.egg-info/PKG-INFO
+src/agents_relay.egg-info/SOURCES.txt
+src/agents_relay.egg-info/dependency_links.txt
+src/agents_relay.egg-info/entry_points.txt
+src/agents_relay.egg-info/top_level.txt
+tests/test_relay.py

agents_relay-0.0.1/src/agents_relay.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

agents_relay-0.0.1/src/agents_relay.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+agents-relay = agents_relay.__main__:main

agents_relay-0.0.1/src/agents_relay.egg-info/top_level.txt

@@ -0,0 +1 @@
+agents_relay

agents_relay-0.0.1/tests/test_relay.py

@@ -0,0 +1,138 @@
+"""Relay unit tests."""
+
+from __future__ import annotations
+
+import json
+import unittest
+from dataclasses import dataclass
+from http.client import HTTPConnection
+from unittest.mock import patch
+
+from agents_relay.config import RelayConfig
+from agents_relay.http_adapter import serve_http
+from agents_relay.loop_client import LOOP_TRAILER_MARKER, parse_loop_stdout, run_loop_turn
+
+
+class TestTrailerParse(unittest.TestCase):
+    def test_parse_trailer(self):
+        stdout = f"hello\n{LOOP_TRAILER_MARKER}\n" + json.dumps(
+            {"session": "ses_x", "user_id": "u_y", "alias": "telegram:1"}
+        )
+        parsed = parse_loop_stdout(stdout)
+        self.assertEqual(parsed["reply"], "hello")
+        self.assertEqual(parsed["session"], "ses_x")
+        self.assertEqual(parsed["user_id"], "u_y")
+        self.assertEqual(parsed["alias"], "telegram:1")
+
+
+class TestLoopSubprocess(unittest.TestCase):
+    def test_mock_loop_subprocess(self):
+        trailer = json.dumps({"session": "s1", "user_id": "u1", "alias": "a1"})
+        fake_stdout = f"pong\n{LOOP_TRAILER_MARKER}\n{trailer}\n"
+
+        @dataclass
+        class FakeProc:
+            returncode: int = 0
+            stdout: str = fake_stdout
+            stderr: str = ""
+
+        cfg = RelayConfig(
+            loop_cmd=("python", "-c", "print('skip')"),
+            loop_provider="echo",
+            relay_secret="sekrit",
+            telegram_bot_token="",
+            telegram_allowed_chat_ids=(),
+            relay_host="127.0.0.1",
+            relay_port=0,
+            telegram_poll_timeout=1,
+        )
+        with patch("agents_relay.loop_client.subprocess.run", return_value=FakeProc()):
+            result = run_loop_turn(channel="http", user="u", message="ping", config=cfg)
+        self.assertEqual(result.reply, "pong")
+        self.assertEqual(result.session, "s1")
+
+
+class TestHttpTurn(unittest.TestCase):
+    def test_v1_turn_auth(self):
+        cfg = RelayConfig(
+            loop_cmd=("python", "-m", "runner.loop"),
+            loop_provider="echo",
+            relay_secret="expected",
+            telegram_bot_token="",
+            telegram_allowed_chat_ids=(),
+            relay_host="127.0.0.1",
+            relay_port=0,
+            telegram_poll_timeout=1,
+        )
+
+        def fake_turn(**kwargs):
+            from agents_relay.loop_client import LoopTurnResult
+
+            return LoopTurnResult(reply="ok", session="", user_id="", alias="", returncode=0, stderr="")
+
+        server = serve_http(cfg, on_turn=fake_turn)
+        server.server_port  # type: ignore[attr-defined]
+        host, port = server.server_address  # type: ignore[misc]
+        server_thread = __import__("threading").Thread(target=server.serve_forever, daemon=True)
+        server_thread.start()
+        try:
+            conn = HTTPConnection(host, port, timeout=5)
+            body = json.dumps({"channel": "http", "user": "t", "text": "hi"})
+            conn.request("POST", "/v1/turn", body=body, headers={"Content-Type": "application/json"})
+            resp = conn.getresponse()
+            self.assertEqual(resp.status, 401)
+
+            conn = HTTPConnection(host, port, timeout=5)
+            conn.request(
+                "POST",
+                "/v1/turn",
+                body=body,
+                headers={"Content-Type": "application/json", "X-Relay-Secret": "expected"},
+            )
+            resp = conn.getresponse()
+            self.assertEqual(resp.status, 200)
+            data = json.loads(resp.read().decode())
+            self.assertEqual(data["reply"], "ok")
+            self.assertFalse(data["notified"])
+
+            # Test /v1/alert with notification mocking
+            with patch("agents_relay.telegram_adapter.send_message") as mock_send:
+                cfg_with_tg = RelayConfig(
+                    loop_cmd=("python", "-m", "runner.loop"),
+                    loop_provider="echo",
+                    relay_secret="expected",
+                    telegram_bot_token="fake_bot_token",
+                    telegram_allowed_chat_ids=(12345,),
+                    relay_host="127.0.0.1",
+                    relay_port=0,
+                    telegram_poll_timeout=1,
+                )
+                tg_server = serve_http(cfg_with_tg, on_turn=fake_turn)
+                tg_host, tg_port = tg_server.server_address
+                tg_thread = __import__("threading").Thread(target=tg_server.serve_forever, daemon=True)
+                tg_thread.start()
+                try:
+                    alert_conn = HTTPConnection(tg_host, tg_port, timeout=5)
+                    alert_body = json.dumps({"text": "system alert"})
+                    alert_conn.request(
+                        "POST",
+                        "/v1/alert",
+                        body=alert_body,
+                        headers={"Content-Type": "application/json", "X-Relay-Secret": "expected"},
+                    )
+                    alert_resp = alert_conn.getresponse()
+                    self.assertEqual(alert_resp.status, 200)
+                    alert_data = json.loads(alert_resp.read().decode())
+                    self.assertTrue(alert_data["notified"])
+                    mock_send.assert_called_once()
+                finally:
+                    tg_server.shutdown()
+                    tg_thread.join(timeout=2)
+        finally:
+            server.shutdown()
+            server_thread.join(timeout=2)
+
+
+if __name__ == "__main__":
+    unittest.main()
+