hyperagents 1.2.3rc5.post3__py3-none-any.whl

models/claude_client.py

@@ -0,0 +1,235 @@
+"""
+ClaudeClient — async Anthropic API client with retry logic, streaming, and cost tracking.
+"""
+from __future__ import annotations
+
+import asyncio
+import logging
+import time
+from typing import AsyncIterator
+
+import os
+
+import anthropic
+
+log = logging.getLogger("hyperclaw.claude_client")
+
+# Cost per 1K tokens (approximate, subject to Anthropic pricing changes)
+_INPUT_COST_PER_1K = 0.003
+_OUTPUT_COST_PER_1K = 0.015
+
+
+class ClaudeClient:
+    """
+    Async Anthropic Claude client.
+
+    Retries up to 3 times with exponential backoff on transient errors.
+    Logs every call: model, token counts, latency, and cost estimate.
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        model: str = "claude-sonnet-4-6",
+        max_tokens: int | None = None,
+        base_url: str | None = None,
+    ) -> None:
+        from hyperclaw.cost_guard import guard_client, max_output
+        resolved_base_url = base_url or os.environ.get("OPENAI_BASE_URL")
+        prov = os.environ.get("LLM_PROVIDER", "anthropic")
+        self._provider = prov
+        if prov == "bedrock":
+            pass  # no client needed — uses boto3 per-call
+        elif prov == "openai_compat":
+            import openai as _oai
+            self._oai_client = guard_client(_oai.AsyncOpenAI(
+                api_key=api_key or os.environ.get("OPENAI_API_KEY", "placeholder"),
+                base_url=resolved_base_url or os.environ.get("OPENAI_BASE_URL"),
+            ))
+        else:
+            # anthropic or anthropic_compat
+            kwargs: dict = {"api_key": api_key or None}
+            base = resolved_base_url or os.environ.get("ANTHROPIC_BASE_URL")
+            if base:
+                kwargs["base_url"] = base
+            self._client = guard_client(anthropic.AsyncAnthropic(**kwargs), "anthropic")
+        self.model = model
+        # explicit max output on every call (cost guard path "chat")
+        self.max_tokens = max_output("chat", "anthropic", model, requested=max_tokens)
+
+    async def chat(
+        self,
+        messages: list[dict],
+        system: str = "",
+    ) -> str:
+        """
+        Send a chat request with retry logic (3 attempts, exponential backoff).
+        Returns the assistant's text response.
+        """
+        last_error: Exception | None = None
+        for attempt in range(3):
+            try:
+                return await self._do_chat(messages, system)
+            except (anthropic.APIConnectionError, anthropic.APITimeoutError) as e:
+                last_error = e
+                wait = 2 ** attempt
+                log.warning(f"Claude transient error (attempt {attempt+1}/3): {e}. Retrying in {wait}s...")
+                await asyncio.sleep(wait)
+            except anthropic.RateLimitError as e:
+                last_error = e
+                wait = 4 ** attempt
+                log.warning(f"Claude rate limit (attempt {attempt+1}/3). Retrying in {wait}s...")
+                await asyncio.sleep(wait)
+        raise last_error or RuntimeError("Claude chat failed after 3 attempts")
+
+    async def _do_chat(self, messages: list[dict], system: str) -> str:
+        if self._provider == "bedrock":
+            return await self._do_chat_bedrock(messages, system)
+        if self._provider == "openai_compat":
+            return await self._do_chat_openai(messages, system)
+        t0 = time.time()
+        kwargs: dict = dict(
+            model=self.model,
+            max_tokens=self.max_tokens,
+            messages=messages,
+        )
+        if system:
+            kwargs["system"] = system
+
+        response = await self._client.messages.create(**kwargs)
+        latency_ms = (time.time() - t0) * 1000
+
+        input_tokens = response.usage.input_tokens
+        output_tokens = response.usage.output_tokens
+        cost = (input_tokens / 1000 * _INPUT_COST_PER_1K) + (output_tokens / 1000 * _OUTPUT_COST_PER_1K)
+        # Handle text and thinking content blocks
+        text = ""
+        for block in (response.content or []):
+            if hasattr(block, "type") and block.type == "text":
+                text = block.text
+                break
+        if not text and response.content:
+            text = getattr(response.content[0], "text", "") or ""
+
+        log.info(
+            f"Claude call | model={self.model} | "
+            f"in={input_tokens} out={output_tokens} | "
+            f"latency={latency_ms:.0f}ms | cost=${cost:.5f}"
+        )
+        return text
+
+    async def _do_chat_bedrock(self, messages: list[dict], system: str) -> str:
+        try:
+            from core.providers.llm import BedrockProvider, Message as BMsg
+        except ImportError:
+            import sys as _sys, pathlib as _pl
+            _sys.path.insert(0, str(_pl.Path(__file__).parent.parent))
+            from core.providers.llm import BedrockProvider, Message as BMsg
+        t0 = time.time()
+        provider = BedrockProvider(
+            access_key=os.environ.get("AWS_ACCESS_KEY_ID"),
+            secret_key=os.environ.get("AWS_SECRET_ACCESS_KEY"),
+            region=os.environ.get("AWS_REGION", "us-east-1"),
+        )
+        bedrock_model = os.environ.get("BEDROCK_MODEL", "anthropic.claude-sonnet-5")
+        bmsgs = [BMsg(role=m["role"], content=m["content"]) for m in messages]
+        response = await provider.complete(
+            messages=bmsgs,
+            model=bedrock_model,
+            max_tokens=self.max_tokens,
+            system=system or None,
+        )
+        latency_ms = (time.time() - t0) * 1000
+        log.info(
+            f"Bedrock call | model={bedrock_model} | "
+            f"in={response.input_tokens} out={response.output_tokens} | "
+            f"latency={latency_ms:.0f}ms"
+        )
+        return response.content
+
+    async def _do_chat_openai(self, messages: list[dict], system: str) -> str:
+        t0 = time.time()
+        oai_messages = []
+        if system:
+            oai_messages.append({"role": "system", "content": system})
+        oai_messages.extend(messages)
+        model = os.environ.get("OPENAI_MODEL", self.model)
+        try:
+            response = await self._oai_client.chat.completions.create(
+                model=model,
+                messages=oai_messages,
+                max_tokens=self.max_tokens,
+            )
+        except Exception as _e:
+            _err = str(_e).lower()
+            if any(k in _err for k in ("connection", "connect", "unreachable", "refused", "timeout")):
+                log.warning(f"OpenAI-compat unreachable ({_e}), falling back to Bedrock")
+                import re as _re
+                from pathlib import Path as _Path
+                _bedrock_model = os.environ.get("BEDROCK_MODEL", "us.anthropic.claude-sonnet-5")
+                os.environ["LLM_PROVIDER"] = "bedrock"
+                os.environ.setdefault("AWS_REGION", "us-west-2")
+                os.environ.setdefault("AWS_PROFILE", "hyper")
+                os.environ["BEDROCK_MODEL"] = _bedrock_model
+                _env_f = _Path.home() / ".hyperclaw" / ".env"
+                if _env_f.exists():
+                    _txt = _env_f.read_text()
+                    _txt = _re.sub(r'^LLM_PROVIDER=.*$', 'LLM_PROVIDER=bedrock', _txt, flags=_re.MULTILINE)
+                    _env_f.write_text(_txt)
+                self._provider = "bedrock"
+                return await self._do_chat_bedrock(messages, system)
+            raise
+        latency_ms = (time.time() - t0) * 1000
+        usage = response.usage
+        log.info(
+            f"OpenAI-compat call | model={model} | "
+            f"in={usage.prompt_tokens if usage else '?'} "
+            f"out={usage.completion_tokens if usage else '?'} | "
+            f"latency={latency_ms:.0f}ms"
+        )
+        return response.choices[0].message.content or ""
+
+    async def chat_stream(
+        self,
+        messages: list[dict],
+        system: str = "",
+    ) -> AsyncIterator[str]:
+        """
+        Stream a chat response. Yields text chunks as they arrive.
+        """
+        if self._provider == "bedrock":
+            # BedrockProvider has no streaming; yield full response as single chunk
+            text = await self._do_chat_bedrock(messages, system)
+            yield text
+            return
+
+        if self._provider == "openai_compat":
+            oai_messages = []
+            if system:
+                oai_messages.append({"role": "system", "content": system})
+            oai_messages.extend(messages)
+            model = os.environ.get("OPENAI_MODEL", self.model)
+            async with self._oai_client.chat.completions.create(
+                model=model,
+                messages=oai_messages,
+                max_tokens=self.max_tokens,
+                stream=True,
+            ) as stream:
+                async for chunk in stream:
+                    delta = chunk.choices[0].delta.content if chunk.choices else None
+                    if delta:
+                        yield delta
+            return
+
+        # anthropic / anthropic_compat
+        kwargs: dict = dict(
+            model=self.model,
+            max_tokens=self.max_tokens,
+            messages=messages,
+        )
+        if system:
+            kwargs["system"] = system
+
+        async with self._client.messages.stream(**kwargs) as stream:
+            async for text in stream.text_stream:
+                yield text

models/claude_code_subagent.py

@@ -0,0 +1,192 @@
+"""
+ClaudeCodeSubagent — empirical code certification loop.
+Generates code via Claude, executes it in subprocess, iterates on failures.
+"""
+from __future__ import annotations
+
+import asyncio
+import logging
+import re
+import time
+from dataclasses import dataclass, field
+
+from core.hyperstate.certifier import CertificationError, Certifier
+from core.hyperstate.schema import CertifiedMethod, ExperimentEntry
+from .claude_client import ClaudeClient
+
+log = logging.getLogger("hyperclaw.claude_code_subagent")
+
+_CODE_BLOCK_RE = re.compile(r"```(?:python)?\n(.*?)```", re.DOTALL)
+
+_GENERATE_SYSTEM = """You are a precise Python code generator. 
+When given a task, output ONLY a complete, runnable Python script in a ```python code block.
+Include inline tests using assert statements or a simple main() function.
+The code must be self-contained and executable."""
+
+_FIX_SYSTEM = """You are a Python debugging expert.
+You will be given code that failed along with its error output.
+Output ONLY the fixed, complete, runnable Python script in a ```python code block.
+Do not explain — just fix the code."""
+
+
+@dataclass
+class SubagentResult:
+    code: str
+    test_trace: str
+    success: bool
+    iterations: int
+    total_time_seconds: float
+    error: str | None = None
+
+
+class ClaudeCodeSubagent:
+    """
+    Iterative code generation and certification agent.
+
+    Workflow:
+    1. Ask Claude to generate code for a task
+    2. Execute generated code in a subprocess (30s timeout)
+    3. If tests pass → return success
+    4. If tests fail → feed error back to Claude with "Fix this:" prompt
+    5. Repeat up to max_iterations
+    6. On final failure → return SubagentResult(success=False)
+    """
+
+    def __init__(self, claude_client: ClaudeClient) -> None:
+        self._claude = claude_client
+        self._certifier = Certifier()
+
+    async def run(
+        self,
+        task: str,
+        context: str = "",
+        max_iterations: int = 5,
+    ) -> SubagentResult:
+        """
+        Run the code generation → execution → fix loop.
+        Returns a SubagentResult with success/failure and full test trace.
+        """
+        t0 = time.time()
+        messages: list[dict] = []
+        code = ""
+        test_trace = ""
+        last_error: str | None = None
+
+        # Initial generation request
+        user_msg = f"Task: {task}"
+        if context:
+            user_msg += f"\n\nContext:\n{context}"
+        messages.append({"role": "user", "content": user_msg})
+
+        for iteration in range(1, max_iterations + 1):
+            log.info(f"Subagent iteration {iteration}/{max_iterations}")
+
+            # Generate / fix
+            response = await self._claude.chat(messages, system=_GENERATE_SYSTEM if iteration == 1 else _FIX_SYSTEM)
+            messages.append({"role": "assistant", "content": response})
+
+            # Extract code block
+            code = _extract_code(response)
+            if not code:
+                last_error = "No code block found in Claude response"
+                messages.append({"role": "user", "content": f"Fix this: {last_error}\n\nOutput a complete Python script in a ```python block."})
+                continue
+
+            # Execute
+            stdout, stderr, returncode = await _run_subprocess(code, timeout=30)
+            test_trace = f"=== Iteration {iteration} ===\n{stdout}"
+            if stderr:
+                test_trace += f"\n--- stderr ---\n{stderr}"
+            test_trace += f"\n--- exit code: {returncode} ---"
+
+            if returncode == 0:
+                total_time = time.time() - t0
+                log.info(f"Subagent succeeded on iteration {iteration} in {total_time:.1f}s")
+                return SubagentResult(
+                    code=code,
+                    test_trace=test_trace,
+                    success=True,
+                    iterations=iteration,
+                    total_time_seconds=total_time,
+                    error=None,
+                )
+            else:
+                last_error = f"Exit code {returncode}\nstdout: {stdout}\nstderr: {stderr}"
+                messages.append({
+                    "role": "user",
+                    "content": f"Fix this:\n\n{last_error}\n\nOutput the complete fixed Python script in a ```python block.",
+                })
+
+        total_time = time.time() - t0
+        log.warning(f"Subagent exhausted {max_iterations} iterations. Last error: {last_error}")
+        return SubagentResult(
+            code=code,
+            test_trace=test_trace,
+            success=False,
+            iterations=max_iterations,
+            total_time_seconds=total_time,
+            error=last_error,
+        )
+
+    async def certify(
+        self,
+        task: str,
+        context: str = "",
+    ) -> tuple[str, CertifiedMethod]:
+        """
+        Run the subagent loop and certify the result if successful.
+
+        Returns:
+            (code, CertifiedMethod) on success
+        Raises:
+            CertificationError if the run failed or certification criteria not met
+        """
+        result = await self.run(task, context)
+        if not result.success:
+            raise CertificationError(
+                f"Subagent failed after {result.iterations} iterations: {result.error}"
+            )
+
+        entry = ExperimentEntry(
+            method=f"claude_code_subagent:{task[:60]}",
+            model_used=self._claude.model,
+            result=result.code[:500],
+            certified=True,
+            test_trace=result.test_trace,
+            cost_usd=0.0,
+            latency_ms=result.total_time_seconds * 1000,
+        )
+        certified_method = self._certifier.certify(entry)
+        return result.code, certified_method
+
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+
+def _extract_code(text: str) -> str:
+    """Extract the first Python code block from a markdown-formatted response."""
+    match = _CODE_BLOCK_RE.search(text)
+    if match:
+        return match.group(1).strip()
+    # Fallback: return the whole response if it looks like code
+    if text.strip().startswith(("def ", "import ", "class ", "#")):
+        return text.strip()
+    return ""
+
+
+async def _run_subprocess(code: str, timeout: float = 30.0) -> tuple[str, str, int]:
+    """
+    Execute Python code in a subprocess. Returns (stdout, stderr, returncode).
+    Times out after `timeout` seconds.
+    """
+    proc = await asyncio.create_subprocess_exec(
+        "python3", "-c", code,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    try:
+        stdout_b, stderr_b = await asyncio.wait_for(proc.communicate(), timeout=timeout)
+        return stdout_b.decode(), stderr_b.decode(), proc.returncode or 0
+    except asyncio.TimeoutError:
+        proc.kill()
+        await proc.communicate()
+        return "", f"Process timed out after {timeout}s", 1

models/openai_client.py

@@ -0,0 +1,120 @@
+"""
+OpenAIClient — async OpenAI-compatible client supporting custom base_url.
+Works with OpenAI, Azure OpenAI, local vLLM, LiteLLM, Ollama, and any
+endpoint that implements the OpenAI chat completions API.
+"""
+from __future__ import annotations
+
+import asyncio
+import logging
+import time
+from typing import AsyncIterator
+
+from openai import AsyncOpenAI, APIConnectionError, APITimeoutError, RateLimitError
+
+log = logging.getLogger("hyperclaw.openai_client")
+
+
+class OpenAIClient:
+    """
+    Async OpenAI-compatible client with retry logic and cost tracking.
+
+    Pass base_url to point at any OpenAI-compatible endpoint:
+      - Azure OpenAI: https://<resource>.openai.azure.com/openai/deployments/<deployment>
+      - vLLM:         http://localhost:8000/v1
+      - LiteLLM:      http://localhost:4000/v1
+      - Ollama:       http://localhost:11434/v1
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        model: str = "gpt-4o",
+        max_tokens: int | None = None,
+        base_url: str | None = None,
+        cost_per_1k_input: float = 0.005,
+        cost_per_1k_output: float = 0.015,
+    ) -> None:
+        from hyperclaw.cost_guard import guard_client, max_output
+        self._client = guard_client(AsyncOpenAI(
+            api_key=api_key,
+            base_url=base_url,
+        ))
+        self.model = model
+        # explicit max output on every call (cost guard path "chat")
+        self.max_tokens = max_output("chat", "openai", model, requested=max_tokens)
+        self._cost_in = cost_per_1k_input
+        self._cost_out = cost_per_1k_output
+
+    async def chat(
+        self,
+        messages: list[dict],
+        system: str = "",
+    ) -> str:
+        """
+        Send a chat request with retry logic (3 attempts, exponential backoff).
+        Returns the assistant's text response.
+        """
+        full_messages = []
+        if system:
+            full_messages.append({"role": "system", "content": system})
+        full_messages.extend(messages)
+
+        last_error: Exception | None = None
+        for attempt in range(3):
+            try:
+                return await self._do_chat(full_messages)
+            except (APIConnectionError, APITimeoutError) as e:
+                last_error = e
+                wait = 2 ** attempt
+                log.warning(f"OpenAI transient error (attempt {attempt+1}/3): {e}. Retrying in {wait}s...")
+                await asyncio.sleep(wait)
+            except RateLimitError as e:
+                last_error = e
+                wait = 4 ** attempt
+                log.warning(f"OpenAI rate limit (attempt {attempt+1}/3). Retrying in {wait}s...")
+                await asyncio.sleep(wait)
+        raise last_error or RuntimeError("OpenAI chat failed after 3 attempts")
+
+    async def _do_chat(self, messages: list[dict]) -> str:
+        t0 = time.time()
+        response = await self._client.chat.completions.create(
+            model=self.model,
+            max_tokens=self.max_tokens,
+            messages=messages,
+        )
+        latency_ms = (time.time() - t0) * 1000
+
+        input_tokens = response.usage.prompt_tokens if response.usage else 0
+        output_tokens = response.usage.completion_tokens if response.usage else 0
+        cost = (input_tokens / 1000 * self._cost_in) + (output_tokens / 1000 * self._cost_out)
+        text = response.choices[0].message.content or "" if response.choices else ""
+
+        log.info(
+            f"OpenAI call | model={self.model} | "
+            f"in={input_tokens} out={output_tokens} | "
+            f"latency={latency_ms:.0f}ms | cost=${cost:.5f}"
+        )
+        return text
+
+    async def chat_stream(
+        self,
+        messages: list[dict],
+        system: str = "",
+    ) -> AsyncIterator[str]:
+        """Stream a chat response. Yields text chunks as they arrive."""
+        full_messages = []
+        if system:
+            full_messages.append({"role": "system", "content": system})
+        full_messages.extend(messages)
+
+        stream = await self._client.chat.completions.create(
+            model=self.model,
+            max_tokens=self.max_tokens,
+            messages=full_messages,
+            stream=True,
+        )
+        async for chunk in stream:
+            delta = chunk.choices[0].delta.content if chunk.choices else None
+            if delta:
+                yield delta