agentram 0.1.20 → 0.1.29

package/agentram/orchestration.py

@@ -1,12 +1,14 @@
-from __future__ import annotations
+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 os
+from pathlib import Path
+import re
+import shlex
+import subprocess
+import tempfile
 import urllib.error
 import urllib.request
 from typing import Any, Callable
@@ -30,6 +32,12 @@ PROVIDER_ALIASES = {
     "claudesubagent": "claude-subagent",
     "claude_subagent": "claude-subagent",
     "claude-subagent": "claude-subagent",
+    "codex": "codex-cli",
+    "codexcli": "codex-cli",
+    "codex_cli": "codex-cli",
+    "codex-code": "codex-cli",
+    "codex_cli_agent": "codex-cli",
+    "codex-cli": "codex-cli",
 }
 
 
@@ -38,6 +46,38 @@ def normalize_provider_name(provider: str) -> str:
     return PROVIDER_ALIASES.get(normalized, normalized)
 
 
+def split_cli_command(command: str) -> list[str]:
+    cleaned = command.strip().strip('"')
+    if not cleaned:
+        return []
+    if os.name == "nt":
+        lowered = cleaned.lower()
+        for marker in (".cmd", ".exe", ".bat", ".ps1"):
+            index = lowered.find(marker)
+            if index != -1:
+                end = index + len(marker)
+                program = cleaned[:end]
+                rest = cleaned[end:].strip()
+                return [program, *shlex.split(rest)] if rest else [program]
+    return shlex.split(cleaned)
+
+def env_value(name: str) -> str:
+    value = os.getenv(name, "")
+    if value:
+        return value
+    env_path = Path(".env")
+    if not env_path.exists():
+        return ""
+    for line in env_path.read_text(encoding="utf-8", errors="ignore").splitlines():
+        stripped = line.strip()
+        if not stripped or stripped.startswith("#") or "=" not in stripped:
+            continue
+        key, raw_value = stripped.split("=", 1)
+        if key.strip() == name:
+            return raw_value.strip().strip('"').strip("'")
+    return ""
+
+
 @dataclass(frozen=True)
 class AgentModelEndpoint:
     provider: str
@@ -137,10 +177,12 @@ class MultiModelCodingOrchestrator:
             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)
+        if provider in {"codex-cli"}:
+            return self._call_codex_cli_agent(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 ""
+        api_key = env_value(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:
@@ -162,17 +204,20 @@ class MultiModelCodingOrchestrator:
             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", ""))
+        try:
+            data = json.loads(raw)
+        except json.JSONDecodeError as error:
+            mixed_json = parse_openai_mixed_json(raw)
+            if mixed_json:
+                return extract_openai_message(mixed_json)
+            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 extract_openai_message(data)
 
     def _call_anthropic(self, endpoint: AgentModelEndpoint, prompt: str) -> str:
-        api_key = os.getenv(endpoint.api_key_env) if endpoint.api_key_env else ""
+        api_key = env_value(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"
@@ -192,7 +237,7 @@ class MultiModelCodingOrchestrator:
 
     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)
+        args = split_cli_command(command)
         if not args:
             raise ValueError("claude command is required")
         subagent_prompt = "\n".join(
@@ -200,25 +245,81 @@ class MultiModelCodingOrchestrator:
                 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.",
+                "If role is coder/main, you may inspect and edit files using Claude Code tools. If role is memory/small, do not edit files; write notes only.",
+                "Return concise coding-agent output, changed files, and verification status.",
                 "",
                 prompt,
             ]
         )
-        process = subprocess.run(
-            [*args, "-p", subagent_prompt],
-            check=False,
-            capture_output=True,
-            encoding="utf-8",
-            timeout=300,
-        )
+        try:
+            process = subprocess.run(
+                [*args, "-p", subagent_prompt],
+                check=False,
+                capture_output=True,
+                encoding="utf-8",
+                timeout=300,
+            )
+        except FileNotFoundError as error:
+            raise RuntimeError(f"Claude Code command not found: {args[0]}. Install Claude Code CLI or set base_url to the full command path.") from error
         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:
+    def _call_codex_cli_agent(self, endpoint: AgentModelEndpoint, prompt: str) -> str:
+        command = endpoint.base_url.strip() or os.getenv("AGENTRAM_CODEX_COMMAND", "codex exec")
+        args = split_cli_command(command)
+        if not args:
+            raise ValueError("codex command is required")
+        if len(args) == 1:
+            args.append("exec")
+        codex_prompt = "\n".join(
+            [
+                f"You are AgentRAM {endpoint.role} agent running through Codex CLI.",
+                f"Model hint: {endpoint.model}",
+                "If role is coder/main, inspect and edit files as needed in the current repo. If role is memory/small, do not edit files; write notes only.",
+                "Return concise result, changed files, tests/verification, and blockers.",
+                "",
+                prompt,
+            ]
+        )
+        prompt_path = ""
+        try:
+            with tempfile.NamedTemporaryFile(
+                "w",
+                encoding="utf-8",
+                delete=False,
+                dir=os.getcwd(),
+                prefix=".agentram_codex_prompt_",
+                suffix=".txt",
+            ) as prompt_file:
+                prompt_file.write(codex_prompt)
+                prompt_path = prompt_file.name
+            short_prompt = f"Read AgentRAM task from file and execute it: {prompt_path}"
+            process = subprocess.run(
+                [*args, short_prompt],
+                check=False,
+                capture_output=True,
+                encoding="utf-8",
+                timeout=int(os.getenv("AGENTRAM_CLI_TIMEOUT", "900")),
+            )
+        except FileNotFoundError as error:
+            raise RuntimeError(f"Codex CLI command not found: {args[0]}. Install Codex CLI or set base_url to the full command path.") from error
+        finally:
+            if prompt_path:
+                try:
+                    os.remove(prompt_path)
+                except OSError:
+                    pass
+        output = (process.stdout or "").strip()
+        error = (process.stderr or "").strip()
+        if process.returncode != 0:
+            raise RuntimeError(error or f"codex 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()
@@ -245,9 +346,39 @@ def parse_openai_sse(raw: str) -> str:
         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:
+    return strip_thinking_blocks("".join(parts)).strip()
+
+def parse_openai_mixed_json(raw: str) -> dict[str, Any]:
+    stripped = raw.strip()
+    if not stripped.startswith("{"):
+        return {}
+    for marker in ("\ndata:", "\r\ndata:"):
+        if marker not in stripped:
+            continue
+        candidate = stripped.split(marker, 1)[0].strip()
+        try:
+            value = json.loads(candidate)
+        except json.JSONDecodeError:
+            return {}
+        return value if isinstance(value, dict) else {}
+    return {}
+
+def extract_openai_message(data: dict[str, Any]) -> str:
+    choices = data.get("choices", [])
+    if not choices or not isinstance(choices, list):
+        return ""
+    first = choices[0]
+    if not isinstance(first, dict):
+        return ""
+    message = first.get("message", {})
+    if isinstance(message, dict):
+        return strip_thinking_blocks(str(message.get("content", ""))).strip()
+    delta = first.get("delta", {})
+    if isinstance(delta, dict):
+        return strip_thinking_blocks(str(delta.get("content", ""))).strip()
+    return ""
+
+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)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentram",
-  "version": "0.1.20",
+  "version": "0.1.29",
   "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.20"
+version = "0.1.29"
 description = "Async, model-agnostic RAM layer for agentic coding tools."
 readme = "README.md"
 license = "MIT"