hyperagents 1.2.3rc5.post3__py3-none-any.whl

hyperclaw/team/model.py

@@ -0,0 +1,135 @@
+"""
+The model a specialist talks to.
+
+A ``ModelHandle`` gives the specialist loop one call shape (Anthropic
+Messages: system, messages, tools -> content blocks + stop_reason) whatever
+the provider is. Every call:
+
+- goes through a cost-guarded client (``cost_guard.guard_client``), so it is
+  reserved against the per-task and daily caps BEFORE it is made and settled
+  after; at a cap it raises ``CostCapReached`` and nothing is called;
+- sets an explicit max output (``max_tokens``; HC-037);
+- comes from a provider whose tool use is declared AND qualified (signed
+  record). Without one the specialist does not run (``NoToolModel``): the
+  failure is reported, never papered over with a chat-only model.
+"""
+from __future__ import annotations
+
+import json
+import uuid
+from dataclasses import dataclass
+from types import SimpleNamespace
+from typing import Any, Callable, List, Optional
+
+from hyperclaw.team.roster import Specialist
+
+MAX_OUTPUT_PATH = "specialist"   # cost_guard.DEFAULT_MAX_OUTPUT_PER_PATH (!33)
+
+
+class NoToolModel(RuntimeError):
+    """No provider with qualified tool use is configured for specialists."""
+
+    def __init__(self) -> None:
+        super().__init__("no model with qualified tool use is configured, so the specialist "
+                         "could not run")
+
+
+@dataclass
+class ModelHandle:
+    client: Any                 # cost-guarded, Anthropic Messages shape (.messages.create)
+    model: str
+    provider: str = ""
+
+    def create(self, *, system: str, messages: list, tools: list) -> Any:
+        from hyperclaw.cost_guard import max_output
+        extra = {"tools": tools} if tools else {}
+        return self.client.messages.create(
+            model=self.model, max_tokens=max_output(MAX_OUTPUT_PATH, self.provider, self.model),
+            system=system, messages=messages, **extra)
+
+
+# ───────────────────────── OpenAI-compatible providers ─────────────────────────
+
+class _OpenAIMessages:
+    """Anthropic-shaped .create() over a cost-guarded chat.completions client."""
+
+    def __init__(self, client, provider_name: str, base_url: str):
+        self._client = client
+        self._provider = provider_name
+        self._base = base_url
+
+    def create(self, *, model: str, max_tokens: int, system: str, messages: list,
+               tools: Optional[list] = None):
+        from hyperclaw.truth_guard import history_to_openai
+        from hyperclaw.xai import clean_request
+        oai = [{"role": "system", "content": system}] + history_to_openai(messages,
+                                                                          native_tools=True)
+        kw = dict(model=model, messages=oai, max_tokens=int(max_tokens), stream=False)
+        if tools:
+            kw["tools"] = [{"type": "function", "function": {
+                "name": t["name"], "description": t.get("description", ""),
+                "parameters": t.get("input_schema", {})}} for t in tools]
+            kw["tool_choice"] = "auto"
+        kw = clean_request(self._provider, self._base, model, kw)
+        res = self._client.chat.completions.create(**kw)
+        ch = (getattr(res, "choices", None) or [None])[0]
+        msg = getattr(ch, "message", None)
+        blocks: List[Any] = []
+        text = getattr(msg, "content", None) or ""
+        if text:
+            blocks.append(SimpleNamespace(type="text", text=text))
+        for tc in getattr(msg, "tool_calls", None) or []:
+            fn = getattr(tc, "function", None)
+            raw = getattr(fn, "arguments", "") or "{}"
+            try:
+                args = json.loads(raw)
+            except ValueError:
+                args = raw          # the registry answers invalid_args, never {}
+            blocks.append(SimpleNamespace(type="tool_use", id=getattr(tc, "id", "") or
+                                          f"call_{uuid.uuid4().hex[:12]}",
+                                          name=getattr(fn, "name", ""), input=args))
+        fr = getattr(ch, "finish_reason", None)
+        stop = {"tool_calls": "tool_use", "length": "max_tokens"}.get(fr, "end_turn")
+        return SimpleNamespace(content=blocks, stop_reason=stop)
+
+
+class _OpenAIShim:
+    def __init__(self, client, provider_name: str, base_url: str):
+        self.messages = _OpenAIMessages(client, provider_name, base_url)
+
+
+# ───────────────────────── resolution ─────────────────────────
+
+def _candidates(spec: Specialist) -> list:
+    from hyperclaw.providers import registry
+    reg = registry()
+    out = []
+    for slot in (spec.tier, "tools", "primary"):
+        for c in reg.resolve(slot, {"chat", "tool_use"}):
+            if c not in out:
+                out.append(c)
+    return out
+
+
+def default_handle(spec: Specialist) -> ModelHandle:
+    """A cost-guarded handle on a qualified tool-use model, preferring the
+    specialist's tier. Raises NoToolModel when none is configured."""
+    from hyperclaw.cost_guard import guard_client
+    cands = _candidates(spec)
+    if not cands:
+        raise NoToolModel()
+    prov, model = cands[0]
+    if prov.kind == "anthropic":
+        import anthropic
+        client = guard_client(anthropic.Anthropic(api_key=prov.api_key,
+                                                  base_url=prov.base_url or None,
+                                                  timeout=60.0, max_retries=0), prov.name)
+        return ModelHandle(client, model, prov.name)
+    import openai
+    raw = guard_client(openai.OpenAI(api_key=prov.api_key or "unused",
+                                     base_url=prov.base_url or None, timeout=60.0,
+                                     max_retries=0), prov.name)
+    return ModelHandle(_OpenAIShim(raw, prov.name, prov.base_url or ""), model, prov.name)
+
+
+HandleFactory = Callable[[Specialist], ModelHandle]

hyperclaw/team/morning.py

@@ -0,0 +1,238 @@
+"""
+The morning brief's "your day" sections (HC-038), at each person's chosen
+time (``brief.time``), extending the existing daily brief: the same
+scheduled job (one background service) and the same Telegram delivery (one
+Telegram connection, link previews off).
+
+Four sections, each from whichever connector is present:
+
+    Today's calendar        CalendarSource
+    Email that needs you    MailSource
+    Slack mentions and DMs  SlackSource
+    MRs waiting on you      ReposSource
+
+A missing connector is skipped honestly ("not connected"), a failed read is
+named ("could not read ..."), and an empty one says "nothing". Nothing is
+written by a model here: every line is taken from what the source returned,
+so the brief never claims anything that is not on this install.
+
+Integration points (marked ``INTEGRATION``): the Gmail / Calendar / Slack
+readers may be replaced by the connector lane's readers; each source is a
+small class with ``connected()`` and ``read(now)``, and tests use fakes.
+Everything read is connector content (``hyperclaw.taint``): it is delivered
+to the owner and never saved to memory, learning or training data.
+"""
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
+from typing import List, Optional, Sequence
+
+log = logging.getLogger("hyperclaw.team.morning")
+
+MAX_LINES = 8
+LINE_CHARS = 140
+
+
+class SourceUnavailable(Exception):
+    """A connected source that could not be read (the reason is shown)."""
+
+
+@dataclass
+class Section:
+    title: str
+    lines: List[str]
+    state: str = "ok"          # ok | not_connected | failed
+
+    def render(self) -> str:
+        if self.state == "not_connected":
+            return f"{self.title}: not connected."
+        if self.state == "failed":
+            return f"{self.title}: could not read it ({self.lines[0] if self.lines else 'error'})."
+        if not self.lines:
+            return f"{self.title}: nothing."
+        shown = self.lines[:MAX_LINES]
+        more = len(self.lines) - len(shown)
+        body = "\n".join(f"- {_clip(l)}" for l in shown)
+        return f"{self.title}:\n{body}" + (f"\n- and {more} more" if more > 0 else "")
+
+
+def _clip(s: str) -> str:
+    """One line, no web addresses (link previews and taps stay off)."""
+    from hyperclaw.team.watchers import _SPACE, _URL
+    t = _SPACE.sub(" ", _URL.sub("[link removed]", str(s or ""))).strip()
+    return t if len(t) <= LINE_CHARS else t[:LINE_CHARS - 1].rstrip() + "…"
+
+
+class Source:
+    title = ""
+
+    def connected(self) -> bool:
+        raise NotImplementedError
+
+    def read(self, now: datetime) -> List[str]:
+        raise NotImplementedError
+
+
+# ───────────────────────── default sources ─────────────────────────
+
+def _google_connected() -> bool:
+    try:
+        from hyperclaw.api_utils import gmail_configured
+        return gmail_configured()
+    except Exception:
+        return False
+
+
+class CalendarSource(Source):
+    """INTEGRATION: Google Calendar via integrations_layer (the connector
+    lane's reader replaces ``_events``)."""
+    title = "Today's calendar"
+
+    def connected(self) -> bool:
+        return _google_connected()
+
+    def _events(self) -> list:
+        from hyperclaw import integrations_layer as il
+        return il.calendar_get_events(days_ahead=1)
+
+    def read(self, now: datetime) -> List[str]:
+        events = self._events()
+        if events and isinstance(events[0], dict) and events[0].get("error"):
+            raise SourceUnavailable("Google Calendar refused the request")
+        day = now.date().isoformat()
+        out = []
+        for e in events:
+            start = str(e.get("start") or "")
+            if start[:10] != day:
+                continue
+            when = start[11:16] if len(start) > 10 else "all day"
+            out.append(f"{when} {e.get('summary') or 'Untitled'}")
+        return out
+
+
+class MailSource(Source):
+    """INTEGRATION: Gmail via integrations_layer: unread mail in the inbox
+    from the last day that Gmail marks important."""
+    title = "Email that needs you"
+    QUERY = "in:inbox is:unread is:important newer_than:1d"
+
+    def connected(self) -> bool:
+        return _google_connected()
+
+    def _search(self) -> list:
+        from hyperclaw import integrations_layer as il
+        return il.gmail_search(self.QUERY, max_results=15)
+
+    def read(self, now: datetime) -> List[str]:
+        mails = self._search()
+        if mails and isinstance(mails[0], dict) and mails[0].get("error"):
+            raise SourceUnavailable("Gmail refused the request")
+        return [f"{m.get('from') or 'someone'}: {m.get('subject') or '(no subject)'}"
+                for m in mails if isinstance(m, dict) and not m.get("is_sent")]
+
+
+class SlackSource(Source):
+    """INTEGRATION: the connected digest's read-only Slack collector (the
+    owner's user token): mentions and DMs since yesterday morning."""
+    title = "Slack mentions and DMs"
+
+    def connected(self) -> bool:
+        try:
+            from hyperclaw.digest import state
+            return "slack" in state.connections()
+        except Exception:
+            return False
+
+    def _collect(self, since: datetime):
+        from hyperclaw.digest import service, state
+        meta = state.connections().get("slack") or {}
+        token = service._read_token("slack", meta)
+        if not token:
+            raise SourceUnavailable("the Slack token is missing")
+        col = service.make_collector("slack", token)
+        try:
+            col.verify()
+            return col.collect(since)
+        finally:
+            col.close()
+
+    def read(self, now: datetime) -> List[str]:
+        from hyperclaw.digest.errors import DigestError
+        try:
+            res = self._collect(now - timedelta(hours=24))
+        except DigestError as e:
+            raise SourceUnavailable(e.text)
+        if not res.ok:
+            raise SourceUnavailable("Slack could not be read")
+        out = []
+        for i in res.items:
+            if not isinstance(i, dict):
+                continue
+            where = "DM" if i.get("kind") in ("dm", "group_dm") else i.get("where") or "Slack"
+            out.append(f"{i.get('from') or 'someone'} ({where}): {i.get('text') or ''}")
+        return out
+
+
+class ReposSource(Source):
+    title = "MRs waiting on you"
+
+    def connected(self) -> bool:
+        try:
+            from hyperclaw.digest import state
+            return "gitlab" in state.connections()
+        except Exception:
+            return False
+
+    def read(self, now: datetime) -> List[str]:
+        from hyperclaw.team import repos
+        items, problem = repos.waiting(now)
+        if problem:
+            raise SourceUnavailable(problem.rstrip("."))
+        out = []
+        for i in items:
+            if i.get("kind") == "todo":
+                out.append(f"to-do: {i.get('action') or ''} {i.get('title') or ''}".strip())
+            else:
+                role = "review" if i.get("kind") == "mr_reviewing" else "assigned"
+                out.append(f"{i.get('ref') or ''} {i.get('title') or ''} ({role})")
+        return out
+
+
+def default_sources() -> List[Source]:
+    return [CalendarSource(), MailSource(), SlackSource(), ReposSource()]
+
+
+# ───────────────────────── compose ─────────────────────────
+
+def sections(now: Optional[datetime] = None,
+             sources: Optional[Sequence[Source]] = None) -> List[Section]:
+    now = now or datetime.now(timezone.utc)
+    out = []
+    for src in (default_sources() if sources is None else sources):
+        try:
+            if not src.connected():
+                out.append(Section(src.title, [], "not_connected"))
+                continue
+            out.append(Section(src.title, list(src.read(now))))
+        except SourceUnavailable as e:
+            out.append(Section(src.title, [str(e)], "failed"))
+        except Exception as e:
+            log.warning("morning: %s not read (%s)", src.title, type(e).__name__, exc_info=True)
+            out.append(Section(src.title, ["an internal error"], "failed"))
+    return out
+
+
+def render(now: Optional[datetime] = None,
+           sources: Optional[Sequence[Source]] = None) -> str:
+    return "\n\n".join(s.render() for s in sections(now, sources))
+
+
+def enabled() -> bool:
+    """On unless the person turned it off (config brief.morning = false)."""
+    try:
+        from hyperclaw.brief import store
+        return store.config().get("morning", True) is not False
+    except Exception:
+        return True

hyperclaw/team/repos.py

@@ -0,0 +1,66 @@
+"""
+Merge requests and to-dos waiting on the person (the Repos specialist's one
+tool, and the morning brief's "MRs waiting on you" section).
+
+Read-only, through the connected digest's GitLab connection (read-only token,
+verified scopes; ``hyperclaw.digest.gitlab``). Everything returned is GitLab
+content: marked as connector content (``hyperclaw.taint``).
+"""
+from __future__ import annotations
+
+import json
+from datetime import datetime, timedelta, timezone
+from typing import Callable, Optional
+
+NOT_CONNECTED = "GitLab is not connected (hyperclaw digest connect gitlab)."
+WINDOW = timedelta(days=14)
+
+
+def _collect(now: datetime, *, collector_factory: Optional[Callable] = None):
+    from hyperclaw.digest import service, state
+    from hyperclaw.digest.errors import DigestError
+    meta = state.connections().get("gitlab")
+    if not meta:
+        return None, NOT_CONNECTED
+    col = None
+    try:
+        if collector_factory is not None:
+            col = collector_factory()
+        else:
+            token = service._read_token("gitlab", meta)
+            if not token:
+                return None, NOT_CONNECTED
+            col = service.make_collector("gitlab", token, gitlab_url=meta.get("url", ""))
+        col.verify()
+        return col.collect(now - WINDOW), ""
+    except DigestError as e:
+        return None, f"Could not read GitLab: {e.text}"
+    finally:
+        if col is not None:
+            try:
+                col.close()
+            except Exception:
+                pass
+
+
+def waiting(now: Optional[datetime] = None, *, collector_factory: Optional[Callable] = None):
+    """(items, problem). items: MRs assigned to / awaiting review from the
+    person, and their pending to-dos. problem: '' or why nothing was read."""
+    now = now or datetime.now(timezone.utc)
+    res, problem = _collect(now, collector_factory=collector_factory)
+    if res is None:
+        return [], problem
+    if not res.ok:
+        return [], "Could not read GitLab."
+    keep = ("mr_assigned", "mr_reviewing", "todo")
+    return [i for i in res.items if isinstance(i, dict) and i.get("kind") in keep], ""
+
+
+def tool_review_queue(args: dict) -> str:
+    """The gitlab_review_queue tool: JSON list, or a not-connected / failure line."""
+    items, problem = waiting()
+    if problem:
+        return problem
+    out = [{k: i.get(k) for k in ("kind", "ref", "title", "author", "from", "action", "updated",
+                                   "when", "link") if i.get(k)} for i in items]
+    return json.dumps({"waiting_on_you": out, "count": len(out)})