@triclaps/cli 0.0.5 → 0.0.7

package/adapters/hermes_claps_adapter.py

@@ -11,9 +11,11 @@ Events emitted (one JSON object per line):
   {"type":"item.started","item":{"type":"<tool>","id":"<id>","command":"..."}}
   {"type":"item.completed","item":{"type":"<tool>","id":"<id>","status":"completed","aggregated_output":"..."}}
   {"type":"item.completed","item":{"type":"agent_message"}}
+  {"type":"request.completed","success":true,"response":"...","session_id":"..."}
 
 Usage:
-  python3 hermes_claps_adapter.py --prompt "..." [-o /tmp/output.txt] [--resume ID]
+  python3 hermes_claps_adapter.py --prompt "..." [--yolo] [-o /tmp/output.txt] [--resume ID]
+  python3 hermes_claps_adapter.py --server [--yolo] [--resume ID]
 
 The final agent response is written to the file specified by -o (if provided).
 All structured NDJSON events are emitted to stdout.
@@ -25,9 +27,13 @@ import inspect
 import json
 import os
 from pathlib import Path
+import time
 from typing import Any
 import sys
 import threading
+import urllib.error
+import urllib.parse
+import urllib.request
 
 # ---------------------------------------------------------------------------
 # Redirect stdout BEFORE importing any Hermes modules.
@@ -71,16 +77,36 @@ def resolve_debug_body_limit() -> int:
 
 
 DEBUG_BODY_LIMIT = resolve_debug_body_limit()
+DEFAULT_CLARIFY_TIMEOUT_RESPONSE = (
+    "The user did not provide a response within the time limit. "
+    "Use your best judgement to make the choice and proceed."
+)
+CURRENT_REQUEST_CONTEXT: dict[str, str | None] = {
+    "request_id": None,
+    "ticket_id": None,
+}
 
 
-def emit(event: dict) -> None:
+def emit(event: dict, *, request_id: str | None = None) -> None:
     """Write one NDJSON event to the real stdout (fd-level) and flush."""
-    line = json.dumps(event, ensure_ascii=False) + "\n"
+    payload = dict(event)
+    if request_id:
+        payload["request_id"] = request_id
+    line = json.dumps(payload, ensure_ascii=False) + "\n"
     with _emit_lock:
         _ndjson_out.write(line)
         _ndjson_out.flush()
 
 
+def set_current_request_context(
+    *,
+    request_id: str | None,
+    ticket_id: str | None,
+) -> None:
+    CURRENT_REQUEST_CONTEXT["request_id"] = request_id
+    CURRENT_REQUEST_CONTEXT["ticket_id"] = ticket_id
+
+
 def clip_debug_text(text: str) -> str:
     if len(text) <= DEBUG_BODY_LIMIT:
         return text
@@ -88,6 +114,72 @@ def clip_debug_text(text: str) -> str:
     return f"{text[:DEBUG_BODY_LIMIT]}... [truncated {remaining} chars]"
 
 
+def sanitize_topic_title(title: str | None) -> str | None:
+    if not isinstance(title, str):
+        return None
+
+    cleaned = " ".join(title.replace("[", " ").replace("]", " ").split()).strip()
+    lowered = cleaned.lower()
+
+    if (
+        not cleaned
+        or lowered == "{sanitized_title}"
+        or "sanitized_title" in lowered
+        or (cleaned.startswith("{") and cleaned.endswith("}"))
+    ):
+        return None
+
+    return cleaned or None
+
+
+def response_already_sets_topic_title(response: str) -> bool:
+    return "[[TOPIC_TITLE:" in (response or "")
+
+
+def resolve_topic_title_from_session(cli, *, wait_timeout_sec: float = 2.0) -> str | None:
+    session_db = getattr(cli, "_session_db", None)
+    session_id = getattr(cli, "session_id", None)
+    conversation_history = getattr(cli, "conversation_history", None) or []
+
+    if session_db is None or not session_id:
+        return None
+
+    user_message_count = sum(
+        1
+        for item in conversation_history
+        if isinstance(item, dict) and item.get("role") == "user"
+    )
+    should_wait_for_background_title = user_message_count <= 2
+    deadline = time.monotonic() + (
+        max(wait_timeout_sec, 0.0) if should_wait_for_background_title else 0.0
+    )
+
+    while True:
+        try:
+            current_title = sanitize_topic_title(session_db.get_session_title(session_id))
+        except Exception:
+            return None
+
+        if current_title:
+            return current_title
+
+        if time.monotonic() >= deadline:
+            return None
+
+        time.sleep(0.05)
+
+
+def append_topic_title_control_line(response: str, topic_title: str | None) -> str:
+    sanitized_title = sanitize_topic_title(topic_title)
+    if not sanitized_title or response_already_sets_topic_title(response):
+        return response
+
+    if not response.strip():
+        return f"[[TOPIC_TITLE:{sanitized_title}]]"
+
+    return f"{response.rstrip()}\n[[TOPIC_TITLE:{sanitized_title}]]"
+
+
 def normalize_debug_value(value: Any) -> Any:
     if value is None:
         return None
@@ -388,9 +480,421 @@ def resolve_toolsets_from_env() -> list[str] | None:
     return toolsets or None
 
 
+def prepare_agent_for_request(cli, prompt: str, max_turns: int | None):
+    if not cli._ensure_runtime_credentials():
+        raise RuntimeError("Hermes credential initialization failed")
+
+    turn_route = cli._resolve_turn_agent_config(prompt)
+    route_signature = turn_route.get("signature")
+    if route_signature != cli._active_agent_route_signature:
+        cli.agent = None
+
+    init_agent_kwargs = {
+        "model_override": turn_route.get("model"),
+        "runtime_override": turn_route.get("runtime"),
+        "request_overrides": turn_route.get("request_overrides"),
+    }
+    try:
+        init_agent_signature = inspect.signature(cli._init_agent)
+    except (TypeError, ValueError):
+        init_agent_signature = None
+
+    if init_agent_signature and "route_label" in init_agent_signature.parameters:
+        route_label = turn_route.get("label")
+        if route_label is not None:
+            init_agent_kwargs["route_label"] = route_label
+
+    if not cli._init_agent(**init_agent_kwargs):
+        raise RuntimeError("Hermes agent initialization failed")
+
+    debug_log(
+        "agent_initialized",
+        {
+            "session_id": cli.session_id,
+            "turn_route": turn_route,
+            "model": getattr(cli, "model", None),
+            "provider": getattr(cli, "provider", None),
+            "base_url": getattr(cli, "base_url", None),
+        },
+    )
+
+    agent = cli.agent
+    agent.quiet_mode = True
+    agent.suppress_status_output = True
+
+    if max_turns:
+        agent.max_iterations = max_turns
+
+    if not getattr(agent, "_supports_reasoning_extra_body", lambda: False)():
+        overrides = dict(getattr(agent, "request_overrides", None) or {})
+        existing_extra = overrides.get("extra_body", {})
+        if "reasoning" not in existing_extra and "thinking" not in existing_extra:
+            existing_extra["thinking"] = {"type": "enabled", "budget_tokens": 8192}
+            overrides["extra_body"] = existing_extra
+            agent.request_overrides = overrides
+
+    return agent
+
+
+def install_ndjson_callbacks(agent, *, request_id: str | None):
+    agent.stream_delta_callback = None
+    agent.tool_progress_callback = lambda *args, **kwargs: None
+    agent.tool_gen_callback = None
+
+    def on_reasoning(text: str) -> None:
+        stripped = (text or "").strip()
+        if not stripped:
+            return
+        emit(
+            {
+                "type": "item.completed",
+                "item": {"type": "reasoning", "text": stripped},
+            },
+            request_id=request_id,
+        )
+
+    def on_tool_start(call_id: str, name: str, arguments) -> None:
+        cmd = ""
+        if isinstance(arguments, dict):
+            cmd = (
+                arguments.get("command", "")
+                or arguments.get("code", "")
+                or arguments.get("query", "")
+                or ""
+            )
+        emit(
+            {
+                "type": "item.started",
+                "item": {
+                    "type": name,
+                    "id": call_id or f"{name}-started",
+                    "command": str(cmd)[:2000] if cmd else None,
+                },
+            },
+            request_id=request_id,
+        )
+
+    def on_tool_complete(call_id: str, name: str, arguments, result: str) -> None:
+        emit(
+            {
+                "type": "item.completed",
+                "item": {
+                    "type": name,
+                    "id": call_id or f"{name}-completed",
+                    "status": "completed",
+                    "aggregated_output": (result or "")[:6000],
+                },
+            },
+            request_id=request_id,
+        )
+
+    def on_clarify(question: str, choices=None) -> str:
+        api_base_url = os.environ.get("CLAPS_API_BASE_URL", "").strip().rstrip("/")
+        agent_token = os.environ.get("CLAPS_AGENT_TOKEN", "").strip()
+        ticket_id = (
+            CURRENT_REQUEST_CONTEXT.get("ticket_id")
+            or os.environ.get("CLAPS_CONVERSATION_TICKET_ID", "")
+        ).strip()
+        timeout_raw = os.environ.get("CLAPS_CLARIFY_TIMEOUT_SEC", "").strip()
+
+        try:
+            timeout_sec = int(timeout_raw) if timeout_raw else 120
+        except ValueError:
+            timeout_sec = 120
+
+        timeout_sec = max(1, min(timeout_sec, 300))
+
+        if not api_base_url or not agent_token or not ticket_id:
+            debug_log(
+                "clarify_unconfigured",
+                {
+                    "api_base_url": api_base_url,
+                    "has_agent_token": bool(agent_token),
+                    "ticket_id": ticket_id,
+                },
+            )
+            return DEFAULT_CLARIFY_TIMEOUT_RESPONSE
+
+        payload = {
+            "question": str(question or "").strip(),
+            "choices": choices,
+            "timeoutSec": timeout_sec,
+        }
+        debug_log(
+            "clarify_request_started",
+            {
+                "api_base_url": api_base_url,
+                "ticket_id": ticket_id,
+                "timeout_sec": timeout_sec,
+                "question": payload["question"],
+                "choices": payload["choices"],
+            },
+        )
+        request_url = (
+            f"{api_base_url}/api/conversation-tickets/"
+            f"{urllib.parse.quote(ticket_id)}/clarify-requests"
+        )
+        request = urllib.request.Request(
+            request_url,
+            data=json.dumps(payload, ensure_ascii=False).encode("utf-8"),
+            headers={
+                "authorization": f"Bearer {agent_token}",
+                "content-type": "application/json",
+                "accept": "application/json",
+            },
+            method="POST",
+        )
+
+        try:
+            with urllib.request.urlopen(request, timeout=timeout_sec + 15) as response:
+                body = response.read().decode("utf-8", errors="replace")
+        except urllib.error.HTTPError as exc:
+            body = exc.read().decode("utf-8", errors="replace")
+            print(
+                f"[adapter] clarify request failed: {exc.code} {exc.reason} {body}",
+                file=sys.stderr,
+                flush=True,
+            )
+            return DEFAULT_CLARIFY_TIMEOUT_RESPONSE
+        except Exception as exc:
+            print(f"[adapter] clarify request failed: {exc}", file=sys.stderr, flush=True)
+            return DEFAULT_CLARIFY_TIMEOUT_RESPONSE
+
+        try:
+            parsed = json.loads(body)
+        except json.JSONDecodeError:
+            print(
+                f"[adapter] clarify response was not valid JSON: {body}",
+                file=sys.stderr,
+                flush=True,
+            )
+            return DEFAULT_CLARIFY_TIMEOUT_RESPONSE
+
+        debug_log(
+            "clarify_request_resolved",
+            {
+                "ticket_id": ticket_id,
+                "response": parsed,
+            },
+        )
+        answer = parsed.get("answer")
+        if isinstance(answer, str) and answer.strip():
+            return answer.strip()
+
+        return DEFAULT_CLARIFY_TIMEOUT_RESPONSE
+
+    agent.reasoning_callback = on_reasoning
+    agent.tool_start_callback = on_tool_start
+    agent.tool_complete_callback = on_tool_complete
+    agent.clarify_callback = on_clarify
+
+
+def run_request(
+    cli,
+    *,
+    prompt: str,
+    output_path: str | None = None,
+    max_turns: int | None = None,
+    request_id: str | None = None,
+    ticket_id: str | None = None,
+) -> dict[str, Any]:
+    set_current_request_context(request_id=request_id, ticket_id=ticket_id)
+    emit({"type": "session_meta", "payload": {"id": cli.session_id}}, request_id=request_id)
+
+    try:
+        try:
+            agent = prepare_agent_for_request(cli, prompt, max_turns)
+            install_ndjson_callbacks(agent, request_id=request_id)
+        except Exception as exc:
+            failure_message = f"Hermes execution failed: {exc}"
+            emit({"type": "error", "error": failure_message}, request_id=request_id)
+            emit({"type": "session_meta", "payload": {"id": cli.session_id}}, request_id=request_id)
+            return {
+                "success": False,
+                "response": "",
+                "error": failure_message,
+                "session_id": cli.session_id,
+                "exit_code": 1,
+            }
+
+        failed = False
+        response = ""
+        result_error = ""
+        result_partial = False
+        result_completed = True
+
+        try:
+            result = agent.run_conversation(
+                user_message=prompt,
+                conversation_history=cli.conversation_history,
+            )
+            debug_log("run_conversation_result", {"result": result})
+            if isinstance(result, dict):
+                response = result.get("final_response", "") or ""
+                failed = result.get("failed", False)
+                result_partial = bool(result.get("partial", False))
+                if "completed" in result:
+                    result_completed = bool(result.get("completed"))
+                raw_error = result.get("error")
+                if isinstance(raw_error, str):
+                    result_error = raw_error.strip()
+                elif raw_error is not None:
+                    result_error = str(raw_error).strip()
+            else:
+                response = str(result) if result else ""
+        except Exception as exc:
+            failure_message = f"Hermes execution failed: {exc}"
+            emit({"type": "error", "error": failure_message}, request_id=request_id)
+            emit({"type": "session_meta", "payload": {"id": cli.session_id}}, request_id=request_id)
+            return {
+                "success": False,
+                "response": "",
+                "error": failure_message,
+                "session_id": cli.session_id,
+                "exit_code": 1,
+            }
+
+        if (
+            response
+            and not failed
+            and not result_partial
+            and result_completed
+            and not response_already_sets_topic_title(response)
+        ):
+            response = append_topic_title_control_line(
+                response,
+                resolve_topic_title_from_session(cli),
+            )
+
+        if response:
+            emit(
+                {
+                    "type": "item.completed",
+                    "item": {"type": "agent_message", "content": response},
+                },
+                request_id=request_id,
+            )
+
+        should_fail = failed or (
+            not response.strip() and (result_partial or not result_completed or bool(result_error))
+        )
+        failure_message = (
+            result_error or "Hermes returned an incomplete result without a final response."
+        )
+
+        if should_fail:
+            emit({"type": "error", "error": failure_message}, request_id=request_id)
+
+        emit({"type": "session_meta", "payload": {"id": cli.session_id}}, request_id=request_id)
+
+        if output_path:
+            try:
+                with open(output_path, "w", encoding="utf-8") as f:
+                    f.write(response)
+            except OSError as exc:
+                print(f"[adapter] failed to write output file: {exc}", file=sys.stderr)
+
+        return {
+            "success": not should_fail,
+            "response": response,
+            "error": failure_message if should_fail else None,
+            "session_id": cli.session_id,
+            "exit_code": 0 if not should_fail else 1,
+        }
+    finally:
+        set_current_request_context(request_id=None, ticket_id=None)
+
+
+def serve_requests(cli, *, default_max_turns: int | None = None) -> None:
+    for raw_line in sys.stdin:
+        payload_text = raw_line.strip()
+
+        if not payload_text:
+            continue
+
+        try:
+            payload = json.loads(payload_text)
+        except json.JSONDecodeError as exc:
+            print(f"[adapter] invalid server request JSON: {exc}", file=sys.stderr, flush=True)
+            continue
+
+        if not isinstance(payload, dict):
+            print("[adapter] invalid server request payload", file=sys.stderr, flush=True)
+            continue
+
+        if payload.get("type") == "shutdown":
+            break
+
+        request_id = payload.get("request_id")
+        if not isinstance(request_id, str) or not request_id.strip():
+            request_id = f"server_request_{time.time_ns()}"
+
+        prompt = payload.get("prompt")
+        if not isinstance(prompt, str) or not prompt.strip():
+            emit(
+                {
+                    "type": "request.completed",
+                    "success": False,
+                    "response": "",
+                    "error": "Server request is missing a prompt.",
+                    "session_id": getattr(cli, "session_id", None),
+                    "exit_code": 1,
+                },
+                request_id=request_id,
+            )
+            continue
+
+        max_turns = (
+            payload.get("max_turns")
+            if isinstance(payload.get("max_turns"), int)
+            else default_max_turns
+        )
+        ticket_id = payload.get("ticket_id") if isinstance(payload.get("ticket_id"), str) else None
+        try:
+            result = run_request(
+                cli,
+                prompt=prompt,
+                output_path=None,
+                max_turns=max_turns,
+                request_id=request_id,
+                ticket_id=ticket_id,
+            )
+        except Exception as exc:
+            failure_message = f"Hermes execution failed: {exc}"
+            emit({"type": "error", "error": failure_message}, request_id=request_id)
+            emit(
+                {"type": "session_meta", "payload": {"id": getattr(cli, "session_id", None)}},
+                request_id=request_id,
+            )
+            emit(
+                {
+                    "type": "request.completed",
+                    "success": False,
+                    "response": "",
+                    "error": failure_message,
+                    "session_id": getattr(cli, "session_id", None),
+                    "exit_code": 1,
+                },
+                request_id=request_id,
+            )
+            continue
+
+        emit(
+            {
+                "type": "request.completed",
+                "success": result["success"],
+                "response": result["response"],
+                "error": result["error"],
+                "session_id": result["session_id"],
+                "exit_code": result["exit_code"],
+            },
+            request_id=request_id,
+        )
+
+
 def main() -> None:
     parser = argparse.ArgumentParser(description="CLAPS Hermes structured adapter")
-    parser.add_argument("--prompt", required=True, help="User prompt")
+    parser.add_argument("--prompt", default=None, help="User prompt")
     parser.add_argument("-o", "--output", default=None, help="Output file for the final response")
     parser.add_argument("--resume", default=None, help="Hermes session ID to resume")
     parser.add_argument(
@@ -400,8 +904,21 @@ def main() -> None:
     )
     parser.add_argument("--max-turns", type=int, default=None, help="Max tool iterations")
     parser.add_argument("--skills", default=None, help="Comma-separated skill names to preload")
+    parser.add_argument(
+        "--yolo",
+        action="store_true",
+        help="Enable Hermes YOLO mode so dangerous command approvals are auto-bypassed.",
+    )
+    parser.add_argument(
+        "--server",
+        action="store_true",
+        help="Keep Hermes initialized and serve multiple requests from stdin.",
+    )
     args = parser.parse_args()
 
+    if not args.server and (not isinstance(args.prompt, str) or not args.prompt.strip()):
+        parser.error("--prompt is required unless --server is used")
+
     debug_log(
         "incoming_request",
         {
@@ -410,9 +927,12 @@ def main() -> None:
             "session_id": args.session_id,
             "max_turns": args.max_turns,
             "skills": args.skills,
+            "yolo": args.yolo,
             "prompt": args.prompt,
+            "server": args.server,
             "env": {
                 "HERMES_HOME": os.environ.get("HERMES_HOME"),
+                "HERMES_YOLO_MODE": os.environ.get("HERMES_YOLO_MODE"),
                 "HERMES_PROJECT_ROOT": os.environ.get("HERMES_PROJECT_ROOT"),
                 "HERMES_INFERENCE_PROVIDER": os.environ.get("HERMES_INFERENCE_PROVIDER"),
                 "HERMES_BASE_URL": os.environ.get("HERMES_BASE_URL"),
@@ -425,7 +945,9 @@ def main() -> None:
         },
     )
 
-    # ── Import Hermes modules ────────────────────────────────────────────
+    if args.yolo:
+        os.environ["HERMES_YOLO_MODE"] = "1"
+
     hermes_root = ensure_hermes_import_path()
     try:
         from cli import HermesCLI
@@ -439,7 +961,6 @@ def main() -> None:
         emit({"type": "error", "error": f"Cannot import Hermes modules: {exc}. {root_hint}"})
         sys.exit(1)
 
-    # ── Create CLI instance (handles config loading, credential setup) ──
     runtime_overrides = resolve_runtime_overrides_from_env()
     configured_toolsets = resolve_toolsets_from_env()
     install_http_debug_logging()
@@ -467,17 +988,6 @@ def main() -> None:
     cli = HermesCLI(**cli_init_kwargs)
     cli.tool_progress_mode = "off"
 
-    # ── Override session id for fresh sessions ───────────────────────────
-    # When CLAPS provides a deterministic --session-id, use it so that the
-    # same CLAPS conversation maps 1:1 onto a Hermes session.  We only
-    # override on cold starts; resume paths already locate the session via
-    # --resume so the id must come from the persisted record.
-    #
-    # HermesCLI.__init__ auto-generates a timestamp-based session_id and may
-    # have already registered it with SessionDB before we get here, which
-    # leaves orphan session_<timestamp>_<hash>.json files behind on every
-    # cold start. Clean up the orphan id after overriding so each CLAPS
-    # conversation maps to exactly one hermes session file.
     if args.session_id and not args.resume:
         auto_session_id = cli.session_id
         cli.session_id = args.session_id
@@ -502,10 +1012,10 @@ def main() -> None:
                     file=sys.stderr,
                 )
 
-    # ── Preload skills if requested ──────────────────────────────────────
     if args.skills:
         try:
             from hermes_cli.skills_loader import build_preloaded_skills_prompt
+
             skill_names = [s.strip() for s in args.skills.split(",") if s.strip()]
             skills_prompt, _loaded, _missing = build_preloaded_skills_prompt(
                 skill_names, task_id=cli.session_id,
@@ -517,180 +1027,23 @@ def main() -> None:
         except Exception as exc:
             print(f"[adapter] skill preload failed: {exc}", file=sys.stderr)
 
-    # ── Ensure credentials & initialize agent ────────────────────────────
     if not cli._ensure_runtime_credentials():
         emit({"type": "error", "error": "Hermes credential initialization failed"})
         sys.exit(1)
 
-    turn_route = cli._resolve_turn_agent_config(args.prompt)
-    route_signature = turn_route.get("signature")
-    if route_signature != cli._active_agent_route_signature:
-        cli.agent = None
-
-    init_agent_kwargs = {
-        "model_override": turn_route.get("model"),
-        "runtime_override": turn_route.get("runtime"),
-        "request_overrides": turn_route.get("request_overrides"),
-    }
-    try:
-        init_agent_signature = inspect.signature(cli._init_agent)
-    except (TypeError, ValueError):
-        init_agent_signature = None
-
-    if init_agent_signature and "route_label" in init_agent_signature.parameters:
-        route_label = turn_route.get("label")
-        if route_label is not None:
-            init_agent_kwargs["route_label"] = route_label
-
-    if not cli._init_agent(**init_agent_kwargs):
-        emit({"type": "error", "error": "Hermes agent initialization failed"})
-        sys.exit(1)
-
-    debug_log(
-        "agent_initialized",
-        {
-            "session_id": cli.session_id,
-            "turn_route": turn_route,
-            "model": getattr(cli, "model", None),
-            "provider": getattr(cli, "provider", None),
-            "base_url": getattr(cli, "base_url", None),
-        },
-    )
-
-    agent = cli.agent
-    agent.quiet_mode = True
-    agent.suppress_status_output = True
-
-    if args.max_turns:
-        agent.max_iterations = args.max_turns
-
-    # ── Ensure thinking/reasoning tokens are requested ───────────────────
-    # Some providers (e.g. Gemini via LiteLLM) need an explicit thinking
-    # config in extra_body.  Hermes only sends this for known providers
-    # (OpenRouter, Nous, GitHub), so custom/LiteLLM endpoints miss out.
-    # Inject it via request_overrides so reasoning_callback actually fires.
-    if not getattr(agent, "_supports_reasoning_extra_body", lambda: False)():
-        overrides = dict(getattr(agent, "request_overrides", None) or {})
-        existing_extra = overrides.get("extra_body", {})
-        if "reasoning" not in existing_extra and "thinking" not in existing_extra:
-            existing_extra["thinking"] = {"type": "enabled", "budget_tokens": 8192}
-            overrides["extra_body"] = existing_extra
-            agent.request_overrides = overrides
-
-    # ── Override callbacks with NDJSON emitters ──────────────────────────
-    # Disable streaming so reasoning_callback fires once with the complete
-    # reasoning text (instead of many deltas).  Tool callbacks fire
-    # independently of the streaming path.
-    agent.stream_delta_callback = None
-    agent.tool_progress_callback = None
-    agent.tool_gen_callback = None
-
-    _last_reasoning_text = None
-
-    def on_reasoning(text: str) -> None:
-        nonlocal _last_reasoning_text
-        stripped = (text or "").strip()
-        if stripped and stripped != _last_reasoning_text:
-            _last_reasoning_text = stripped
-            emit({
-                "type": "item.completed",
-                "item": {"type": "reasoning", "text": stripped},
-            })
-
-    def on_tool_start(call_id: str, name: str, arguments) -> None:
-        cmd = ""
-        if isinstance(arguments, dict):
-            cmd = (
-                arguments.get("command", "")
-                or arguments.get("code", "")
-                or arguments.get("query", "")
-                or ""
-            )
-        emit({
-            "type": "item.started",
-            "item": {
-                "type": name,
-                "id": call_id or f"{name}-started",
-                "command": str(cmd)[:2000] if cmd else None,
-            },
-        })
-
-    def on_tool_complete(call_id: str, name: str, arguments, result: str) -> None:
-        emit({
-            "type": "item.completed",
-            "item": {
-                "type": name,
-                "id": call_id or f"{name}-completed",
-                "status": "completed",
-                "aggregated_output": (result or "")[:6000],
-            },
-        })
-
-    agent.reasoning_callback = on_reasoning
-    agent.tool_start_callback = on_tool_start
-    agent.tool_complete_callback = on_tool_complete
-
-    # ── Emit initial session meta ────────────────────────────────────────
-    emit({"type": "session_meta", "payload": {"id": cli.session_id}})
-
-    # ── Run conversation ─────────────────────────────────────────────────
-    failed = False
-    response = ""
-    result_error = ""
-    result_partial = False
-    result_completed = True
-    try:
-        result = agent.run_conversation(
-            user_message=args.prompt,
-            conversation_history=cli.conversation_history,
-        )
-        debug_log("run_conversation_result", {"result": result})
-        if isinstance(result, dict):
-            response = result.get("final_response", "") or ""
-            failed = result.get("failed", False)
-            result_partial = bool(result.get("partial", False))
-            if "completed" in result:
-                result_completed = bool(result.get("completed"))
-            raw_error = result.get("error")
-            if isinstance(raw_error, str):
-                result_error = raw_error.strip()
-            elif raw_error is not None:
-                result_error = str(raw_error).strip()
-        else:
-            response = str(result) if result else ""
-    except Exception as exc:
-        emit({"type": "error", "error": f"Hermes execution failed: {exc}"})
-        sys.exit(1)
-
-    # ── Emit final agent message event (consumed but filtered by CLAPS) ─
-    if response:
-        emit({
-            "type": "item.completed",
-            "item": {"type": "agent_message", "content": response},
-        })
+    if args.server:
+        serve_requests(cli, default_max_turns=args.max_turns)
+        return
 
-    should_fail = failed or (
-        not response.strip() and (result_partial or not result_completed or bool(result_error))
+    result = run_request(
+        cli,
+        prompt=args.prompt.strip(),
+        output_path=args.output,
+        max_turns=args.max_turns,
+        request_id=None,
+        ticket_id=None,
     )
-
-    if should_fail:
-        emit({
-            "type": "error",
-            "error": result_error or "Hermes returned an incomplete result without a final response.",
-        })
-
-    # ── Emit closing session meta (session_id may update on resume) ──────
-    emit({"type": "session_meta", "payload": {"id": cli.session_id}})
-
-    # ── Write clean response to output file ──────────────────────────────
-    if args.output:
-        try:
-            with open(args.output, "w", encoding="utf-8") as f:
-                f.write(response)
-        except OSError as exc:
-            print(f"[adapter] failed to write output file: {exc}", file=sys.stderr)
-
-    sys.exit(1 if should_fail else 0)
+    sys.exit(0 if result["success"] else 1)
 
 
 if __name__ == "__main__":