@agentikos/omega-os 0.1.0 → 0.19.5

package/omega/Agentik_Engine/omega_engine/prompts.py

@@ -0,0 +1,158 @@
+"""Agent prompt loader — the bridge between SSOT and the provider.
+
+Every role in the engine (oracle, worker, architect, keymaker, …) has a
+fully-written system prompt living in ``Agentik_SSOT/agents/<suite>/<role>.md``.
+This module locates the file, strips any YAML frontmatter, and returns the
+prompt text for the provider to inject as the ``system`` message.
+
+The AISB suite — 13 named agents + the LMC protocol + per-agent checkers —
+is shipped by the installer from ``bootstrap/templates/aisb/``. New suites
+drop into ``Agentik_SSOT/agents/<name>/`` and are picked up by id.
+
+Resolution order for a role:
+  1. ``Agentik_SSOT/agents/aisb/<role>.md``  (the AISB suite)
+  2. ``Agentik_SSOT/agents/<any-suite>/<role>.md`` (any other suite)
+  3. None — the provider falls back to a minimal generic envelope.
+
+The LMC protocol + shared protocols are concatenated into every agent's
+system prompt so they always know the contract.
+"""
+from __future__ import annotations
+
+import re
+from functools import lru_cache
+from pathlib import Path
+
+
+_FRONTMATTER_RE = re.compile(r"^---\s*\n.*?\n---\s*\n", re.DOTALL)
+
+
+def _strip_frontmatter(text: str) -> str:
+    """Drop the leading YAML frontmatter block if present."""
+    match = _FRONTMATTER_RE.match(text)
+    return text[match.end():] if match else text
+
+
+def _agents_root(omega_home: Path) -> Path:
+    return Path(omega_home) / "Agentik_SSOT" / "agents"
+
+
+# Topology-name → AISB-suite-name aliases.
+# The orchestration topology YAMLs use generic role names (`aisb`, `oracle`,
+# `manager`, `worker`, `audit`) but the AISB suite ships its own canonical
+# names (`niobe`, `oracle`, `keymaker`, `construct`, `seraph`). Without
+# this map, ``load_agent_prompt("worker")`` returns None and the worker
+# spawns with the engine's generic fallback envelope — losing the rich
+# identity Gareth's home system relies on.
+#
+# Direction is topology → suite. Add entries here when a topology introduces
+# a new role name that maps to an existing suite agent.
+_ROLE_ALIASES: dict[str, str] = {
+    "aisb":     "niobe",       # the matriarch / root scope
+    "manager":  "keymaker",    # the planner
+    "worker":   "construct",   # the executor
+    "audit":    "seraph",      # the verifier
+    "verifier": "seraph",      # synonym used by some topologies
+    "link":     "link",        # already canonical
+}
+
+
+@lru_cache(maxsize=64)
+def _read_agent_file(path: str) -> str | None:
+    p = Path(path)
+    if not p.exists():
+        return None
+    try:
+        return _strip_frontmatter(p.read_text()).strip()
+    except OSError:
+        return None
+
+
+def find_agent_file(omega_home: str | Path, role: str) -> Path | None:
+    """Return the on-disk path for a role's agent prompt, or None.
+
+    Resolution order:
+      1. Direct match on the role name in the AISB suite.
+      2. Alias-mapped name (e.g. ``worker`` → ``construct``).
+      3. Direct match in any other suite.
+      4. Alias-mapped match in any other suite.
+    """
+    root = _agents_root(Path(omega_home))
+    if not root.is_dir():
+        return None
+
+    candidates_for_role: list[str] = [role]
+    aliased = _ROLE_ALIASES.get(role)
+    if aliased and aliased != role:
+        candidates_for_role.append(aliased)
+
+    # 1+2. AISB suite first (the master), with alias fallback.
+    aisb_dir = root / "aisb"
+    if aisb_dir.is_dir():
+        for cand in candidates_for_role:
+            p = aisb_dir / f"{cand}.md"
+            if p.exists():
+                return p
+
+    # 3+4. Any other suite that names a file after the role (or its alias).
+    for suite in sorted(root.iterdir()):
+        if not suite.is_dir() or suite.name == "aisb":
+            continue
+        for cand in candidates_for_role:
+            p = suite / f"{cand}.md"
+            if p.exists():
+                return p
+    return None
+
+
+def load_agent_prompt(omega_home: str | Path, role: str) -> str | None:
+    """Return the agent's full system prompt, or None if not shipped.
+
+    Includes the LMC + shared protocols when found, so every loaded agent
+    knows the contract without us repeating it in every file.
+    """
+    path = find_agent_file(omega_home, role)
+    if path is None:
+        return None
+    text = _read_agent_file(str(path))
+    if text is None:
+        return None
+
+    # Append any protocol files that live next to the agent.
+    suite_dir = path.parent
+    extras: list[str] = []
+    for proto in ("lmc-protocol.md",):
+        proto_path = suite_dir / proto
+        body = _read_agent_file(str(proto_path))
+        if body:
+            extras.append(f"\n\n--- PROTOCOL: {proto} ---\n\n{body}")
+    shared = suite_dir / "protocols" / "shared-protocol.md"
+    body = _read_agent_file(str(shared))
+    if body:
+        extras.append(f"\n\n--- SHARED PROTOCOL ---\n\n{body}")
+    return text + "".join(extras)
+
+
+def list_available_agents(omega_home: str | Path) -> dict[str, list[str]]:
+    """Return ``{suite: [roles]}`` for every agent file shipped under
+    Agentik_SSOT/agents/."""
+    root = _agents_root(Path(omega_home))
+    out: dict[str, list[str]] = {}
+    if not root.is_dir():
+        return out
+    for suite in sorted(root.iterdir()):
+        if not suite.is_dir():
+            continue
+        roles = sorted(
+            p.stem for p in suite.glob("*.md")
+            if not p.stem.startswith(("checker-", "lmc-", "handoff-",
+                                       "shared-", "CLAUDE"))
+        )
+        if roles:
+            out[suite.name] = roles
+    return out
+
+
+def clear_cache() -> None:
+    """Drop the prompt-file cache. Useful in tests and after re-installs."""
+    _read_agent_file.cache_clear()

package/omega/Agentik_Engine/omega_engine/provider.py

@@ -1,12 +1,20 @@
 """The provider abstraction — one contract, any LLM.
 
 The executor talks only to `AgentProvider`. `MockProvider` makes the whole
-orchestration testable with no network. `ClaudeProvider` is the real adapter.
+orchestration testable with no network. `ClaudeProvider` wraps Anthropic;
+`GLMProvider`, `OpenAIProvider`, and `DeepSeekProvider` wrap the OpenAI
+chat-completions wire format used by Zhipu/BigModel, OpenAI, and DeepSeek.
+
+The real adapters use the stdlib only (`urllib.request`, `json`). They never
+fail at construction — a missing API key only raises when `.run()` is called.
 """
 from __future__ import annotations
 
 import json
+import os
 import re
+import urllib.error
+import urllib.request
 from dataclasses import dataclass, field
 from typing import Any, Protocol, runtime_checkable
 
@@ -14,8 +22,10 @@ from typing import Any, Protocol, runtime_checkable
 @dataclass
 class AgentRequest:
     role: str                                   # "aisb" | "oracle" | "worker" | ...
-    prompt: str
+    prompt: str                                 # the user-facing message
     context: dict[str, Any] = field(default_factory=dict)
+    system: str | None = None                   # the role-aware system prompt
+                                                # (built by omega_engine.envelope)
 
 
 @dataclass
@@ -36,6 +46,144 @@ class AgentProvider(Protocol):
     def run(self, req: AgentRequest) -> AgentResult: ...
 
 
+class ClaudeMaxProvider:
+    """The Claude Code Max subprocess provider — uses the operator's OAuth,
+    NOT an API key.
+
+    Spawns ``claude -p "<prompt>" --output-format json --model <model>`` and
+    parses the structured response. Authentication is whatever the
+    operator did via ``claude /login`` — no ANTHROPIC_API_KEY needed.
+    Token usage AND a real ``total_cost_usd`` are returned directly by
+    the Claude Code CLI (calculated against Max account billing).
+
+    System prompts go via ``--append-system-prompt`` so the envelope's
+    rich role-aware prompt still drives the agent.
+
+    Sessions: when ``session_id`` is set on the request context, we use
+    ``--resume <session-id>`` so multi-turn conversations work. The CLI's
+    own session-id is returned in the result and propagated back as
+    ``result.artifacts["session_id"]``.
+
+    Use this on any machine where ``claude`` CLI is installed and the
+    operator is logged in (verified via ``claude --version``).
+    """
+
+    id = "claude-max"
+
+    def __init__(
+        self,
+        model: str = "sonnet",
+        timeout_s: int = 600,
+        bin_path: str = "claude",
+    ) -> None:
+        self._model = model
+        self._timeout_s = timeout_s
+        self._bin = bin_path
+
+    def _model_for(self, role: str) -> str:
+        """Resolve the model for a role — explicit > role default > self."""
+        # Allow the request itself to override via context.model
+        try:
+            from omega_engine.worker import default_model_for_role
+            role_model = default_model_for_role(role)
+        except ImportError:
+            role_model = self._model
+        return role_model
+
+    @staticmethod
+    def is_available(bin_path: str = "claude") -> bool:
+        """True iff `claude` CLI is on PATH and answers --version."""
+        import shutil
+        if shutil.which(bin_path) is None:
+            return False
+        try:
+            import subprocess
+            proc = subprocess.run(
+                [bin_path, "--version"],
+                check=False, capture_output=True, text=True, timeout=15,
+            )
+            return proc.returncode == 0
+        except (OSError, subprocess.SubprocessError):
+            return False
+
+    def run(self, req: AgentRequest) -> AgentResult:
+        import subprocess
+        # Per-request model: explicit context.model > role default > self default
+        model = (req.context or {}).get("model") or self._model_for(req.role)
+        cmd = [
+            self._bin, "-p", req.prompt,
+            "--output-format", "json",
+            "--model", model,
+            # bypass tool-permission dialogs in headless mode — operator
+            # already set the default permission mode via settings.json
+            "--dangerously-skip-permissions",
+        ]
+        # The envelope's `system` becomes an --append-system-prompt so the
+        # default Claude Code system prompt + our role-specific identity +
+        # contract all merge.
+        if req.system:
+            cmd += ["--append-system-prompt", req.system]
+        # If the caller passes a session_id in the context, resume that
+        # session — turns the provider into a stateful conversation.
+        sid = (req.context or {}).get("session_id")
+        if sid:
+            cmd += ["--resume", str(sid)]
+
+        try:
+            proc = subprocess.run(
+                cmd, check=False, capture_output=True, text=True,
+                timeout=self._timeout_s,
+            )
+        except subprocess.TimeoutExpired:
+            raise RuntimeError(
+                f"claude -p timed out after {self._timeout_s}s"
+            )
+        if proc.returncode != 0:
+            raise RuntimeError(
+                f"claude -p exit {proc.returncode}: "
+                f"{(proc.stderr or proc.stdout or '').strip()[:500]}"
+            )
+
+        raw_text = (proc.stdout or "").strip()
+        try:
+            data = json.loads(raw_text)
+        except json.JSONDecodeError:
+            raise RuntimeError(
+                f"claude -p returned non-JSON: {raw_text[:200]}"
+            )
+
+        text = str(data.get("result", ""))
+        usage_in = data.get("usage", {}) or {}
+        artifacts: dict[str, Any] = {
+            "session_id": data.get("session_id", ""),
+            "stop_reason": data.get("stop_reason", ""),
+            "num_turns": int(data.get("num_turns", 0) or 0),
+            "duration_ms": int(data.get("duration_ms", 0) or 0),
+            "total_cost_usd": float(data.get("total_cost_usd", 0.0) or 0.0),
+        }
+        # Dispatcher roles still need to surface a plan when they
+        # produced one. Try a JSON parse of the text body.
+        plan = (
+            _extract_plan(text)
+            if req.role in ("aisb", "oracle", "manager") else []
+        )
+        return AgentResult(
+            text=text, claimed_done=True, plan=plan, artifacts=artifacts,
+            usage={
+                "input_tokens": int(usage_in.get("input_tokens", 0) or 0),
+                "output_tokens": int(usage_in.get("output_tokens", 0) or 0),
+                "cache_read_input_tokens": int(
+                    usage_in.get("cache_read_input_tokens", 0) or 0
+                ),
+                "cache_creation_input_tokens": int(
+                    usage_in.get("cache_creation_input_tokens", 0) or 0
+                ),
+                # Real Max cost — calculated by Claude Code itself.
+                "cost_usd": float(data.get("total_cost_usd", 0.0) or 0.0),
+            },
+        )
+
+
 class MockProvider:
     """Deterministic provider — makes the executor fully testable with no API.
 
@@ -47,6 +195,8 @@ class MockProvider:
 
     def __init__(self, plan_size: int = 2) -> None:
         self._plan_size = plan_size
+        self._grader_calls = 0
+        self._agent_calls = 0
 
     def run(self, req: AgentRequest) -> AgentResult:
         role = req.role
@@ -75,6 +225,67 @@ class MockProvider:
                     "summary": "mock forensic audit — no falsifiable claims found",
                     "findings": [], "fix_plan": [],
                 }})
+        if role == "educator" or role.startswith("educator-"):
+            # a structured generation result — what the Educators expect.
+            # The mock returns a plausible artifact + self-critique score so the
+            # promotion pipeline has something real to gate on.
+            intent = req.context.get("intent", "generate")
+            kind = req.context.get("kind", "artifact")
+            educator = role.split("-", 1)[1] if "-" in role else "educator"
+            return AgentResult(
+                text=f"educator {educator} produced {kind} for: {intent}",
+                claimed_done=True,
+                artifacts={"proposal": {
+                    "kind": kind,
+                    "content": (
+                        f"# {kind} for {intent}\n\n"
+                        f"Generated by mock {educator} educator.\n"
+                    ),
+                    "score": 92,
+                    "summary": f"mock {educator} artifact for '{intent}'",
+                    "fix_plan": [],
+                }})
+
+        # --- RAG roles ---
+        if role == "rag-route":
+            # Default to hybrid (matches the architecture's "hybrid is the
+            # default" guidance). The router still applies its own heuristic
+            # for query-specific overrides.
+            return AgentResult(
+                text="route: hybrid", claimed_done=True,
+                artifacts={"strategy": "hybrid"},
+            )
+        if role == "rag-agent":
+            self._agent_calls += 1
+            # Terminate after one refinement hop — bounded behaviour, no loops.
+            original = req.context.get("original_query") or req.context.get(
+                "current_query", "")
+            done = self._agent_calls >= 2
+            return AgentResult(
+                text="agent step", claimed_done=True,
+                artifacts={
+                    "next_query": f"deeper: {original}",
+                    "done": done,
+                },
+            )
+        if role == "rag-grader":
+            self._grader_calls += 1
+            docs = req.context.get("documents", []) or []
+            # First call: every doc scores 40 (forces a Corrective retry).
+            # Second+ call: every doc scores 90 (lands above the threshold).
+            score = 40 if self._grader_calls == 1 else 90
+            return AgentResult(
+                text=f"graded {len(docs)} docs at {score}",
+                claimed_done=True,
+                artifacts={"scores": [score for _ in docs] or [score]},
+            )
+        if role == "rag-caption":
+            path = req.context.get("path", "")
+            return AgentResult(
+                text="captioned", claimed_done=True,
+                artifacts={"caption": f"mock caption for {path}"},
+            )
+
         return AgentResult(text="ok", claimed_done=True)
 
 
@@ -102,17 +313,26 @@ class ClaudeProvider:
             ) from exc
 
         client = anthropic.Anthropic(api_key=self._api_key)  # reads env if None
-        prompt = req.prompt
-        if req.role in ("oracle", "manager", "aisb"):
-            prompt += (
-                "\n\nRespond with a JSON array of subtasks, each "
-                '{"role":"worker","spec":{"task":"..."}}. JSON only.'
-            )
-        msg = client.messages.create(
-            model=self._model,
-            max_tokens=4096,
-            messages=[{"role": "user", "content": prompt}],
-        )
+        # Envelope path: when the executor passes an explicit `system`, use it
+        # verbatim and send the user prompt as-is. Otherwise fall back to the
+        # legacy single-message form so old callers keep working.
+        kwargs: dict[str, Any] = {
+            "model": self._model,
+            "max_tokens": 4096,
+            "messages": [{"role": "user", "content": req.prompt}],
+        }
+        if req.system:
+            kwargs["system"] = req.system
+        elif req.role in ("oracle", "manager", "aisb"):
+            # Legacy minimal dispatcher hint, only when no envelope was built.
+            kwargs["messages"] = [{
+                "role": "user",
+                "content": req.prompt + (
+                    "\n\nRespond with a JSON array of subtasks, each "
+                    '{"role":"worker","spec":{"task":"..."}}. JSON only.'
+                ),
+            }]
+        msg = client.messages.create(**kwargs)
         text = "".join(
             b.text for b in msg.content if getattr(b, "type", "") == "text"
         )
@@ -127,6 +347,181 @@ class ClaudeProvider:
         )
 
 
+# ---------------------------------------------------------------------------
+# OpenAI-compatible providers: GLM (BigModel/Zhipu), OpenAI, DeepSeek.
+#
+# All three speak the same chat-completions wire format. We share one tiny
+# stdlib HTTP transport (`_post_json`) and one response parser, then expose
+# three small adapter classes — each with its own id, default model, env key,
+# and base URL.
+# ---------------------------------------------------------------------------
+
+_DEFAULT_TIMEOUT = 120.0
+
+
+def _post_json(url: str, headers: dict[str, str], body: dict[str, Any],
+               timeout: float = _DEFAULT_TIMEOUT) -> dict[str, Any]:
+    """POST JSON, return parsed JSON. Raises RuntimeError on protocol errors.
+
+    Stdlib-only (`urllib.request`) so the providers stay dependency-free.
+    """
+    data = json.dumps(body).encode("utf-8")
+    headers = {"Content-Type": "application/json", **headers}
+    req = urllib.request.Request(url, data=data, headers=headers, method="POST")
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            raw = resp.read().decode("utf-8")
+    except urllib.error.HTTPError as exc:
+        detail = exc.read().decode("utf-8", errors="replace") if exc.fp else ""
+        raise RuntimeError(
+            f"HTTP {exc.code} from {url}: {detail[:500]}"
+        ) from exc
+    except urllib.error.URLError as exc:
+        raise RuntimeError(f"network error talking to {url}: {exc.reason}") from exc
+    try:
+        return json.loads(raw)
+    except json.JSONDecodeError as exc:
+        raise RuntimeError(
+            f"non-JSON response from {url}: {raw[:500]}"
+        ) from exc
+
+
+def _parse_openai_chat_response(payload: dict[str, Any]) -> tuple[str, dict[str, int]]:
+    """Pull text + usage from an OpenAI-format chat completion response.
+
+    Returns ("", {}) if the structure is unexpected, rather than crashing.
+    """
+    text = ""
+    choices = payload.get("choices") or []
+    if choices and isinstance(choices, list):
+        first = choices[0] or {}
+        msg = first.get("message") or {}
+        content = msg.get("content")
+        if isinstance(content, str):
+            text = content
+        elif isinstance(content, list):
+            # GLM/anthropic-style content blocks: list of {"type": "text", "text": "..."}
+            parts: list[str] = []
+            for block in content:
+                if isinstance(block, dict):
+                    val = block.get("text") or block.get("content") or ""
+                    if isinstance(val, str):
+                        parts.append(val)
+            text = "".join(parts)
+    usage_raw = payload.get("usage") or {}
+    usage = {
+        "input_tokens": int(usage_raw.get("prompt_tokens", 0) or 0),
+        "output_tokens": int(usage_raw.get("completion_tokens", 0) or 0),
+    }
+    return text, usage
+
+
+class _OpenAICompatProvider:
+    """Shared transport for OpenAI-format chat completion APIs.
+
+    Subclasses set `id`, `_default_model`, `_env_var`, `_default_base_url`.
+    Construction never fails on missing key — `.run()` raises if it's still
+    missing when called.
+    """
+
+    id: str = "openai-compat"
+    _default_model: str = ""
+    _env_var: str = ""
+    _default_base_url: str = ""
+
+    def __init__(
+        self,
+        model: str | None = None,
+        api_key: str | None = None,
+        base_url: str | None = None,
+    ) -> None:
+        self._model = model or self._default_model
+        self._api_key = api_key
+        self._base_url = base_url or self._default_base_url
+
+    def _resolve_key(self) -> str:
+        key = self._api_key or os.environ.get(self._env_var)
+        if not key:
+            raise RuntimeError(
+                f"{type(self).__name__} requires an API key. "
+                f"Pass api_key=... or set {self._env_var} in the environment."
+            )
+        return key
+
+    def _build_messages(self, req: AgentRequest) -> list[dict[str, str]]:
+        prompt = req.prompt
+        if req.role in ("oracle", "manager", "aisb"):
+            prompt = prompt + (
+                "\n\nRespond with a JSON array of subtasks, each "
+                '{"role":"worker","spec":{"task":"..."}}. JSON only.'
+            )
+        return [{"role": "user", "content": prompt}]
+
+    def _extra_body(self) -> dict[str, Any]:
+        """Adapter-specific knobs (overridable). Default: no extras."""
+        return {}
+
+    def run(self, req: AgentRequest) -> AgentResult:
+        api_key = self._resolve_key()
+        body: dict[str, Any] = {
+            "model": self._model,
+            "messages": self._build_messages(req),
+            "max_tokens": 4096,
+        }
+        body.update(self._extra_body())
+        payload = _post_json(
+            self._base_url,
+            {"Authorization": f"Bearer {api_key}"},
+            body,
+        )
+        text, usage = _parse_openai_chat_response(payload)
+        return AgentResult(
+            text=text,
+            claimed_done=True,
+            plan=_extract_plan(text) if req.role in ("oracle", "manager", "aisb") else [],
+            usage=usage,
+        )
+
+
+class GLMProvider(_OpenAICompatProvider):
+    """Zhipu / BigModel GLM via the OpenAI-compatible chat-completions API.
+
+    Endpoint: https://open.bigmodel.cn/api/paas/v4/chat/completions
+    Env: `GLM_API_KEY`.
+    """
+
+    id = "glm"
+    _default_model = "glm-4.6"
+    _env_var = "GLM_API_KEY"
+    _default_base_url = "https://open.bigmodel.cn/api/paas/v4/chat/completions"
+
+
+class OpenAIProvider(_OpenAICompatProvider):
+    """OpenAI Chat Completions.
+
+    Endpoint: https://api.openai.com/v1/chat/completions
+    Env: `OPENAI_API_KEY`.
+    """
+
+    id = "openai"
+    _default_model = "gpt-4o"
+    _env_var = "OPENAI_API_KEY"
+    _default_base_url = "https://api.openai.com/v1/chat/completions"
+
+
+class DeepSeekProvider(_OpenAICompatProvider):
+    """DeepSeek (OpenAI-compatible chat completions).
+
+    Endpoint: https://api.deepseek.com/v1/chat/completions
+    Env: `DEEPSEEK_API_KEY`.
+    """
+
+    id = "deepseek"
+    _default_model = "deepseek-chat"
+    _env_var = "DEEPSEEK_API_KEY"
+    _default_base_url = "https://api.deepseek.com/v1/chat/completions"
+
+
 def _extract_plan(text: str) -> list[dict[str, Any]]:
     """Pull a JSON subtask array out of an LLM response. Empty list if none."""
     match = re.search(r"\[.*\]", text, re.DOTALL)