agent-team 0.5.0__py3-none-any.whl

agent_team/__init__.py

@@ -0,0 +1,3 @@
+"""agent-team: a configurable team of AI agents that works on a project through GitHub."""
+
+__version__ = "0.5.0"

agent_team/agent.py

@@ -0,0 +1,109 @@
+"""A team member at runtime: its config, its provider, and an append-only conversation."""
+from __future__ import annotations
+
+from importlib import resources
+from pathlib import Path
+
+from . import budget, providers, ui, usage
+from .config import AgentConfig, Team
+
+
+def role_prompt(team: Team, agent: AgentConfig, name: str | None = None) -> str:
+    """The agent's prompt text: its own file if configured, else the packaged one for its role."""
+    if agent.prompt and name is None:
+        return (team.root / agent.prompt).read_text(encoding="utf-8")
+    fname = f"{name or agent.role}.md"
+    try:
+        return resources.files("agent_team.prompts").joinpath(fname).read_text(encoding="utf-8")
+    except FileNotFoundError:
+        return resources.files("agent_team.prompts").joinpath("member.md").read_text(encoding="utf-8")
+
+
+def team_roster(team: Team) -> str:
+    lines = []
+    for a in team.agents.values():
+        where = team.providers[a.provider]
+        place = f"remote node {where.url}" if where.kind == "agent-http" else f"{where.kind} model {a.model}"
+        desc = f" {a.description}" if a.description else ""
+        owns = f" Owns: {', '.join(a.owns)}." if a.owns else ""
+        skills = f" Skills: {', '.join(_skill_names(team, a))}." if a.skills else ""
+        lines.append(f"- {a.name} ({a.role}, {place}).{desc}{owns}{skills}")
+    return "\n".join(lines)
+
+
+class Agent:
+    def __init__(self, team: Team, cfg: AgentConfig, system: str, label_suffix: str = ""):
+        self.team, self.cfg, self.system = team, cfg, system
+        pcfg = team.providers[cfg.provider]
+        self.provider = providers.build(pcfg, team.secret(pcfg))
+        self.label = ui.label(cfg.name, cfg.role + label_suffix, cfg.color)
+        self.messages: list[dict] = []   # append-only, so provider-side reasoning stays valid
+
+    @property
+    def name(self) -> str:
+        return self.cfg.name
+
+    def turn(self, content) -> str:
+        if not self.provider.supports_images and not isinstance(content, str):
+            content = providers.base.to_text(content)
+        budget.check(self.team)
+        self.messages.append({"role": "user", "content": content})
+        reply = self.provider.complete(self.system, self.messages, model=self.cfg.model,
+                                       effort=self.cfg.effort, label=self.label)
+        self.messages.append({"role": "assistant", "content": reply.content})
+        # A remote node reports the model it really ran, so its member is priced correctly.
+        u = dict(reply.usage or {})
+        kind, model = u.pop("kind", "") or self.provider.kind, u.pop("model", "") or self.cfg.model
+        usage.record(self.team.root, self.cfg.name, kind, model, u)
+        return reply.text
+
+
+def _skill_names(team: Team, cfg: AgentConfig) -> list[str]:
+    from . import skills
+    names = []
+    for entry in cfg.skills:
+        try:
+            names.append(skills.load_one(team, entry).name)
+        except Exception:
+            names.append(entry)
+    return names
+
+
+def make(team: Team, cfg: AgentConfig, prompt_name: str | None = None, label_suffix: str = "",
+         **fields) -> Agent:
+    """Build an agent whose system prompt is its role prompt filled with team and project facts."""
+    template = role_prompt(team, cfg, prompt_name)
+    values = {
+        "name": cfg.name, "role": cfg.role, "project": team.project.name, "repo": team.project.repo,
+        "roster": team_roster(team), "owns": ", ".join(cfg.owns) or "nothing",
+        "guarantees": "\n".join(f"- {g}" for g in team.project.guarantees) or "- (none listed)",
+        "test_command": team.project.test_command or "(none configured)",
+        **fields,
+    }
+    system = _fill(template, values)
+    from . import memory
+    learned = memory.for_prompt(team.root)
+    if learned:
+        system = f"{system.rstrip()}\n\n{learned}"
+    if cfg.skills:
+        from . import skills
+        system = f"{system.rstrip()}\n\n{skills.render(skills.load(team, cfg))}"
+    return Agent(team, cfg, system, label_suffix)
+
+
+def _fill(template: str, values: dict) -> str:
+    """str.format that leaves unknown {placeholders} and literal braces alone."""
+    class Keep(dict):
+        def __missing__(self, key):
+            return "{" + key + "}"
+    try:
+        return template.format_map(Keep(values))
+    except (ValueError, IndexError):
+        out = template
+        for k, v in values.items():
+            out = out.replace("{" + k + "}", str(v))
+        return out
+
+
+def prompt_path(team: Team, agent: AgentConfig) -> Path | None:
+    return team.root / agent.prompt if agent.prompt else None

agent_team/budget.py

@@ -0,0 +1,56 @@
+"""Spend limits: stop a run before it costs more than `[limits]` allows.
+
+    [limits]
+    per_run = 5.0     # US dollars for one workflow run
+    per_day = 20.0    # US dollars per UTC day, across every run in this project
+
+Checked before every model call, from the estimates in `.team/usage.jsonl`. A call already in
+flight finishes, so a run can go over by at most one reply.
+"""
+from __future__ import annotations
+
+from . import usage
+from .config import Team
+
+
+class SpendLimitError(RuntimeError):
+    pass
+
+
+def spent(team: Team, run: str | None = None) -> dict:
+    """Estimated dollars spent in this run and today (UTC)."""
+    run = usage.current_run() if run is None else run
+    today = usage.now()[:10]
+    out = {"run": 0.0, "today": 0.0}
+    for e in usage.load(team.root):
+        cost = usage.price_for(e.get("model", ""), e.get("kind", ""), team.pricing).cost(e)
+        if run and e.get("run") == run:
+            out["run"] += cost
+        if (e.get("at") or "")[:10] == today:
+            out["today"] += cost
+    return {k: round(v, 4) for k, v in out.items()}
+
+
+def milestone_spent(team: Team, milestone: str) -> float:
+    return round(sum(usage.price_for(e.get("model", ""), e.get("kind", ""), team.pricing).cost(e)
+                     for e in usage.load(team.root) if e.get("milestone") == milestone), 4)
+
+
+def check(team: Team) -> None:
+    limits = team.limits
+    milestone = usage.current_milestone()
+    cap = limits.milestones.get(milestone) if milestone else None
+    if cap:
+        spent_m = milestone_spent(team, milestone)
+        if spent_m >= cap:
+            raise SpendLimitError(f"milestone {milestone} has spent an estimated ${spent_m:.2f}, reaching its "
+                                  f"[limits.milestones] budget of ${cap:.2f}")
+    if not (limits.per_run or limits.per_day):
+        return
+    s = spent(team)
+    if limits.per_run and s["run"] >= limits.per_run:
+        raise SpendLimitError(f"this run has spent an estimated ${s['run']:.2f}, reaching the "
+                              f"[limits].per_run limit of ${limits.per_run:.2f}")
+    if limits.per_day and s["today"] >= limits.per_day:
+        raise SpendLimitError(f"this project has spent an estimated ${s['today']:.2f} today (UTC), reaching "
+                              f"the [limits].per_day limit of ${limits.per_day:.2f}")