baserun-cli 0.1.0__py3-none-any.whl

baserun_cli/_vendored/parsers/bash_agent.py

@@ -0,0 +1,83 @@
+"""Bash Agent stream-json parser.
+
+Format: `ccagent --output stream-json` (bash-agent C implementation).
+All text/thinking is token-level delta only; no complete message blocks
+and no result event with final text. The delta accumulator in cli.py
+handles flushing complete events.
+"""
+from __future__ import annotations
+
+from ..base import ConnectorEvent, ConnectorEventType
+from .base import BaseParser
+
+
+class BashAgentParser(BaseParser):
+    schema = "bash_agent"
+
+    @staticmethod
+    def extract_session_id(obj: dict) -> str | None:
+        if obj.get("type") == "session_start":
+            return obj.get("session_id")
+        return None
+
+    @staticmethod
+    def parse(obj: dict) -> list[ConnectorEvent]:
+        out: list[ConnectorEvent] = []
+        t = obj.get("type", "")
+
+        if t in ("session_start", "user_input"):
+            return out
+
+        if t == "thinking":
+            out.append(ConnectorEvent(
+                ConnectorEventType.THINKING,
+                {"delta": obj.get("content", ""), "is_delta": True},
+            ))
+        elif t == "text":
+            out.append(ConnectorEvent(
+                ConnectorEventType.MESSAGE,
+                {"delta": obj.get("content", ""), "is_delta": True},
+            ))
+        elif t == "tool_call":
+            out.append(ConnectorEvent(
+                ConnectorEventType.TOOL_CALL,
+                {"tool": obj.get("name", ""), "args": obj.get("input", {}), "call_id": obj.get("id", "")},
+            ))
+        elif t == "tool_result":
+            out.append(ConnectorEvent(
+                ConnectorEventType.TOOL_RESULT,
+                {"call_id": obj.get("tool_use_id", ""), "result": obj.get("content", "")},
+            ))
+        elif t == "usage":
+            _in = obj.get("input_tokens", 0)
+            _out = obj.get("output_tokens", 0)
+            _cache_read = obj.get("cache_read_input_tokens", 0) or 0
+            _cache_creation = obj.get("cache_creation_input_tokens", 0) or 0
+            raw = {k: v for k, v in obj.items() if k != "type"}
+            out.append(ConnectorEvent(
+                ConnectorEventType.USAGE,
+                {
+                    "input": _in,
+                    "output": _out,
+                    "cache_read_input_tokens": _cache_read,
+                    "cache_creation_input_tokens": _cache_creation,
+                    "total": _in + _out + _cache_read + _cache_creation,
+                    "raw": raw,
+                },
+            ))
+        elif t == "error":
+            out.append(ConnectorEvent(
+                ConnectorEventType.ERROR,
+                {"message": obj.get("message", str(obj))},
+            ))
+        elif t == "stop":
+            if obj.get("reason") == "end_turn":
+                out.append(ConnectorEvent(
+                    ConnectorEventType.FINAL,
+                    {"text": "", "session_id": None},
+                ))
+            # tool_use → non-terminal, skip
+        else:
+            out.append(BaseParser.catch_all(f"bash_agent:unhandled:{t}", obj))
+
+        return out

baserun_cli/_vendored/parsers/claude.py

@@ -0,0 +1,97 @@
+"""Claude Code stream-json parser.
+
+Format: `claude -p --output-format stream-json --verbose --include-partial-messages`
+--verbose outputs stream_event (token-level delta) + complete assistant messages.
+text/thinking arrive as stream_event deltas (per-token); tool_use arrives in
+assistant blocks (with full args).
+"""
+from __future__ import annotations
+
+from ..base import ConnectorEvent, ConnectorEventType
+from .base import BaseParser
+
+
+class ClaudeParser(BaseParser):
+    schema = "claude"
+
+    @staticmethod
+    def extract_session_id(obj: dict) -> str | None:
+        if obj.get("type") == "system" and obj.get("subtype") == "init":
+            return obj.get("session_id")
+        return None
+
+    @staticmethod
+    def parse(obj: dict) -> list[ConnectorEvent]:
+        out: list[ConnectorEvent] = []
+        t = obj.get("type")
+
+        if t == "stream_event":
+            event = obj.get("event", {})
+            et = event.get("type")
+            if et == "content_block_delta":
+                delta = event.get("delta", {})
+                dt = delta.get("type")
+                if dt == "text_delta":
+                    out.append(ConnectorEvent(
+                        ConnectorEventType.MESSAGE,
+                        {"delta": delta.get("text", ""), "is_delta": True},
+                    ))
+                elif dt == "thinking_delta":
+                    out.append(ConnectorEvent(
+                        ConnectorEventType.THINKING,
+                        {"delta": delta.get("thinking", ""), "is_delta": True},
+                    ))
+                # input_json_delta (tool args delta) — partial JSON, skip
+        elif t == "assistant":
+            for block in obj.get("message", {}).get("content", []):
+                bt = block.get("type")
+                if bt == "thinking":
+                    out.append(ConnectorEvent(
+                        ConnectorEventType.THINKING,
+                        {"delta": block.get("thinking", ""), "is_delta": False},
+                    ))
+                elif bt == "text":
+                    out.append(ConnectorEvent(
+                        ConnectorEventType.MESSAGE,
+                        {"delta": block.get("text", ""), "is_delta": False},
+                    ))
+                elif bt == "tool_use":
+                    out.append(ConnectorEvent(
+                        ConnectorEventType.TOOL_CALL,
+                        {"tool": block.get("name"), "args": block.get("input"), "call_id": block.get("id")},
+                    ))
+        elif t == "user":
+            for block in obj.get("message", {}).get("content", []):
+                if block.get("type") == "tool_result":
+                    out.append(ConnectorEvent(
+                        ConnectorEventType.TOOL_RESULT,
+                        {"call_id": block.get("tool_use_id"), "result": block.get("content")},
+                    ))
+        elif t == "result":
+            usage = obj.get("usage", {}) or {}
+            if usage:
+                _in = usage.get("input_tokens", 0)
+                _out = usage.get("output_tokens", 0)
+                _cache_read = usage.get("cache_read_input_tokens", 0) or 0
+                _cache_creation = usage.get("cache_creation_input_tokens", 0) or 0
+                out.append(ConnectorEvent(
+                    ConnectorEventType.USAGE,
+                    {
+                        "input": _in,
+                        "output": _out,
+                        "cache_read_input_tokens": _cache_read,
+                        "cache_creation_input_tokens": _cache_creation,
+                        "total": _in + _out + _cache_read + _cache_creation,
+                        "raw": dict(usage),
+                    },
+                ))
+            out.append(ConnectorEvent(
+                ConnectorEventType.FINAL,
+                {"text": obj.get("result", ""), "session_id": None},
+            ))
+        elif t == "system":
+            pass  # system/init handled by extract_session_id
+        else:
+            out.append(BaseParser.catch_all(f"claude:unhandled:{t}", obj))
+
+        return out

baserun_cli/_vendored/parsers/codex.py

@@ -0,0 +1,202 @@
+"""Codex CLI JSONL parser.
+
+Format: `codex exec --json --full-auto`
+Validated against real CLI output + binary analysis of codex-cli 0.125.0.
+"""
+from __future__ import annotations
+
+from ..base import ConnectorEvent, ConnectorEventType
+from .base import BaseParser
+
+# Item types that are pure lifecycle noise — skipped entirely.
+_SKIP_ITEMS = frozenset({
+    "context_compaction",
+    "hook_prompt",
+    "user_message",
+    "entered_review_mode",
+    "exited_review_mode",
+})
+
+
+def _extract_plan_text(item: dict) -> str:
+    fragments = item.get("fragments") or []
+    parts = []
+    for frag in fragments:
+        if isinstance(frag, dict):
+            md = frag.get("plan_markdown") or frag.get("markdown") or ""
+            if md:
+                parts.append(md)
+    if not parts:
+        md = item.get("plan_markdown", "")
+        if md:
+            return md
+        import json as _json
+        return f"[plan] {_json.dumps(item, ensure_ascii=False)[:500]}"
+    return "\n".join(parts)
+
+
+def _extract_reasoning_text(item: dict) -> str:
+    text = item.get("summary_text") or item.get("raw_content") or ""
+    if text:
+        return text
+    for key in ("summary", "text", "content"):
+        val = item.get(key)
+        if isinstance(val, str) and val:
+            return val
+    import json as _json
+    return f"[reasoning] {_json.dumps(item, ensure_ascii=False)[:500]}"
+
+
+class CodexParser(BaseParser):
+    schema = "codex"
+
+    @staticmethod
+    def extract_session_id(obj: dict) -> str | None:
+        if obj.get("type") == "thread.started":
+            return obj.get("thread_id")
+        return None
+
+    @staticmethod
+    def parse(obj: dict) -> list[ConnectorEvent]:
+        out: list[ConnectorEvent] = []
+        t = obj.get("type", "")
+
+        if t in ("thread.started", "turn.started"):
+            return out
+
+        if t == "item.started":
+            return CodexParser._item_started(obj.get("item", {}))
+
+        if t == "item.completed":
+            return CodexParser._item_completed(obj.get("item", {}))
+
+        if t == "turn.completed":
+            usage = obj.get("usage", {}) or {}
+            if usage:
+                _in = usage.get("input_tokens", 0)
+                _cached = usage.get("cached_input_tokens", 0)
+                _out = usage.get("output_tokens", 0)
+                fresh_in = max(0, _in - _cached)
+                _total = _in + _out
+                out.append(ConnectorEvent(
+                    ConnectorEventType.USAGE,
+                    {
+                        "input": fresh_in,
+                        "output": _out,
+                        "cached_input_tokens": _cached,
+                        "total": _total,
+                        "raw": dict(usage),
+                    },
+                ))
+            out.append(ConnectorEvent(
+                ConnectorEventType.FINAL,
+                {"text": "", "session_id": None},
+            ))
+            return out
+
+        if t in ("error", "turn.failed"):
+            if t == "error":
+                msg = obj.get("message", "")
+            else:
+                err = obj.get("error", {})
+                msg = err.get("message", "") if isinstance(err, dict) else str(err)
+            out.append(ConnectorEvent(
+                ConnectorEventType.ERROR,
+                {"message": msg},
+            ))
+            if t == "turn.failed":
+                out.append(ConnectorEvent(
+                    ConnectorEventType.FINAL,
+                    {"text": "", "session_id": None},
+                ))
+            return out
+
+        out.append(BaseParser.catch_all(f"codex:unhandled:{t}", obj))
+        return out
+
+    @staticmethod
+    def _item_started(item: dict) -> list[ConnectorEvent]:
+        item_type = item.get("type")
+        item_id = item.get("id")
+
+        if item_type in _SKIP_ITEMS:
+            return []
+
+        tool_map = {
+            "command_execution": ("shell", {"command": item.get("command", "")}),
+            "file_change": ("file_change", {"changes": item.get("changes", [])}),
+            "web_search": ("web_search", {"queries": item.get("queries", [])}),
+            "image_generation": ("image_generation", item.get("input", {})),
+            "image_view": ("image_view", {"path": item.get("path", "")}),
+            "collab_agent_tool_call": ("collab_agent", {"prompt": item.get("prompt", "")}),
+        }
+        if item_type in tool_map:
+            name, args = tool_map[item_type]
+            return [ConnectorEvent(
+                ConnectorEventType.TOOL_CALL,
+                {"tool": name, "args": args, "call_id": item_id},
+            )]
+        if item_type in ("mcp_tool_call", "dynamic_tool_call"):
+            prefix = "mcp" if item_type == "mcp_tool_call" else "dynamic"
+            return [ConnectorEvent(
+                ConnectorEventType.TOOL_CALL,
+                {"tool": f"{prefix}:{item.get('name', 'unknown')}", "args": item.get("arguments"), "call_id": item_id},
+            )]
+        if item_type == "plan":
+            return [ConnectorEvent(
+                ConnectorEventType.THINKING,
+                {"delta": _extract_plan_text(item), "is_delta": False},
+            )]
+        if item_type == "reasoning":
+            return [ConnectorEvent(
+                ConnectorEventType.THINKING,
+                {"delta": _extract_reasoning_text(item), "is_delta": False},
+            )]
+
+        return [BaseParser.catch_all(f"codex:item.started:{item_type}", item)]
+
+    @staticmethod
+    def _item_completed(item: dict) -> list[ConnectorEvent]:
+        item_type = item.get("type")
+        item_id = item.get("id")
+
+        if item_type in _SKIP_ITEMS:
+            return []
+
+        if item_type == "agent_message":
+            return [ConnectorEvent(
+                ConnectorEventType.MESSAGE,
+                {"delta": item.get("text", ""), "is_delta": False},
+            )]
+
+        # all tool-like completions → TOOL_RESULT
+        tool_result_types = {
+            "command_execution", "file_change", "web_search",
+            "mcp_tool_call", "dynamic_tool_call",
+            "collab_agent_tool_call", "image_generation", "image_view",
+        }
+        if item_type in tool_result_types:
+            result_val = (
+                item.get("aggregated_output")
+                or item.get("output")
+                or item.get("result")
+                or item.get("changes")
+                or item
+            )
+            return [ConnectorEvent(
+                ConnectorEventType.TOOL_RESULT,
+                {"call_id": item_id, "result": result_val},
+            )]
+
+        if item_type == "plan":
+            return [ConnectorEvent(
+                ConnectorEventType.THINKING,
+                {"delta": _extract_plan_text(item), "is_delta": False},
+            )]
+        if item_type == "reasoning":
+            return [ConnectorEvent(
+                ConnectorEventType.THINKING,
+                {"delta": _extract_reasoning_text(item), "is_delta": False},
+            )]
+
+        return [BaseParser.catch_all(f"codex:item.completed:{item_type}", item)]