relay-code 0.1.0__py3-none-any.whl

client/response.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+from dataclasses import dataclass, field
+from enum import Enum
+import json
+from typing import Any
+
+@dataclass
+class TextDelta:
+    content: str
+
+    def __str__(self):
+        return self.content
+
+class StreamEventType(str, Enum):
+    TEXT_DELTA = "text_delta"
+    MESSAGE_COMPLETE = "message_complete"
+    ERROR = "error"
+
+    TOOL_CALL_START = "tool_call_start"
+    TOOL_CALL_DELTA = "tool_call_delta"
+    TOOL_CALL_COMPLETE = "tool_call_complete"
+
+@dataclass
+class TokenUsage:
+    prompt_tokens: int = 0
+    completion_tokens: int = 0
+    total_tokens: int = 0
+    cached_tokens: int = 0
+
+    def __add__(self, other: TokenUsage):
+        return TokenUsage(
+            prompt_tokens=self.prompt_tokens + other.prompt_tokens,
+            completion_tokens=self.completion_tokens + other.completion_tokens,
+            total_tokens=self.total_tokens + other.total_tokens,
+            cached_tokens=self.cached_tokens + other.cached_tokens,
+        )
+    
+@dataclass
+class ToolCallDelta:
+    call_id: str
+    name: str | None = None
+    arguments_delta: str = ""
+
+@dataclass
+class ToolCall:
+    call_id: str
+    name: str | None = None
+    arguments: dict[str, Any] = field(default_factory=dict)
+
+@dataclass
+class StreamEvent:
+    type: StreamEventType
+    text_delta: TextDelta | None = None
+    tool_calls: list[ToolCall] = field(default_factory=list)
+    error: str | None = None
+    finish_reason: str | None = None
+    tool_call_delta: ToolCallDelta | None = None
+    tool_call: ToolCall | None = None
+    usage: TokenUsage | None = None
+
+@dataclass
+class ToolResultMessage:
+    tool_call_id: str
+    content: str
+    is_error: bool = False
+
+    def to_openai_message(self) -> dict[str, Any]:
+        return {
+            'role': 'tool',
+            'tool_call_id': self.tool_call_id,
+            'content': self.content
+        }
+
+def parse_tool_call_arguments(arguments_str: str) -> dict[str, Any]:
+    if not arguments_str:
+        return {}
+    
+    try:
+        return json.loads(arguments_str)
+    except json.JSONDecodeError:
+        return {
+            'raw_arguments': arguments_str
+        }

config/__init__.py

@@ -0,0 +1,6 @@
+"""Configuration module for Relay."""
+
+from config.config import Config, ModelConfig
+from config.loader import load_config
+
+__all__ = ['Config', 'ModelConfig', 'load_config']

config/config.py

@@ -0,0 +1,76 @@
+import os
+from pathlib import Path
+from pydantic import BaseModel, Field
+
+from config.credentials import load_credentials
+
+class ModelConfig(BaseModel):
+
+    name: str = "tencent/hy3:free"
+    
+    temperature: float = Field(
+        default=1, 
+        ge=0.0, 
+        le=2.0
+    ) # clarity of the model
+
+    context_window: int = 256_000
+
+class ShellEnvironmentConfig(BaseModel):
+    ignore_default_excludes: bool = False # for filtering keys, secrets
+    exclude_patterns: list[str] = Field(
+        default_factory=lambda: ["*KEY*", "*TOKEN*", "*SECRET*"]
+    )
+    set_vars: dict[str, str] = Field(default_factory=dict)
+
+class Config(BaseModel):
+
+    model: ModelConfig = Field(default_factory=ModelConfig)
+    cwd: Path = Field(default_factory=Path.cwd)
+    shell_environment: ShellEnvironmentConfig = Field(
+        default_factory=ShellEnvironmentConfig
+    )
+
+    max_turns: int = 100
+    max_tool_output_tokens: int = 50_000
+
+    developer_instructions: str | None = None
+    user_instructions: str | None = None
+    debug: bool = False
+
+    @property
+    def api_key(self) -> str | None:
+        # Env var wins (handy for CI / one-off overrides); otherwise fall
+        # back to whatever `relay login` saved.
+        return os.environ.get("API_KEY") or load_credentials().get("api_key")
+
+    @property
+    def base_url(self) -> str | None:
+        return os.environ.get("BASE_URL") or load_credentials().get("base_url")
+    
+    @property
+    def model_name(self) -> str:
+        return self.model.name
+    
+    @model_name.setter
+    def model_name(self, value: str) -> None:
+        self.model.name = value
+
+    @property
+    def temperature(self) -> float:
+        return self.model.temperature
+
+    @temperature.setter
+    def temperature(self, value: float) -> None:
+        self.model.temperature = value
+    
+    def validate(self) -> list[str]:
+        errors: list[str] = []
+
+        if not self.api_key:
+            errors.append("No API key was found. Solution: run `relay login` (or set the API_KEY environment variable)")
+        
+        if not self.cwd.exists():
+            errors.append(f"Working directory does not exist: {self.cwd}")
+        
+        return errors

config/credentials.py

@@ -0,0 +1,54 @@
+import os
+from pathlib import Path
+
+from platformdirs import user_config_dir
+
+try:
+    import tomllib
+except ModuleNotFoundError:
+    import tomli as tomllib
+
+CREDENTIALS_FILE = "credentials.toml"
+
+
+def get_credentials_path() -> Path:
+    return Path(user_config_dir("relay")) / CREDENTIALS_FILE
+
+
+def load_credentials() -> dict[str, str]:
+    path = get_credentials_path()
+    if not path.is_file():
+        return {}
+    try:
+        with open(path, "rb") as f:
+            return tomllib.load(f)
+    except (OSError, tomllib.TOMLDecodeError):
+        return {}
+
+
+def _toml_escape(value: str) -> str:
+    return value.replace("\\", "\\\\").replace('"', '\\"')
+
+
+def save_credentials(api_key: str, base_url: str | None = None) -> Path:
+    path = get_credentials_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    lines = ["# relay credentials, written by `relay login`. Do not commit.\n"]
+    lines.append(f'api_key = "{_toml_escape(api_key)}"\n')
+    if base_url:
+        lines.append(f'base_url = "{_toml_escape(base_url)}"\n')
+
+    fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+    with os.fdopen(fd, "w", encoding="utf-8") as f:
+        f.writelines(lines)
+    os.chmod(path, 0o600)
+    return path
+
+
+def clear_credentials() -> bool:
+    path = get_credentials_path()
+    if path.is_file():
+        path.unlink()
+        return True
+    return False

config/loader.py

@@ -0,0 +1,108 @@
+from pathlib import Path
+from config.config import Config
+from platformdirs import user_config_dir
+try:
+    import tomllib
+except ModuleNotFoundError:
+    import tomli as tomllib
+import logging
+from typing import Any
+
+from utils.errors import ConfigError
+
+logger = logging.getLogger(__name__)
+
+CONFIG_FILE = 'config.toml'
+AGENT_MD_FILE = 'AGENTS.md'
+
+def get_config_dir() -> Path:
+    return Path(user_config_dir('relay'))
+
+def get_data_dir() -> Path:
+    return Path(user_config_dir('relay'))
+
+def get_system_config_path() -> Path:
+    return get_config_dir() / CONFIG_FILE
+
+def _parse_toml(path: Path):
+    try:
+        with open(path, 'rb') as f:
+            return tomllib.load(f)
+    except tomllib.TOMLDecodeError as e:
+        raise ConfigError(f"Invalid TOML in {path}: {e}", config_file=str(path)) from e
+    except (OSError, IOError) as e:
+        raise ConfigError(f"Failed to read config file: {path}: {e}", config_file=str(path)) from e
+    
+def _get_project_config(cwd: Path) -> Path:
+
+    current = cwd.resolve()
+    agent_dir = current / '.relay'
+
+    if agent_dir.is_dir():
+        config_file = agent_dir / CONFIG_FILE
+        if config_file.is_file():
+            return config_file
+    
+    return None
+
+def _get_agent_md(cwd: Path) -> Path:
+
+    current = cwd.resolve()
+    
+    if current.is_dir():
+        agent_md_file = current / AGENT_MD_FILE
+        if agent_md_file.is_file():
+            return agent_md_file.read_text(encoding='utf-8')
+    
+    return None
+
+def _merge_dicts(
+        base: dict[str, Any], 
+        override: dict[str, Any]) -> dict[str, Any]:
+    result = base.copy()
+    for key, value in override.items():
+        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+            result[key] = _merge_dicts(result[key], value)
+        else:
+            result[key] = value
+        
+    return result
+
+def load_config(cwd: Path | None) -> Config:
+    cwd = cwd or Path.cwd()
+
+    system_path = get_system_config_path()
+
+    config_dict: dict[str, Any] = {}
+
+    if system_path.is_file():
+        try:
+            config_dict = _merge_dicts(config_dict, _parse_toml(system_path))
+        except ConfigError:
+            logger.exception(f"Invalid system config: {system_path}")
+            raise
+
+    project_path = _get_project_config(cwd)
+    if project_path:
+        try:
+            project_config_dict = _parse_toml(project_path)
+            config_dict = _merge_dicts(config_dict, project_config_dict)
+        except ConfigError:
+            logger.exception(f"Invalid project config: {project_path}")
+            raise
+
+    if "cwd" not in config_dict:
+        config_dict["cwd"] = cwd
+
+    if "developer_instructions" not in config_dict:
+        agent_md_content = _get_agent_md(cwd)
+
+        if agent_md_content:
+            config_dict['developer_instructions'] = agent_md_content
+
+    try:
+        config = Config(**config_dict)
+    except Exception as e:
+        raise ConfigError(f"Invalid config: {e}") from e
+
+    return config

config/oauth.py

@@ -0,0 +1,137 @@
+import base64
+import hashlib
+import secrets
+import threading
+import urllib.parse
+import webbrowser
+from http.server import BaseHTTPRequestHandler, HTTPServer
+
+import httpx
+
+AUTH_URL = "https://openrouter.ai/auth"
+# Token exchange lives under the API base; keep it in step with base_url.
+KEYS_PATH = "/auth/keys"
+
+# How long we'll wait for the user to finish authorizing in the browser.
+CALLBACK_TIMEOUT_SECONDS = 300
+
+
+class OAuthError(Exception):
+    """Raised when the OAuth flow can't be completed."""
+
+
+def _generate_pkce_pair() -> tuple[str, str]:
+    """Return (code_verifier, code_challenge) for the S256 method."""
+    # 32 random bytes -> 43-char base64url string, within the RFC 7636
+    # 43..128 length window.
+    verifier = base64.urlsafe_b64encode(secrets.token_bytes(32)).rstrip(b"=").decode()
+    digest = hashlib.sha256(verifier.encode()).digest()
+    challenge = base64.urlsafe_b64encode(digest).rstrip(b"=").decode()
+    return verifier, challenge
+
+
+class _CallbackHandler(BaseHTTPRequestHandler):
+    """Single-shot handler that captures the `code` from the redirect."""
+
+    # Set by the server factory below.
+    result: dict[str, str] = {}
+
+    def do_GET(self) -> None:  # noqa: N802 (http.server naming)
+        query = urllib.parse.urlparse(self.path).query
+        params = urllib.parse.parse_qs(query)
+        code = params.get("code", [None])[0]
+
+        if code:
+            type(self).result["code"] = code
+            body = "<h2>relay is now logged in.</h2><p>You can close this tab.</p>"
+        else:
+            type(self).result["error"] = params.get("error", ["unknown error"])[0]
+            body = "<h2>Login failed.</h2><p>You can close this tab and try again.</p>"
+
+        self.send_response(200)
+        self.send_header("Content-Type", "text/html; charset=utf-8")
+        self.end_headers()
+        self.wfile.write(body.encode())
+
+    def log_message(self, *_args) -> None:
+        # Silence the default stderr request logging; it just clutters the CLI.
+        pass
+
+
+def _wait_for_code(server: HTTPServer, result: dict[str, str]) -> str:
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    try:
+        # Poll rather than block forever so a user who never finishes in the
+        # browser eventually gets a clear timeout instead of a hung CLI.
+        deadline = threading.Event()
+        waited = 0.0
+        while not (result.get("code") or result.get("error")):
+            if deadline.wait(0.25):
+                break
+            waited += 0.25
+            if waited >= CALLBACK_TIMEOUT_SECONDS:
+                raise OAuthError("Timed out waiting for browser authorization.")
+    finally:
+        server.shutdown()
+        thread.join(timeout=1)
+
+    if result.get("error"):
+        raise OAuthError(f"Authorization was denied: {result['error']}")
+    return result["code"]
+
+
+def _exchange_code(base_url: str, code: str, verifier: str) -> str:
+    keys_url = base_url.rstrip("/") + KEYS_PATH
+    try:
+        resp = httpx.post(
+            keys_url,
+            json={
+                "code": code,
+                "code_verifier": verifier,
+                "code_challenge_method": "S256",
+            },
+            timeout=30,
+        )
+        resp.raise_for_status()
+        key = resp.json().get("key")
+    except httpx.HTTPError as e:
+        raise OAuthError(f"Failed to exchange code for a key: {e}") from e
+
+    if not key:
+        raise OAuthError("OpenRouter did not return an API key.")
+    return key
+
+
+def login_with_oauth(base_url: str, open_browser=webbrowser.open) -> str:
+    verifier, challenge = _generate_pkce_pair()
+
+    # Port 0 -> the OS hands us a free ephemeral port. OpenRouter accepts any
+    # localhost callback, so nothing needs pre-registering.
+    handler = type("_Handler", (_CallbackHandler,), {"result": {}})
+    server = HTTPServer(("127.0.0.1", 0), handler)
+    port = server.server_address[1]
+    callback_url = f"http://localhost:{port}"
+
+    params = urllib.parse.urlencode(
+        {
+            "callback_url": callback_url,
+            "code_challenge": challenge,
+            "code_challenge_method": "S256",
+        }
+    )
+    auth_url = f"{AUTH_URL}?{params}"
+
+    opened = False
+    try:
+        opened = open_browser(auth_url)
+    except webbrowser.Error:
+        opened = False
+
+    if not opened:
+        # Headless / no default browser: let the user open it themselves.
+        print("Open this URL in your browser to authorize relay:")
+        print(f"  {auth_url}")
+
+    code = _wait_for_code(server, handler.result)
+    return _exchange_code(base_url, code, verifier)

context/__init__.py

@@ -0,0 +1,5 @@
+"""Context module for conversation management."""
+
+from context.manager import ContextManager, MessageItem
+
+__all__ = ['ContextManager', 'MessageItem']

context/manager.py

@@ -0,0 +1,92 @@
+from config.config import Config
+from prompts.system import get_system_prompt
+from dataclasses import dataclass, field
+from utils.text import count_tokens
+from typing import Any
+
+@dataclass
+class MessageItem:
+    role: str
+    content: str
+    token_count: int | None = None
+    tool_call_id: str | None = None
+    tool_calls: list[dict[str, Any]] = field(default_factory=list)
+
+    def to_dict(self) -> dict[str, Any]:
+        result: dict[str, Any] = {
+           "role": self.role 
+        }
+
+        if self.tool_call_id:
+            result['tool_call_id'] = self.tool_call_id
+        
+        if self.tool_calls:
+            result['tool_calls'] = self.tool_calls
+
+        if self.content:
+            result['content'] = self.content
+        
+        return result
+
+class ContextManager:
+    def __init__(self, config: Config, user_memory: str | None ) -> None:
+        self._system_prompt = get_system_prompt(config, user_memory)
+        self.config = config
+        self._model_name = self.config.model_name
+        self._messages: list[MessageItem] = []
+    
+    def add_user_message(self, content):
+        item = MessageItem(
+            role = 'user', 
+            content = content,
+            token_count=count_tokens(content, self._model_name)
+        )
+
+        self._messages.append(item)
+    
+    def add_assistant_message(
+            self, 
+            content: str, 
+            tool_calls: list[dict[str, Any]] | None = None,
+            ) -> None:
+        item = MessageItem(
+            role = 'assistant', 
+            content = content or "",
+            token_count=count_tokens(
+                content or "",
+                self._model_name
+            ),
+            tool_calls=tool_calls or []
+        )
+
+        self._messages.append(item)
+    
+    def get_messages(self) -> list[dict[str, Any]]:
+        messages = []
+
+        if self._system_prompt:
+            messages.append(
+                {
+                'role': 'system',
+                'content': self._system_prompt
+                }
+            )
+        
+        for item in self._messages:
+            messages.append(item.to_dict())
+        
+        return messages
+    
+    def add_tool_result(
+            self, 
+            tool_call_id: str, 
+            content: str
+            ) -> None:
+        item = MessageItem(
+            role='tool',
+            content=content,
+            tool_call_id=tool_call_id,
+            token_count=count_tokens(content, self._model_name)
+        )
+
+        self._messages.append(item)