bareagent-cli 0.1.0__py3-none-any.whl

bareagent/team/protocols.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+import json
+import time
+from enum import Enum
+
+from bareagent.team.mailbox import Message, MessageBus
+
+
+class Protocol(Enum):
+    PLAN_APPROVAL = "plan_approval"
+    SHUTDOWN = "shutdown"
+
+
+class ProtocolFSM:
+    """Simple polling request-response helper built on MessageBus."""
+
+    def __init__(self, bus: MessageBus, agent_name: str) -> None:
+        self.bus = bus
+        self.agent_name = agent_name
+        self.bus.ensure_mailbox(agent_name)
+
+    def request(self, to: str, protocol: Protocol, content: str) -> str:
+        return self.bus.send(
+            Message(
+                id="",
+                from_agent=self.agent_name,
+                to_agent=to,
+                content=encode_protocol_content(protocol, content),
+                msg_type="request",
+                timestamp="",
+            )
+        )
+
+    def wait_response(self, msg_id: str, timeout: float = 60) -> Message | None:
+        deadline = time.monotonic() + timeout
+        cursor: str | None = None
+
+        while time.monotonic() < deadline:
+            messages = self.bus.receive(self.agent_name, since_id=cursor)
+            if messages:
+                cursor = messages[-1].id
+            for message in messages:
+                if message.msg_type != "response":
+                    continue
+                if message.in_reply_to == msg_id:
+                    return message
+            remaining = deadline - time.monotonic()
+            if remaining <= 0:
+                break
+            self.bus.wait_for_message(self.agent_name, timeout=min(remaining, 0.5))
+
+        return None
+
+    def respond(self, in_reply_to: str, content: str) -> str:
+        request_message = self.bus.find_message(in_reply_to)
+        if request_message is None:
+            raise ValueError(f"Unknown request message id: {in_reply_to}")
+
+        protocol, _ = decode_protocol_content(request_message.content)
+        response_content = (
+            encode_protocol_content(protocol, content)
+            if protocol is not None
+            else content
+        )
+        return self.bus.send(
+            Message(
+                id="",
+                from_agent=self.agent_name,
+                to_agent=request_message.from_agent,
+                content=response_content,
+                msg_type="response",
+                timestamp="",
+                in_reply_to=in_reply_to,
+            )
+        )
+
+    def broadcast(self, protocol: Protocol, content: str) -> list[str]:
+        recipients = [
+            agent_name
+            for agent_name in self.bus.list_agents()
+            if agent_name != self.agent_name
+        ]
+        message_ids: list[str] = []
+        for recipient in recipients:
+            message_ids.append(
+                self.bus.send(
+                    Message(
+                        id="",
+                        from_agent=self.agent_name,
+                        to_agent=recipient,
+                        content=encode_protocol_content(protocol, content),
+                        msg_type="broadcast",
+                        timestamp="",
+                    )
+                )
+            )
+        return message_ids
+
+
+def encode_protocol_content(protocol: Protocol, content: str) -> str:
+    return json.dumps(
+        {
+            "protocol": protocol.value,
+            "content": content,
+        },
+        ensure_ascii=False,
+    )
+
+
+def decode_protocol_content(content: str) -> tuple[Protocol | None, str]:
+    try:
+        payload = json.loads(content)
+    except (TypeError, json.JSONDecodeError):
+        return None, str(content)
+
+    if not isinstance(payload, dict):
+        return None, str(content)
+
+    protocol_name = payload.get("protocol")
+    body = payload.get("content", "")
+    if not isinstance(protocol_name, str):
+        return None, str(content)
+
+    try:
+        protocol = Protocol(protocol_name)
+    except ValueError:
+        return None, str(content)
+    return protocol, str(body)

bareagent/tracing/__init__.py

@@ -0,0 +1,12 @@
+from bareagent.tracing._api import NullSpan, NullTracer, Span, Tracer
+from bareagent.tracing._proxy import ProxyTracer, enable_tracing, tracer
+
+__all__ = [
+    "NullSpan",
+    "NullTracer",
+    "Span",
+    "Tracer",
+    "ProxyTracer",
+    "enable_tracing",
+    "tracer",
+]

bareagent/tracing/_api.py

@@ -0,0 +1,92 @@
+"""Tracing abstractions: Span and Tracer ABCs."""
+
+from __future__ import annotations
+
+import abc
+import contextlib
+from collections.abc import Iterator
+from typing import Any
+
+
+class Span(abc.ABC):
+    """A single instrumented operation."""
+
+    @abc.abstractmethod
+    def set_tag(self, key: str, value: Any) -> None:
+        """Attach metadata (model name, tool name, etc.)."""
+
+    @abc.abstractmethod
+    def set_content_tag(self, key: str, value: Any) -> None:
+        """Attach content-sensitive data (messages, outputs).
+
+        Backends may skip these if content tracing is disabled.
+        """
+
+    @abc.abstractmethod
+    def set_error(self, error: str) -> None:
+        """Mark the span as failed."""
+
+    @abc.abstractmethod
+    def end(self) -> None:
+        """Finalize the span."""
+
+
+class Tracer(abc.ABC):
+    """Interface for instrumenting code with spans."""
+
+    @abc.abstractmethod
+    @contextlib.contextmanager
+    def trace(
+        self,
+        operation_name: str,
+        tags: dict[str, Any] | None = None,
+        *,
+        parent_span: Span | None = None,
+    ) -> Iterator[Span]:
+        """Create a span for the given operation."""
+
+    @abc.abstractmethod
+    def current_span(self) -> Span | None:
+        """Return the currently active span, if any."""
+
+    # flush/shutdown are optional no-op hooks; subclasses override as needed.
+    def flush(self) -> None:  # noqa: B027
+        """Flush pending data to the backend. No-op by default."""
+
+    def shutdown(self) -> None:  # noqa: B027
+        """Release resources. No-op by default."""
+
+
+class NullSpan(Span):
+    """Zero-overhead no-op span."""
+
+    def set_tag(self, key: str, value: Any) -> None:
+        pass
+
+    def set_content_tag(self, key: str, value: Any) -> None:
+        pass
+
+    def set_error(self, error: str) -> None:
+        pass
+
+    def end(self) -> None:
+        pass
+
+
+class NullTracer(Tracer):
+    """Zero-overhead no-op tracer."""
+
+    _NULL_SPAN = NullSpan()
+
+    @contextlib.contextmanager
+    def trace(
+        self,
+        operation_name: str,
+        tags: dict[str, Any] | None = None,
+        *,
+        parent_span: Span | None = None,
+    ) -> Iterator[Span]:
+        yield self._NULL_SPAN
+
+    def current_span(self) -> Span | None:
+        return None

bareagent/tracing/_proxy.py

@@ -0,0 +1,60 @@
+"""Global proxy tracer -- hot-swappable at runtime (Haystack pattern)."""
+
+from __future__ import annotations
+
+import contextlib
+import os
+import threading
+from collections.abc import Iterator
+from typing import Any
+
+from bareagent.tracing._api import NullTracer, Span, Tracer
+
+
+class ProxyTracer(Tracer):
+    """Delegates to an inner tracer that can be replaced at runtime."""
+
+    def __init__(self, inner: Tracer | None = None) -> None:
+        self._inner: Tracer = inner or NullTracer()
+        self._lock = threading.Lock()
+        self.is_content_tracing_enabled: bool = os.getenv(
+            "BAREAGENT_CONTENT_TRACING_ENABLED", "true"
+        ).lower() in {"1", "true", "yes", "on"}
+
+    @property
+    def inner(self) -> Tracer:
+        return self._inner
+
+    @inner.setter
+    def inner(self, tracer: Tracer) -> None:
+        with self._lock:
+            self._inner = tracer
+
+    @contextlib.contextmanager
+    def trace(
+        self,
+        operation_name: str,
+        tags: dict[str, Any] | None = None,
+        *,
+        parent_span: Span | None = None,
+    ) -> Iterator[Span]:
+        with self._inner.trace(operation_name, tags, parent_span=parent_span) as span:
+            yield span
+
+    def current_span(self) -> Span | None:
+        return self._inner.current_span()
+
+    def flush(self) -> None:
+        self._inner.flush()
+
+    def shutdown(self) -> None:
+        self._inner.shutdown()
+
+
+# Global singleton -- the only import any module needs.
+tracer: ProxyTracer = ProxyTracer()
+
+
+def enable_tracing(provided_tracer: Tracer) -> None:
+    """Replace the global tracer backend at runtime."""
+    tracer.inner = provided_tracer

bareagent/tracing/composite.py

@@ -0,0 +1,115 @@
+"""Fan-out tracer that delegates to N backends."""
+
+from __future__ import annotations
+
+import contextlib
+from collections.abc import Iterator
+from typing import Any
+
+from bareagent.tracing._api import Span, Tracer
+
+
+class CompositeSpan(Span):
+    """Span that fans out to multiple backend spans."""
+
+    def __init__(self, spans: list[Span]) -> None:
+        self._spans = spans
+
+    def set_tag(self, key: str, value: Any) -> None:
+        for span in self._spans:
+            try:
+                span.set_tag(key, value)
+            except Exception:
+                pass
+
+    def set_content_tag(self, key: str, value: Any) -> None:
+        for span in self._spans:
+            try:
+                span.set_content_tag(key, value)
+            except Exception:
+                pass
+
+    def set_error(self, error: str) -> None:
+        for span in self._spans:
+            try:
+                span.set_error(error)
+            except Exception:
+                pass
+
+    def end(self) -> None:
+        for span in self._spans:
+            try:
+                span.end()
+            except Exception:
+                pass
+
+
+class CompositeTracer(Tracer):
+    """Tracer that fans out to N backends simultaneously."""
+
+    def __init__(self, tracers: list[Tracer]) -> None:
+        self._tracers = list(tracers)
+
+    @contextlib.contextmanager
+    def trace(
+        self,
+        operation_name: str,
+        tags: dict[str, Any] | None = None,
+        *,
+        parent_span: Span | None = None,
+    ) -> Iterator[Span]:
+        spans: list[Span] = []
+        exits: list[contextlib.AbstractContextManager[Span]] = []
+        try:
+            for tracer in self._tracers:
+                cm = tracer.trace(operation_name, tags, parent_span=parent_span)
+                span = cm.__enter__()
+                spans.append(span)
+                exits.append(cm)
+            yield CompositeSpan(spans)
+        finally:
+            for cm in reversed(exits):
+                try:
+                    cm.__exit__(None, None, None)
+                except Exception:
+                    pass
+
+    def current_span(self) -> Span | None:
+        for tracer in self._tracers:
+            span = tracer.current_span()
+            if span is not None:
+                return span
+        return None
+
+    def flush(self) -> None:
+        for tracer in self._tracers:
+            try:
+                tracer.flush()
+            except Exception:
+                pass
+
+    def shutdown(self) -> None:
+        for tracer in self._tracers:
+            try:
+                tracer.shutdown()
+            except Exception:
+                pass
+
+    # ---- Delegate InteractionLogger query methods to first JsonFileTracer ----
+
+    def _json_file_tracer(self) -> Any:
+        from bareagent.tracing.json_file import JsonFileTracer
+
+        for tracer in self._tracers:
+            if isinstance(tracer, JsonFileTracer):
+                return tracer
+        return None
+
+    def __getattr__(self, name: str) -> Any:
+        """Forward InteractionLogger methods to the first JsonFileTracer."""
+        jft = self._json_file_tracer()
+        if jft is not None:
+            attr = getattr(jft, name, None)
+            if attr is not None:
+                return attr
+        raise AttributeError(name)

bareagent/tracing/json_file.py

@@ -0,0 +1,115 @@
+"""JSON file tracer -- wraps InteractionLogger via composition."""
+
+from __future__ import annotations
+
+import contextlib
+from collections.abc import Iterator
+from typing import Any
+
+from bareagent.debug.interaction_log import InteractionLogger
+from bareagent.tracing._api import Span, Tracer
+
+
+class JsonFileSpan(Span):
+    """Span that accumulates tags for the JSON file backend."""
+
+    def __init__(self, operation_name: str) -> None:
+        self.operation_name = operation_name
+        self._tags: dict[str, Any] = {}
+        self._content_tags: dict[str, Any] = {}
+        self._error: str | None = None
+
+    def set_tag(self, key: str, value: Any) -> None:
+        self._tags[key] = value
+
+    def set_content_tag(self, key: str, value: Any) -> None:
+        self._content_tags[key] = value
+
+    def set_error(self, error: str) -> None:
+        self._error = error
+
+    def end(self) -> None:
+        pass
+
+
+class JsonFileTracer(Tracer):
+    """Tracer backed by InteractionLogger -- full backward compat.
+
+    The underlying ``InteractionLogger`` is exposed via the ``.logger``
+    property so that the web viewer and ``/log`` commands can continue
+    using it directly.  All ``InteractionLogger`` public methods are
+    also proxied on this class so that duck-typed call sites (e.g.
+    ``_safe_log_request`` in *agent_loop*) work transparently.
+    """
+
+    def __init__(self, logger: InteractionLogger) -> None:
+        self._logger = logger
+        self._current_span: JsonFileSpan | None = None
+
+    @property
+    def logger(self) -> InteractionLogger:
+        """Expose the underlying logger for web_viewer / /log commands."""
+        return self._logger
+
+    @contextlib.contextmanager
+    def trace(
+        self,
+        operation_name: str,
+        tags: dict[str, Any] | None = None,
+        *,
+        parent_span: Span | None = None,
+    ) -> Iterator[Span]:
+        span = JsonFileSpan(operation_name)
+        if tags:
+            for k, v in tags.items():
+                span.set_tag(k, v)
+        prev = self._current_span
+        self._current_span = span
+        try:
+            yield span
+        except Exception as exc:
+            span.set_error(str(exc))
+            raise
+        finally:
+            span.end()
+            self._current_span = prev
+
+    def current_span(self) -> Span | None:
+        return self._current_span
+
+    # ---- Delegation: InteractionLogger methods for /log and web_viewer ----
+
+    @property
+    def session_id(self) -> str:
+        return self._logger.session_id
+
+    @session_id.setter
+    def session_id(self, value: str) -> None:
+        self._logger.session_id = value
+
+    def log_request(
+        self,
+        messages: list[dict[str, Any]],
+        tools: list[dict[str, Any]],
+        *,
+        provider_info: dict[str, Any] | None = None,
+    ) -> int:
+        return self._logger.log_request(messages, tools, provider_info=provider_info)
+
+    def log_response(self, seq: int, **kwargs: Any) -> None:
+        self._logger.log_response(seq, **kwargs)
+
+    def list_sessions(self) -> list[str]:
+        return self._logger.list_sessions()
+
+    def list_interactions(self, session_id: str) -> list[dict[str, Any]]:
+        return self._logger.list_interactions(session_id)
+
+    def get_interaction(self, session_id: str, seq: int) -> dict[str, Any]:
+        return self._logger.get_interaction(session_id, seq)
+
+    def subscribe_events(self, **kwargs: Any) -> Any:
+        return self._logger.subscribe_events(**kwargs)
+
+    def unsubscribe_events(self, event_queue: Any) -> None:
+        return self._logger.unsubscribe_events(event_queue)

bareagent/tracing/langfuse.py

@@ -0,0 +1,139 @@
+"""Langfuse tracer backend (optional dependency).
+
+Requires the ``langfuse`` package::
+
+    pip install langfuse
+    # or: pip install bareagent-cli[langfuse]
+
+Activated automatically when ``LANGFUSE_PUBLIC_KEY`` is set, or when
+``[tracing] langfuse = true`` appears in the config file.
+"""
+
+from __future__ import annotations
+
+import contextlib
+from collections.abc import Iterator
+from typing import Any
+
+from bareagent.tracing._api import Span, Tracer
+
+
+class LangfuseSpan(Span):
+    """Span backed by a Langfuse generation or span object."""
+
+    def __init__(self, langfuse_object: Any) -> None:
+        self._lf = langfuse_object
+        self._metadata: dict[str, Any] = {}
+        self._error: str | None = None
+
+    def set_tag(self, key: str, value: Any) -> None:
+        self._metadata[key] = value
+
+    def set_content_tag(self, key: str, value: Any) -> None:
+        if key == "input":
+            self._lf.input = value
+        elif key == "output":
+            self._lf.output = value
+        else:
+            self._metadata[key] = value
+
+    def set_error(self, error: str) -> None:
+        self._error = error
+
+    def end(self) -> None:
+        kwargs: dict[str, Any] = {}
+        if self._metadata:
+            kwargs["metadata"] = self._metadata
+        if self._error:
+            kwargs["level"] = "ERROR"
+            kwargs["status_message"] = self._error
+
+        # Langfuse generation objects accept usage on end()
+        input_tokens = self._metadata.get("input_tokens")
+        output_tokens = self._metadata.get("output_tokens")
+        if input_tokens is not None or output_tokens is not None:
+            kwargs["usage"] = {}
+            if input_tokens is not None:
+                kwargs["usage"]["input"] = int(input_tokens)
+            if output_tokens is not None:
+                kwargs["usage"]["output"] = int(output_tokens)
+
+        self._lf.end(**kwargs)
+
+
+class LangfuseTracer(Tracer):
+    """Tracer that sends spans to Langfuse.
+
+    Reads credentials from standard Langfuse environment variables
+    (``LANGFUSE_PUBLIC_KEY``, ``LANGFUSE_SECRET_KEY``, ``LANGFUSE_HOST``).
+    """
+
+    def __init__(
+        self,
+        *,
+        session_id: str = "default",
+        **langfuse_kwargs: Any,
+    ) -> None:
+        from langfuse import Langfuse  # type: ignore
+
+        self._langfuse = Langfuse(**langfuse_kwargs)
+        self._session_id = session_id
+        self._trace = self._langfuse.trace(
+            name="bareagent-session",
+            session_id=session_id,
+        )
+        self._current_span: LangfuseSpan | None = None
+
+    @property
+    def session_id(self) -> str:
+        return self._session_id
+
+    @session_id.setter
+    def session_id(self, value: str) -> None:
+        self._session_id = value
+        self._trace = self._langfuse.trace(
+            name="bareagent-session",
+            session_id=value,
+        )
+
+    @contextlib.contextmanager
+    def trace(
+        self,
+        operation_name: str,
+        tags: dict[str, Any] | None = None,
+        *,
+        parent_span: Span | None = None,
+    ) -> Iterator[Span]:
+        parent = (
+            parent_span._lf  # type: ignore[union-attr]
+            if isinstance(parent_span, LangfuseSpan)
+            else self._trace
+        )
+
+        if operation_name == "llm_call":
+            model = (tags or {}).get("model", "unknown")
+            lf_obj = parent.generation(name=operation_name, model=model, metadata=tags)
+        else:
+            lf_obj = parent.span(name=operation_name, metadata=tags)
+
+        span = LangfuseSpan(lf_obj)
+        prev = self._current_span
+        self._current_span = span
+        try:
+            yield span
+        except Exception as exc:
+            span.set_error(str(exc))
+            raise
+        finally:
+            span.end()
+            self._current_span = prev
+
+    def current_span(self) -> Span | None:
+        return self._current_span
+
+    def flush(self) -> None:
+        self._langfuse.flush()
+
+    def shutdown(self) -> None:
+        self._langfuse.flush()
+        self._langfuse.shutdown()