opsveritas 0.1.1__tar.gz

opsveritas-0.1.1/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: opsveritas
+Version: 0.1.1
+Summary: Monitor your AI agents with 2 lines of code
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: pytest-mock>=3.12; extra == "dev"

opsveritas-0.1.1/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "opsveritas"
+version = "0.1.1"
+description = "Monitor your AI agents with 2 lines of code"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.8"
+dependencies = []
+
+[project.optional-dependencies]
+dev = [
+  "pytest>=7.0",
+  "pytest-asyncio>=0.23",
+  "pytest-mock>=3.12",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]

opsveritas-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

opsveritas-0.1.1/src/opsveritas/__init__.py

@@ -0,0 +1,7 @@
+from ._config import init
+from ._context import run
+from .trace import monitor
+from .wrap import wrap
+
+__version__ = "0.1.0"
+__all__ = ["init", "monitor", "run", "wrap"]

opsveritas-0.1.1/src/opsveritas/_config.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Optional
+
+@dataclass
+class _Config:
+    api_key: str
+    endpoint: str
+
+_config: Optional[_Config] = None
+
+
+def init(api_key: str, *, endpoint: str = "https://agents.opsveritas.com") -> None:
+    global _config
+    if not api_key or not isinstance(api_key, str):
+        raise ValueError("[OpsVeritas] api_key is required")
+    _config = _Config(api_key=api_key, endpoint=endpoint.rstrip("/"))
+
+
+def get_config() -> _Config:
+    if _config is None:
+        raise RuntimeError("[OpsVeritas] Call opsveritas.init(api_key) before using the SDK")
+    return _config

opsveritas-0.1.1/src/opsveritas/_context.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+import threading
+import time
+from datetime import datetime, timezone
+from typing import Any, Optional
+
+_local = threading.local()
+
+
+class run:
+    """
+    Group multiple LLM calls into one execution record.
+
+    Usage:
+        with opsveritas.run('My Agent') as r:
+            resp1 = wrapped_openai.chat.completions.create(...)
+            resp2 = wrapped_anthropic.messages.create(...)
+        # → ONE execution sent with combined cost, tokens, duration
+    """
+
+    def __init__(self, agent_name: str, *, user_id: Optional[str] = None) -> None:
+        self.agent_name = agent_name
+        self.user_id = user_id
+        self._start: float = 0.0
+        self._executed_at: str = ''
+        self._calls: list[dict[str, Any]] = []
+
+    def __enter__(self) -> 'run':
+        self._start = time.monotonic()
+        self._executed_at = datetime.now(timezone.utc).isoformat()
+        _local.current = self
+        return self
+
+    def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> bool:
+        _local.current = None
+        try:
+            duration_ms = int((time.monotonic() - self._start) * 1000)
+            status = 'failed' if exc_type is not None else 'success'
+            error_message = str(exc_val) if exc_val is not None else None
+
+            total_input  = sum(c.get('input_tokens')  or 0 for c in self._calls)
+            total_output = sum(c.get('output_tokens') or 0 for c in self._calls)
+            total_cost   = sum(c.get('cost_usd')      or 0.0 for c in self._calls)
+
+            # Preserve call order, deduplicate
+            seen: set[str] = set()
+            models: list[str] = []
+            for c in self._calls:
+                m = c.get('model')
+                if m and m not in seen:
+                    seen.add(m)
+                    models.append(m)
+
+            platform = (self._calls[0].get('platform') or 'custom_webhook') if self._calls else 'custom_webhook'
+
+            payload: dict[str, Any] = {
+                'platform':     platform,
+                'agent_name':   self.agent_name,
+                'status':       status,
+                'executed_at':  self._executed_at,
+                'duration_ms':  duration_ms,
+                'error_message': error_message,
+            }
+            if total_input:
+                payload['input_tokens'] = total_input
+            if total_output:
+                payload['output_tokens'] = total_output
+            if total_cost:
+                payload['cost_usd'] = round(total_cost, 6)
+            if models:
+                payload['models'] = models
+            if self.user_id:
+                payload['user_id'] = self.user_id
+
+            from opsveritas._http import send_execution_sync
+            send_execution_sync(payload)
+        except Exception:
+            pass
+        return False  # never suppress exceptions
+
+    def _record(self, sub_call: dict[str, Any]) -> None:
+        self._calls.append(sub_call)
+
+
+def get_active_run() -> Optional[run]:
+    return getattr(_local, 'current', None)

opsveritas-0.1.1/src/opsveritas/_http.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+import atexit
+import json
+import threading
+import urllib.request
+from typing import Any, Optional
+from ._config import get_config
+
+_pending: list[threading.Thread] = []
+_lock = threading.Lock()
+
+
+def _flush() -> None:
+    with _lock:
+        threads = list(_pending)
+    for t in threads:
+        t.join(timeout=6)
+
+
+atexit.register(_flush)
+
+
+def _post_sync(url: str, api_key: str, payload: dict[str, Any]) -> None:
+    try:
+        data = json.dumps(payload).encode("utf-8")
+        req = urllib.request.Request(
+            url,
+            data=data,
+            headers={"Content-Type": "application/json", "x-opsveritas-key": api_key},
+            method="POST",
+        )
+        with urllib.request.urlopen(req, timeout=5):
+            pass
+    except Exception:
+        pass  # Never crash user code
+
+
+def send_execution(payload: dict[str, Any]) -> None:
+    cfg = get_config()
+    url = f"{cfg.endpoint}/webhooks/agent-execution"
+    t = threading.Thread(target=_post_sync, args=(url, cfg.api_key, payload), daemon=True)
+    with _lock:
+        _pending.append(t)
+    t.start()
+
+
+def send_execution_sync(payload: dict[str, Any]) -> None:
+    """Blocking send — use when the caller is already blocking (e.g. run.__exit__)."""
+    cfg = get_config()
+    _post_sync(f"{cfg.endpoint}/webhooks/agent-execution", cfg.api_key, payload)
+
+
+async def send_execution_async(payload: dict[str, Any]) -> None:
+    """Async variant — tries httpx first, falls back to sync thread."""
+    try:
+        import httpx  # optional fast path
+        cfg = get_config()
+        async with httpx.AsyncClient(timeout=5) as client:
+            await client.post(
+                f"{cfg.endpoint}/webhooks/agent-execution",
+                json=payload,
+                headers={"x-opsveritas-key": cfg.api_key},
+            )
+    except ImportError:
+        send_execution(payload)  # fallback to sync thread
+    except Exception:
+        pass

opsveritas-0.1.1/src/opsveritas/_pricing.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+from typing import Optional
+
+# Cost per 1M tokens (input, output) in USD
+# ORDERING NOTE: more-specific keys must appear before generic prefixes they share.
+# e.g. "gpt-4.1" before "gpt-4" — otherwise the substring match hits the wrong entry.
+_PRICING: dict[str, tuple[float, float]] = {
+    # ── OpenAI ────────────────────────────────────────────────────────────────
+    # GPT-4.1 family (April 2025) — must be before "gpt-4" to avoid wrong match
+    "gpt-4.1-nano":              (0.10,   0.40),
+    "gpt-4.1-mini":              (0.40,   1.60),
+    "gpt-4.1":                   (2.00,   8.00),
+    # GPT-4o
+    "gpt-4o-mini":               (0.15,   0.60),
+    "gpt-4o":                    (2.50,  10.00),
+    # Legacy GPT-4
+    "gpt-4-turbo":               (10.00, 30.00),
+    "gpt-4":                     (30.00, 60.00),
+    "gpt-3.5-turbo":             (0.50,   1.50),
+    # Reasoning models
+    "o4-mini":                   (1.10,   4.40),
+    "o3-mini":                   (1.10,   4.40),
+    "o3":                        (10.00, 40.00),
+    "o1-mini":                   (3.00,  12.00),
+    "o1":                        (15.00, 60.00),
+
+    # ── Anthropic ─────────────────────────────────────────────────────────────
+    # Claude 4 family — matched by substring for versioned IDs
+    # e.g. "claude-opus-4-8" matches "claude-opus-4"
+    "claude-opus-4":             (15.00, 75.00),
+    "claude-sonnet-4":           (3.00,  15.00),
+    "claude-haiku-4":            (0.80,   4.00),
+    # Claude 3.7
+    "claude-3-7-sonnet":         (3.00,  15.00),
+    # Claude 3.5
+    "claude-3-5-sonnet":         (3.00,  15.00),
+    "claude-3-5-haiku":          (0.80,   4.00),
+    # Claude 3
+    "claude-3-opus":             (15.00, 75.00),
+    "claude-3-sonnet":           (3.00,  15.00),
+    "claude-3-haiku":            (0.25,   1.25),
+
+    # ── Groq ──────────────────────────────────────────────────────────────────
+    # Llama 3.x  (new naming: llama-3.x-…)
+    "llama-3.3-70b":             (0.59,   0.79),
+    "llama-3.1-70b":             (0.59,   0.79),
+    "llama-3.1-8b":              (0.05,   0.08),
+    # Legacy Groq naming (llama3-…)
+    "llama3-70b":                (0.59,   0.79),
+    "llama3-8b":                 (0.05,   0.08),
+    "mixtral-8x7b":              (0.24,   0.24),
+    "gemma2-9b":                 (0.20,   0.20),
+
+    # ── Google Gemini ─────────────────────────────────────────────────────────
+    "gemini-2.5-pro":            (1.25,  10.00),
+    "gemini-2.5-flash":          (0.15,   0.60),
+    "gemini-2.0-flash":          (0.10,   0.40),
+    "gemini-1.5-pro":            (1.25,   5.00),
+    "gemini-1.5-flash":          (0.075,  0.30),
+}
+
+
+def calc_cost(model: str, input_tokens: int, output_tokens: int) -> Optional[float]:
+    model_lower = model.lower()
+    key = next(
+        (k for k in _PRICING if model_lower in k or k in model_lower),
+        None,
+    )
+    if key is None:
+        return None
+    input_rate, output_rate = _PRICING[key]
+    raw = (input_tokens * input_rate + output_tokens * output_rate) / 1_000_000
+    return round(raw, 6)

opsveritas-0.1.1/src/opsveritas/_usage.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+from typing import Any, Optional
+
+
+def extract_usage(result: Any) -> dict[str, Any]:
+    """Auto-detect OpenAI / Anthropic / Gemini response and extract token usage."""
+    if result is None:
+        return {}
+
+    usage = getattr(result, "usage", None)
+    model = getattr(result, "model", None)
+
+    if usage is not None:
+        # OpenAI: usage.prompt_tokens / usage.completion_tokens
+        prompt_tokens = getattr(usage, "prompt_tokens", None)
+        if prompt_tokens is not None:
+            completion_tokens = getattr(usage, "completion_tokens", 0) or 0
+            tool_calls: Optional[int] = None
+            choices = getattr(result, "choices", None)
+            if choices:
+                msg = getattr(choices[0], "message", None)
+                tc = getattr(msg, "tool_calls", None) if msg else None
+                if tc:
+                    tool_calls = len(tc)
+            return {
+                "model": model,
+                "input_tokens": prompt_tokens,
+                "output_tokens": completion_tokens,
+                **({"tool_calls": tool_calls} if tool_calls else {}),
+            }
+
+        # Anthropic: usage.input_tokens / usage.output_tokens
+        input_tokens = getattr(usage, "input_tokens", None)
+        if input_tokens is not None:
+            output_tokens = getattr(usage, "output_tokens", 0) or 0
+            content = getattr(result, "content", None)
+            tool_calls = None
+            if content:
+                tc_count = sum(1 for b in content if getattr(b, "type", None) == "tool_use")
+                if tc_count:
+                    tool_calls = tc_count
+            return {
+                "model": model,
+                "input_tokens": input_tokens,
+                "output_tokens": output_tokens,
+                **({"tool_calls": tool_calls} if tool_calls else {}),
+            }
+
+    # Gemini: result.usage_metadata.prompt_token_count / candidates_token_count
+    # (model name is on the model instance, injected separately by wrap())
+    usage_meta = getattr(result, "usage_metadata", None)
+    if usage_meta is not None:
+        prompt_token_count = getattr(usage_meta, "prompt_token_count", None)
+        if prompt_token_count is not None:
+            return {
+                "input_tokens": prompt_token_count,
+                "output_tokens": getattr(usage_meta, "candidates_token_count", 0) or 0,
+            }
+
+    return {}

opsveritas-0.1.1/src/opsveritas/trace.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+import functools
+import inspect
+import json
+import time
+from datetime import datetime, timezone
+from typing import Any, Callable, Optional, TypeVar
+
+from ._http import send_execution, send_execution_async
+from ._pricing import calc_cost
+from ._usage import extract_usage
+
+
+def _summarize(result: Any) -> Optional[str]:
+    """Derive a short output_summary from a non-LLM return value.
+
+    Used so the server's silent-failure detector (which treats null output_tokens
+    + null output_summary as silent) doesn't false-positive on agents that return
+    structured data instead of a raw LLM response object.
+    """
+    if result is None:
+        return None
+    try:
+        if isinstance(result, str):
+            s = result.strip()
+            return s[:500] if s else None
+        if isinstance(result, (dict, list)):
+            return json.dumps(result, default=str)[:500]
+        return str(result)[:500]
+    except Exception:
+        return None
+
+F = TypeVar("F", bound=Callable[..., Any])
+
+
+def monitor(
+    agent_name: str,
+    *,
+    platform: str = "custom_webhook",
+    user_id: Optional[str] = None,
+) -> Callable[[F], F]:
+    """Decorator that auto-instruments any sync or async function."""
+    def decorator(fn: F) -> F:
+        if inspect.iscoroutinefunction(fn):
+            @functools.wraps(fn)
+            async def async_wrapper(*args: Any, **kwargs: Any) -> Any:
+                executed_at = datetime.now(timezone.utc).isoformat()
+                t0 = time.monotonic()
+                status = "success"
+                error_message = None
+                result = None
+                try:
+                    result = await fn(*args, **kwargs)
+                    return result
+                except Exception as exc:
+                    status = "failed"
+                    error_message = str(exc)
+                    raise
+                finally:
+                    try:
+                        duration_ms = int((time.monotonic() - t0) * 1000)
+                        usage = extract_usage(result)
+                        cost_usd = (
+                            calc_cost(usage["model"], usage["input_tokens"], usage["output_tokens"])
+                            if usage.get("model") and usage.get("input_tokens") is not None
+                            else None
+                        )
+                        payload: dict[str, Any] = {
+                            "platform": platform,
+                            "agent_name": agent_name,
+                            "status": status,
+                            "executed_at": executed_at,
+                            "duration_ms": duration_ms,
+                            "error_message": error_message,
+                            **{k: v for k, v in usage.items() if v is not None},
+                        }
+                        if cost_usd is not None:
+                            payload["cost_usd"] = cost_usd
+                        if user_id:
+                            payload["user_id"] = user_id
+                        # If no token usage was captured (non-LLM return value), derive a
+                        # summary so the server doesn't false-positive a silent failure.
+                        if "output_tokens" not in payload and "output_summary" not in payload:
+                            s = _summarize(result)
+                            if s:
+                                payload["output_summary"] = s
+                        await send_execution_async(payload)
+                    except Exception:
+                        pass  # Never crash user code
+            return async_wrapper  # type: ignore[return-value]
+        else:
+            @functools.wraps(fn)
+            def sync_wrapper(*args: Any, **kwargs: Any) -> Any:
+                executed_at = datetime.now(timezone.utc).isoformat()
+                t0 = time.monotonic()
+                status = "success"
+                error_message = None
+                result = None
+                try:
+                    result = fn(*args, **kwargs)
+                    return result
+                except Exception as exc:
+                    status = "failed"
+                    error_message = str(exc)
+                    raise
+                finally:
+                    try:
+                        duration_ms = int((time.monotonic() - t0) * 1000)
+                        usage = extract_usage(result)
+                        cost_usd = (
+                            calc_cost(usage["model"], usage["input_tokens"], usage["output_tokens"])
+                            if usage.get("model") and usage.get("input_tokens") is not None
+                            else None
+                        )
+                        payload: dict[str, Any] = {
+                            "platform": platform,
+                            "agent_name": agent_name,
+                            "status": status,
+                            "executed_at": executed_at,
+                            "duration_ms": duration_ms,
+                            "error_message": error_message,
+                            **{k: v for k, v in usage.items() if v is not None},
+                        }
+                        if cost_usd is not None:
+                            payload["cost_usd"] = cost_usd
+                        if user_id:
+                            payload["user_id"] = user_id
+                        # If no token usage was captured (non-LLM return value), derive a
+                        # summary so the server doesn't false-positive a silent failure.
+                        if "output_tokens" not in payload and "output_summary" not in payload:
+                            s = _summarize(result)
+                            if s:
+                                payload["output_summary"] = s
+                        send_execution(payload)
+                    except Exception:
+                        pass  # Never crash user code
+            return sync_wrapper  # type: ignore[return-value]
+    return decorator

opsveritas-0.1.1/src/opsveritas/wrap.py

@@ -0,0 +1,359 @@
+from __future__ import annotations
+import time
+from datetime import datetime, timezone
+from typing import Any, Optional, TypeVar
+
+from ._context import get_active_run
+from ._http import send_execution, send_execution_async
+from ._pricing import calc_cost
+from ._usage import extract_usage
+from .trace import _summarize
+
+T = TypeVar("T")
+
+_PATCHED = "_opsveritas_patched"
+
+
+def _extract_llm_output(result: Any) -> Optional[str]:
+    if result is None:
+        return None
+    try:
+        # OpenAI / Groq style
+        choices = getattr(result, "choices", None)
+        if choices:
+            content = getattr(getattr(choices[0], "message", None), "content", None)
+            if isinstance(content, str) and content.strip():
+                return content[:300]
+        # Anthropic style
+        content_blocks = getattr(result, "content", None)
+        if content_blocks:
+            for block in content_blocks:
+                if getattr(block, "type", None) == "text":
+                    text = getattr(block, "text", None)
+                    if isinstance(text, str) and text.strip():
+                        return text[:300]
+        # Gemini old SDK
+        resp = getattr(result, "response", None)
+        if resp:
+            try:
+                text = resp.text
+                if isinstance(text, str) and text.strip():
+                    return text[:300]
+            except Exception:
+                pass
+    except Exception:
+        pass
+    return None
+
+
+def _patch_openai_sync(client: Any, agent_name: str, platform: str, user_id: Optional[str]) -> None:
+    completions = getattr(getattr(client, "chat", None), "completions", None)
+    if completions is None or getattr(completions, _PATCHED, None) is True:
+        return
+
+    orig_create = completions.create
+
+    def patched_create(*args: Any, **kwargs: Any) -> Any:
+        executed_at = datetime.now(timezone.utc).isoformat()
+        t0 = time.monotonic()
+        status = "success"
+        error_message = None
+        result = None
+        try:
+            result = orig_create(*args, **kwargs)
+            return result
+        except Exception as exc:
+            status = "failed"
+            error_message = str(exc)
+            raise
+        finally:
+            try:
+                duration_ms = int((time.monotonic() - t0) * 1000)
+                usage = extract_usage(result)
+                cost_usd = (
+                    calc_cost(usage["model"], usage["input_tokens"], usage["output_tokens"])
+                    if usage.get("model") and usage.get("input_tokens") is not None
+                    else None
+                )
+                payload: dict[str, Any] = {
+                    "platform": platform,
+                    "agent_name": agent_name,
+                    "status": status,
+                    "executed_at": executed_at,
+                    "duration_ms": duration_ms,
+                    "error_message": error_message,
+                    **{k: v for k, v in usage.items() if v is not None},
+                }
+                if cost_usd is not None:
+                    payload["cost_usd"] = cost_usd
+                if user_id:
+                    payload["user_id"] = user_id
+                s = _extract_llm_output(result)
+                if s:
+                    payload["output_summary"] = s
+                active = get_active_run()
+                if active is not None:
+                    active._record(payload)
+                else:
+                    send_execution(payload)
+            except Exception:
+                pass  # Never crash user code
+
+    completions.create = patched_create
+    setattr(completions, _PATCHED, True)
+
+
+def _patch_openai_async(client: Any, agent_name: str, platform: str, user_id: Optional[str]) -> None:
+    completions = getattr(getattr(client, "chat", None), "completions", None)
+    if completions is None or getattr(completions, _PATCHED, None) is True:
+        return
+
+    orig_create = completions.create
+
+    async def patched_create(*args: Any, **kwargs: Any) -> Any:
+        executed_at = datetime.now(timezone.utc).isoformat()
+        t0 = time.monotonic()
+        status = "success"
+        error_message = None
+        result = None
+        try:
+            result = await orig_create(*args, **kwargs)
+            return result
+        except Exception as exc:
+            status = "failed"
+            error_message = str(exc)
+            raise
+        finally:
+            duration_ms = int((time.monotonic() - t0) * 1000)
+            usage = extract_usage(result)
+            cost_usd = (
+                calc_cost(usage["model"], usage["input_tokens"], usage["output_tokens"])
+                if usage.get("model") and usage.get("input_tokens") is not None
+                else None
+            )
+            payload: dict[str, Any] = {
+                "platform": platform,
+                "agent_name": agent_name,
+                "status": status,
+                "executed_at": executed_at,
+                "duration_ms": duration_ms,
+                "error_message": error_message,
+                **{k: v for k, v in usage.items() if v is not None},
+            }
+            if cost_usd is not None:
+                payload["cost_usd"] = cost_usd
+            if user_id:
+                payload["user_id"] = user_id
+            s = _extract_llm_output(result)
+            if s:
+                payload["output_summary"] = s
+            active = get_active_run()
+            if active is not None:
+                active._record(payload)
+            else:
+                await send_execution_async(payload)
+
+    completions.create = patched_create
+    setattr(completions, _PATCHED, True)
+
+
+def _patch_anthropic_sync(client: Any, agent_name: str, platform: str, user_id: Optional[str]) -> None:
+    messages = getattr(client, "messages", None)
+    if messages is None or getattr(messages, _PATCHED, None) is True:
+        return
+
+    orig_create = messages.create
+
+    def patched_create(*args: Any, **kwargs: Any) -> Any:
+        executed_at = datetime.now(timezone.utc).isoformat()
+        t0 = time.monotonic()
+        status = "success"
+        error_message = None
+        result = None
+        try:
+            result = orig_create(*args, **kwargs)
+            return result
+        except Exception as exc:
+            status = "failed"
+            error_message = str(exc)
+            raise
+        finally:
+            duration_ms = int((time.monotonic() - t0) * 1000)
+            usage = extract_usage(result)
+            cost_usd = (
+                calc_cost(usage["model"], usage["input_tokens"], usage["output_tokens"])
+                if usage.get("model") and usage.get("input_tokens") is not None
+                else None
+            )
+            payload: dict[str, Any] = {
+                "platform": platform,
+                "agent_name": agent_name,
+                "status": status,
+                "executed_at": executed_at,
+                "duration_ms": duration_ms,
+                "error_message": error_message,
+                **{k: v for k, v in usage.items() if v is not None},
+            }
+            if cost_usd is not None:
+                payload["cost_usd"] = cost_usd
+            if user_id:
+                payload["user_id"] = user_id
+            s = _extract_llm_output(result)
+            if s:
+                payload["output_summary"] = s
+            active = get_active_run()
+            if active is not None:
+                active._record(payload)
+            else:
+                send_execution(payload)
+
+    messages.create = patched_create
+    setattr(messages, _PATCHED, True)
+
+
+def _patch_gemini_sync(client: Any, agent_name: str, platform: str, user_id: Optional[str]) -> None:
+    if getattr(client, _PATCHED, None) is True:
+        return
+
+    # Strip "models/" prefix (Gemini SDK uses "models/gemini-1.5-flash" format)
+    raw_name = getattr(client, "model_name", None) or getattr(client, "model", None)
+    model_name: Optional[str] = str(raw_name).replace("models/", "") if raw_name else None
+
+    orig_generate = client.generate_content
+
+    def patched_generate(*args: Any, **kwargs: Any) -> Any:
+        executed_at = datetime.now(timezone.utc).isoformat()
+        t0 = time.monotonic()
+        status = "success"
+        error_message = None
+        result = None
+        try:
+            result = orig_generate(*args, **kwargs)
+            return result
+        except Exception as exc:
+            status = "failed"
+            error_message = str(exc)
+            raise
+        finally:
+            try:
+                duration_ms = int((time.monotonic() - t0) * 1000)
+                usage = extract_usage(result)
+                # Gemini doesn't embed model in response — inject from instance
+                if model_name and "model" not in usage:
+                    usage = {**usage, "model": model_name}
+                cost_usd = (
+                    calc_cost(usage["model"], usage["input_tokens"], usage["output_tokens"])
+                    if usage.get("model") and usage.get("input_tokens") is not None
+                    else None
+                )
+                payload: dict[str, Any] = {
+                    "platform": platform,
+                    "agent_name": agent_name,
+                    "status": status,
+                    "executed_at": executed_at,
+                    "duration_ms": duration_ms,
+                    "error_message": error_message,
+                    **{k: v for k, v in usage.items() if v is not None},
+                }
+                if cost_usd is not None:
+                    payload["cost_usd"] = cost_usd
+                if user_id:
+                    payload["user_id"] = user_id
+                if "output_tokens" not in payload and "output_summary" not in payload:
+                    s = _summarize(result)
+                    if s:
+                        payload["output_summary"] = s
+                active = get_active_run()
+                if active is not None:
+                    active._record(payload)
+                else:
+                    send_execution(payload)
+            except Exception:
+                pass
+
+    client.generate_content = patched_generate
+    setattr(client, _PATCHED, True)
+
+
+def _patch_gemini_new_sync(client: Any, agent_name: str, platform: str, user_id: Optional[str]) -> None:
+    """Patch the new google-genai SDK: client.models.generate_content(model=..., contents=...)."""
+    models = getattr(client, "models", None)
+    if models is None or getattr(models, _PATCHED, None) is True:
+        return
+
+    orig_generate = models.generate_content
+
+    def patched_generate(*args: Any, **kwargs: Any) -> Any:
+        executed_at = datetime.now(timezone.utc).isoformat()
+        t0 = time.monotonic()
+        status = "success"
+        error_message = None
+        result = None
+        # model name is passed as kwarg or first positional arg
+        raw_model = kwargs.get("model") or (args[0] if args else None)
+        model_name: Optional[str] = str(raw_model).replace("models/", "") if raw_model else None
+        try:
+            result = orig_generate(*args, **kwargs)
+            return result
+        except Exception as exc:
+            status = "failed"
+            error_message = str(exc)
+            raise
+        finally:
+            try:
+                duration_ms = int((time.monotonic() - t0) * 1000)
+                usage = extract_usage(result)
+                if model_name and "model" not in usage:
+                    usage = {**usage, "model": model_name}
+                cost_usd = (
+                    calc_cost(usage["model"], usage["input_tokens"], usage["output_tokens"])
+                    if usage.get("model") and usage.get("input_tokens") is not None
+                    else None
+                )
+                payload: dict[str, Any] = {
+                    "platform": platform,
+                    "agent_name": agent_name,
+                    "status": status,
+                    "executed_at": executed_at,
+                    "duration_ms": duration_ms,
+                    "error_message": error_message,
+                    **{k: v for k, v in usage.items() if v is not None},
+                }
+                if cost_usd is not None:
+                    payload["cost_usd"] = cost_usd
+                if user_id:
+                    payload["user_id"] = user_id
+                if "output_tokens" not in payload and "output_summary" not in payload:
+                    s = _summarize(result)
+                    if s:
+                        payload["output_summary"] = s
+                active = get_active_run()
+                if active is not None:
+                    active._record(payload)
+                else:
+                    send_execution(payload)
+            except Exception:
+                pass
+
+    models.generate_content = patched_generate
+    setattr(models, _PATCHED, True)
+
+
+def wrap(client: T, *, agent_name: str, platform: str = "sdk", user_id: Optional[str] = None) -> T:
+    """Auto-instrument an OpenAI, Anthropic, or Gemini client."""
+    cls_name = type(client).__name__
+
+    if "AsyncOpenAI" in cls_name or "AsyncAzureOpenAI" in cls_name:
+        _patch_openai_async(client, agent_name, platform, user_id)
+    elif "Anthropic" in cls_name and "OpenAI" not in cls_name:
+        _patch_anthropic_sync(client, agent_name, platform, user_id)
+    elif hasattr(client, "chat") and hasattr(getattr(client, "chat", None), "completions"):
+        _patch_openai_sync(client, agent_name, platform, user_id)
+    elif hasattr(client, "messages") and callable(getattr(getattr(client, "messages", None), "create", None)):
+        _patch_anthropic_sync(client, agent_name, platform, user_id)
+    elif callable(getattr(client, "generate_content", None)):
+        _patch_gemini_sync(client, agent_name, platform, user_id)
+    elif callable(getattr(getattr(client, "models", None), "generate_content", None)):
+        _patch_gemini_new_sync(client, agent_name, platform, user_id)
+
+    return client

opsveritas-0.1.1/src/opsveritas.egg-info/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: opsveritas
+Version: 0.1.1
+Summary: Monitor your AI agents with 2 lines of code
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: pytest-mock>=3.12; extra == "dev"

opsveritas-0.1.1/src/opsveritas.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+pyproject.toml
+src/opsveritas/__init__.py
+src/opsveritas/_config.py
+src/opsveritas/_context.py
+src/opsveritas/_http.py
+src/opsveritas/_pricing.py
+src/opsveritas/_usage.py
+src/opsveritas/trace.py
+src/opsveritas/wrap.py
+src/opsveritas.egg-info/PKG-INFO
+src/opsveritas.egg-info/SOURCES.txt
+src/opsveritas.egg-info/dependency_links.txt
+src/opsveritas.egg-info/requires.txt
+src/opsveritas.egg-info/top_level.txt
+tests/test_monitor.py
+tests/test_wrap.py

opsveritas-0.1.1/src/opsveritas.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

opsveritas-0.1.1/src/opsveritas.egg-info/requires.txt

@@ -0,0 +1,5 @@
+
+[dev]
+pytest>=7.0
+pytest-asyncio>=0.23
+pytest-mock>=3.12

opsveritas-0.1.1/src/opsveritas.egg-info/top_level.txt

@@ -0,0 +1 @@
+opsveritas

opsveritas-0.1.1/tests/test_monitor.py

@@ -0,0 +1,131 @@
+import pytest
+from unittest.mock import MagicMock, patch
+import opsveritas
+from opsveritas.trace import monitor
+
+
+@pytest.fixture(autouse=True)
+def setup_sdk():
+    opsveritas.init("test-secret", endpoint="http://localhost:3001")
+
+
+# Fake OpenAI response
+def fake_openai_response():
+    usage = MagicMock()
+    usage.prompt_tokens = 100
+    usage.completion_tokens = 50
+    usage.total_tokens = 150
+    resp = MagicMock()
+    resp.model = "gpt-4o-mini"
+    resp.usage = usage
+    resp.choices = []
+    return resp
+
+
+# Fake Anthropic response
+def fake_anthropic_response():
+    usage = MagicMock()
+    usage.input_tokens = 80
+    usage.output_tokens = 40
+    # No prompt_tokens — distinguishes Anthropic from OpenAI
+    del usage.prompt_tokens
+    resp = MagicMock()
+    resp.model = "claude-3-5-sonnet-20241022"
+    resp.usage = usage
+    resp.content = []
+    return resp
+
+
+class TestMonitorSync:
+    def test_success_with_openai_shape(self):
+        posted = []
+
+        def fake_send(payload):
+            posted.append(payload)
+
+        with patch("opsveritas.trace.send_execution", side_effect=fake_send):
+            @monitor("sync-openai-agent")
+            def run():
+                return fake_openai_response()
+
+            result = run()
+
+        assert result is not None
+        assert len(posted) == 1
+        p = posted[0]
+        assert p["agent_name"] == "sync-openai-agent"
+        assert p["status"] == "success"
+        assert p["input_tokens"] == 100
+        assert p["output_tokens"] == 50
+        assert p["model"] == "gpt-4o-mini"
+        assert p["cost_usd"] > 0
+        assert p["duration_ms"] >= 0
+
+    def test_failure_sets_status(self):
+        posted = []
+
+        def fake_send(payload):
+            posted.append(payload)
+
+        with patch("opsveritas.trace.send_execution", side_effect=fake_send):
+            @monitor("failing-agent")
+            def run():
+                raise ValueError("API down")
+
+            with pytest.raises(ValueError, match="API down"):
+                run()
+
+        assert posted[0]["status"] == "failed"
+        assert posted[0]["error_message"] == "API down"
+
+    def test_does_not_crash_if_send_fails(self):
+        with patch("opsveritas.trace.send_execution", side_effect=Exception("network")):
+            @monitor("robust-agent")
+            def run():
+                return "ok"
+
+            # Should not raise
+            assert run() == "ok"
+
+
+class TestMonitorAsync:
+    @pytest.mark.asyncio
+    async def test_async_success_with_anthropic_shape(self):
+        posted = []
+
+        async def fake_send_async(payload):
+            posted.append(payload)
+
+        with patch("opsveritas.trace.send_execution_async", side_effect=fake_send_async):
+            @monitor("async-anthropic-agent")
+            async def run():
+                return fake_anthropic_response()
+
+            await run()
+
+        assert len(posted) == 1
+        p = posted[0]
+        assert p["agent_name"] == "async-anthropic-agent"
+        assert p["status"] == "success"
+        assert p["input_tokens"] == 80
+        assert p["output_tokens"] == 40
+        assert p["model"] == "claude-3-5-sonnet-20241022"
+        assert p["cost_usd"] > 0
+
+    @pytest.mark.asyncio
+    async def test_async_failure(self):
+        posted = []
+
+        async def fake_send_async(payload):
+            posted.append(payload)
+
+        with patch("opsveritas.trace.send_execution_async", side_effect=fake_send_async):
+            @monitor("async-fail")
+            async def run():
+                raise RuntimeError("timeout")
+
+            with pytest.raises(RuntimeError):
+                await run()
+
+        assert posted[0]["status"] == "failed"
+        assert "timeout" in posted[0]["error_message"]

opsveritas-0.1.1/tests/test_wrap.py

@@ -0,0 +1,243 @@
+import pytest
+from unittest.mock import MagicMock, patch
+import opsveritas
+from opsveritas.wrap import wrap, _PATCHED
+
+
+@pytest.fixture(autouse=True)
+def setup_sdk():
+    opsveritas.init("test-secret", endpoint="http://localhost:3001")
+
+
+# ── Client stubs — use plain classes so hasattr() gives exact answers ─────────
+
+def make_openai_client(response):
+    """Stub with only chat.completions — no messages attribute."""
+    create_mock = MagicMock(return_value=response)
+
+    class Completions:
+        create = create_mock
+
+    class Chat:
+        completions = Completions()
+
+    class FakeOpenAI:
+        chat = Chat()
+
+    return FakeOpenAI()
+
+
+def make_anthropic_client(response):
+    """Stub with only messages — no chat attribute."""
+    create_mock = MagicMock(return_value=response)
+
+    class Messages:
+        create = create_mock
+
+    class FakeAnthropic:
+        messages = Messages()
+
+    return FakeAnthropic()
+
+
+def make_failing_openai_client():
+    """Stub whose create() raises."""
+    create_mock = MagicMock(side_effect=Exception("rate limited"))
+
+    class Completions:
+        create = create_mock
+
+    class Chat:
+        completions = Completions()
+
+    class FakeOpenAI:
+        chat = Chat()
+
+    return FakeOpenAI()
+
+
+def fake_openai_response():
+    usage = MagicMock()
+    usage.prompt_tokens = 120
+    usage.completion_tokens = 60
+    resp = MagicMock()
+    resp.model = "gpt-4o-mini"
+    resp.usage = usage
+    resp.choices = []
+    return resp
+
+
+def fake_anthropic_response():
+    usage = MagicMock()
+    usage.input_tokens = 90
+    usage.output_tokens = 45
+    del usage.prompt_tokens
+    resp = MagicMock()
+    resp.model = "claude-3-5-sonnet-20241022"
+    resp.usage = usage
+    resp.content = []
+    return resp
+
+
+# ── OpenAI tests ──────────────────────────────────────────────────────────────
+
+class TestWrapOpenAI:
+    def test_intercepts_create_and_sends_telemetry(self):
+        posted = []
+
+        def fake_send(payload):
+            posted.append(payload)
+
+        resp = fake_openai_response()
+        client = make_openai_client(resp)
+
+        with patch("opsveritas.wrap.send_execution", side_effect=fake_send):
+            wrapped = wrap(client, agent_name="wrapped-openai")
+            result = wrapped.chat.completions.create(model="gpt-4o-mini", messages=[])
+
+        assert result is resp
+        assert len(posted) == 1
+        p = posted[0]
+        assert p["agent_name"] == "wrapped-openai"
+        assert p["status"] == "success"
+        assert p["input_tokens"] == 120
+        assert p["output_tokens"] == 60
+        assert p["model"] == "gpt-4o-mini"
+        assert p["cost_usd"] > 0
+
+    def test_failed_call(self):
+        posted = []
+
+        def fake_send(payload):
+            posted.append(payload)
+
+        client = make_failing_openai_client()
+
+        with patch("opsveritas.wrap.send_execution", side_effect=fake_send):
+            wrapped = wrap(client, agent_name="fail-openai")
+            with pytest.raises(Exception, match="rate limited"):
+                wrapped.chat.completions.create(model="gpt-4o-mini", messages=[])
+
+        assert posted[0]["status"] == "failed"
+        assert "rate limited" in posted[0]["error_message"]
+
+    def test_no_double_patch(self):
+        posted = []
+
+        def fake_send(payload):
+            posted.append(payload)
+
+        resp = fake_openai_response()
+        client = make_openai_client(resp)
+
+        with patch("opsveritas.wrap.send_execution", side_effect=fake_send):
+            wrap(client, agent_name="agent-a")
+            wrap(client, agent_name="agent-b")  # second call — no-op
+
+            client.chat.completions.create(model="gpt-4o-mini", messages=[])
+
+        assert len(posted) == 1  # only one telemetry event
+
+
+# ── Anthropic tests ───────────────────────────────────────────────────────────
+
+class TestWrapAnthropic:
+    def test_intercepts_messages_create(self):
+        posted = []
+
+        def fake_send(payload):
+            posted.append(payload)
+
+        resp = fake_anthropic_response()
+        client = make_anthropic_client(resp)
+
+        with patch("opsveritas.wrap.send_execution", side_effect=fake_send):
+            wrapped = wrap(client, agent_name="wrapped-anthropic")
+            result = wrapped.messages.create(model="claude-3-5-sonnet-20241022", messages=[])
+
+        assert result is resp
+        p = posted[0]
+        assert p["agent_name"] == "wrapped-anthropic"
+        assert p["input_tokens"] == 90
+        assert p["output_tokens"] == 45
+        assert p["model"] == "claude-3-5-sonnet-20241022"
+        assert p["cost_usd"] > 0
+
+
+# ── Gemini tests ─────────────────────────────────────────────────────────────
+
+def fake_gemini_response():
+    # Use plain classes so hasattr() gives exact answers (no MagicMock auto-attributes)
+    class UsageMetadata:
+        prompt_token_count = 110
+        candidates_token_count = 55
+
+    class GeminiResponse:
+        usage_metadata = UsageMetadata()
+
+    return GeminiResponse()
+
+
+def make_gemini_model(response):
+    class FakeGenerativeModel:
+        model_name = "models/gemini-1.5-flash"
+        generate_content = MagicMock(return_value=response)
+
+    return FakeGenerativeModel()
+
+
+class TestWrapGemini:
+    def test_intercepts_generate_content(self):
+        posted = []
+
+        def fake_send(payload):
+            posted.append(payload)
+
+        resp = fake_gemini_response()
+        model = make_gemini_model(resp)
+
+        with patch("opsveritas.wrap.send_execution", side_effect=fake_send):
+            wrapped = wrap(model, agent_name="gemini-agent")
+            result = wrapped.generate_content("say hi")
+
+        assert result is resp
+        assert len(posted) == 1
+        p = posted[0]
+        assert p["agent_name"] == "gemini-agent"
+        assert p["status"] == "success"
+        assert p["input_tokens"] == 110
+        assert p["output_tokens"] == 55
+        assert p["model"] == "gemini-1.5-flash"  # "models/" prefix stripped
+        assert p["cost_usd"] > 0
+
+    def test_failed_generate_content(self):
+        posted = []
+
+        def fake_send(payload):
+            posted.append(payload)
+
+        class FakeGenerativeModel:
+            model_name = "gemini-1.5-flash"
+            generate_content = MagicMock(side_effect=Exception("quota exceeded"))
+
+        model = FakeGenerativeModel()
+
+        with patch("opsveritas.wrap.send_execution", side_effect=fake_send):
+            wrapped = wrap(model, agent_name="gemini-fail")
+            with pytest.raises(Exception, match="quota exceeded"):
+                wrapped.generate_content("hi")
+
+        assert posted[0]["status"] == "failed"
+        assert "quota exceeded" in posted[0]["error_message"]
+
+
+# ── Unknown client ────────────────────────────────────────────────────────────
+
+class TestWrapUnknown:
+    def test_passthrough_unknown_client(self):
+        class Unknown:
+            pass
+
+        client = Unknown()
+        result = wrap(client, agent_name="unknown")
+        assert result is client