elidia-agent-cli 0.1.0__py3-none-any.whl

elidia/agent/portal.py

@@ -0,0 +1,115 @@
+import json
+import logging
+from typing import Any
+
+import httpx
+
+from elidia.tools.base import ToolDefinition, ToolRegistry, ToolResult
+
+logger = logging.getLogger(__name__)
+
+
+class PortalToolBridge:
+    """Executes AiUtils portal tools (111 tools) via the Developer API."""
+
+    def __init__(self, api_key: str, base_url: str = "https://developer.aiutils.io/v1") -> None:
+        logger.debug(f"Entered into PortalToolBridge.__init__: base_url={base_url}")
+        self._api_key = api_key
+        self._base_url = base_url.rstrip("/")
+        self._tools: list[dict[str, Any]] = []
+
+    async def discover_tools(self) -> list[dict[str, Any]]:
+        logger.debug("Entered into discover_tools")
+        async with httpx.AsyncClient(
+            timeout=30,
+            headers={
+                "Authorization": f"Bearer {self._api_key}",
+                "Content-Type": "application/json",
+            },
+        ) as client:
+            try:
+                resp = await client.get(f"{self._base_url}/tools")
+                resp.raise_for_status()
+                data = resp.json()
+                self._tools = data.get("tools", data.get("data", []))
+                logger.info(f"Discovered {len(self._tools)} portal tools")
+                return self._tools
+            except Exception as e:
+                logger.warning(f"Failed to discover portal tools: {e}")
+                return []
+
+    async def execute_tool(self, tool_slug: str, inputs: dict[str, Any]) -> ToolResult:
+        logger.debug(f"Entered into execute_tool: tool_slug={tool_slug}")
+        async with httpx.AsyncClient(
+            timeout=120,
+            headers={
+                "Authorization": f"Bearer {self._api_key}",
+                "Content-Type": "application/json",
+            },
+        ) as client:
+            try:
+                resp = await client.post(
+                    f"{self._base_url}/tools/{tool_slug}/execute",
+                    json={"inputs": inputs},
+                )
+                if resp.status_code == 402:
+                    return ToolResult(content="Insufficient balance for this tool", is_error=True)
+                if resp.status_code == 404:
+                    return ToolResult(content=f"Tool '{tool_slug}' not found on portal", is_error=True)
+                resp.raise_for_status()
+
+                data = resp.json()
+                output = data.get("output", data.get("result", data))
+
+                if isinstance(output, dict):
+                    content = json.dumps(output, indent=2, default=str)
+                elif isinstance(output, list):
+                    content = json.dumps(output, indent=2, default=str)
+                else:
+                    content = str(output)
+
+                return ToolResult(
+                    content=content,
+                    metadata={"tool_slug": tool_slug, "credits_used": data.get("credits_used", 0)},
+                )
+            except httpx.HTTPStatusError as e:
+                return ToolResult(content=f"Portal API error {e.response.status_code}: {e}", is_error=True)
+            except Exception as e:
+                return ToolResult(content=f"Portal tool error: {e}", is_error=True)
+
+    def register_portal_tools(self, registry: ToolRegistry) -> None:
+        logger.debug("Entered into register_portal_tools")
+        for tool in self._tools:
+            slug = tool.get("slug", tool.get("name", ""))
+            if not slug:
+                continue
+
+            description = tool.get("description", f"Portal tool: {slug}")
+            input_schema = tool.get("input_schema", tool.get("parameters", {}))
+            if not input_schema:
+                input_schema = {"type": "object", "properties": {}}
+
+            async def handler(tool_slug: str = slug, **kwargs: Any) -> ToolResult:
+                return await self.execute_tool(tool_slug, kwargs)
+
+            registry.register(ToolDefinition(
+                name=f"portal__{slug}",
+                description=description[:200],
+                parameters=input_schema,
+                handler=handler,
+                category="portal",
+            ))
+
+        logger.info(f"Registered {len(self._tools)} portal tools in registry")
+
+    def get_tool_list(self) -> list[dict[str, str]]:
+        logger.debug("Entered into get_tool_list")
+        return [
+            {
+                "slug": t.get("slug", t.get("name", "")),
+                "name": t.get("name", ""),
+                "description": t.get("description", "")[:100],
+                "genre": t.get("genre", ""),
+            }
+            for t in self._tools
+        ]

elidia/api/client.py

@@ -0,0 +1,221 @@
+import asyncio
+import json
+import logging
+import time
+from collections.abc import AsyncIterator
+from dataclasses import dataclass
+
+import httpx
+
+from elidia.api.streaming import SSEEvent, parse_sse_stream
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ChatMessage:
+    role: str  # "user", "assistant", "system"
+    content: str
+
+
+@dataclass
+class ChatResponse:
+    content: str = ""
+    model: str = ""
+    tokens_in: int = 0
+    tokens_out: int = 0
+    cost_dt: float = 0.0
+    finish_reason: str = ""
+    elapsed_ms: int = 0
+
+
+class AiUtilsClient:
+    """Client for the AiUtils Developer API."""
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = "https://developer.aiutils.io/v1",
+        timeout: int = 120,
+        max_retries: int = 3,
+    ):
+        logger.debug(f"Entered into AiUtilsClient.__init__: base_url={base_url}")
+        self._api_key = api_key
+        self._base_url = base_url.rstrip("/")
+        self._timeout = timeout
+        self._max_retries = max_retries
+        self._client: httpx.AsyncClient | None = None
+
+    async def _get_client(self) -> httpx.AsyncClient:
+        logger.debug("Entered into _get_client")
+        if self._client is None or self._client.is_closed:
+            pool_limits = httpx.Limits(
+                max_connections=20,
+                max_keepalive_connections=10,
+                keepalive_expiry=30.0,
+            )
+            self._client = httpx.AsyncClient(
+                base_url=self._base_url,
+                headers={
+                    "Authorization": f"Bearer {self._api_key}",
+                    "Content-Type": "application/json",
+                    "User-Agent": "elidia-cli/0.1.0",
+                },
+                timeout=httpx.Timeout(self._timeout, connect=10.0),
+                limits=pool_limits,
+                http2=True,
+            )
+        return self._client
+
+    async def close(self) -> None:
+        logger.debug("Entered into AiUtilsClient.close")
+        if self._client and not self._client.is_closed:
+            await self._client.aclose()
+            self._client = None
+
+    async def chat_completion_stream(
+        self,
+        messages: list[ChatMessage],
+        model: str = "deepseek-chat",
+        temperature: float = 0.7,
+        max_tokens: int | None = None,
+    ) -> AsyncIterator[SSEEvent]:
+        """Stream a chat completion from the AiUtils API."""
+        logger.debug(f"Entered into chat_completion_stream: model={model}, messages={len(messages)}")
+
+        client = await self._get_client()
+        payload = {
+            "model": model,
+            "messages": [{"role": m.role, "content": m.content} for m in messages],
+            "stream": True,
+            "temperature": temperature,
+        }
+        if max_tokens:
+            payload["max_tokens"] = max_tokens
+
+        last_error: object = None
+        for attempt in range(self._max_retries):
+            try:
+                async with client.stream("POST", "/chat/completions", json=payload) as response:
+                    if response.status_code == 401:
+                        yield SSEEvent(
+                            event_type="error",
+                            data={"message": "Invalid API key. Run 'elidia auth login' to set a valid key."},
+                        )
+                        return
+                    if response.status_code == 402:
+                        yield SSEEvent(
+                            event_type="error",
+                            data={"message": "Insufficient balance. Top up at developer.aiutils.io"},
+                        )
+                        return
+                    if response.status_code == 429:
+                        retry_after = int(response.headers.get("retry-after", 2 ** attempt))
+                        last_error = "rate limited (429)"
+                        logger.warning(f"Rate limited, retrying in {retry_after}s (attempt {attempt + 1})")
+                        await asyncio.sleep(retry_after)
+                        continue
+                    if response.status_code >= 500:
+                        last_error = f"server error ({response.status_code})"
+                        logger.warning(f"Server error {response.status_code}, retrying (attempt {attempt + 1})")
+                        await asyncio.sleep(2 ** attempt)
+                        continue
+                    response.raise_for_status()
+                    content_type = response.headers.get("content-type", "")
+                    if "text/event-stream" in content_type:
+                        async for event in parse_sse_stream(response):
+                            yield event
+                    else:
+                        # Gateway returns non-streaming JSON — parse it as a single response
+                        body = await response.aread()
+                        async for event in _parse_json_response(body):
+                            yield event
+                    return
+            except httpx.HTTPStatusError as e:
+                logger.warning(f"HTTP error {e.response.status_code} from chat_completion_stream: {e}")
+                yield SSEEvent(
+                    event_type="error",
+                    data={"message": f"API error {e.response.status_code}: {e}"},
+                )
+                return
+            except httpx.ConnectError as e:
+                last_error = e
+                logger.warning(f"Connection failed (attempt {attempt + 1}): {e}")
+                await asyncio.sleep(2 ** attempt)
+            except httpx.ReadTimeout as e:
+                last_error = e
+                logger.warning(f"Read timeout (attempt {attempt + 1})")
+                await asyncio.sleep(1)
+
+        yield SSEEvent(event_type="error", data={"message": f"Failed after {self._max_retries} attempts: {last_error}"})
+
+    async def chat_completion(
+        self,
+        messages: list[ChatMessage],
+        model: str = "deepseek-chat",
+        temperature: float = 0.7,
+        max_tokens: int | None = None,
+    ) -> ChatResponse:
+        """Non-streaming chat completion (collects full response)."""
+        logger.debug(f"Entered into chat_completion: model={model}")
+        start = time.monotonic()
+        result = ChatResponse(model=model)
+        async for event in self.chat_completion_stream(messages, model, temperature, max_tokens):
+            if event.event_type == "content":
+                result.content += event.data
+            elif event.event_type == "usage" and isinstance(event.data, dict):
+                result.tokens_in = event.data.get("prompt_tokens", 0)
+                result.tokens_out = event.data.get("completion_tokens", 0)
+            elif event.event_type == "error":
+                msg = event.data.get("message", str(event.data)) if isinstance(event.data, dict) else str(event.data)
+                raise RuntimeError(msg)
+        result.elapsed_ms = int((time.monotonic() - start) * 1000)
+        return result
+
+    async def list_models(self) -> list[dict]:
+        """Fetch available models from the API."""
+        logger.debug("Entered into list_models")
+        client = await self._get_client()
+        response = await client.get("/models")
+        response.raise_for_status()
+        data = response.json()
+        return data.get("data", data.get("models", []))
+
+    async def get_balance(self) -> dict:
+        """Fetch current DT balance."""
+        logger.debug("Entered into get_balance")
+        client = await self._get_client()
+        try:
+            response = await client.get("/wallet/balance")
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            logger.warning(f"Failed to fetch balance: {e}")
+            return {"balance_dt": -1, "error": str(e)}
+
+
+async def _parse_json_response(body: bytes) -> AsyncIterator[SSEEvent]:
+    """Parse a non-streaming JSON chat completion response into SSEEvents."""
+    logger.debug("Entered into _parse_json_response")
+    try:
+        data = json.loads(body)
+    except json.JSONDecodeError:
+        yield SSEEvent(event_type="error", data={"message": f"Invalid JSON response: {body[:200].decode()}"})
+        return
+
+    if "error" in data:
+        yield SSEEvent(event_type="error", data=data["error"])
+        return
+
+    choices = data.get("choices", [])
+    if choices:
+        message = choices[0].get("message", {})
+        content = message.get("content")
+        if content:
+            yield SSEEvent(event_type="content", data=content)
+
+    usage = data.get("usage")
+    if usage:
+        yield SSEEvent(event_type="usage", data=usage)
+
+    yield SSEEvent(event_type="done")

elidia/api/streaming.py

@@ -0,0 +1,55 @@
+import json
+import logging
+from collections.abc import AsyncIterator
+from dataclasses import dataclass
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class SSEEvent:
+    event_type: str  # "content", "usage", "error", "done"
+    data: dict | str | None = None
+
+
+async def parse_sse_stream(response) -> AsyncIterator[SSEEvent]:
+    """Parse SSE lines from an httpx streaming response.
+
+    Expected format (OpenAI-compatible):
+    data: {"choices": [{"delta": {"content": "Hello"}}]}
+    data: {"usage": {"prompt_tokens": 10, "completion_tokens": 5}}
+    data: [DONE]
+    """
+    logger.debug("Entered into parse_sse_stream")
+    buffer = ""
+    async for chunk in response.aiter_text():
+        buffer += chunk
+        while "\n" in buffer:
+            line, buffer = buffer.split("\n", 1)
+            line = line.strip()
+            if not line:
+                continue
+            if line.startswith("data: "):
+                data_str = line[6:]
+                if data_str == "[DONE]":
+                    yield SSEEvent(event_type="done")
+                    return
+                try:
+                    data = json.loads(data_str)
+                    choices = data.get("choices", [])
+                    if choices:
+                        delta = choices[0].get("delta", {})
+                        content = delta.get("content")
+                        if content is not None:
+                            yield SSEEvent(event_type="content", data=content)
+                        finish_reason = choices[0].get("finish_reason")
+                        if finish_reason:
+                            usage = data.get("usage")
+                            if usage:
+                                yield SSEEvent(event_type="usage", data=usage)
+                    elif "usage" in data:
+                        yield SSEEvent(event_type="usage", data=data["usage"])
+                    elif "error" in data:
+                        yield SSEEvent(event_type="error", data=data["error"])
+                except json.JSONDecodeError:
+                    logger.warning(f"Failed to parse SSE data: {data_str[:100]}")

elidia/auth/keychain.py

@@ -0,0 +1,86 @@
+import logging
+import os
+import stat
+
+import keyring
+import keyring.errors
+
+from elidia.config.settings import ELIDIA_HOME
+
+logger = logging.getLogger(__name__)
+
+SERVICE_NAME = "elidia-cli"
+ACCOUNT_NAME = "api_key"
+
+_FALLBACK_KEY_PATH = ELIDIA_HOME / ".api_key"
+
+
+def store_api_key(key: str) -> None:
+    """Store API key in OS keychain. Fallback to encrypted file."""
+    logger.debug("Entered into store_api_key: storing API key")
+    try:
+        keyring.set_password(SERVICE_NAME, ACCOUNT_NAME, key)
+    except keyring.errors.KeyringError as exc:
+        logger.warning(
+            f"Entered into store_api_key: keychain unavailable ({exc.__class__.__name__}), falling back to file storage"
+        )
+        _store_api_key_fallback(key)
+
+
+def _store_api_key_fallback(key: str) -> None:
+    logger.debug("Entered into _store_api_key_fallback: writing API key to fallback file")
+    ELIDIA_HOME.mkdir(parents=True, exist_ok=True)
+    _FALLBACK_KEY_PATH.write_text(key, encoding="utf-8")
+    os.chmod(_FALLBACK_KEY_PATH, stat.S_IRUSR | stat.S_IWUSR)
+
+
+def get_api_key() -> str | None:
+    """Retrieve API key from OS keychain, then fallback file, then env, else None."""
+    logger.debug("Entered into get_api_key: retrieving API key")
+    try:
+        value = keyring.get_password(SERVICE_NAME, ACCOUNT_NAME)
+        if value:
+            return value
+    except keyring.errors.KeyringError as exc:
+        logger.warning(
+            f"Entered into get_api_key: keychain unavailable ({exc.__class__.__name__}), checking fallback file"
+        )
+
+    if _FALLBACK_KEY_PATH.exists():
+        value = _FALLBACK_KEY_PATH.read_text(encoding="utf-8").strip()
+        if value:
+            return value
+
+    env_value = os.environ.get("AIUTILS_API_KEY")
+    if env_value:
+        return env_value
+
+    return None
+
+
+def delete_api_key() -> None:
+    """Remove API key from keychain and fallback file."""
+    logger.debug("Entered into delete_api_key: removing API key")
+    try:
+        keyring.delete_password(SERVICE_NAME, ACCOUNT_NAME)
+    except keyring.errors.PasswordDeleteError:
+        pass
+    except keyring.errors.KeyringError as exc:
+        logger.warning(f"Entered into delete_api_key: keychain unavailable ({exc.__class__.__name__})")
+
+    if _FALLBACK_KEY_PATH.exists():
+        _FALLBACK_KEY_PATH.unlink()
+
+
+def validate_api_key(key: str) -> bool:
+    """Check key format: must start with 'ak-dev-'."""
+    logger.debug("Entered into validate_api_key: checking key format")
+    return key.startswith("ak-dev-") and len(key) > 10
+
+
+def mask_api_key(key: str) -> str:
+    """Return masked version: ak-dev-****7f2a"""
+    logger.debug("Entered into mask_api_key: masking key for display")
+    if len(key) <= 12:
+        return "ak-dev-****"
+    return f"{key[:7]}****{key[-4:]}"

elidia/cache/__init__.py

@@ -0,0 +1 @@
+"""Response cache — LRU caching for LLM and tool responses."""

elidia/cache/lru.py

@@ -0,0 +1,158 @@
+"""LRU response cache — caches LLM and tool responses within a session.
+
+Provides a bounded cache with TTL support for deduplicating identical
+queries within a session. The cache key is derived from the model,
+message content, and temperature to avoid cross-contamination.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import logging
+import time
+from collections import OrderedDict
+from dataclasses import dataclass, field
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class CacheEntry:
+    key: str
+    value: Any
+    created_at: float = field(default_factory=time.time)
+    hits: int = 0
+    ttl: float = 0.0
+
+    @property
+    def is_expired(self) -> bool:
+        if self.ttl <= 0:
+            return False
+        return (time.time() - self.created_at) > self.ttl
+
+
+class ResponseCache:
+    """Bounded LRU cache with TTL for LLM responses."""
+
+    def __init__(
+        self,
+        max_size: int = 128,
+        default_ttl: float = 300.0,
+        enabled: bool = True,
+    ) -> None:
+        logger.debug(f"Entered into ResponseCache.__init__: max_size={max_size}, ttl={default_ttl}")
+        self._max_size = max_size
+        self._default_ttl = default_ttl
+        self._enabled = enabled
+        self._cache: OrderedDict[str, CacheEntry] = OrderedDict()
+        self._total_hits: int = 0
+        self._total_misses: int = 0
+
+    @property
+    def enabled(self) -> bool:
+        return self._enabled
+
+    @enabled.setter
+    def enabled(self, value: bool) -> None:
+        self._enabled = value
+
+    def make_key(
+        self,
+        model: str,
+        messages: list[dict[str, str]],
+        temperature: float = 0.7,
+    ) -> str:
+        logger.debug(f"Entered into make_key: model={model}")
+        payload = json.dumps({
+            "model": model,
+            "messages": messages,
+            "temperature": temperature,
+        }, sort_keys=True, default=str)
+        return hashlib.sha256(payload.encode()).hexdigest()[:32]
+
+    def get(self, key: str) -> Any | None:
+        logger.debug(f"Entered into get: key={key[:12]}")
+        if not self._enabled:
+            return None
+
+        entry = self._cache.get(key)
+        if entry is None:
+            self._total_misses += 1
+            return None
+
+        if entry.is_expired:
+            del self._cache[key]
+            self._total_misses += 1
+            return None
+
+        entry.hits += 1
+        self._total_hits += 1
+        self._cache.move_to_end(key)
+        return entry.value
+
+    def put(
+        self,
+        key: str,
+        value: Any,
+        ttl: float | None = None,
+    ) -> None:
+        logger.debug(f"Entered into put: key={key[:12]}")
+        if not self._enabled:
+            return
+
+        if key in self._cache:
+            self._cache.move_to_end(key)
+            self._cache[key].value = value
+            self._cache[key].created_at = time.time()
+            return
+
+        while len(self._cache) >= self._max_size:
+            self._cache.popitem(last=False)
+
+        self._cache[key] = CacheEntry(
+            key=key,
+            value=value,
+            ttl=ttl if ttl is not None else self._default_ttl,
+        )
+
+    def invalidate(self, key: str) -> bool:
+        logger.debug(f"Entered into invalidate: key={key[:12]}")
+        if key in self._cache:
+            del self._cache[key]
+            return True
+        return False
+
+    def clear(self) -> int:
+        logger.debug("Entered into clear")
+        count = len(self._cache)
+        self._cache.clear()
+        return count
+
+    def evict_expired(self) -> int:
+        logger.debug("Entered into evict_expired")
+        expired_keys = [k for k, v in self._cache.items() if v.is_expired]
+        for k in expired_keys:
+            del self._cache[k]
+        return len(expired_keys)
+
+    def get_stats(self) -> dict[str, Any]:
+        logger.debug("Entered into get_stats")
+        total = self._total_hits + self._total_misses
+        hit_rate = (self._total_hits / total * 100) if total > 0 else 0.0
+        return {
+            "size": len(self._cache),
+            "max_size": self._max_size,
+            "hits": self._total_hits,
+            "misses": self._total_misses,
+            "hit_rate_pct": round(hit_rate, 1),
+            "default_ttl": self._default_ttl,
+            "enabled": self._enabled,
+        }
+
+    def __len__(self) -> int:
+        return len(self._cache)
+
+    def __contains__(self, key: str) -> bool:
+        entry = self._cache.get(key)
+        return entry is not None and not entry.is_expired