relia-sdk 0.1.0__tar.gz

relia_sdk-0.1.0/.gitignore

@@ -0,0 +1,70 @@
+# Dependencies
+node_modules
+node_modules/
+**/node_modules
+**/node_modules/
+**/node_modules/**
+.pnp
+.pnp.*
+
+# Python
+__pycache__/
+**/__pycache__/
+*.py[cod]
+*$py.class
+.venv/
+venv/
+ENV/
+.pytest_cache/
+.uv/
+.coverage
+htmlcov/
+
+# Build & Output
+dist/
+**/dist/
+dist-ssr/
+build/
+out/
+.next/
+*.tsbuildinfo
+
+# Environment & Secrets
+.env
+.env.*
+!.env.example
+!.env.template
+*.pem
+*.key
+
+# Logs
+logs/
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+!src/components/logs/
+
+# Databases
+*.sqlite
+*.sqlite3
+*.db
+
+# IDE & OS
+.DS_Store
+Thumbs.db
+.idea/
+.vscode/*
+!.vscode/extensions.json
+*.sw?
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+
+# Other Tooling
+.vercel/
+.antigravitycli
+.turbo/

relia_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.5
+Name: relia-sdk
+Version: 0.1.0
+Summary: RELIA Observability & AI Agent Monitoring SDK for Python
+Author-email: RELIA Team <support@tryrelia.com>
+License: MIT
+Keywords: ai-agents,apm,fastapi,llm-monitoring,observability,opentelemetry,relia,tracing
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.24.0
+Provides-Extra: agent
+Requires-Dist: httpx>=0.24.0; extra == 'agent'
+Provides-Extra: all
+Requires-Dist: django>=4.0; extra == 'all'
+Requires-Dist: fastapi>=0.100.0; extra == 'all'
+Requires-Dist: flask>=2.0.0; extra == 'all'
+Requires-Dist: httpx>=0.24.0; extra == 'all'
+Requires-Dist: opentelemetry-api>=1.20.0; extra == 'all'
+Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.20.0; extra == 'all'
+Requires-Dist: opentelemetry-instrumentation-django>=0.40b0; extra == 'all'
+Requires-Dist: opentelemetry-instrumentation-fastapi>=0.40b0; extra == 'all'
+Requires-Dist: opentelemetry-instrumentation-flask>=0.40b0; extra == 'all'
+Requires-Dist: opentelemetry-instrumentation-httpx>=0.40b0; extra == 'all'
+Requires-Dist: opentelemetry-instrumentation-requests>=0.40b0; extra == 'all'
+Requires-Dist: opentelemetry-sdk>=1.20.0; extra == 'all'
+Provides-Extra: dev
+Requires-Dist: fastapi>=0.100.0; extra == 'dev'
+Requires-Dist: httpx>=0.24.0; extra == 'dev'
+Requires-Dist: opentelemetry-api>=1.20.0; extra == 'dev'
+Requires-Dist: opentelemetry-sdk>=1.20.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'
+Requires-Dist: pytest-mock>=3.12.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Provides-Extra: django
+Requires-Dist: django>=4.0; extra == 'django'
+Requires-Dist: opentelemetry-api>=1.20.0; extra == 'django'
+Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.20.0; extra == 'django'
+Requires-Dist: opentelemetry-instrumentation-django>=0.40b0; extra == 'django'
+Requires-Dist: opentelemetry-instrumentation-httpx>=0.40b0; extra == 'django'
+Requires-Dist: opentelemetry-instrumentation-requests>=0.40b0; extra == 'django'
+Requires-Dist: opentelemetry-sdk>=1.20.0; extra == 'django'
+Provides-Extra: fastapi
+Requires-Dist: fastapi>=0.100.0; extra == 'fastapi'
+Requires-Dist: opentelemetry-api>=1.20.0; extra == 'fastapi'
+Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.20.0; extra == 'fastapi'
+Requires-Dist: opentelemetry-instrumentation-fastapi>=0.40b0; extra == 'fastapi'
+Requires-Dist: opentelemetry-instrumentation-httpx>=0.40b0; extra == 'fastapi'
+Requires-Dist: opentelemetry-instrumentation-requests>=0.40b0; extra == 'fastapi'
+Requires-Dist: opentelemetry-sdk>=1.20.0; extra == 'fastapi'
+Provides-Extra: flask
+Requires-Dist: flask>=2.0.0; extra == 'flask'
+Requires-Dist: opentelemetry-api>=1.20.0; extra == 'flask'
+Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.20.0; extra == 'flask'
+Requires-Dist: opentelemetry-instrumentation-flask>=0.40b0; extra == 'flask'
+Requires-Dist: opentelemetry-instrumentation-httpx>=0.40b0; extra == 'flask'
+Requires-Dist: opentelemetry-instrumentation-requests>=0.40b0; extra == 'flask'
+Requires-Dist: opentelemetry-sdk>=1.20.0; extra == 'flask'
+Provides-Extra: otel
+Requires-Dist: opentelemetry-api>=1.20.0; extra == 'otel'
+Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.20.0; extra == 'otel'
+Requires-Dist: opentelemetry-instrumentation-httpx>=0.40b0; extra == 'otel'
+Requires-Dist: opentelemetry-instrumentation-requests>=0.40b0; extra == 'otel'
+Requires-Dist: opentelemetry-sdk>=1.20.0; extra == 'otel'

relia_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,79 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "relia-sdk"
+version = "0.1.0"
+description = "RELIA Observability & AI Agent Monitoring SDK for Python"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [
+    { name = "RELIA Team", email = "support@tryrelia.com" }
+]
+keywords = ["observability", "opentelemetry", "tracing", "apm", "ai-agents", "llm-monitoring", "fastapi", "relia"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: System :: Monitoring",
+]
+dependencies = [
+    "httpx>=0.24.0",
+]
+
+[project.optional-dependencies]
+otel = [
+    "opentelemetry-api>=1.20.0",
+    "opentelemetry-sdk>=1.20.0",
+    "opentelemetry-exporter-otlp-proto-http>=1.20.0",
+    "opentelemetry-instrumentation-requests>=0.40b0",
+    "opentelemetry-instrumentation-httpx>=0.40b0",
+]
+fastapi = [
+    "relia-sdk[otel]",
+    "opentelemetry-instrumentation-fastapi>=0.40b0",
+    "fastapi>=0.100.0",
+]
+flask = [
+    "relia-sdk[otel]",
+    "opentelemetry-instrumentation-flask>=0.40b0",
+    "flask>=2.0.0",
+]
+django = [
+    "relia-sdk[otel]",
+    "opentelemetry-instrumentation-django>=0.40b0",
+    "django>=4.0",
+]
+agent = [
+    "httpx>=0.24.0",
+]
+all = [
+    "relia-sdk[fastapi,flask,django,agent]",
+]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-asyncio>=0.23.0",
+    "pytest-mock>=3.12.0",
+    "fastapi>=0.100.0",
+    "httpx>=0.24.0",
+    "opentelemetry-api>=1.20.0",
+    "opentelemetry-sdk>=1.20.0",
+]
+
+[project.scripts]
+relia = "relia.cli.main:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/relia"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+asyncio_mode = "auto"
+

relia_sdk-0.1.0/src/relia/__init__.py

@@ -0,0 +1,29 @@
+from relia.agent import estimate_cost, report_run, tool, trace, trace_run
+from relia.agent.auto import init as init_agent
+from relia.config import ReliaConfig
+from relia.core.sanitize import sanitize_data, sanitize_object, sanitize_payload_string
+from relia.core.transport import flush
+from relia.integrations.fastapi import instrument_fastapi
+from relia.tracing import start
+
+__version__ = "0.1.0"
+
+init = init_agent
+
+__all__ = [
+    "start",
+    "init",
+    "instrument_fastapi",
+    "trace",
+    "tool",
+    "trace_run",
+    "report_run",
+    "estimate_cost",
+    "flush",
+    "sanitize_data",
+    "sanitize_object",
+    "sanitize_payload_string",
+    "ReliaConfig",
+    "__version__",
+]
+

relia_sdk-0.1.0/src/relia/__main__.py

@@ -0,0 +1,4 @@
+from relia.cli.main import main
+
+if __name__ == "__main__":
+    main()

relia_sdk-0.1.0/src/relia/agent/__init__.py

@@ -0,0 +1,21 @@
+from relia.agent.auto import init
+from relia.agent.core import extract_prompt_from_messages, report_run, resolve_agent_id
+from relia.agent.cost import estimate_cost
+from relia.agent.decorator import tool, trace, trace_run
+from relia.agent.wrappers import ReliaCallbackHandler, patch_anthropic, patch_openai
+from relia.core.transport import flush
+
+__all__ = [
+    "init",
+    "trace",
+    "tool",
+    "trace_run",
+    "report_run",
+    "estimate_cost",
+    "resolve_agent_id",
+    "extract_prompt_from_messages",
+    "patch_openai",
+    "patch_anthropic",
+    "ReliaCallbackHandler",
+    "flush",
+]

relia_sdk-0.1.0/src/relia/agent/auto.py

@@ -0,0 +1,41 @@
+import logging
+from typing import Optional
+from relia.agent.wrappers.anthropic import patch_anthropic
+from relia.agent.wrappers.openai import patch_openai
+from relia.config import ReliaConfig
+
+logger = logging.getLogger("relia")
+
+_initialized = False
+
+def init(
+    agent_id: Optional[str] = None,
+    agent_name: Optional[str] = None,
+    endpoint: Optional[str] = None,
+) -> bool:
+    """
+    Auto-initialize AI agent tracking by patching installed LLM libraries (OpenAI, Anthropic).
+    """
+    global _initialized
+    if _initialized:
+        return False
+
+    config = ReliaConfig.from_env(
+        agent_id=agent_id,
+        agent_name=agent_name,
+        agent_endpoint=endpoint,
+    )
+
+    from relia.agent.interceptor import init_interceptor
+
+    interceptor_success = init_interceptor()
+    openai_success = patch_openai()
+    anthropic_success = patch_anthropic()
+
+    _initialized = True
+
+    if interceptor_success or openai_success or anthropic_success:
+        logger.info("[relia] agent tracing initialized for %s", config.agent_name)
+        return True
+
+    return False

relia_sdk-0.1.0/src/relia/agent/core.py

@@ -0,0 +1,121 @@
+import hashlib
+import os
+from typing import Any, Dict, List, Optional
+from relia.agent.cost import estimate_cost
+from relia.config import DEFAULT_AGENT_ENDPOINT, ReliaConfig
+from relia.core.transport import report
+from relia.core.types import AgentRunPayload, AgentStep
+
+def resolve_agent_id(agent_name: str) -> str:
+    env_id = os.getenv("RELIA_AGENT_ID")
+    if env_id:
+        return env_id
+    base = agent_name or "agent"
+    return hashlib.sha1(base.encode("utf-8")).hexdigest()[:24]
+
+def extract_prompt_from_messages(messages: Any) -> str:
+    if isinstance(messages, str):
+        return messages[:5000]
+    if not isinstance(messages, list) or not messages:
+        return ""
+
+    # Find the last user message, fallback to last message
+    user_msg = None
+    for m in reversed(messages):
+        role = getattr(m, "role", None) or (m.get("role") if isinstance(m, dict) else None)
+        if role == "user":
+            user_msg = m
+            break
+    if not user_msg:
+        user_msg = messages[-1]
+
+    content = getattr(user_msg, "content", None) or (user_msg.get("content") if isinstance(user_msg, dict) else user_msg)
+    if isinstance(content, str):
+        return content[:5000]
+    if isinstance(content, list):
+        text_parts = []
+        for p in content:
+            if isinstance(p, str):
+                text_parts.append(p)
+            elif isinstance(p, dict):
+                text_parts.append(str(p.get("text", "")))
+            elif hasattr(p, "text"):
+                text_parts.append(str(getattr(p, "text", "")))
+        return " ".join(filter(None, text_parts))[:5000]
+
+    return str(content or "")[:5000]
+
+def report_run(
+    agent_id: Optional[str] = None,
+    name: Optional[str] = None,
+    service_name: Optional[str] = None,
+    primary_model: str = "ai-model",
+    prompt: str = "",
+    answer: str = "",
+    duration_ms: int = 0,
+    tokens_in: int = 0,
+    tokens_out: int = 0,
+    status: str = "ok",
+    steps: Optional[List[Dict[str, Any]]] = None,
+    endpoint: Optional[str] = None,
+    user: Optional[str] = None,
+    error: Optional[Any] = None,
+    cost_usd: Optional[float] = None,
+    version: str = "1.0.0",
+) -> None:
+    """
+    Report an AI Agent execution run directly to the RELIA backend.
+    """
+    config = ReliaConfig.from_env()
+    final_name = name or service_name or config.agent_name or "agent"
+    final_agent_id = agent_id or config.agent_id or final_name
+    final_endpoint = endpoint or config.agent_endpoint or DEFAULT_AGENT_ENDPOINT
+    final_user = user or config.agent_user or ""
+
+
+    if cost_usd is None:
+        cost_usd = estimate_cost(primary_model, tokens_in, tokens_out)
+
+    final_status = status
+    if error is not None:
+        final_status = "error"
+
+    raw_steps = steps or []
+    formatted_steps: List[AgentStep] = []
+    for s in raw_steps:
+        formatted_steps.append({
+            "type": s.get("type", "model"),
+            "name": str(s.get("name", "step"))[:100],
+            "detail": str(s.get("detail", ""))[:500] if s.get("detail") is not None else "",
+            "offset_ms": int(s.get("offset_ms", 0)),
+            "duration_ms": int(s.get("duration_ms", 0)),
+            "tokens": s.get("tokens"),
+            "tokens_in": s.get("tokens_in"),
+            "tokens_out": s.get("tokens_out"),
+            "provider": str(s.get("provider", "")) if s.get("provider") else None,
+            "model": str(s.get("model", "")) if s.get("model") else None,
+            "status": "error" if s.get("status") == "error" else "ok",
+            "input": str(s.get("input", ""))[:10000] if s.get("input") is not None else None,
+            "output": str(s.get("output", ""))[:10000] if s.get("output") is not None else None,
+        })
+
+
+    payload: AgentRunPayload = {
+        "agent_id": final_agent_id,
+        "name": final_name,
+        "service_name": final_name,
+        "primary_model": primary_model or "ai-model",
+        "version": version,
+        "endpoint": final_endpoint.replace("/runs", ""),
+        "user": final_user,
+        "duration_ms": max(0, duration_ms),
+        "tokens_in": max(0, tokens_in),
+        "tokens_out": max(0, tokens_out),
+        "cost_usd": cost_usd,
+        "status": "error" if final_status == "error" else "ok",
+        "prompt": str(prompt)[:5000],
+        "answer": str(answer)[:5000],
+        "steps": formatted_steps,
+    }
+
+    report(payload, final_endpoint)

relia_sdk-0.1.0/src/relia/agent/cost.py

@@ -0,0 +1,60 @@
+import re
+from typing import Dict, Tuple
+
+PRICES_PER_1M: Dict[str, Tuple[float, float]] = {
+    # model: (input_cost_per_1M, output_cost_per_1M)
+    "gpt-5.5-instant": (0.5, 2.0),
+    "gpt-5": (1.25, 10.0),
+    "gpt-4o": (2.5, 10.0),
+    "gpt-4o-mini": (0.15, 0.6),
+    "gpt-4.1": (2.0, 8.0),
+    "gpt-4.1-mini": (0.4, 1.6),
+    "gpt-4-turbo": (10.0, 30.0),
+    "o1": (15.0, 60.0),
+    "o1-mini": (1.1, 4.4),
+    "o3": (2.0, 8.0),
+    "o3-mini": (1.1, 4.4),
+    "o4-mini": (1.1, 4.4),
+    "claude-opus": (15.0, 75.0),
+    "claude-opus-4": (15.0, 75.0),
+    "claude-sonnet": (3.0, 15.0),
+    "claude-sonnet-4": (3.0, 15.0),
+    "claude-3-7-sonnet": (3.0, 15.0),
+    "claude-3-5-sonnet": (3.0, 15.0),
+    "claude-3-haiku": (0.25, 1.25),
+    "claude-3-5-haiku": (0.8, 4.0),
+    "deepseek-chat": (0.14, 0.28),
+    "deepseek-reasoner": (0.55, 2.19),
+    "gemini-2.5-pro": (1.25, 10.0),
+    "gemini-2.5-flash": (0.3, 2.5),
+    "gemini-2.0-flash": (0.1, 0.4),
+    "gemini-1.5-pro": (1.25, 5.0),
+    "gemini-1.5-flash": (0.075, 0.3),
+}
+
+def normalize_model(model: str) -> str:
+    cleaned = model.lower()
+    cleaned = re.sub(r"^[a-z0-9-]+\/", "", cleaned)
+    cleaned = re.sub(r":.*$", "", cleaned)
+    return cleaned.strip()
+
+def estimate_cost(model: str, tokens_in: int, tokens_out: int) -> float:
+    """
+    Estimate USD cost based on tokens_in and tokens_out for the given model ID.
+    """
+    if not model or (tokens_in <= 0 and tokens_out <= 0):
+        return 0.0
+
+    key = normalize_model(model)
+    price = (
+        PRICES_PER_1M.get(key)
+        or PRICES_PER_1M.get(re.sub(r"-\d+$", "", key))
+        or PRICES_PER_1M.get(key.split("-")[0])
+    )
+
+    if not price:
+        return 0.0
+
+    in_price, out_price = price
+    total = (tokens_in / 1_000_000.0) * in_price + (tokens_out / 1_000_000.0) * out_price
+    return round(total, 6)