bareagent-cli 0.1.0__py3-none-any.whl

bareagent/team/autonomous.py

@@ -0,0 +1,193 @@
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from bareagent.core.loop import agent_loop
+from bareagent.planning.tasks import Task, TaskManager
+from bareagent.team.mailbox import Message, MessageBus
+from bareagent.team.protocols import Protocol, ProtocolFSM, decode_protocol_content
+from bareagent.tracing import tracer as global_tracer
+
+
+def _noop_compact(_messages: list[dict[str, Any]]) -> None:
+    """Default compaction hook: do nothing (stateless / test-friendly)."""
+
+
+class AutonomousAgent:
+    """Daemon-friendly idle-poll-claim-work loop for teammate agents."""
+
+    def __init__(
+        self,
+        name: str,
+        provider: Any,
+        tools: list[dict[str, Any]],
+        handlers: dict[str, Any],
+        bus: MessageBus,
+        task_manager: TaskManager | None,
+        *,
+        permission: Any = None,
+        system_prompt: str = "",
+        poll_interval: float = 5.0,
+        compact_fn: Any = None,
+        memory_enabled: bool = False,
+    ) -> None:
+        self.name = name
+        self.provider = provider
+        self.tools = tools
+        self.handlers = handlers
+        self.bus = bus
+        self.task_manager = task_manager
+        self.permission = permission
+        self.system_prompt = system_prompt.strip()
+        self.poll_interval = poll_interval
+        self._memory_enabled = memory_enabled
+        # Injected per-teammate Compactor (mirrors the main loop's compact_fn).
+        # A no-op default keeps stateless teammates and unit tests simple while
+        # decoupling AutonomousAgent from the Compactor implementation.
+        self._compact_fn = compact_fn if compact_fn is not None else _noop_compact
+        # Conversational memory accrues across *requests* only (Q1); the system
+        # prompt is seeded once here so it is not re-prepended every turn.
+        self._messages: list[dict[str, Any]] = []
+        if self._memory_enabled and self.system_prompt:
+            self._messages.append({"role": "system", "content": self.system_prompt})
+        self._shutdown = False
+        self.bus.ensure_mailbox(name)
+        self._last_seen_id: str | None = self.bus.latest_message_id(name)
+        self._protocol = ProtocolFSM(bus, agent_name=name)
+
+    def run(self) -> str:
+        while not self._shutdown:
+            incoming = self.bus.receive(self.name, since_id=self._last_seen_id)
+            if incoming:
+                self._last_seen_id = incoming[-1].id
+                self._handle_messages(incoming)
+                continue
+
+            if self.task_manager is not None:
+                ready_tasks = self.task_manager.get_ready_tasks()
+                for task in ready_tasks:
+                    claimed_task = self._claim_task(task)
+                    if claimed_task is None:
+                        continue
+                    self._execute_task(claimed_task)
+                    break
+                else:
+                    self.bus.wait_for_message(self.name, timeout=self.poll_interval)
+                continue
+
+            self.bus.wait_for_message(self.name, timeout=self.poll_interval)
+
+        return f"{self.name} stopped"
+
+    def _handle_messages(self, messages: list[Message]) -> None:
+        for message in messages:
+            protocol, content = decode_protocol_content(message.content)
+            if protocol == Protocol.SHUTDOWN:
+                self._shutdown = True
+                break
+
+            if message.msg_type != "request":
+                continue
+
+            # Isolate request handling: a single failing request must not kill
+            # the daemon thread (which would silently strand the teammate and
+            # leave a blocking ``team_send`` waiting out its full timeout). On
+            # error, reply with the reason so the requester learns immediately.
+            try:
+                prompt = self._build_incoming_prompt(content, protocol=protocol)
+                # Requests accrue conversational memory (Q1) when enabled; tasks
+                # always stay stateless (handled in _execute_task).
+                if self._memory_enabled:
+                    response_text = self._run_request(prompt)
+                else:
+                    response_text = self._run_prompt(prompt)
+            except Exception as exc:
+                logging.exception("Request handling failed in agent %s", self.name)
+                response_text = f"[error] {type(exc).__name__}: {exc}"
+            self._protocol.respond(message.id, response_text)
+
+    def _claim_task(self, task: Task) -> Task | None:
+        if self.task_manager is None:
+            return None
+
+        try:
+            return self.task_manager.update(
+                task.id,
+                status="in_progress",
+                expected_status="pending",
+            )
+        except ValueError:
+            return None
+
+    def _execute_task(self, task: Task) -> None:
+        if self.task_manager is None:
+            return
+
+        try:
+            self._run_prompt(self._build_task_prompt(task))
+        except Exception:
+            logging.exception("Task %s failed in agent %s", task.id, self.name)
+            self.task_manager.update(task.id, status="failed")
+            return
+
+        self.task_manager.update(task.id, status="done")
+
+    def _run_request(self, prompt: str) -> str:
+        """Stateful request turn: append onto the persistent conversation, run.
+
+        On failure roll the in-flight turn back so a transient error cannot
+        poison the memory list's user/assistant alternation (mirrors the
+        ``/goal`` ``_drive_goal`` rollback). The injected ``compact_fn`` keeps
+        the accumulated history bounded.
+        """
+        snapshot = len(self._messages)
+        self._messages.append({"role": "user", "content": prompt})
+        try:
+            with global_tracer.trace("teammate_run", tags={"agent": self.name}):
+                return agent_loop(
+                    provider=self.provider,
+                    messages=self._messages,
+                    tools=self.tools,
+                    handlers=self.handlers,
+                    permission=self.permission,
+                    compact_fn=self._compact_fn,
+                )
+        except BaseException:
+            del self._messages[snapshot:]
+            raise
+
+    def _run_prompt(self, prompt: str) -> str:
+        messages: list[dict[str, Any]] = []
+        if self.system_prompt:
+            messages.append({"role": "system", "content": self.system_prompt})
+        messages.append({"role": "user", "content": prompt})
+        with global_tracer.trace("teammate_run", tags={"agent": self.name}):
+            return agent_loop(
+                provider=self.provider,
+                messages=messages,
+                tools=self.tools,
+                handlers=self.handlers,
+                permission=self.permission,
+                compact_fn=lambda _messages: None,
+            )
+
+    def _build_incoming_prompt(
+        self,
+        content: str,
+        *,
+        protocol: Protocol | None,
+    ) -> str:
+        if protocol == Protocol.PLAN_APPROVAL:
+            return "请审阅下面的计划，判断是否应批准，并给出简洁理由。\n\n" + content
+        return content
+
+    def _build_task_prompt(self, task: Task) -> str:
+        lines = [
+            f"你是队友 {self.name}，请完成下面的任务。",
+            f"任务标题: {task.title}",
+        ]
+        if task.description:
+            lines.append(f"任务描述: {task.description}")
+        lines.append("完成后给出简洁结果。")
+        return "\n".join(lines)

bareagent/team/mailbox.py

@@ -0,0 +1,239 @@
+from __future__ import annotations
+
+import json
+import re
+import threading
+from collections import OrderedDict
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any
+
+from bareagent.core.fileutil import generate_random_id, optional_string, utc_timestamp_iso
+
+_VALID_AGENT_NAME = re.compile(r"^[A-Za-z0-9_-]+$")
+
+
+def _validate_agent_name(name: str) -> str:
+    normalized = name.strip()
+    if not normalized:
+        raise ValueError("agent_name must not be empty")
+    if not _VALID_AGENT_NAME.fullmatch(normalized):
+        raise ValueError(
+            f"Invalid agent name (only alphanumeric, _, - allowed): {normalized!r}"
+        )
+    return normalized
+
+
+@dataclass(slots=True)
+class Message:
+    id: str
+    from_agent: str
+    to_agent: str
+    content: str
+    msg_type: str
+    timestamp: str
+    in_reply_to: str | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, payload: dict[str, Any]) -> Message:
+        return cls(
+            id=str(payload.get("id", "")),
+            from_agent=str(payload.get("from_agent", "")),
+            to_agent=str(payload.get("to_agent", "")),
+            content=str(payload.get("content", "")),
+            msg_type=str(payload.get("msg_type", "")),
+            timestamp=str(payload.get("timestamp", "")),
+            in_reply_to=optional_string(payload.get("in_reply_to")),
+        )
+
+
+class MessageBus:
+    """Append-only JSONL mailboxes, one file per agent."""
+
+    def __init__(self, mailbox_dir: str | Path = ".mailbox") -> None:
+        self.mailbox_dir = Path(mailbox_dir)
+        self.mailbox_dir.mkdir(parents=True, exist_ok=True)
+        self._locks: dict[str, threading.Lock] = {}
+        self._locks_guard = threading.Lock()
+        self._message_index: OrderedDict[str, tuple[str, Message]] = OrderedDict()
+        self._index_lock = threading.Lock()
+        self._max_index_size = 10000
+        self._conds: dict[str, threading.Condition] = {}
+        self._conds_guard = threading.Lock()
+        self._signal_counts: dict[str, int] = {}
+        # Ids of messages already handed to the consumer out of band -- e.g. a
+        # blocking ``team_send`` that synchronously waited for and returned the
+        # reply. The polling drain consults this so it does not deliver the same
+        # message a second time. Bound to the bus instance, so it resets for free
+        # when a new session swaps in a fresh bus.
+        self._delivered: set[str] = set()
+        self._delivered_lock = threading.Lock()
+
+    def send(self, msg: Message) -> str:
+        resolved = self._prepare_message(msg)
+        self._append(resolved.to_agent, resolved)
+        return resolved.id
+
+    def receive(self, agent_name: str, since_id: str | None = None) -> list[Message]:
+        normalized_name = _validate_agent_name(agent_name)
+
+        mailbox_path = self._mailbox_path(normalized_name)
+        self.ensure_mailbox(normalized_name)
+        with self._lock_for(normalized_name):
+            lines = mailbox_path.read_text(encoding="utf-8").splitlines()
+
+        messages: list[Message] = []
+        found_cursor = since_id is None
+        for index, line in enumerate(lines, start=1):
+            if not line.strip():
+                continue
+            try:
+                payload = json.loads(line)
+            except json.JSONDecodeError as exc:
+                raise ValueError(
+                    f"Invalid mailbox entry in {mailbox_path} at line {index}: {exc}"
+                ) from exc
+            message = Message.from_dict(payload)
+            if not found_cursor:
+                if message.id == since_id:
+                    found_cursor = True
+                continue
+            messages.append(message)
+        return messages
+
+    def ensure_mailbox(self, agent_name: str) -> Path:
+        normalized_name = _validate_agent_name(agent_name)
+        mailbox_path = self._mailbox_path(normalized_name)
+        mailbox_path.parent.mkdir(parents=True, exist_ok=True)
+        mailbox_path.touch(exist_ok=True)
+        return mailbox_path
+
+    def list_agents(self) -> list[str]:
+        self.mailbox_dir.mkdir(parents=True, exist_ok=True)
+        return sorted(path.stem for path in self.mailbox_dir.glob("*.jsonl"))
+
+    def latest_message_id(self, agent_name: str) -> str | None:
+        normalized_name = _validate_agent_name(agent_name)
+
+        mailbox_path = self.ensure_mailbox(normalized_name)
+        with self._lock_for(normalized_name):
+            lines = mailbox_path.read_text(encoding="utf-8").splitlines()
+
+        for index, line in enumerate(reversed(lines), start=1):
+            if not line.strip():
+                continue
+            try:
+                payload = json.loads(line)
+            except json.JSONDecodeError as exc:
+                raise ValueError(
+                    f"Invalid mailbox entry in {mailbox_path} near tail line {index}: {exc}"
+                ) from exc
+            message = Message.from_dict(payload)
+            return message.id
+        return None
+
+    def find_message(self, message_id: str) -> Message | None:
+        normalized_id = message_id.strip()
+        if not normalized_id:
+            raise ValueError("message_id must not be empty")
+
+        with self._index_lock:
+            cached = self._message_index.get(normalized_id)
+        if cached is not None:
+            return cached[1]
+
+        for agent_name in self.list_agents():
+            for message in self.receive(agent_name):
+                with self._index_lock:
+                    self._message_index[message.id] = (agent_name, message)
+                    if len(self._message_index) > self._max_index_size:
+                        self._message_index.popitem(last=False)
+                if message.id == normalized_id:
+                    return message
+        return None
+
+    def _append(self, agent_name: str, msg: Message) -> None:
+        mailbox_path = self.ensure_mailbox(agent_name)
+        line = json.dumps(msg.to_dict(), ensure_ascii=False)
+        with self._lock_for(agent_name):
+            with mailbox_path.open("a", encoding="utf-8") as file:
+                file.write(line)
+                file.write("\n")
+        with self._index_lock:
+            self._message_index[msg.id] = (agent_name, msg)
+            if len(self._message_index) > self._max_index_size:
+                self._message_index.popitem(last=False)
+        cond = self._cond_for(agent_name)
+        with cond:
+            self._signal_counts[agent_name] = self._signal_counts.get(agent_name, 0) + 1
+            cond.notify_all()
+
+    def _cond_for(self, agent_name: str) -> threading.Condition:
+        with self._conds_guard:
+            cond = self._conds.get(agent_name)
+            if cond is None:
+                cond = threading.Condition()
+                self._conds[agent_name] = cond
+            return cond
+
+    def wait_for_message(self, agent_name: str, timeout: float) -> None:
+        """Block until a message is appended to *agent_name*'s mailbox or *timeout* elapses."""
+        cond = self._cond_for(agent_name)
+        with cond:
+            initial = self._signal_counts.get(agent_name, 0)
+            cond.wait_for(
+                lambda: self._signal_counts.get(agent_name, 0) != initial,
+                timeout=timeout,
+            )
+
+    def mark_delivered(self, message_id: str) -> None:
+        """Record that ``message_id`` was already delivered out of band.
+
+        Used by a blocking consumer (e.g. ``team_send`` waiting for a reply) so
+        the polling drain does not surface the same message a second time.
+        """
+        normalized_id = message_id.strip()
+        if not normalized_id:
+            return
+        with self._delivered_lock:
+            self._delivered.add(normalized_id)
+
+    def was_delivered(self, message_id: str) -> bool:
+        with self._delivered_lock:
+            return message_id.strip() in self._delivered
+
+    def _mailbox_path(self, agent_name: str) -> Path:
+        return self.mailbox_dir / f"{agent_name}.jsonl"
+
+    def _lock_for(self, agent_name: str) -> threading.Lock:
+        with self._locks_guard:
+            lock = self._locks.get(agent_name)
+            if lock is None:
+                lock = threading.Lock()
+                self._locks[agent_name] = lock
+            return lock
+
+    def _prepare_message(self, msg: Message) -> Message:
+        from_agent = _validate_agent_name(msg.from_agent)
+        to_agent = _validate_agent_name(msg.to_agent)
+        if not msg.msg_type.strip():
+            raise ValueError("msg_type must not be empty")
+
+        message_id = msg.id.strip() or _generate_message_id()
+        timestamp = msg.timestamp.strip() or utc_timestamp_iso()
+        return Message(
+            id=message_id,
+            from_agent=from_agent,
+            to_agent=to_agent,
+            content=msg.content,
+            msg_type=msg.msg_type.strip(),
+            timestamp=timestamp,
+            in_reply_to=optional_string(msg.in_reply_to),
+        )
+
+
+def _generate_message_id(length: int = 12) -> str:
+    return generate_random_id(length)

bareagent/team/manager.py

@@ -0,0 +1,155 @@
+from __future__ import annotations
+
+import json
+import threading
+from collections.abc import Callable
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import Any
+
+from bareagent.core.fileutil import atomic_write_json
+
+
+@dataclass(slots=True)
+class Teammate:
+    name: str
+    role: str
+    system_prompt: str
+    provider_config: dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass(slots=True)
+class AgentInstance:
+    name: str
+    role: str
+    system_prompt: str
+    provider: Any
+    provider_config: dict[str, Any] = field(default_factory=dict)
+
+
+class TeammateManager:
+    """Persist teammate definitions and spawn independent agent instances."""
+
+    def __init__(self, config_file: str | Path = ".team.json") -> None:
+        self.config_file = Path(config_file)
+        self.teammates: dict[str, Teammate] = {}
+        self._lock = threading.RLock()
+        self._load()
+
+    @classmethod
+    def create_empty(cls, config_file: str | Path) -> TeammateManager:
+        instance = cls.__new__(cls)
+        instance.config_file = Path(config_file)
+        instance.teammates = {}
+        instance._lock = threading.RLock()
+        return instance
+
+    def register(
+        self,
+        name: str,
+        role: str,
+        system_prompt: str,
+        provider_config: dict[str, Any] | None = None,
+    ) -> Teammate:
+        with self._lock:
+            normalized_name = name.strip()
+            normalized_role = role.strip()
+            normalized_prompt = system_prompt.strip()
+            if not normalized_name:
+                raise ValueError("name must not be empty")
+            if not normalized_role:
+                raise ValueError("role must not be empty")
+            if not normalized_prompt:
+                raise ValueError("system_prompt must not be empty")
+
+            teammate = Teammate(
+                name=normalized_name,
+                role=normalized_role,
+                system_prompt=normalized_prompt,
+                provider_config=dict(provider_config or {}),
+            )
+            self.teammates[normalized_name] = teammate
+            self._save()
+            return teammate
+
+    def get(self, name: str) -> Teammate:
+        with self._lock:
+            teammate = self.teammates.get(name.strip())
+            if teammate is None:
+                raise ValueError(f"Unknown teammate: {name}")
+            return teammate
+
+    def list(self) -> list[Teammate]:
+        with self._lock:
+            return sorted(self.teammates.values(), key=lambda teammate: teammate.name)
+
+    def spawn(
+        self,
+        name: str,
+        provider_factory: Callable[[dict[str, Any]], Any],
+    ) -> AgentInstance:
+        with self._lock:
+            teammate = self.get(name)
+            provider_config = dict(teammate.provider_config)
+            snapshot_name = teammate.name
+            snapshot_role = teammate.role
+            snapshot_prompt = teammate.system_prompt
+        provider = provider_factory(provider_config)
+        return AgentInstance(
+            name=snapshot_name,
+            role=snapshot_role,
+            system_prompt=snapshot_prompt,
+            provider=provider,
+            provider_config=provider_config,
+        )
+
+    def _save(self) -> None:
+        payload = {
+            "teammates": {teammate.name: teammate.to_dict() for teammate in self.list()}
+        }
+        atomic_write_json(self.config_file, payload)
+
+    def _load(self) -> None:
+        try:
+            with self.config_file.open("r", encoding="utf-8") as file:
+                payload = json.load(file)
+        except FileNotFoundError:
+            self.teammates = {}
+            return
+
+        if not isinstance(payload, dict):
+            raise ValueError("Team config must contain a JSON object")
+
+        raw_teammates = payload.get("teammates", {})
+        if not isinstance(raw_teammates, dict):
+            raise ValueError("Team config 'teammates' field must be an object")
+
+        loaded: dict[str, Teammate] = {}
+        for teammate_name, raw_teammate in raw_teammates.items():
+            if not isinstance(raw_teammate, dict):
+                raise ValueError(f"Invalid teammate payload for {teammate_name}")
+            provider_config = raw_teammate.get("provider_config") or {}
+            if not isinstance(provider_config, dict):
+                raise ValueError(
+                    f"Teammate provider_config must be an object: {teammate_name}"
+                )
+            teammate = Teammate(
+                name=str(raw_teammate.get("name", teammate_name)).strip(),
+                role=str(raw_teammate.get("role", "")).strip(),
+                system_prompt=str(raw_teammate.get("system_prompt", "")).strip(),
+                provider_config=dict(provider_config),
+            )
+            if not teammate.name:
+                raise ValueError(f"Teammate name must not be empty: {teammate_name}")
+            if not teammate.role:
+                raise ValueError(f"Teammate role must not be empty: {teammate_name}")
+            if not teammate.system_prompt:
+                raise ValueError(
+                    f"Teammate system_prompt must not be empty: {teammate_name}"
+                )
+            loaded[teammate.name] = teammate
+
+        self.teammates = loaded