torrix-sdk 1.1.0__py3-none-any.whl

torrix/__init__.py

@@ -0,0 +1,157 @@
+"""torrix — self-hosted LLM observability SDK.
+
+Intercept and log every model call your application makes to a Torrix
+instance. Two usage styles are supported:
+
+``torrix.init(...)`` then ``torrix.wrap()``
+    Apply a global patch to the OpenAI or Anthropic SDK so
+    ``chat.completions.create`` / ``messages.create`` are captured
+    automatically (sync and async, streaming included).
+
+``torrix.ingest(record)``
+    Log arbitrary run records manually — useful for providers without a
+    ready-made wrapper or for custom tooling. Records are delivered by a
+    background thread and flushed on process exit.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional, Union
+
+from ._client import TorrixClient, TorrixError
+from ._context import current_context, run_context
+from ._wrap import patch_classes as _patch_classes
+from ._wrap import wrap as _wrap_sdk
+from ._wrap import unwrap as _unpatch
+
+__all__ = [
+    "init",
+    "wrap",
+    "unwrap",
+    "ingest",
+    "flush",
+    "current",
+    "get_client",
+    "run_context",
+    "current_run_context",
+    "TorrixClient",
+    "TorrixError",
+]
+__version__ = "1.1.0"
+
+_DEFAULT: Optional[TorrixClient] = None
+
+
+def init(
+    api_key: Optional[str] = None,
+    base_url: Optional[str] = None,
+    *,
+    project: Optional[str] = None,
+    sample_rate: float = 1.0,
+    timeout: float = 10.0,
+    enabled: bool = True,
+    background: bool = True,
+    auto_instrument: bool = True,
+) -> TorrixClient:
+    """Configure the default Torrix client used by ``wrap`` and ``ingest``.
+
+    ``api_key`` is one of your Torrix API keys (``trxk_...``) and ``base_url``
+    points at the running Torrix server (default ``http://localhost:8088``).
+    The older ``init(base_url, api_key)`` order is detected and accepted.
+    ``project`` selects the project by id or name; when omitted the account's
+    default project is used. ``sample_rate`` in ``(0, 1]`` controls what
+    fraction of calls are recorded.
+
+    Unless ``auto_instrument=False``, init patches the OpenAI and Anthropic SDK
+    resource classes (whichever are installed) so calls are traced without an
+    explicit ``wrap()``; ``wrap()`` then becomes a no-op returning the existing
+    handle.
+    """
+    global _DEFAULT
+    api_key, base_url = _normalize_endpoint(api_key, base_url)
+    _DEFAULT = TorrixClient(
+        base_url,
+        api_key,
+        project=project,
+        sample_rate=sample_rate,
+        timeout=timeout,
+        enabled=enabled,
+        background=background,
+    )
+    if auto_instrument:
+        for provider in ("openai", "anthropic"):
+            try:
+                _patch_classes(provider)
+            except Exception:
+                # the SDK is optional; a missing library is not an error
+                pass
+    return _DEFAULT
+
+
+def _normalize_endpoint(
+    api_key: Optional[str],
+    base_url: Optional[str],
+) -> tuple[Optional[str], str]:
+    default = "http://localhost:8088"
+    looks_like_url = isinstance(api_key, str) and api_key.startswith(("http://", "https://"))
+    if looks_like_url and (base_url is None or not base_url.startswith(("http://", "https://"))):
+        # Legacy init(base_url, api_key) order.
+        return base_url or None, api_key.rstrip("/")
+    return api_key, (base_url or default).rstrip("/")
+
+
+def current() -> Optional[TorrixClient]:
+    """Return the default client configured by ``init`` (or ``None``)."""
+    return _DEFAULT
+
+
+def get_client() -> Optional[TorrixClient]:
+    """Alias for :func:`current`."""
+    return _DEFAULT
+
+
+def current_run_context() -> Optional[Dict[str, Any]]:
+    """Return the active run context fields, or ``None`` outside a context."""
+    return current_context()
+
+
+def wrap(target: Any = None, provider: Optional[str] = None) -> Any:
+    """Patch the OpenAI or Anthropic SDK to auto-log calls into Torrix.
+
+    ``wrap()`` / ``wrap("anthropic")`` patch the SDK resource classes globally
+    (sync, async and streaming). ``wrap(client)`` returns a tracing proxy for a
+    single client instance instead. The handle returned by the class-level form
+    can be passed to ``unwrap``; proxies are dropped by using the raw client
+    again.
+    """
+    return _wrap_sdk(target, provider)
+
+
+def unwrap(handle: Optional[int] = None) -> None:
+    """Restore the original SDK methods for a wrapped ``handle`` (or all)."""
+    _unpatch(handle)
+
+
+def ingest(records: Union[Dict[str, Any], List[Dict[str, Any]]], *, wait: bool = False) -> List[str]:
+    """Log one or several run records through the default client.
+
+    Background delivery is the default; pass ``wait=True`` to block until the
+    records are accepted and receive their ids. Raises :class:`TorrixError` if
+    no client has been configured with :func:`init`.
+    """
+    if _DEFAULT is None:
+        raise TorrixError("torrix not initialized: call torrix.init() first")
+    return _DEFAULT.ingest(records, wait=wait)
+
+
+def flush(timeout: float = 5.0) -> bool:
+    """Wait for queued records to be delivered (5 second default)."""
+    if _DEFAULT is None:
+        return True
+    return _DEFAULT.flush(timeout)
+
+
+def health() -> bool:
+    if _DEFAULT is None:
+        return False
+    return _DEFAULT.health()

torrix/_client.py

@@ -0,0 +1,197 @@
+"""Low-level ingest client for the Torrix server.
+
+Records are queued and delivered by a background daemon thread, so logging
+never blocks a request path. The queue is flushed on interpreter shutdown
+(``atexit``) and can be flushed manually with :meth:`TorrixClient.flush`.
+"""
+
+from __future__ import annotations
+
+import atexit
+import json
+import queue
+import random
+import uuid
+import threading
+import time
+from typing import Any, Dict, List, Optional, Union
+from urllib import request
+
+from ._context import current_context
+
+
+class TorrixError(RuntimeError):
+    """Raised when the Torrix server rejects a payload or cannot be reached."""
+
+
+_BATCH_SIZE = 500
+_FLUSH_TIMEOUT_SECONDS = 5.0
+
+
+class TorrixClient:
+    """Posts run records to a Torrix instance over HTTP."""
+
+    def __init__(
+        self,
+        base_url: str,
+        api_key: Optional[str] = None,
+        *,
+        project: Optional[str] = None,
+        sample_rate: float = 1.0,
+        timeout: float = 10.0,
+        enabled: bool = True,
+        background: bool = True,
+    ) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self.project = project
+        self.sample_rate = _clamp01(sample_rate)
+        self.timeout = timeout
+        self.enabled = enabled
+        self.background = background
+        self._accepted = 0
+        self._dropped = 0
+        self._last_error: Optional[str] = None
+        self._queue: "queue.Queue[List[Dict[str, Any]] | None]" = queue.Queue()
+        self._worker: Optional[threading.Thread] = None
+        self._lock = threading.Lock()
+        self._closed = False
+        if background:
+            self._worker = threading.Thread(target=self._worker_loop, name="torrix-ingest", daemon=True)
+            self._worker.start()
+            atexit.register(self.close)
+
+    def ingest(
+        self,
+        records: Union[Dict[str, Any], List[Dict[str, Any]]],
+        *,
+        wait: bool = False,
+    ) -> List[str]:
+        """Send one run record (or a batch) and return the accepted run ids.
+
+        With the default background mode the call returns immediately (an empty
+        list) after queueing; pass ``wait=True`` to deliver synchronously and
+        receive the ids. Each record accepts the fields documented for
+        ``POST /api/ingest``: ``request`` / ``response`` (each ``{"body": ...}``),
+        ``model``, ``provider``, ``status``, ``error``, ``latency_ms``,
+        ``start_time`` / ``end_time``, ``input_tokens``, ``output_tokens``,
+        ``cost_usd``, ``target_url``, ``trace_id``, ``session_id``, ``tags``.
+        """
+        if not self.enabled or self._closed:
+            return []
+        items = [records] if isinstance(records, dict) else list(records)
+        if not items:
+            return []
+        context = current_context()
+        if context:
+            for record in items:
+                if not isinstance(record, dict):
+                    continue
+                record.setdefault("trace_id", context.get("trace_id"))
+                if context.get("session_id"):
+                    record.setdefault("session_id", context["session_id"])
+                if context.get("agent_name"):
+                    record.setdefault("agent_name", context["agent_name"])
+                # Calls inside one context are siblings under the context's parent;
+                # only a nested context hangs under the latest call of its enclosing one.
+                if context.get("parent_run_id"):
+                    record.setdefault("parent_run_id", context["parent_run_id"])
+                if context.get("name") and not record.get("name"):
+                    record["name"] = context["name"]
+                record.setdefault("id", uuid.uuid4().hex)
+                context["last_run_id"] = record["id"]
+
+        accepted: List[str] = []
+        for start in range(0, len(items), _BATCH_SIZE):
+            batch = [r for r in items[start : start + _BATCH_SIZE] if random.random() < self.sample_rate]
+            if not batch:
+                continue
+            if self.background and not wait:
+                self._queue.put(batch)
+            else:
+                accepted.extend(self._send(batch, timeout=self.timeout))
+        self._accepted += len(accepted)
+        self._dropped += len(items) - len(accepted)
+        return accepted
+
+    def flush(self, timeout: float = _FLUSH_TIMEOUT_SECONDS) -> bool:
+        """Block until the queue drains or ``timeout`` elapses."""
+        if not self.background:
+            return True
+        deadline = time.monotonic() + timeout
+        while time.monotonic() < deadline:
+            if self._queue.unfinished_tasks == 0:
+                return True
+            time.sleep(0.01)
+        return self._queue.unfinished_tasks == 0
+
+    def close(self) -> None:
+        """Flush pending records and stop the worker thread."""
+        with self._lock:
+            if self._closed:
+                return
+            self._closed = True
+        if self.background:
+            self.flush()
+            self._queue.put(None)
+            if self._worker is not None:
+                self._worker.join(timeout=1.0)
+
+    def stats(self) -> Dict[str, Any]:
+        return {
+            "accepted": self._accepted,
+            "dropped": self._dropped,
+            "queued": self._queue.qsize(),
+            "last_error": self._last_error,
+        }
+
+    def _worker_loop(self) -> None:
+        while True:
+            batch = self._queue.get()
+            try:
+                if batch is None:
+                    return
+                self._send(batch, timeout=min(self.timeout, _FLUSH_TIMEOUT_SECONDS))
+            except TorrixError as exc:
+                self._last_error = str(exc)
+            except Exception as exc:  # pragma: no cover - defensive
+                self._last_error = str(exc)
+            finally:
+                self._queue.task_done()
+
+    def _send(self, batch: List[Dict[str, Any]], *, timeout: float) -> List[str]:
+        url = f"{self.base_url}/api/ingest"
+        payload = json.dumps({"records": batch}).encode("utf-8")
+        headers = {"content-type": "application/json", "user-agent": "torrix-sdk/1.1.0"}
+        if self.api_key:
+            headers["authorization"] = f"Bearer {self.api_key}"
+        if self.project:
+            headers["x-torrix-project"] = self.project
+        req = request.Request(url, data=payload, headers=headers, method="POST")
+        try:
+            with request.urlopen(req, timeout=timeout) as resp:
+                body = resp.read().decode("utf-8")
+                if resp.status >= 400:
+                    raise TorrixError(f"ingest rejected with HTTP {resp.status}: {body}")
+                parsed = json.loads(body) if body else {}
+                return list(parsed.get("ids", []))
+        except TorrixError:
+            self._last_error = "torrix_rejected"
+            raise
+        except Exception as exc:  # network, DNS, timeout
+            self._last_error = str(exc)
+            raise TorrixError(f"torrix unreachable: {exc}") from exc
+
+    def health(self) -> bool:
+        try:
+            with request.urlopen(f"{self.base_url}/health", timeout=self.timeout) as resp:
+                return resp.status == 200
+        except Exception:
+            return False
+
+
+def _clamp01(value: float) -> float:
+    try:
+        return min(1.0, max(0.0, float(value)))
+    except (TypeError, ValueError):
+        return 1.0

torrix/_context.py

@@ -0,0 +1,53 @@
+"""Run context propagation for automatic trace and parent linkage.
+
+``torrix.run_context(...)`` groups every call made inside the block into one
+trace and chains parent-child relationships without manual ids, so nested
+``torrix.wrap()`` calls build an agent tree on their own.
+"""
+
+from __future__ import annotations
+
+import uuid
+from contextlib import contextmanager
+from contextvars import ContextVar
+from typing import Any, Dict, Iterator, Optional
+
+_current: ContextVar[Optional[Dict[str, Any]]] = ContextVar("torrix_run_context", default=None)
+
+
+def current_context() -> Optional[Dict[str, Any]]:
+    """Return the active run context, if any (mostly useful in tests/debugging)."""
+    return _current.get()
+
+
+@contextmanager
+def run_context(
+    name: Optional[str] = None,
+    trace_id: Optional[str] = None,
+    session_id: Optional[str] = None,
+    agent_name: Optional[str] = None,
+    parent_run_id: Optional[str] = None,
+) -> Iterator[Dict[str, Any]]:
+    """Group calls into one trace and auto-link parents.
+
+    Records created inside the block inherit the context's ``trace_id``,
+    ``session_id`` and ``agent_name`` when they do not set their own. Calls in
+    the same block are siblings: they all get the block's ``parent_run_id``
+    (the enclosing context's latest run when the block was opened). Nested
+    blocks therefore hang a subagent's calls under the call that started it,
+    without turning sequential calls into one long chain.
+    """
+    parent = _current.get() or {}
+    context: Dict[str, Any] = {
+        "trace_id": trace_id or parent.get("trace_id") or uuid.uuid4().hex,
+        "session_id": session_id or parent.get("session_id"),
+        "agent_name": agent_name or parent.get("agent_name"),
+        "parent_run_id": parent_run_id or parent.get("last_run_id"),
+        "name": name or parent.get("name"),
+        "last_run_id": None,
+    }
+    token = _current.set(context)
+    try:
+        yield context
+    finally:
+        _current.reset(token)

torrix/_wrap.py

@@ -0,0 +1,642 @@
+"""Automatic capture of OpenAI and Anthropic SDK calls into Torrix.
+
+``wrap("openai")`` and ``wrap("anthropic")`` patch the sync and async resource
+classes so ``chat.completions.create`` / ``messages.create`` calls are recorded
+and forwarded to the configured Torrix instance. Streaming responses are
+accumulated as the caller iterates them, then recorded once at end of stream
+with the reconstructed response text, tool calls and usage.
+"""
+
+from __future__ import annotations
+
+import json
+import time
+import uuid
+from datetime import datetime, timezone
+from typing import Any, Callable, Dict, List, Optional, Tuple
+
+_TRANSPORT_KEYS = {"timeout", "max_retries", "extra_headers", "extra_query", "extra_body", "api_key", "base_url"}
+
+_PATCHED: Dict[int, List[Tuple[Any, Any, str]]] = {}
+_CLASS_PATCHES: Dict[str, int] = {}
+
+
+def patch_classes(provider: str = "openai") -> int:
+    """Patch the SDK resource classes once per provider; returns the handle.
+
+    Safe to call repeatedly: a second call returns the existing handle instead
+    of stacking another wrapper. Missing SDKs raise ImportError, which callers
+    like ``init`` swallow so an uninstalled library cannot crash startup.
+    """
+    if provider in _CLASS_PATCHES:
+        return _CLASS_PATCHES[provider]
+    if provider == "openai":
+        import openai.resources.chat.completions as chat
+        import openai.resources.completions as base
+
+        targets = [
+            (chat.Completions, "create"),
+            (chat.AsyncCompletions, "create"),
+            (base.Completions, "create"),
+            (base.AsyncCompletions, "create"),
+        ]
+    elif provider == "anthropic":
+        import anthropic.resources.messages as messages
+
+        targets = [
+            (messages.Messages, "create"),
+            (messages.AsyncMessages, "create"),
+        ]
+    else:
+        raise ValueError(f"unsupported provider '{provider}' (expected 'openai' or 'anthropic')")
+
+    handle = uuid.uuid4().int
+    patches = []
+    for cls, name in targets:
+        original = getattr(cls, name)
+        setattr(cls, name, _chain(original, provider))
+        patches.append((original, cls, name))
+    _PATCHED[handle] = patches
+    _CLASS_PATCHES[provider] = handle
+    return handle
+
+
+def wrap(target: Any = None, provider: Optional[str] = None) -> Any:
+    """Wrap the OpenAI or Anthropic SDK calls into Torrix.
+
+    Two call styles are supported, matching the original SDK:
+
+    ``torrix.wrap()`` / ``torrix.wrap("anthropic")``
+        Patch the SDK's resource classes globally (sync and async), including
+        streaming responses. Returns a numeric handle for ``unwrap``.
+
+    ``torrix.wrap(client)``
+        Return a lightweight proxy around one client instance. Use the proxy
+        in place of the raw client; the original object is untouched.
+    """
+    if target is None or isinstance(target, str):
+        if isinstance(target, str) and provider is None:
+            provider = target
+        return patch_classes(provider or "openai")
+    resolved = provider or _detect_provider(target)
+    return _instrument_client(target, resolved)
+
+
+def _detect_provider(client: Any) -> str:
+    module = type(client).__module__.lower()
+    name = type(client).__name__.lower()
+    return "anthropic" if "anthropic" in module or "anthropic" in name else "openai"
+
+
+class _OpenAICompletionsProxy:
+    def __init__(self, resource: Any) -> None:
+        self._resource = resource
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._resource, name)
+
+    def create(self, *args: Any, **kwargs: Any) -> Any:
+        return _create_wrapper(self._resource, self._resource.create, "openai", *args, **kwargs)
+
+
+class _OpenAIChatProxy:
+    def __init__(self, chat: Any) -> None:
+        self._chat = chat
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._chat, name)
+
+    @property
+    def completions(self) -> _OpenAICompletionsProxy:
+        return _OpenAICompletionsProxy(self._chat.completions)
+
+
+class _AnthropicMessagesProxy:
+    def __init__(self, resource: Any) -> None:
+        self._resource = resource
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._resource, name)
+
+    def create(self, *args: Any, **kwargs: Any) -> Any:
+        return _create_wrapper(self._resource, self._resource.create, "anthropic", *args, **kwargs)
+
+
+class _OpenAIClientProxy:
+    def __init__(self, client: Any) -> None:
+        self._client = client
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._client, name)
+
+    @property
+    def chat(self) -> _OpenAIChatProxy:
+        return _OpenAIChatProxy(self._client.chat)
+
+    @property
+    def completions(self) -> _OpenAICompletionsProxy:
+        return _OpenAICompletionsProxy(self._client.completions)
+
+
+class _AnthropicClientProxy:
+    def __init__(self, client: Any) -> None:
+        self._client = client
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._client, name)
+
+    @property
+    def messages(self) -> _AnthropicMessagesProxy:
+        return _AnthropicMessagesProxy(self._client.messages)
+
+
+def _instrument_client(client: Any, provider: str) -> Any:
+    if provider == "anthropic":
+        return _AnthropicClientProxy(client)
+    return _OpenAIClientProxy(client)
+
+
+def unwrap(handle: Optional[int] = None) -> None:
+    """Restore the original SDK methods for a wrapped handle (or all)."""
+    handles = list(_PATCHED.keys()) if handle is None else [handle]
+    for key in handles:
+        for original, cls, name in _PATCHED.pop(key, []):
+            if getattr(cls, name, None) is not None:
+                setattr(cls, name, original)
+    for provider, value in list(_CLASS_PATCHES.items()):
+        if value not in _PATCHED:
+            _CLASS_PATCHES.pop(provider, None)
+
+
+def _chain(original: Callable[..., Any], provider: str) -> Callable[..., Any]:
+    def wrapped(self: Any, *args: Any, **kwargs: Any) -> Any:
+        return _create_wrapper(self, original, provider, *args, **kwargs)
+
+    return wrapped
+
+
+def _create_wrapper(self: Any, original: Callable[..., Any], provider: str, *args: Any, **kwargs: Any) -> Any:
+    from . import current
+
+    client = current()
+    if client is None or not client.enabled:
+        return original(self, *args, **kwargs)
+
+    name = kwargs.pop("torrix_name", None)
+    request_body = _request_payload(kwargs)
+    start = time.monotonic()
+    try:
+        result = original(self, *args, **kwargs)
+    except Exception as exc:
+        _record(
+            client,
+            provider,
+            request_body,
+            name=name,
+            error=str(exc),
+            error_detail=repr(exc),
+            latency_ms=_since(start),
+            status=_status_for(exc),
+        )
+        raise
+
+    if _is_stream(result, kwargs):
+        return _wrap_stream(result, client, provider, request_body, start, name)
+
+    _record(client, provider, request_body, name=name, response=_response_dict(result), latency_ms=_since(start))
+    return result
+
+
+def _is_stream(result: Any, kwargs: Dict[str, Any]) -> bool:
+    if kwargs.get("stream") is True:
+        return True
+    name = type(result).__name__.lower()
+    return "stream" in name
+
+
+def _request_payload(kwargs: Dict[str, Any]) -> Dict[str, Any]:
+    payload: Dict[str, Any] = {}
+    for key, value in kwargs.items():
+        if key in _TRANSPORT_KEYS:
+            continue
+        payload[key] = _to_jsonable(value)
+    return payload
+
+
+def _record(
+    client: Any,
+    provider: str,
+    request_body: Dict[str, Any],
+    *,
+    name: Optional[str] = None,
+    response: Optional[Dict[str, Any]] = None,
+    error: Optional[str] = None,
+    error_detail: Optional[str] = None,
+    latency_ms: Optional[int] = None,
+    status: Optional[int] = None,
+) -> None:
+    now = datetime.now(timezone.utc)
+    record: Dict[str, Any] = {
+        "id": uuid.uuid4().hex,
+        "model": request_body.get("model") or None,
+        "request": {"body": request_body},
+        "provider": provider,
+    }
+    if name:
+        record["name"] = str(name)
+    if latency_ms is not None:
+        record["latency_ms"] = latency_ms
+        record["start_time"] = datetime.fromtimestamp(now.timestamp() - latency_ms / 1000, tz=timezone.utc).isoformat(timespec="milliseconds")
+        record["end_time"] = now.isoformat(timespec="milliseconds")
+    if response is not None:
+        record["response"] = {"body": response}
+        record.update(_token_counts(provider, response))
+        record.setdefault("status", 200)
+    else:
+        record["status"] = status if status is not None else (502 if error else 200)
+    if error:
+        record["error"] = error
+        if error_detail:
+            record["error_detail"] = error_detail
+    try:
+        client.ingest(record)
+    except Exception:
+        pass
+
+
+def _token_counts(provider: str, response: Dict[str, Any]) -> Dict[str, int]:
+    usage = response.get("usage") or {}
+    if not isinstance(usage, dict):
+        return {}
+    counts: Dict[str, int] = {}
+    if provider == "anthropic":
+        if isinstance(usage.get("input_tokens"), int):
+            counts["input_tokens"] = usage["input_tokens"]
+        if isinstance(usage.get("output_tokens"), int):
+            counts["output_tokens"] = usage["output_tokens"]
+        if isinstance(usage.get("cache_read_input_tokens"), int):
+            counts["cache_read_tokens"] = usage["cache_read_input_tokens"]
+        if isinstance(usage.get("cache_creation_input_tokens"), int):
+            counts["cache_creation_tokens"] = usage["cache_creation_input_tokens"]
+        return counts
+    if isinstance(usage.get("prompt_tokens"), int):
+        counts["input_tokens"] = usage["prompt_tokens"]
+    if isinstance(usage.get("completion_tokens"), int):
+        counts["output_tokens"] = usage["completion_tokens"]
+    details = usage.get("prompt_tokens_details")
+    if isinstance(details, dict) and isinstance(details.get("cached_tokens"), int):
+        counts["cache_read_tokens"] = details["cached_tokens"]
+    return counts
+
+
+def _status_for(exc: Exception) -> Optional[int]:
+    status = getattr(exc, "status_code", None)
+    return status if isinstance(status, int) else None
+
+
+def _since(start: float) -> int:
+    return int((time.monotonic() - start) * 1000)
+
+
+def _response_dict(obj: Any) -> Dict[str, Any]:
+    return _serialize(obj)
+
+
+def _serialize(obj: Any) -> Dict[str, Any]:
+    dump = getattr(obj, "model_dump", None)
+    if callable(dump):
+        try:
+            return _to_jsonable(dump())  # type: ignore[call-arg]
+        except Exception:
+            pass
+    dump_json = getattr(obj, "model_dump_json", None)
+    if callable(dump_json):
+        try:
+            return json.loads(str(dump_json()))
+        except Exception:
+            pass
+    return _to_jsonable(vars(obj) if hasattr(obj, "__dict__") else obj)
+
+
+def _to_jsonable(value: Any) -> Any:
+    if value is None or isinstance(value, (str, int, float, bool)):
+        return value
+    if isinstance(value, (list, tuple)):
+        return [_to_jsonable(v) for v in value]
+    if isinstance(value, dict):
+        return {str(k): _to_jsonable(v) for k, v in value.items()}
+    dump = getattr(value, "model_dump", None)
+    if callable(dump):
+        try:
+            return _to_jsonable(dump())  # type: ignore[call-arg]
+        except Exception:
+            pass
+    return str(value)
+
+
+class _SyncStreamProxy:
+    """Wraps a sync stream, delegating attributes and accumulating chunks."""
+
+    def __init__(
+        self,
+        stream: Any,
+        accumulate: Callable[[Any], None],
+        finish: Callable[[Optional[Exception]], None],
+    ) -> None:
+        self._stream = stream
+        self._accumulate = accumulate
+        self._finish_fn = finish
+        self._finished = False
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._stream, name)
+
+    def __iter__(self) -> "_SyncStreamProxy":
+        return self
+
+    def __next__(self) -> Any:
+        try:
+            chunk = next(self._stream)
+        except StopIteration:
+            self._finish(None)
+            raise
+        except Exception as exc:
+            self._finish(exc)
+            raise
+        self._accumulate(chunk)
+        return chunk
+
+    def close(self) -> None:
+        close = getattr(self._stream, "close", None)
+        if callable(close):
+            try:
+                close()
+            except Exception:
+                pass
+        self._finish(None)
+
+    def __enter__(self) -> "_SyncStreamProxy":
+        enter = getattr(self._stream, "__enter__", None)
+        if callable(enter):
+            try:
+                enter()
+            except Exception:
+                pass
+        return self
+
+    def __exit__(self, *args: Any) -> None:
+        self.close()
+
+    def _finish(self, error: Optional[Exception]) -> None:
+        if self._finished:
+            return
+        self._finished = True
+        self._finish_fn(error)
+
+
+class _AsyncStreamProxy:
+    """Wraps an async stream, delegating attributes and accumulating chunks."""
+
+    def __init__(
+        self,
+        stream: Any,
+        accumulate: Callable[[Any], None],
+        finish: Callable[[Optional[Exception]], None],
+    ) -> None:
+        self._stream = stream
+        self._accumulate = accumulate
+        self._finish_fn = finish
+        self._finished = False
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._stream, name)
+
+    def __aiter__(self) -> "_AsyncStreamProxy":
+        return self
+
+    async def __anext__(self) -> Any:
+        try:
+            chunk = await self._stream.__anext__()
+        except StopAsyncIteration:
+            self._finish(None)
+            raise
+        except Exception as exc:
+            self._finish(exc)
+            raise
+        self._accumulate(chunk)
+        return chunk
+
+    async def aclose(self) -> None:
+        close = getattr(self._stream, "aclose", None)
+        if callable(close):
+            try:
+                await close()
+            except Exception:
+                pass
+        self._finish(None)
+
+    async def __aenter__(self) -> "_AsyncStreamProxy":
+        enter = getattr(self._stream, "__aenter__", None)
+        if callable(enter):
+            try:
+                await enter()
+            except Exception:
+                pass
+        return self
+
+    async def __aexit__(self, *args: Any) -> None:
+        await self.aclose()
+
+    def _finish(self, error: Optional[Exception]) -> None:
+        if self._finished:
+            return
+        self._finished = True
+        self._finish_fn(error)
+
+
+def _wrap_stream(
+    result: Any,
+    client: Any,
+    provider: str,
+    request_body: Dict[str, Any],
+    start: float,
+    name: Optional[str] = None,
+) -> Any:
+    accumulator = _new_accumulator(provider)
+
+    def accumulate(chunk: Any) -> None:
+        _accumulate(provider, accumulator, chunk)
+
+    def finish(error: Optional[Exception]) -> None:
+        if error is not None:
+            _record(
+                client,
+                provider,
+                request_body,
+                name=name,
+                error=str(error),
+                error_detail=repr(error),
+                latency_ms=_since(start),
+                status=_status_for(error),
+            )
+            return
+        _record(
+            client,
+            provider,
+            request_body,
+            name=name,
+            response=_assembled_response(provider, accumulator),
+            latency_ms=_since(start),
+        )
+
+    if hasattr(result, "__anext__"):
+        return _AsyncStreamProxy(result, accumulate, finish)
+    return _SyncStreamProxy(result, accumulate, finish)
+
+
+def _new_accumulator(provider: str) -> Dict[str, Any]:
+    if provider == "anthropic":
+        return {
+            "model": None,
+            "content": "",
+            "thinking": "",
+            "tool_calls": [],
+            "usage": {},
+            "finish_reason": None,
+            "role": "assistant",
+        }
+    return {
+        "model": None,
+        "content": "",
+        "thinking": "",
+        "tool_calls": [],
+        "usage": {},
+        "finish_reason": None,
+        "role": "assistant",
+    }
+
+
+def _accumulate(provider: str, accumulator: Dict[str, Any], chunk: Any) -> None:
+    data = _serialize(chunk) if not isinstance(chunk, dict) else chunk
+    if provider == "anthropic":
+        _accumulate_anthropic(accumulator, data)
+    else:
+        _accumulate_openai(accumulator, data)
+
+
+def _accumulate_openai(accumulator: Dict[str, Any], data: Dict[str, Any]) -> None:
+    if isinstance(data.get("model"), str) and accumulator["model"] is None:
+        accumulator["model"] = data["model"]
+    choices = data.get("choices")
+    if isinstance(choices, list) and choices:
+        choice = choices[0] if isinstance(choices[0], dict) else {}
+        delta = choice.get("delta") if isinstance(choice.get("delta"), dict) else {}
+        if isinstance(delta.get("content"), str):
+            accumulator["content"] += delta["content"]
+        if isinstance(delta.get("reasoning_content"), str):
+            accumulator["thinking"] += delta["reasoning_content"]
+        for tool_call in delta.get("tool_calls") or []:
+            if not isinstance(tool_call, dict):
+                continue
+            index = tool_call.get("index", len(accumulator["tool_calls"]))
+            while len(accumulator["tool_calls"]) <= index:
+                accumulator["tool_calls"].append({"id": None, "name": "", "arguments": ""})
+            entry = accumulator["tool_calls"][index]
+            if tool_call.get("id"):
+                entry["id"] = tool_call["id"]
+            function = tool_call.get("function") if isinstance(tool_call.get("function"), dict) else {}
+            if isinstance(function.get("name"), str):
+                entry["name"] += function["name"]
+            if isinstance(function.get("arguments"), str):
+                entry["arguments"] += function["arguments"]
+        if choice.get("finish_reason"):
+            accumulator["finish_reason"] = choice["finish_reason"]
+    usage = data.get("usage")
+    if isinstance(usage, dict):
+        accumulator["usage"] = usage
+
+
+def _accumulate_anthropic(accumulator: Dict[str, Any], data: Dict[str, Any]) -> None:
+    if isinstance(data.get("model"), str) and accumulator["model"] is None:
+        accumulator["model"] = data["model"]
+    event_type = data.get("type")
+    if event_type == "message_start":
+        message = data.get("message") if isinstance(data.get("message"), dict) else {}
+        if isinstance(message.get("model"), str):
+            accumulator["model"] = message["model"]
+        if isinstance(message.get("usage"), dict):
+            accumulator["usage"].update(message["usage"])
+    elif event_type == "content_block_start":
+        block = data.get("content_block") if isinstance(data.get("content_block"), dict) else {}
+        if block.get("type") == "tool_use":
+            accumulator["tool_calls"].append(
+                {"id": block.get("id"), "name": block.get("name") or "", "arguments": ""}
+            )
+    elif event_type == "content_block_delta":
+        delta = data.get("delta") if isinstance(data.get("delta"), dict) else {}
+        if delta.get("type") == "text_delta" and isinstance(delta.get("text"), str):
+            accumulator["content"] += delta["text"]
+        elif delta.get("type") == "thinking_delta" and isinstance(delta.get("thinking"), str):
+            accumulator["thinking"] += delta["thinking"]
+        elif delta.get("type") == "input_json_delta" and isinstance(delta.get("partial_json"), str):
+            if accumulator["tool_calls"]:
+                accumulator["tool_calls"][-1]["arguments"] += delta["partial_json"]
+    elif event_type == "message_delta":
+        delta = data.get("delta") if isinstance(data.get("delta"), dict) else {}
+        if delta.get("stop_reason"):
+            accumulator["finish_reason"] = delta["stop_reason"]
+        if isinstance(data.get("usage"), dict):
+            accumulator["usage"].update(data["usage"])
+
+
+def _assembled_response(provider: str, accumulator: Dict[str, Any]) -> Dict[str, Any]:
+    tool_calls = [entry for entry in accumulator["tool_calls"] if entry.get("name")]
+    if provider == "anthropic":
+        content: List[Dict[str, Any]] = []
+        if accumulator["content"]:
+            content.append({"type": "text", "text": accumulator["content"]})
+        for tool in tool_calls:
+            content.append(
+                {
+                    "type": "tool_use",
+                    "id": tool.get("id") or f"toolu_{uuid.uuid4().hex[:12]}",
+                    "name": tool["name"],
+                    "input": _maybe_json(tool.get("arguments")),
+                }
+            )
+        response: Dict[str, Any] = {
+            "model": accumulator["model"],
+            "role": "assistant",
+            "content": content,
+            "stop_reason": accumulator["finish_reason"],
+            "usage": accumulator["usage"],
+        }
+        if accumulator["thinking"]:
+            response["thinking"] = accumulator["thinking"]
+        return response
+    message: Dict[str, Any] = {"role": "assistant", "content": accumulator["content"]}
+    if accumulator["thinking"]:
+        message["reasoning_content"] = accumulator["thinking"]
+    if tool_calls:
+        message["tool_calls"] = [
+            {
+                "id": tool.get("id") or f"call_{uuid.uuid4().hex[:12]}",
+                "type": "function",
+                "function": {"name": tool["name"], "arguments": tool.get("arguments") or "{}"},
+            }
+            for tool in tool_calls
+        ]
+    return {
+        "model": accumulator["model"],
+        "choices": [{"index": 0, "message": message, "finish_reason": accumulator["finish_reason"]}],
+        "usage": accumulator["usage"],
+    }
+
+
+def _maybe_json(text: Optional[str]) -> Any:
+    if not text:
+        return {}
+    try:
+        return json.loads(text)
+    except (TypeError, ValueError):
+        return text

torrix_sdk-1.1.0.dist-info/METADATA

@@ -0,0 +1,78 @@
+Metadata-Version: 2.4
+Name: torrix-sdk
+Version: 1.1.0
+Summary: Python SDK for Torrix, self-hosted observability for AI agents: record OpenAI and Anthropic calls with no dependencies.
+Author: Torrix
+License: MIT
+Project-URL: Homepage, https://github.com/TorrixAI/torrix
+Project-URL: Documentation, https://github.com/TorrixAI/torrix/blob/main/docs/integrations/python-sdk.md
+Project-URL: Issues, https://github.com/TorrixAI/torrix/issues
+Keywords: llm,observability,ai-agents,openai,anthropic,tracing,cost,self-hosted
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: openai
+Requires-Dist: openai>=1.0.0; extra == "openai"
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.30.0; extra == "anthropic"
+Dynamic: license-file
+
+# Torrix Python SDK
+
+Record every OpenAI and Anthropic call your Python app or agent makes in
+[Torrix](https://github.com/TorrixAI/torrix), the self-hosted observability platform for AI agents.
+You get the prompt, response, tokens, cost, latency and tool calls of each call, grouped into
+traces and sessions.
+
+- No dependencies of its own. Works with sync, async and streaming clients.
+- Sends data in a background thread, so your app is not slowed down.
+- Your data goes only to your own Torrix server.
+
+## Install
+
+```bash
+pip install torrix-sdk
+```
+
+You also need a running Torrix server. The quickest way:
+
+```bash
+docker run -d --name torrix -p 8088:8088 -v torrix_data:/data gettorrixai/torrix:latest
+```
+
+Open http://localhost:8088, create your account, and copy an API key from **Integrations**.
+
+## Use
+
+The package installs as `torrix-sdk` and imports as `torrix`.
+
+```python
+import torrix
+
+torrix.init(api_key="trxk_YOUR_KEY", base_url="http://localhost:8088")
+```
+
+That is all. Every call made through the installed `openai` and `anthropic` packages is recorded
+from now on.
+
+Group calls into one turn and name the agent that made them:
+
+```python
+with torrix.run_context(session_id="chat-7", agent_name="support-bot"):
+    answer = client.chat.completions.create(model="gpt-4o-mini", messages=[...])
+```
+
+Short scripts and serverless functions should call `torrix.flush()` before they exit.
+
+## Learn more
+
+- [Python SDK guide](https://github.com/TorrixAI/torrix/blob/main/docs/integrations/python-sdk.md)
+- [How Torrix organizes your data](https://github.com/TorrixAI/torrix/blob/main/docs/concepts.md)
+- [Torrix on GitHub](https://github.com/TorrixAI/torrix)
+
+MIT licensed.

torrix_sdk-1.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+torrix/__init__.py,sha256=kKwhoErmXH_fxZuZ5fSd3YI1QCLxm45FyUTSUvHjKJs,5209
+torrix/_client.py,sha256=IuQXKS2iUMmcVex07Z1nS0jZfk0HLubJs62-HmwSiCs,7441
+torrix/_context.py,sha256=Bt6R2v2kzOZ3Dkfl1Xbq_aAHtYmTi2-wY2Mz8uuYg9Y,1989
+torrix/_wrap.py,sha256=tzzbx14iVvclnu5Hs0pKxwZsQVLKX4FPI3cJiHmQxGA,22008
+torrix/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+torrix_sdk-1.1.0.dist-info/licenses/LICENSE,sha256=9AOvIuhmnC9liUXm8O-j7CGzTufXT9E7rRVQs61VHqw,1063
+torrix_sdk-1.1.0.dist-info/METADATA,sha256=CPzex-CgDeQr8-ROHuGvyVFCgPzCueoYFm5Xco-rTH0,2709
+torrix_sdk-1.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+torrix_sdk-1.1.0.dist-info/top_level.txt,sha256=2iagmeW2z45qeI-jFNmSl6oZ36SwRWM-eBIuFsiJqwk,7
+torrix_sdk-1.1.0.dist-info/RECORD,,

torrix_sdk-1.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

torrix_sdk-1.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Torrix
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

torrix_sdk-1.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+torrix