aleph-rlm 0.6.0__py3-none-any.whl

aleph/mcp/server.py

@@ -0,0 +1,20 @@
+"""Compatibility entry point for Aleph MCP server.
+
+This module now aliases the full-featured MCP server.
+"""
+
+from __future__ import annotations
+
+from .local_server import AlephMCPServerLocal, main as _main
+
+AlephMCPServer = AlephMCPServerLocal
+
+__all__ = ["AlephMCPServer", "main"]
+
+
+def main() -> None:
+    _main()
+
+
+if __name__ == "__main__":
+    main()

aleph/prompts/__init__.py

@@ -0,0 +1,5 @@
+"""Prompt templates."""
+
+from .system import DEFAULT_SYSTEM_PROMPT
+
+__all__ = ["DEFAULT_SYSTEM_PROMPT"]

aleph/prompts/system.py

@@ -0,0 +1,45 @@
+"""Default system prompt for Aleph.
+
+This prompt teaches the model how to interact with the REPL and how to signal a
+final answer.
+
+The placeholders are filled by Aleph at runtime.
+"""
+
+from __future__ import annotations
+
+DEFAULT_SYSTEM_PROMPT = """You are Aleph, a Recursive Language Model (RLM) assistant.
+
+You have access to a sandboxed Python REPL environment where a potentially massive context is stored in the variable `{context_var}`.
+
+CONTEXT INFORMATION:
+- Format: {context_format}
+- Size: {context_size_chars:,} characters, {context_size_lines:,} lines, ~{context_size_tokens:,} tokens (estimate)
+- Structure: {structure_hint}
+- Preview (first 500 chars):
+```
+{context_preview}
+```
+
+AVAILABLE FUNCTIONS (in the REPL):
+- `peek(start=0, end=None)` - View characters [start:end] of the context
+- `lines(start=0, end=None)` - View lines [start:end] of the context
+- `search(pattern, context_lines=2, flags=0, max_results=20)` - Regex search returning matches with surrounding context
+- `chunk(chunk_size, overlap=0)` - Split the context into character chunks
+- `semantic_search(query, chunk_size=1000, overlap=100, top_k=5)` - Meaning-based search
+- `sub_query(prompt, context_slice=None)` - Ask a sub-question to another LLM (cheaper model)
+- `sub_aleph(query, context=None)` - Run a recursive Aleph call (higher-level recursion)
+
+WORKFLOW:
+1. Decide what you need from the context.
+2. Use Python code blocks to explore/process the context.
+3. Keep REPL outputs small; summarize or extract only what you need.
+4. When you have the final answer, respond with exactly one of:
+   - `FINAL(your answer)`
+   - `FINAL_VAR(variable_name)`
+
+IMPORTANT:
+- Write Python code inside a fenced block: ```python ... ```
+- You can iterate: write code, inspect output, then write more code.
+- Avoid dumping huge text. Prefer targeted search/slicing.
+"""

aleph/providers/__init__.py

@@ -0,0 +1,14 @@
+"""LLM provider implementations."""
+
+from .base import LLMProvider, ProviderError
+from .anthropic import AnthropicProvider
+from .openai import OpenAIProvider
+from .registry import get_provider
+
+__all__ = [
+    "LLMProvider",
+    "ProviderError",
+    "AnthropicProvider",
+    "OpenAIProvider",
+    "get_provider",
+]

aleph/providers/anthropic.py

@@ -0,0 +1,253 @@
+"""Anthropic provider.
+
+Implements Aleph's provider interface against Anthropic's Messages API.
+
+This module intentionally uses bare HTTP (httpx) to keep dependencies minimal.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import asyncio
+
+import httpx
+
+from .base import LLMProvider, ModelPricing, ProviderError
+from ..utils.tokens import estimate_tokens
+from ..types import Message
+
+
+class AnthropicProvider:
+    """Anthropic Claude provider via the Messages API."""
+
+    # Model -> pricing / limits (rough defaults; override in code if needed)
+    MODEL_INFO: dict[str, ModelPricing] = {
+        # NOTE: Values are approximate and may change; intended for budgeting/telemetry.
+        "claude-sonnet-4-20250514": ModelPricing(200_000, 64_000, 0.003, 0.015),
+        "claude-opus-4-20250514": ModelPricing(200_000, 32_000, 0.015, 0.075),
+        "claude-haiku-3-5-20241022": ModelPricing(200_000, 8_192, 0.0008, 0.004),
+    }
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        base_url: str = "https://api.anthropic.com",
+        anthropic_version: str = "2023-06-01",
+        http_client: httpx.AsyncClient | None = None,
+        max_retries: int = 3,
+        backoff_base_seconds: float = 0.8,
+    ) -> None:
+        self._api_key = api_key or os.getenv("ANTHROPIC_API_KEY")
+        if not self._api_key:
+            # Don't raise immediately; allow creating instance and failing on first call.
+            self._api_key = ""
+        self._base_url = base_url.rstrip("/")
+        self._version = anthropic_version
+        self._client = http_client
+        self._owned_client = http_client is None
+        self._max_retries = max_retries
+        self._backoff_base = backoff_base_seconds
+
+    @property
+    def provider_name(self) -> str:
+        return "anthropic"
+
+    async def _get_client(self) -> httpx.AsyncClient:
+        if self._client is None:
+            self._client = httpx.AsyncClient(timeout=httpx.Timeout(60.0))
+        return self._client
+
+    async def aclose(self) -> None:
+        if self._owned_client and self._client is not None:
+            await self._client.aclose()
+            self._client = None
+
+    def count_tokens(self, text: str, model: str) -> int:
+        # Keep it dependency-free by default.
+        return estimate_tokens(text)
+
+    def get_context_limit(self, model: str) -> int:
+        info = self.MODEL_INFO.get(model)
+        return info.context_limit if info else 200_000
+
+    def get_output_limit(self, model: str) -> int:
+        info = self.MODEL_INFO.get(model)
+        return info.output_limit if info else 8_192
+
+    def _estimate_cost(self, model: str, input_tokens: int, output_tokens: int) -> float:
+        info = self.MODEL_INFO.get(model)
+        if not info:
+            return 0.0
+        return (input_tokens / 1000.0) * info.input_cost_per_1k + (output_tokens / 1000.0) * info.output_cost_per_1k
+
+    @staticmethod
+    def _split_system(messages: list[Message]) -> tuple[str | None, list[Message]]:
+        system_parts: list[str] = []
+        out: list[Message] = []
+        for m in messages:
+            role = m.get("role", "")
+            if role == "system":
+                system_parts.append(m.get("content", ""))
+            else:
+                out.append(m)
+        system = "\n\n".join([p for p in system_parts if p.strip()]) or None
+        return system, out
+
+    async def complete(
+        self,
+        messages: list[Message],
+        model: str,
+        max_tokens: int = 4096,
+        temperature: float = 0.0,
+        stop_sequences: list[str] | None = None,
+        timeout_seconds: float | None = None,
+    ) -> tuple[str, int, int, float]:
+        if not self._api_key:
+            raise ProviderError(
+                "Anthropic API key not set. Provide api_key=... or set ANTHROPIC_API_KEY."
+            )
+
+        system, filtered = self._split_system(messages)
+
+        # Anthropic Messages API uses roles: user/assistant only.
+        anthropic_messages: list[dict[str, str]] = []
+        for m in filtered:
+            role = m.get("role")
+            if role not in {"user", "assistant"}:
+                # Best-effort fallback: treat unknown roles as user content.
+                role = "user"
+            anthropic_messages.append({"role": role, "content": m.get("content", "")})
+
+        url = f"{self._base_url}/v1/messages"
+        headers = {
+            "x-api-key": self._api_key,
+            "anthropic-version": self._version,
+            "content-type": "application/json",
+        }
+
+        payload: dict[str, object] = {
+            "model": model,
+            "max_tokens": max_tokens,
+            "temperature": temperature,
+            "messages": anthropic_messages,
+        }
+        if system:
+            payload["system"] = system
+        if stop_sequences:
+            payload["stop_sequences"] = stop_sequences
+
+        client = await self._get_client()
+        timeout = httpx.Timeout(timeout_seconds) if timeout_seconds else client.timeout
+
+        def _parse_retry_after_seconds(resp: httpx.Response) -> float | None:
+            ra = resp.headers.get("retry-after")
+            if not ra:
+                return None
+            try:
+                return max(0.0, float(ra.strip()))
+            except ValueError:
+                return None
+
+        def _format_http_error(resp: httpx.Response) -> str:
+            request_id = resp.headers.get("request-id") or resp.headers.get("x-request-id")
+            retry_after = _parse_retry_after_seconds(resp)
+
+            msg = None
+            try:
+                data = resp.json()
+                err = data.get("error") if isinstance(data, dict) else None
+                if isinstance(err, dict):
+                    raw = err.get("message")
+                    if isinstance(raw, str) and raw.strip():
+                        msg = raw.strip()
+            except Exception:
+                msg = None
+
+            if msg is None:
+                body = (resp.text or "").strip()
+                msg = body[:500] if body else "(no response body)"
+
+            parts = [f"Anthropic API error {resp.status_code}: {msg}"]
+            if request_id:
+                parts.append(f"request_id={request_id}")
+            if retry_after is not None:
+                parts.append(f"retry_after_seconds={retry_after:.0f}")
+            if len(parts) == 1:
+                return parts[0]
+            return parts[0] + " (" + ", ".join(parts[1:]) + ")"
+
+        last_err: Exception | None = None
+        for attempt in range(1, self._max_retries + 2):
+            try:
+                resp = await client.post(url, headers=headers, json=payload, timeout=timeout)
+
+                if resp.status_code >= 400:
+                    retryable_status = resp.status_code in {408, 409, 429, 500, 502, 503, 504}
+                    if retryable_status and attempt <= self._max_retries:
+                        retry_after = _parse_retry_after_seconds(resp)
+                        delay = retry_after if retry_after is not None else (self._backoff_base * (2 ** (attempt - 1)))
+                        await asyncio.sleep(delay)
+                        continue
+                    raise ProviderError(_format_http_error(resp))
+
+                try:
+                    data = resp.json()
+                except json.JSONDecodeError as e:
+                    raise ProviderError(f"Invalid JSON response from Anthropic: {e}")
+
+                if not isinstance(data, dict):
+                    raise ProviderError(f"Anthropic API returned invalid JSON type: {type(data)}")
+
+                # Response content is a list of blocks; typically first is text.
+                content_blocks = data.get("content") or []
+                text_parts: list[str] = []
+                if isinstance(content_blocks, list):
+                    for block in content_blocks:
+                        if isinstance(block, dict) and block.get("type") == "text":
+                            val = block.get("text", "")
+                            if isinstance(val, str):
+                                text_parts.append(val)
+                text = "".join(text_parts).strip()
+
+                usage = data.get("usage") or {}
+                if not isinstance(usage, dict):
+                    usage = {}
+                input_tokens = int(usage.get("input_tokens") or 0)
+                output_tokens = int(usage.get("output_tokens") or 0)
+
+                # If usage is missing (rare), estimate.
+                if input_tokens == 0:
+                    input_tokens = sum(self.count_tokens(m["content"], model) for m in messages)
+                if output_tokens == 0:
+                    output_tokens = self.count_tokens(text, model)
+
+                cost = self._estimate_cost(model, input_tokens, output_tokens)
+                return text, input_tokens, output_tokens, cost
+
+            except ProviderError:
+                raise
+            except httpx.TimeoutException as e:
+                last_err = e
+                if attempt <= self._max_retries:
+                    await asyncio.sleep(self._backoff_base * (2 ** (attempt - 1)))
+                    continue
+                break
+            except httpx.RequestError as e:
+                last_err = e
+                if attempt <= self._max_retries:
+                    await asyncio.sleep(self._backoff_base * (2 ** (attempt - 1)))
+                    continue
+                break
+            except Exception as e:
+                last_err = e
+                if attempt <= self._max_retries:
+                    await asyncio.sleep(self._backoff_base * (2 ** (attempt - 1)))
+                    continue
+                break
+
+        if isinstance(last_err, httpx.TimeoutException):
+            raise ProviderError(f"Anthropic request timed out: {last_err}")
+        if isinstance(last_err, httpx.RequestError):
+            raise ProviderError(f"Anthropic request failed: {last_err}")
+        raise ProviderError(f"Anthropic provider failed after retries: {last_err}")

aleph/providers/base.py

@@ -0,0 +1,59 @@
+"""Provider abstraction.
+
+Aleph's core logic is provider-agnostic. Any provider can be used as long as it
+implements the LLMProvider protocol.
+
+The interface is intentionally small:
+- complete(): async LLM call
+- count_tokens(): token estimate
+- get_context_limit()/get_output_limit(): model metadata
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Protocol
+
+from ..types import Message
+
+
+class ProviderError(RuntimeError):
+    """Raised when a provider call fails."""
+
+
+class LLMProvider(Protocol):
+    """Protocol all providers must implement."""
+
+    @property
+    def provider_name(self) -> str:
+        ...
+
+    async def complete(
+        self,
+        messages: list[Message],
+        model: str,
+        max_tokens: int = 4096,
+        temperature: float = 0.0,
+        stop_sequences: list[str] | None = None,
+        timeout_seconds: float | None = None,
+    ) -> tuple[str, int, int, float]:
+        """Return (response_text, input_tokens, output_tokens, cost_usd)."""
+
+    def count_tokens(self, text: str, model: str) -> int:
+        ...
+
+    def get_context_limit(self, model: str) -> int:
+        ...
+
+    def get_output_limit(self, model: str) -> int:
+        ...
+
+
+@dataclass(slots=True)
+class ModelPricing:
+    """Token and cost metadata for a model (rough)."""
+
+    context_limit: int
+    output_limit: int
+    input_cost_per_1k: float
+    output_cost_per_1k: float

aleph/providers/openai.py

@@ -0,0 +1,224 @@
+"""OpenAI provider.
+
+Implements Aleph's provider interface against OpenAI's Chat Completions API.
+
+This module uses bare HTTP via httpx for minimal dependencies.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+
+import httpx
+
+from .base import ModelPricing, ProviderError
+from ..utils.tokens import estimate_tokens, try_count_tokens_tiktoken
+from ..types import Message
+
+
+class OpenAIProvider:
+    """OpenAI provider via /v1/chat/completions."""
+
+    MODEL_INFO: dict[str, ModelPricing] = {
+        # NOTE: Prices/limits change; these defaults are for budgeting/telemetry.
+        "gpt-4o": ModelPricing(128_000, 16_384, 0.0025, 0.01),
+        "gpt-4o-mini": ModelPricing(128_000, 16_384, 0.00015, 0.0006),
+        "gpt-4-turbo": ModelPricing(128_000, 4_096, 0.01, 0.03),
+    }
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        base_url: str = "https://api.openai.com",
+        organization: str | None = None,
+        http_client: httpx.AsyncClient | None = None,
+        max_retries: int = 3,
+        backoff_base_seconds: float = 0.8,
+    ) -> None:
+        self._api_key = api_key or os.getenv("OPENAI_API_KEY")
+        if not self._api_key:
+            self._api_key = ""
+        self._base_url = base_url.rstrip("/")
+        self._org = organization or os.getenv("OPENAI_ORG_ID")
+        self._client = http_client
+        self._owned_client = http_client is None
+        self._max_retries = max_retries
+        self._backoff_base = backoff_base_seconds
+
+    @property
+    def provider_name(self) -> str:
+        return "openai"
+
+    async def _get_client(self) -> httpx.AsyncClient:
+        if self._client is None:
+            self._client = httpx.AsyncClient(timeout=httpx.Timeout(60.0))
+        return self._client
+
+    async def aclose(self) -> None:
+        if self._owned_client and self._client is not None:
+            await self._client.aclose()
+            self._client = None
+
+    def count_tokens(self, text: str, model: str) -> int:
+        # Best-effort: use tiktoken if installed.
+        n = try_count_tokens_tiktoken(text, model)
+        if n is not None:
+            return n
+        return estimate_tokens(text)
+
+    def get_context_limit(self, model: str) -> int:
+        info = self.MODEL_INFO.get(model)
+        return info.context_limit if info else 128_000
+
+    def get_output_limit(self, model: str) -> int:
+        info = self.MODEL_INFO.get(model)
+        return info.output_limit if info else 4_096
+
+    def _estimate_cost(self, model: str, input_tokens: int, output_tokens: int) -> float:
+        info = self.MODEL_INFO.get(model)
+        if not info:
+            return 0.0
+        return (input_tokens / 1000.0) * info.input_cost_per_1k + (output_tokens / 1000.0) * info.output_cost_per_1k
+
+    async def complete(
+        self,
+        messages: list[Message],
+        model: str,
+        max_tokens: int = 4096,
+        temperature: float = 0.0,
+        stop_sequences: list[str] | None = None,
+        timeout_seconds: float | None = None,
+    ) -> tuple[str, int, int, float]:
+        if not self._api_key:
+            raise ProviderError("OpenAI API key not set. Provide api_key=... or set OPENAI_API_KEY.")
+
+        url = f"{self._base_url}/v1/chat/completions"
+        headers = {
+            "authorization": f"Bearer {self._api_key}",
+            "content-type": "application/json",
+        }
+        if self._org:
+            headers["openai-organization"] = self._org
+
+        payload: dict[str, object] = {
+            "model": model,
+            "messages": messages,
+            "max_tokens": max_tokens,
+            "temperature": temperature,
+        }
+        if stop_sequences:
+            payload["stop"] = stop_sequences
+
+        client = await self._get_client()
+        timeout = httpx.Timeout(timeout_seconds) if timeout_seconds else client.timeout
+
+        def _parse_retry_after_seconds(resp: httpx.Response) -> float | None:
+            ra = resp.headers.get("retry-after")
+            if not ra:
+                return None
+            try:
+                return max(0.0, float(ra.strip()))
+            except ValueError:
+                return None
+
+        def _format_http_error(resp: httpx.Response) -> str:
+            request_id = resp.headers.get("x-request-id")
+            retry_after = _parse_retry_after_seconds(resp)
+
+            msg = None
+            try:
+                data = resp.json()
+                err = data.get("error") if isinstance(data, dict) else None
+                if isinstance(err, dict):
+                    raw = err.get("message")
+                    if isinstance(raw, str) and raw.strip():
+                        msg = raw.strip()
+            except Exception:
+                msg = None
+
+            if msg is None:
+                body = (resp.text or "").strip()
+                msg = body[:500] if body else "(no response body)"
+
+            parts = [f"OpenAI API error {resp.status_code}: {msg}"]
+            if request_id:
+                parts.append(f"request_id={request_id}")
+            if retry_after is not None:
+                parts.append(f"retry_after_seconds={retry_after:.0f}")
+            if len(parts) == 1:
+                return parts[0]
+            return parts[0] + " (" + ", ".join(parts[1:]) + ")"
+
+        last_err: Exception | None = None
+        for attempt in range(1, self._max_retries + 2):
+            try:
+                resp = await client.post(url, headers=headers, json=payload, timeout=timeout)
+
+                if resp.status_code >= 400:
+                    retryable_status = resp.status_code in {408, 409, 429, 500, 502, 503, 504}
+                    if retryable_status and attempt <= self._max_retries:
+                        retry_after = _parse_retry_after_seconds(resp)
+                        delay = retry_after if retry_after is not None else (self._backoff_base * (2 ** (attempt - 1)))
+                        await asyncio.sleep(delay)
+                        continue
+                    raise ProviderError(_format_http_error(resp))
+
+                try:
+                    data = resp.json()
+                except json.JSONDecodeError as e:
+                    raise ProviderError(f"Invalid JSON response from OpenAI: {e}")
+
+                if not isinstance(data, dict):
+                    raise ProviderError(f"OpenAI API returned invalid JSON type: {type(data)}")
+
+                choices = data.get("choices") or []
+                if not choices:
+                    raise ProviderError(f"OpenAI API returned no choices")
+
+                message = choices[0].get("message") if isinstance(choices[0], dict) else None
+                if not isinstance(message, dict):
+                    message = {}
+                text = (message.get("content") or "").strip()
+
+                usage = data.get("usage") or {}
+                if not isinstance(usage, dict):
+                    usage = {}
+                input_tokens = int(usage.get("prompt_tokens") or 0)
+                output_tokens = int(usage.get("completion_tokens") or 0)
+
+                if input_tokens == 0:
+                    input_tokens = sum(self.count_tokens(m.get("content", ""), model) for m in messages)
+                if output_tokens == 0:
+                    output_tokens = self.count_tokens(text, model)
+
+                cost = self._estimate_cost(model, input_tokens, output_tokens)
+                return text, input_tokens, output_tokens, cost
+
+            except ProviderError:
+                raise
+            except httpx.TimeoutException as e:
+                last_err = e
+                if attempt <= self._max_retries:
+                    await asyncio.sleep(self._backoff_base * (2 ** (attempt - 1)))
+                    continue
+                break
+            except httpx.RequestError as e:
+                last_err = e
+                if attempt <= self._max_retries:
+                    await asyncio.sleep(self._backoff_base * (2 ** (attempt - 1)))
+                    continue
+                break
+            except Exception as e:
+                last_err = e
+                if attempt <= self._max_retries:
+                    await asyncio.sleep(self._backoff_base * (2 ** (attempt - 1)))
+                    continue
+                break
+
+        if isinstance(last_err, httpx.TimeoutException):
+            raise ProviderError(f"OpenAI request timed out: {last_err}")
+        if isinstance(last_err, httpx.RequestError):
+            raise ProviderError(f"OpenAI request failed: {last_err}")
+        raise ProviderError(f"OpenAI provider failed after retries: {last_err}")

aleph/providers/registry.py

@@ -0,0 +1,22 @@
+"""Provider factory."""
+
+from __future__ import annotations
+
+from .anthropic import AnthropicProvider
+from .openai import OpenAIProvider
+from .base import LLMProvider
+
+
+PROVIDERS: dict[str, type[LLMProvider]] = {
+    "anthropic": AnthropicProvider,
+    "openai": OpenAIProvider,
+}
+
+
+def get_provider(name: str, **kwargs: object) -> LLMProvider:
+    """Instantiate a provider by name."""
+
+    key = name.lower().strip()
+    if key not in PROVIDERS:
+        raise ValueError(f"Unknown provider: {name}. Available: {sorted(PROVIDERS.keys())}")
+    return PROVIDERS[key](**kwargs)

aleph/repl/__init__.py

@@ -0,0 +1,5 @@
+"""Sandboxed REPL environment used by Aleph."""
+
+from .sandbox import REPLEnvironment, SandboxConfig, DEFAULT_ALLOWED_IMPORTS
+
+__all__ = ["REPLEnvironment", "SandboxConfig", "DEFAULT_ALLOWED_IMPORTS"]