agentram 0.1.16 → 0.1.20

package/agentram/cli.py

@@ -43,6 +43,7 @@ SLASH_COMMANDS: list[tuple[str, str]] = [
     ("/bind-router provider model", "Bind intent router model"),
     ("/bind-agent slot provider model", "Bind supervisor/main/small agent"),
     ("/workflow", "Show supervisor workflow agents"),
+    ("/setup", "Show model setup panel"),
     ("/route on|off|status", "Toggle auto prompt routing"),
     ("/orchestrate <task>", "Build multi-model agent plan"),
     ("/ask <prompt>", "Execute bound models and return outputs"),
@@ -74,6 +75,7 @@ SLASH_HELP = """Slash commands:
 /bind-router provider model   Bind intent router model
 /bind-agent slot provider model Bind supervisor/main/small agent
 /workflow                     Show supervisor workflow agents
+/setup                        Show model setup panel
 /route on|off|status          Toggle auto prompt routing
 /orchestrate <task>           Build multi-model agent plan
 /ask <prompt>                 Execute bound models and return outputs
@@ -273,7 +275,7 @@ def run_textual_tui(context: McpContext) -> bool:
     try:
         from textual.app import App, ComposeResult
         from textual.containers import Horizontal, Vertical
-        from textual.widgets import Button, Footer, Header, Input, RichLog, Static
+        from textual.widgets import Button, Footer, Header, Input, RichLog, Select, Static
     except ImportError:
         return False
 
@@ -286,13 +288,14 @@ def run_textual_tui(context: McpContext) -> bool:
         #setup { height: auto; border: solid #3b82f6; padding: 1; background: #101826; }
         #setup-title { height: auto; color: #dbeafe; }
         #setup-actions { height: auto; }
+        .agent-setup { height: auto; border: round #263241; padding: 1; }
         .setup-input { height: 3; }
         #chat { height: 1fr; border: solid #263241; padding: 1; overflow-y: scroll; }
         #palette { height: auto; max-height: 12; border: solid #3b82f6; padding: 1; background: #101826; display: none; }
         #input { dock: bottom; border: solid #3b82f6; }
         .muted { color: #8b9bb0; }
         """
-        BINDINGS = [("ctrl+c", "quit", "Quit"), ("tab", "accept_suggestion", "Complete slash"), ("ctrl+s", "save_setup", "Save setup")]
+        BINDINGS = [("ctrl+c", "interrupt_or_quit", "Cancel/Quit"), ("tab", "accept_suggestion", "Complete slash"), ("ctrl+s", "save_setup", "Save setup"), ("up", "history_prev", "Previous prompt"), ("down", "history_next", "Next prompt")]
 
         def __init__(self, mcp_context: McpContext) -> None:
             super().__init__()
@@ -301,14 +304,44 @@ def run_textual_tui(context: McpContext) -> bool:
             self.busy = False
             self.suggestions: list[str] = []
             self.setup_done = False
+            self.prompt_history: list[str] = []
+            self.history_index: int | None = None
+            self.last_ctrl_c_at = 0.0
 
         def compose(self) -> ComposeResult:
             yield Header(show_clock=True)
             with Horizontal(id="layout"):
                 yield Static(id="sidebar")
                 with Vertical(id="main"):
+                    with Vertical(id="setup"):
+                        yield Static("Model setup - configure each agent separately", id="setup-title")
+                        for slot, label, default_model in [
+                            ("supervisor", "Supervisor", ""),
+                            ("main", "Main coding", ""),
+                            ("small", "Small memory", ""),
+                        ]:
+                            with Vertical(classes="agent-setup"):
+                                yield Static(f"{label} agent")
+                                yield Select(
+                                    [
+                                        ("OpenAI Compatible", "openai-compatible"),
+                                        ("Anthropic Compatible", "anthropic"),
+                                        ("Custom", "custom"),
+                                    ],
+                                    value="openai-compatible",
+                                    id=f"setup-{slot}-provider",
+                                    classes="setup-input",
+                                )
+                                yield Input(placeholder="Custom provider if preset=Custom", id=f"setup-{slot}-custom-provider", classes="setup-input")
+                                yield Input(value=default_model, placeholder="Model name", id=f"setup-{slot}-model", classes="setup-input")
+                                yield Input(placeholder="Base URL, e.g. http://localhost:20128/v1", id=f"setup-{slot}-base-url", classes="setup-input")
+                                yield Input(value="OPENAI_API_KEY", placeholder="API key env name, not raw key", id=f"setup-{slot}-api-key-env", classes="setup-input")
+                        with Horizontal(id="setup-actions"):
+                            yield Button("Save setup", id="setup-save", variant="primary")
+                            yield Button("Skip", id="setup-skip")
                     yield RichLog(id="chat", wrap=True, highlight=True, markup=False, auto_scroll=True)
-                    yield Input(placeholder="Prompt hoặc /command. Mouse wheel scroll trong khung chat.", id="input")
+                    yield Static(id="palette")
+                    yield Input(placeholder="Prompt ho?c /command. Mouse wheel scroll trong khung chat.", id="input")
             yield Footer()
 
         def on_mount(self) -> None:
@@ -318,7 +351,10 @@ def run_textual_tui(context: McpContext) -> bool:
             self.prefill_setup_from_profile()
             self.refresh_sidebar()
             self.set_interval(1.0, self.refresh_sidebar)
-            self.query_one("#setup-provider", Input).focus()
+            try:
+                self.query_one("#setup-supervisor-model", Input).focus()
+            except Exception:  # noqa: BLE001 - fallback if setup is hidden/unmounted
+                self.query_one("#input", Input).focus()
 
         @property
         def chat(self) -> RichLog:
@@ -331,30 +367,39 @@ def run_textual_tui(context: McpContext) -> bool:
             agents = self.context.profile_store.list_agents()
             if not agents:
                 return
-            first = next(iter(agents.values()))
-            self.query_one("#setup-provider", Input).value = first.provider
-            self.query_one("#setup-base-url", Input).value = first.base_url
-            self.query_one("#setup-api-key-env", Input).value = first.api_key_env
             for slot in ("supervisor", "main", "small"):
                 endpoint = agents.get(slot)
-                if endpoint:
-                    self.query_one(f"#setup-{slot}", Input).value = endpoint.model
+                if not endpoint:
+                    continue
+                provider = endpoint.provider
+                preset = provider if provider in {"openai-compatible", "anthropic"} else "custom"
+                self.query_one(f"#setup-{slot}-provider", Select).value = preset
+                self.query_one(f"#setup-{slot}-custom-provider", Input).value = "" if preset != "custom" else provider
+                self.query_one(f"#setup-{slot}-model", Input).value = endpoint.model
+                self.query_one(f"#setup-{slot}-base-url", Input).value = endpoint.base_url
+                self.query_one(f"#setup-{slot}-api-key-env", Input).value = endpoint.api_key_env
             self.chat.write("system > Existing workflow models loaded. Save to update, or Skip to keep.")
 
         def setup_value(self, widget_id: str) -> str:
             return self.query_one(f"#{widget_id}", Input).value.strip()
 
+        def setup_provider(self, slot: str) -> str:
+            preset = str(self.query_one(f"#setup-{slot}-provider", Select).value or "openai-compatible")
+            if preset == "custom":
+                return self.setup_value(f"setup-{slot}-custom-provider") or "custom"
+            return preset
+
         def action_save_setup(self) -> None:
-            provider = self.setup_value("setup-provider") or "openai-compatible"
-            base_url = self.setup_value("setup-base-url")
-            api_key_env = self.setup_value("setup-api-key-env")
-            if api_key_env.startswith(("sk-", "gsk_", "sk_")):
-                self.chat.write("agentram > setup error: api key env must be variable name, not raw key")
-                return
             role_by_slot = {"supervisor": "supervisor", "main": "coder", "small": "memory"}
             bound: list[str] = []
             for slot, role in role_by_slot.items():
-                model = self.setup_value(f"setup-{slot}")
+                provider = self.setup_provider(slot)
+                model = self.setup_value(f"setup-{slot}-model")
+                base_url = self.setup_value(f"setup-{slot}-base-url")
+                api_key_env = self.setup_value(f"setup-{slot}-api-key-env")
+                if api_key_env.startswith(("sk-", "gsk_", "sk_")):
+                    self.chat.write(f"agentram > setup error: {slot} api key env must be variable name, not raw key")
+                    return
                 if not model:
                     continue
                 endpoint = AgentModelEndpoint(
@@ -366,7 +411,7 @@ def run_textual_tui(context: McpContext) -> bool:
                     modalities=["text"],
                 )
                 self.context.profile_store.set_agent(slot, endpoint)
-                bound.append(f"{slot}={model}")
+                bound.append(f"{slot}={provider}:{model}")
             if not bound:
                 self.chat.write("agentram > setup skipped: no model entered")
             else:
@@ -379,6 +424,47 @@ def run_textual_tui(context: McpContext) -> bool:
             self.setup_done = True
             self.query_one("#setup", Vertical).styles.display = "none"
 
+        def show_setup(self) -> None:
+            self.setup_done = False
+            self.query_one("#setup", Vertical).styles.display = "block"
+            self.query_one("#setup-supervisor-model", Input).focus()
+
+        def action_history_prev(self) -> None:
+            input_widget = self.query_one("#input", Input)
+            if input_widget.has_focus and self.prompt_history:
+                self.history_index = len(self.prompt_history) - 1 if self.history_index is None else max(0, self.history_index - 1)
+                input_widget.value = self.prompt_history[self.history_index]
+                input_widget.cursor_position = len(input_widget.value)
+
+        def action_history_next(self) -> None:
+            input_widget = self.query_one("#input", Input)
+            if input_widget.has_focus and self.prompt_history and self.history_index is not None:
+                if self.history_index >= len(self.prompt_history) - 1:
+                    self.history_index = None
+                    input_widget.value = ""
+                else:
+                    self.history_index += 1
+                    input_widget.value = self.prompt_history[self.history_index]
+                input_widget.cursor_position = len(input_widget.value)
+
+        def action_interrupt_or_quit(self) -> None:
+            input_widget = self.query_one("#input", Input)
+            now = time.time()
+            if input_widget.has_focus and input_widget.value:
+                input_widget.value = ""
+                self.chat.write("system > Prompt cleared. Press Ctrl+C again to quit.")
+                self.last_ctrl_c_at = now
+                return
+            if self.busy:
+                self.chat.write("system > Current task cannot be cancelled safely yet. Press Ctrl+C again to quit UI.")
+                self.last_ctrl_c_at = now
+                return
+            if now - self.last_ctrl_c_at < 2.0:
+                self.exit()
+            else:
+                self.chat.write("system > Press Ctrl+C again to quit.")
+                self.last_ctrl_c_at = now
+
         def on_button_pressed(self, event: Button.Pressed) -> None:
             if event.button.id == "setup-save":
                 self.action_save_setup()
@@ -442,14 +528,22 @@ def run_textual_tui(context: McpContext) -> bool:
                 return
             text = event.value.strip()
             event.input.value = ""
+            self.history_index = None
             self.hide_palette()
             if not text:
                 return
             if text in {"0", "q", "quit", "exit", "/exit", "/quit"}:
                 self.exit()
                 return
+            if text == "/setup":
+                self.show_setup()
+                self.chat.write("system > Model setup opened.")
+                return
             if text in BUTTONS:
                 text = BUTTONS[text]
+            if text and (not self.prompt_history or self.prompt_history[-1] != text):
+                self.prompt_history.append(text)
+                del self.prompt_history[:-100]
             self.chat.write(f"user > {text}")
             if text == "/clear":
                 self.chat.clear()

package/agentram/orchestration.py

@@ -1,229 +1,254 @@
-from __future__ import annotations
-
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from dataclasses import dataclass, field
-import json
-import os
-import re
-import shlex
-import subprocess
-import urllib.error
-import urllib.request
-from typing import Any, Callable
-from uuid import uuid4
-
-
-@dataclass(frozen=True)
-class AgentModelEndpoint:
-    provider: str
-    model: str
-    role: str = "coder"
-    base_url: str = ""
-    api_key_env: str = ""
-    modalities: list[str] = field(default_factory=lambda: ["text"])
-    enabled: bool = True
-    id: str = field(default_factory=lambda: f"model_{uuid4().hex[:10]}")
-
-    def to_dict(self) -> dict[str, Any]:
-        return {
-            "id": self.id,
-            "provider": self.provider,
-            "model": self.model,
-            "role": self.role,
-            "base_url": self.base_url,
-            "api_key_env": self.api_key_env,
-            "modalities": self.modalities,
-            "enabled": self.enabled,
-        }
-
-    @classmethod
-    def from_dict(cls, data: dict[str, Any]) -> "AgentModelEndpoint":
-        return cls(
-            id=str(data.get("id") or f"model_{uuid4().hex[:10]}"),
-            provider=str(data.get("provider", "openai-compatible")),
-            model=str(data.get("model", "")),
-            role=str(data.get("role", "coder")),
-            base_url=str(data.get("base_url", "")),
-            api_key_env=str(data.get("api_key_env", "")),
-            modalities=[str(item) for item in data.get("modalities", ["text"])],
-            enabled=bool(data.get("enabled", True)),
-        )
-
-
-@dataclass(frozen=True)
-class CodingOrchestrationRequest:
-    task: str
-    context: str = ""
-    files: list[str] = field(default_factory=list)
-    modalities: list[str] = field(default_factory=lambda: ["text"])
-
-    def to_prompt(self, endpoint: AgentModelEndpoint) -> str:
-        return "\n".join(
-            [
-                f"You are AgentRAM {endpoint.role} agent.",
-                f"Model: {endpoint.model}",
-                f"Provider: {endpoint.provider}",
-                f"Modalities: {', '.join(endpoint.modalities)}",
-                "Task:",
-                self.task,
-                "Files:",
-                "\n".join(f"- {item}" for item in self.files) or "- none provided",
-                "AgentRAM Context:",
-                self.context or "No context provided.",
-                "Output contract:",
-                "- Return concise coding findings or patch plan.",
-                "- Mention files to inspect or change.",
-                "- Do not invent repo facts.",
-            ]
-        )
-
-
-class MultiModelCodingOrchestrator:
-    def __init__(self, endpoints: list[AgentModelEndpoint], client: Callable[[AgentModelEndpoint, str], str] | None = None) -> None:
-        self.endpoints = [endpoint for endpoint in endpoints if endpoint.enabled]
-        self.client = client or self._call_endpoint
-
-    def build_plan(self, request: CodingOrchestrationRequest) -> dict[str, Any]:
-        agents = []
-        for endpoint in self.endpoints:
-            agents.append({"endpoint": endpoint.to_dict(), "prompt": request.to_prompt(endpoint)})
-        return {"task": request.task, "agent_count": len(agents), "agents": agents}
-
-    def run(self, request: CodingOrchestrationRequest, max_workers: int = 4) -> dict[str, Any]:
-        results: list[dict[str, Any]] = []
-        if not self.endpoints:
-            return {"task": request.task, "agent_count": 0, "results": []}
-        with ThreadPoolExecutor(max_workers=max(1, min(max_workers, len(self.endpoints)))) as executor:
-            future_map = {executor.submit(self.client, endpoint, request.to_prompt(endpoint)): endpoint for endpoint in self.endpoints}
-            for future in as_completed(future_map):
-                endpoint = future_map[future]
-                try:
-                    output = future.result()
-                    results.append({"endpoint": endpoint.to_dict(), "ok": True, "output": output})
-                except Exception as error:  # noqa: BLE001 - agent boundary
-                    results.append({"endpoint": endpoint.to_dict(), "ok": False, "error": str(error)})
-        return {"task": request.task, "agent_count": len(self.endpoints), "results": results}
-
-    def _call_endpoint(self, endpoint: AgentModelEndpoint, prompt: str) -> str:
-        provider = endpoint.provider.lower()
-        if provider in {"openai", "openai-compatible", "groq", "vllm", "lmstudio", "ollama-v1"}:
-            return self._call_openai_compatible(endpoint, prompt)
-        if provider in {"anthropic", "claude"}:
-            return self._call_anthropic(endpoint, prompt)
-        if provider in {"claude-code", "claude-cli", "claude-subagent", "claude-code-subagent"}:
-            return self._call_claude_code_subagent(endpoint, prompt)
-        raise ValueError(f"Unsupported provider for execution: {endpoint.provider}")
-
-    def _call_openai_compatible(self, endpoint: AgentModelEndpoint, prompt: str) -> str:
-        api_key = os.getenv(endpoint.api_key_env) if endpoint.api_key_env else ""
-        if not endpoint.base_url:
-            raise ValueError("base_url is required")
-        if endpoint.api_key_env and not api_key:
-            raise ValueError(f"missing API key env: {endpoint.api_key_env}")
-        payload = {"model": endpoint.model, "messages": [{"role": "user", "content": prompt}], "temperature": 0}
-        request = urllib.request.Request(
-            endpoint.base_url.rstrip("/") + "/chat/completions",
-            data=json.dumps(payload).encode("utf-8"),
-            headers={"Content-Type": "application/json", "Authorization": f"Bearer {api_key}"} if api_key else {"Content-Type": "application/json"},
-            method="POST",
-        )
-        url = endpoint.base_url.rstrip("/") + "/chat/completions"
-        try:
-            with urllib.request.urlopen(request, timeout=120) as response:
-                raw = response.read().decode("utf-8")
-        except urllib.error.HTTPError as error:
-            body = error.read().decode("utf-8", errors="replace") if error.fp else ""
-            hint = f"OpenAI-compatible HTTP {error.code} at {url}"
-            if error.code == 404:
-                hint += " | base_url should include /v1 but not /chat/completions; verify provider URL and model name"
-            raise RuntimeError(f"{hint} | response={body[:500]}") from error
-        try:
-            data = json.loads(raw)
-        except json.JSONDecodeError as error:
-            streamed = parse_openai_sse(raw)
-            if streamed:
-                return streamed
-            raise RuntimeError(f"OpenAI-compatible returned non-JSON at {url} | response={raw[:500]}") from error
-        return str(data.get("choices", [{}])[0].get("message", {}).get("content", ""))
-
-    def _call_anthropic(self, endpoint: AgentModelEndpoint, prompt: str) -> str:
-        api_key = os.getenv(endpoint.api_key_env) if endpoint.api_key_env else ""
-        if endpoint.api_key_env and not api_key:
-            raise ValueError(f"missing API key env: {endpoint.api_key_env}")
-        base_url = endpoint.base_url.rstrip("/") if endpoint.base_url else "https://api.anthropic.com/v1"
-        payload = {"model": endpoint.model, "max_tokens": 1024, "messages": [{"role": "user", "content": prompt}]}
-        request = urllib.request.Request(
-            base_url + "/messages",
-            data=json.dumps(payload).encode("utf-8"),
-            headers={"Content-Type": "application/json", "x-api-key": api_key, "anthropic-version": "2023-06-01"},
-            method="POST",
-        )
-        with urllib.request.urlopen(request, timeout=120) as response:
-            data = json.loads(response.read().decode("utf-8"))
-        content = data.get("content", [])
-        if content and isinstance(content, list):
-            return "\n".join(str(item.get("text", "")) for item in content if isinstance(item, dict))
-        return str(data)
-
-    def _call_claude_code_subagent(self, endpoint: AgentModelEndpoint, prompt: str) -> str:
-        command = endpoint.base_url.strip() or os.getenv("AGENTRAM_CLAUDE_COMMAND", "claude")
-        args = shlex.split(command)
-        if not args:
-            raise ValueError("claude command is required")
-        subagent_prompt = "\n".join(
-            [
-                f"Use Claude Code subagent entrypoint: {endpoint.model}",
-                f"Subagent role: {endpoint.role}",
-                "If that subagent exists in .claude/agents, follow it. If not, act as this role.",
-                "Return concise coding-agent output only.",
-                "",
-                prompt,
-            ]
-        )
-        process = subprocess.run(
-            [*args, "-p", subagent_prompt],
-            check=False,
-            capture_output=True,
-            encoding="utf-8",
-            timeout=300,
-        )
-        output = (process.stdout or "").strip()
-        error = (process.stderr or "").strip()
-        if process.returncode != 0:
-            raise RuntimeError(error or f"claude command failed with exit code {process.returncode}")
-        return output or error
-
-def parse_openai_sse(raw: str) -> str:
-    parts: list[str] = []
-    for line in raw.splitlines():
-        stripped = line.strip()
-        if not stripped.startswith("data:"):
-            continue
-        payload = stripped[5:].strip()
-        if not payload or payload == "[DONE]":
-            continue
-        try:
-            item = json.loads(payload)
-        except json.JSONDecodeError:
-            continue
-        choices = item.get("choices", [])
-        if not choices or not isinstance(choices, list):
-            continue
-        choice = choices[0]
-        if not isinstance(choice, dict):
-            continue
-        delta = choice.get("delta", {})
-        if isinstance(delta, dict):
-            content = delta.get("content")
-            if content:
-                parts.append(str(content))
-        message = choice.get("message", {})
-        if isinstance(message, dict) and message.get("content"):
-            parts.append(str(message.get("content")))
-    return strip_thinking_blocks("".join(parts)).strip()
-
-def strip_thinking_blocks(text: str) -> str:
-    text = re.sub(r"<thinking>.*?</thinking>", "", text, flags=re.DOTALL | re.IGNORECASE)
-    text = re.sub(r"<think>.*?</think>", "", text, flags=re.DOTALL | re.IGNORECASE)
-    text = re.sub(r"^\s*</?(thinking|think)>\s*", "", text, flags=re.IGNORECASE)
-    return text.strip()
+from __future__ import annotations
+
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from dataclasses import dataclass, field
+import json
+import os
+import re
+import shlex
+import subprocess
+import urllib.error
+import urllib.request
+from typing import Any, Callable
+from uuid import uuid4
+
+
+PROVIDER_ALIASES = {
+    "openai compatible": "openai-compatible",
+    "openai_compatible": "openai-compatible",
+    "openaicompatible": "openai-compatible",
+    "openai-compatible": "openai-compatible",
+    "ollama": "ollama-v1",
+    "ollama_v1": "ollama-v1",
+    "ollama-v1": "ollama-v1",
+    "lm studio": "lmstudio",
+    "lm_studio": "lmstudio",
+    "lmstudio": "lmstudio",
+    "claudecode": "claude-code",
+    "claude_code": "claude-code",
+    "claude-code": "claude-code",
+    "claudesubagent": "claude-subagent",
+    "claude_subagent": "claude-subagent",
+    "claude-subagent": "claude-subagent",
+}
+
+
+def normalize_provider_name(provider: str) -> str:
+    normalized = provider.strip().lower().replace("/", "-")
+    return PROVIDER_ALIASES.get(normalized, normalized)
+
+
+@dataclass(frozen=True)
+class AgentModelEndpoint:
+    provider: str
+    model: str
+    role: str = "coder"
+    base_url: str = ""
+    api_key_env: str = ""
+    modalities: list[str] = field(default_factory=lambda: ["text"])
+    enabled: bool = True
+    id: str = field(default_factory=lambda: f"model_{uuid4().hex[:10]}")
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "id": self.id,
+            "provider": normalize_provider_name(self.provider),
+            "model": self.model,
+            "role": self.role,
+            "base_url": self.base_url,
+            "api_key_env": self.api_key_env,
+            "modalities": self.modalities,
+            "enabled": self.enabled,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "AgentModelEndpoint":
+        return cls(
+            id=str(data.get("id") or f"model_{uuid4().hex[:10]}"),
+            provider=normalize_provider_name(str(data.get("provider", "openai-compatible"))),
+            model=str(data.get("model", "")),
+            role=str(data.get("role", "coder")),
+            base_url=str(data.get("base_url", "")),
+            api_key_env=str(data.get("api_key_env", "")),
+            modalities=[str(item) for item in data.get("modalities", ["text"])],
+            enabled=bool(data.get("enabled", True)),
+        )
+
+
+@dataclass(frozen=True)
+class CodingOrchestrationRequest:
+    task: str
+    context: str = ""
+    files: list[str] = field(default_factory=list)
+    modalities: list[str] = field(default_factory=lambda: ["text"])
+
+    def to_prompt(self, endpoint: AgentModelEndpoint) -> str:
+        return "\n".join(
+            [
+                f"You are AgentRAM {endpoint.role} agent.",
+                f"Model: {endpoint.model}",
+                f"Provider: {endpoint.provider}",
+                f"Modalities: {', '.join(endpoint.modalities)}",
+                "Task:",
+                self.task,
+                "Files:",
+                "\n".join(f"- {item}" for item in self.files) or "- none provided",
+                "AgentRAM Context:",
+                self.context or "No context provided.",
+                "Output contract:",
+                "- Return concise coding findings or patch plan.",
+                "- Mention files to inspect or change.",
+                "- Do not invent repo facts.",
+            ]
+        )
+
+
+class MultiModelCodingOrchestrator:
+    def __init__(self, endpoints: list[AgentModelEndpoint], client: Callable[[AgentModelEndpoint, str], str] | None = None) -> None:
+        self.endpoints = [endpoint for endpoint in endpoints if endpoint.enabled]
+        self.client = client or self._call_endpoint
+
+    def build_plan(self, request: CodingOrchestrationRequest) -> dict[str, Any]:
+        agents = []
+        for endpoint in self.endpoints:
+            agents.append({"endpoint": endpoint.to_dict(), "prompt": request.to_prompt(endpoint)})
+        return {"task": request.task, "agent_count": len(agents), "agents": agents}
+
+    def run(self, request: CodingOrchestrationRequest, max_workers: int = 4) -> dict[str, Any]:
+        results: list[dict[str, Any]] = []
+        if not self.endpoints:
+            return {"task": request.task, "agent_count": 0, "results": []}
+        with ThreadPoolExecutor(max_workers=max(1, min(max_workers, len(self.endpoints)))) as executor:
+            future_map = {executor.submit(self.client, endpoint, request.to_prompt(endpoint)): endpoint for endpoint in self.endpoints}
+            for future in as_completed(future_map):
+                endpoint = future_map[future]
+                try:
+                    output = future.result()
+                    results.append({"endpoint": endpoint.to_dict(), "ok": True, "output": output})
+                except Exception as error:  # noqa: BLE001 - agent boundary
+                    results.append({"endpoint": endpoint.to_dict(), "ok": False, "error": str(error)})
+        return {"task": request.task, "agent_count": len(self.endpoints), "results": results}
+
+    def _call_endpoint(self, endpoint: AgentModelEndpoint, prompt: str) -> str:
+        provider = normalize_provider_name(endpoint.provider)
+        if provider in {"openai", "openai-compatible", "groq", "vllm", "lmstudio", "ollama-v1"}:
+            return self._call_openai_compatible(endpoint, prompt)
+        if provider in {"anthropic", "claude"}:
+            return self._call_anthropic(endpoint, prompt)
+        if provider in {"claude-code", "claude-cli", "claude-subagent", "claude-code-subagent"}:
+            return self._call_claude_code_subagent(endpoint, prompt)
+        raise ValueError(f"Unsupported provider for execution: {endpoint.provider}")
+
+    def _call_openai_compatible(self, endpoint: AgentModelEndpoint, prompt: str) -> str:
+        api_key = os.getenv(endpoint.api_key_env) if endpoint.api_key_env else ""
+        if not endpoint.base_url:
+            raise ValueError("base_url is required")
+        if endpoint.api_key_env and not api_key:
+            raise ValueError(f"missing API key env: {endpoint.api_key_env}")
+        payload = {"model": endpoint.model, "messages": [{"role": "user", "content": prompt}], "temperature": 0}
+        request = urllib.request.Request(
+            endpoint.base_url.rstrip("/") + "/chat/completions",
+            data=json.dumps(payload).encode("utf-8"),
+            headers={"Content-Type": "application/json", "Authorization": f"Bearer {api_key}"} if api_key else {"Content-Type": "application/json"},
+            method="POST",
+        )
+        url = endpoint.base_url.rstrip("/") + "/chat/completions"
+        try:
+            with urllib.request.urlopen(request, timeout=120) as response:
+                raw = response.read().decode("utf-8")
+        except urllib.error.HTTPError as error:
+            body = error.read().decode("utf-8", errors="replace") if error.fp else ""
+            hint = f"OpenAI-compatible HTTP {error.code} at {url}"
+            if error.code == 404:
+                hint += " | base_url should include /v1 but not /chat/completions; verify provider URL and model name"
+            raise RuntimeError(f"{hint} | response={body[:500]}") from error
+        try:
+            data = json.loads(raw)
+        except json.JSONDecodeError as error:
+            streamed = parse_openai_sse(raw)
+            if streamed:
+                return streamed
+            raise RuntimeError(f"OpenAI-compatible returned non-JSON at {url} | response={raw[:500]}") from error
+        return str(data.get("choices", [{}])[0].get("message", {}).get("content", ""))
+
+    def _call_anthropic(self, endpoint: AgentModelEndpoint, prompt: str) -> str:
+        api_key = os.getenv(endpoint.api_key_env) if endpoint.api_key_env else ""
+        if endpoint.api_key_env and not api_key:
+            raise ValueError(f"missing API key env: {endpoint.api_key_env}")
+        base_url = endpoint.base_url.rstrip("/") if endpoint.base_url else "https://api.anthropic.com/v1"
+        payload = {"model": endpoint.model, "max_tokens": 1024, "messages": [{"role": "user", "content": prompt}]}
+        request = urllib.request.Request(
+            base_url + "/messages",
+            data=json.dumps(payload).encode("utf-8"),
+            headers={"Content-Type": "application/json", "x-api-key": api_key, "anthropic-version": "2023-06-01"},
+            method="POST",
+        )
+        with urllib.request.urlopen(request, timeout=120) as response:
+            data = json.loads(response.read().decode("utf-8"))
+        content = data.get("content", [])
+        if content and isinstance(content, list):
+            return "\n".join(str(item.get("text", "")) for item in content if isinstance(item, dict))
+        return str(data)
+
+    def _call_claude_code_subagent(self, endpoint: AgentModelEndpoint, prompt: str) -> str:
+        command = endpoint.base_url.strip() or os.getenv("AGENTRAM_CLAUDE_COMMAND", "claude")
+        args = shlex.split(command)
+        if not args:
+            raise ValueError("claude command is required")
+        subagent_prompt = "\n".join(
+            [
+                f"Use Claude Code subagent entrypoint: {endpoint.model}",
+                f"Subagent role: {endpoint.role}",
+                "If that subagent exists in .claude/agents, follow it. If not, act as this role.",
+                "Return concise coding-agent output only.",
+                "",
+                prompt,
+            ]
+        )
+        process = subprocess.run(
+            [*args, "-p", subagent_prompt],
+            check=False,
+            capture_output=True,
+            encoding="utf-8",
+            timeout=300,
+        )
+        output = (process.stdout or "").strip()
+        error = (process.stderr or "").strip()
+        if process.returncode != 0:
+            raise RuntimeError(error or f"claude command failed with exit code {process.returncode}")
+        return output or error
+
+def parse_openai_sse(raw: str) -> str:
+    parts: list[str] = []
+    for line in raw.splitlines():
+        stripped = line.strip()
+        if not stripped.startswith("data:"):
+            continue
+        payload = stripped[5:].strip()
+        if not payload or payload == "[DONE]":
+            continue
+        try:
+            item = json.loads(payload)
+        except json.JSONDecodeError:
+            continue
+        choices = item.get("choices", [])
+        if not choices or not isinstance(choices, list):
+            continue
+        choice = choices[0]
+        if not isinstance(choice, dict):
+            continue
+        delta = choice.get("delta", {})
+        if isinstance(delta, dict):
+            content = delta.get("content")
+            if content:
+                parts.append(str(content))
+        message = choice.get("message", {})
+        if isinstance(message, dict) and message.get("content"):
+            parts.append(str(message.get("content")))
+    return strip_thinking_blocks("".join(parts)).strip()
+
+def strip_thinking_blocks(text: str) -> str:
+    text = re.sub(r"<thinking>.*?</thinking>", "", text, flags=re.DOTALL | re.IGNORECASE)
+    text = re.sub(r"<think>.*?</think>", "", text, flags=re.DOTALL | re.IGNORECASE)
+    text = re.sub(r"^\s*</?(thinking|think)>\s*", "", text, flags=re.IGNORECASE)
+    return text.strip()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentram",
-  "version": "0.1.16",
+  "version": "0.1.20",
   "description": "Async, model-agnostic Working RAM for coding agents.",
   "license": "MIT",
   "homepage": "https://github.com/trancongnghia/AGENT_RAM#readme",

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agentram"
-version = "0.1.16"
+version = "0.1.20"
 description = "Async, model-agnostic RAM layer for agentic coding tools."
 readme = "README.md"
 license = "MIT"