freesolo 0.1.0__py3-none-any.whl

freesolo/__init__.py

@@ -0,0 +1,21 @@
+from .client import Tracer, configure, get_current_trace_id, get_tracer, start_trace
+from .decorators import trace
+from .providers import (
+    instrument_anthropic,
+    instrument_client,
+    instrument_google,
+    instrument_openai,
+)
+
+__all__ = [
+    "Tracer",
+    "configure",
+    "start_trace",
+    "get_tracer",
+    "get_current_trace_id",
+    "trace",
+    "instrument_openai",
+    "instrument_anthropic",
+    "instrument_google",
+    "instrument_client",
+]

freesolo/client.py

@@ -0,0 +1,385 @@
+from __future__ import annotations
+
+import asyncio
+import contextvars
+import functools
+import os
+import uuid
+from dataclasses import dataclass, field
+from datetime import UTC, datetime
+from typing import Any, Callable
+
+import httpx
+
+from .sanitize import sanitize_value
+
+
+def _utc_now() -> datetime:
+    return datetime.now(UTC)
+
+
+def _env(name: str) -> str | None:
+    value = os.getenv(name)
+    return value or None
+
+
+@dataclass
+class TracerConfig:
+    base_url: str | None = None
+    api_key: str | None = None
+    timeout_seconds: float = 5.0
+    enabled: bool = True
+    endpoint_path: str = "/api/traces/ingest"
+
+
+@dataclass
+class SpanRecord:
+    started_at: datetime
+    input_payload: Any = None
+    output_payload: Any = None
+    provider: str | None = None
+    model: str | None = None
+    input_tokens: int | None = None
+    output_tokens: int | None = None
+    duration_ms: int | None = None
+
+    def as_payload(self) -> dict[str, Any]:
+        return {
+            "provider": self.provider,
+            "model": self.model,
+            "duration_ms": self.duration_ms,
+            "input_tokens": self.input_tokens,
+            "output_tokens": self.output_tokens,
+            "input_payload": self.input_payload,
+            "output_payload": self.output_payload,
+        }
+
+
+@dataclass
+class TraceRecord:
+    trace_id: str
+    metadata: dict[str, Any] | None = None
+    spans: list[SpanRecord] = field(default_factory=list)
+    managed: bool = False
+
+
+@dataclass
+class ActiveSpan:
+    trace: TraceRecord
+    is_root: bool
+    span: SpanRecord
+    trace_token: contextvars.Token[TraceRecord | None] | None
+
+
+_current_trace: contextvars.ContextVar[TraceRecord | None] = contextvars.ContextVar(
+    "freesolo_current_trace",
+    default=None,
+)
+
+
+class Tracer:
+    def __init__(self) -> None:
+        self._config = TracerConfig(
+            base_url=((_env("FREESOLO_BASE_URL") or "").rstrip("/") or None),
+            api_key=_env("FREESOLO_API_KEY"),
+        )
+
+    @property
+    def config(self) -> TracerConfig:
+        return self._config
+
+    def configure(
+        self,
+        *,
+        base_url: str | None = None,
+        api_key: str | None = None,
+    ) -> None:
+        if base_url is not None:
+            self._config.base_url = base_url.rstrip("/")
+        if api_key is not None:
+            self._config.api_key = api_key
+
+    def start_trace(
+        self,
+        trace_id: str | None = None,
+        *,
+        metadata: dict[str, Any] | None = None,
+    ) -> _TraceContext:
+        return _TraceContext(
+            tracer=self,
+            trace=TraceRecord(
+                trace_id=trace_id or str(uuid.uuid4()),
+                metadata=metadata,
+                managed=True,
+            ),
+        )
+
+    def _start_span(
+        self,
+        *,
+        input_payload: Any,
+        provider: str | None = None,
+        model: str | None = None,
+    ) -> ActiveSpan:
+        trace = _current_trace.get()
+        is_root = trace is None
+        trace_token: contextvars.Token[TraceRecord | None] | None = None
+
+        if trace is None:
+            trace = TraceRecord(trace_id=str(uuid.uuid4()))
+            trace_token = _current_trace.set(trace)
+
+        span = SpanRecord(
+            started_at=_utc_now(),
+            input_payload=input_payload,
+            provider=provider,
+            model=model,
+        )
+
+        return ActiveSpan(
+            trace=trace,
+            is_root=is_root,
+            span=span,
+            trace_token=trace_token,
+        )
+
+    def _finish_span(
+        self,
+        active_span: ActiveSpan,
+        *,
+        output_payload: Any = None,
+        usage: dict[str, int | None] | None = None,
+    ) -> None:
+        ended_at = _utc_now()
+        active_span.span.duration_ms = int(
+            (ended_at - active_span.span.started_at).total_seconds() * 1000
+        )
+        active_span.span.output_payload = output_payload
+
+        if usage:
+            active_span.span.input_tokens = usage.get("input_tokens")
+            active_span.span.output_tokens = usage.get("output_tokens")
+
+        active_span.trace.spans.append(active_span.span)
+
+        if not active_span.is_root or active_span.trace.managed:
+            return
+
+        try:
+            self._emit_trace(active_span.trace)
+        finally:
+            if active_span.trace_token is not None:
+                _current_trace.reset(active_span.trace_token)
+
+    async def _finish_span_async(
+        self,
+        active_span: ActiveSpan,
+        *,
+        output_payload: Any = None,
+        usage: dict[str, int | None] | None = None,
+    ) -> None:
+        ended_at = _utc_now()
+        active_span.span.duration_ms = int(
+            (ended_at - active_span.span.started_at).total_seconds() * 1000
+        )
+        active_span.span.output_payload = output_payload
+
+        if usage:
+            active_span.span.input_tokens = usage.get("input_tokens")
+            active_span.span.output_tokens = usage.get("output_tokens")
+
+        active_span.trace.spans.append(active_span.span)
+
+        if not active_span.is_root or active_span.trace.managed:
+            return
+
+        try:
+            await self._emit_trace_async(active_span.trace)
+        finally:
+            if active_span.trace_token is not None:
+                _current_trace.reset(active_span.trace_token)
+
+    def create_payload(self, trace: TraceRecord) -> dict[str, Any]:
+        return {
+            "metadata": trace.metadata,
+            "spans": [span.as_payload() for span in trace.spans],
+        }
+
+    def _emit_trace(self, trace: TraceRecord) -> None:
+        if (
+            not self._config.enabled
+            or not self._config.base_url
+            or not self._config.api_key
+        ):
+            return
+
+        payload = self.create_payload(trace)
+        endpoint = f"{self._config.base_url}{self._config.endpoint_path}"
+
+        try:
+            with httpx.Client(timeout=self._config.timeout_seconds) as client:
+                client.post(
+                    endpoint,
+                    headers={
+                        "Authorization": f"Bearer {self._config.api_key}",
+                        "Content-Type": "application/json",
+                    },
+                    json=payload,
+                ).raise_for_status()
+        except Exception:
+            return
+
+    async def _emit_trace_async(self, trace: TraceRecord) -> None:
+        if (
+            not self._config.enabled
+            or not self._config.base_url
+            or not self._config.api_key
+        ):
+            return
+
+        payload = self.create_payload(trace)
+        endpoint = f"{self._config.base_url}{self._config.endpoint_path}"
+
+        try:
+            async with httpx.AsyncClient(
+                timeout=self._config.timeout_seconds
+            ) as client:
+                response = await client.post(
+                    endpoint,
+                    headers={
+                        "Authorization": f"Bearer {self._config.api_key}",
+                        "Content-Type": "application/json",
+                    },
+                    json=payload,
+                )
+                response.raise_for_status()
+        except Exception:
+            return
+
+    def wrap_callable(
+        self,
+        func: Callable[..., Any],
+        *,
+        input_builder: Callable[[tuple[Any, ...], dict[str, Any]], Any],
+        output_builder: Callable[[Any], Any],
+        attribute_builder: Callable[[tuple[Any, ...], dict[str, Any]], dict[str, Any] | None]
+        | None = None,
+        usage_builder: Callable[[Any], dict[str, int | None] | None] | None = None,
+    ) -> Callable[..., Any]:
+        if asyncio.iscoroutinefunction(func):
+
+            @functools.wraps(func)
+            async def async_wrapper(*args: Any, **kwargs: Any) -> Any:
+                attributes = attribute_builder(args, kwargs) if attribute_builder else {}
+                active_span = self._start_span(
+                    input_payload=input_builder(args, kwargs),
+                    provider=attributes.get("provider"),
+                    model=attributes.get("model"),
+                )
+                try:
+                    result = await func(*args, **kwargs)
+                except BaseException:
+                    await self._finish_span_async(active_span)
+                    raise
+
+                usage = usage_builder(result) if usage_builder else None
+                await self._finish_span_async(
+                    active_span,
+                    output_payload=output_builder(result),
+                    usage=usage,
+                )
+                return result
+
+            return async_wrapper
+
+        @functools.wraps(func)
+        def sync_wrapper(*args: Any, **kwargs: Any) -> Any:
+            attributes = attribute_builder(args, kwargs) if attribute_builder else {}
+            active_span = self._start_span(
+                input_payload=input_builder(args, kwargs),
+                provider=attributes.get("provider"),
+                model=attributes.get("model"),
+            )
+            try:
+                result = func(*args, **kwargs)
+            except BaseException:
+                self._finish_span(active_span)
+                raise
+
+            usage = usage_builder(result) if usage_builder else None
+            self._finish_span(
+                active_span,
+                output_payload=output_builder(result),
+                usage=usage,
+            )
+            return result
+
+        return sync_wrapper
+
+
+@dataclass
+class _TraceContext:
+    tracer: Tracer
+    trace: TraceRecord
+    trace_token: contextvars.Token[TraceRecord | None] | None = None
+
+    def __enter__(self) -> str:
+        self.trace_token = _current_trace.set(self.trace)
+        return self.trace.trace_id
+
+    def __exit__(self, exc_type: Any, exc: Any, tb: Any) -> None:
+        try:
+            if self.trace.spans:
+                self.tracer._emit_trace(self.trace)
+        finally:
+            if self.trace_token is not None:
+                _current_trace.reset(self.trace_token)
+
+    async def __aenter__(self) -> str:
+        return self.__enter__()
+
+    async def __aexit__(self, exc_type: Any, exc: Any, tb: Any) -> None:
+        try:
+            if self.trace.spans:
+                await self.tracer._emit_trace_async(self.trace)
+        finally:
+            if self.trace_token is not None:
+                _current_trace.reset(self.trace_token)
+
+
+_default_tracer = Tracer()
+
+
+def get_tracer() -> Tracer:
+    return _default_tracer
+
+
+def configure(*, base_url: str | None = None, api_key: str | None = None) -> None:
+    _default_tracer.configure(base_url=base_url, api_key=api_key)
+
+
+def start_trace(
+    trace_id: str | None = None,
+    *,
+    metadata: dict[str, Any] | None = None,
+) -> _TraceContext:
+    return _default_tracer.start_trace(trace_id=trace_id, metadata=metadata)
+
+
+def get_current_trace_id() -> str | None:
+    trace = _current_trace.get()
+    if trace is None:
+        return None
+
+    return trace.trace_id
+
+
+def sanitize_call_args(args: tuple[Any, ...], kwargs: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "args": sanitize_value(args),
+        "kwargs": sanitize_value(kwargs),
+    }
+
+
+def sanitize_result(result: Any) -> Any:
+    return sanitize_value(result)

freesolo/decorators.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+import asyncio
+import functools
+from typing import Any, Callable
+
+from .client import get_tracer, sanitize_call_args, sanitize_result
+
+
+def trace(
+    *,
+    capture_input: bool = True,
+    capture_output: bool = True,
+) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+        tracer = get_tracer()
+
+        if asyncio.iscoroutinefunction(func):
+
+            @functools.wraps(func)
+            async def async_wrapper(*args: Any, **kwargs: Any) -> Any:
+                active_span = tracer._start_span(  # noqa: SLF001
+                    input_payload=sanitize_call_args(args, kwargs)
+                    if capture_input
+                    else None,
+                )
+                try:
+                    result = await func(*args, **kwargs)
+                except BaseException:
+                    await tracer._finish_span_async(active_span)  # noqa: SLF001
+                    raise
+
+                await tracer._finish_span_async(  # noqa: SLF001
+                    active_span,
+                    output_payload=sanitize_result(result) if capture_output else None,
+                )
+                return result
+
+            return async_wrapper
+
+        @functools.wraps(func)
+        def sync_wrapper(*args: Any, **kwargs: Any) -> Any:
+            active_span = tracer._start_span(  # noqa: SLF001
+                input_payload=sanitize_call_args(args, kwargs)
+                if capture_input
+                else None,
+            )
+            try:
+                result = func(*args, **kwargs)
+            except BaseException:
+                tracer._finish_span(active_span)  # noqa: SLF001
+                raise
+
+            tracer._finish_span(  # noqa: SLF001
+                active_span,
+                output_payload=sanitize_result(result) if capture_output else None,
+            )
+            return result
+
+        return sync_wrapper
+
+    return decorator

freesolo/providers.py

@@ -0,0 +1,185 @@
+from __future__ import annotations
+
+from typing import Any
+
+from .client import get_tracer, sanitize_call_args, sanitize_result
+
+
+def _extract_usage(result: Any) -> dict[str, int | None] | None:
+    if hasattr(result, "usage"):
+        usage = getattr(result, "usage")
+    elif isinstance(result, dict):
+        usage = result.get("usage")
+    else:
+        usage = None
+
+    if usage is None:
+        return None
+
+    input_tokens = getattr(usage, "input_tokens", None)
+    output_tokens = getattr(usage, "output_tokens", None)
+
+    if isinstance(usage, dict):
+        input_tokens = usage.get("input_tokens", usage.get("prompt_tokens"))
+        output_tokens = usage.get("output_tokens", usage.get("completion_tokens"))
+
+    if hasattr(usage, "prompt_tokens"):
+        input_tokens = input_tokens or getattr(usage, "prompt_tokens", None)
+    if hasattr(usage, "completion_tokens"):
+        output_tokens = output_tokens or getattr(usage, "completion_tokens", None)
+
+    return {
+        "input_tokens": input_tokens,
+        "output_tokens": output_tokens,
+    }
+
+
+def _extract_model(args: tuple[Any, ...], kwargs: dict[str, Any]) -> str | None:
+    if isinstance(kwargs.get("model"), str):
+        return kwargs["model"]
+
+    if args and isinstance(args[0], str):
+        return args[0]
+
+    return None
+
+
+def _wrap_method(
+    owner: Any,
+    method_name: str,
+    *,
+    provider: str,
+) -> None:
+    if owner is None or not hasattr(owner, method_name):
+        return
+
+    original = getattr(owner, method_name)
+    tracer = get_tracer()
+
+    wrapped = tracer.wrap_callable(
+        original,
+        input_builder=sanitize_call_args,
+        output_builder=sanitize_result,
+        attribute_builder=lambda args, kwargs: {
+            "provider": provider,
+            "model": _extract_model(args, kwargs),
+        },
+        usage_builder=_extract_usage,
+    )
+
+    setattr(owner, method_name, wrapped)
+
+
+def instrument_openai(client: Any) -> Any:
+    chat = getattr(client, "chat", None)
+    completions = getattr(chat, "completions", None)
+    legacy_completions = getattr(client, "completions", None)
+    responses = getattr(client, "responses", None)
+    embeddings = getattr(client, "embeddings", None)
+    images = getattr(client, "images", None)
+    audio = getattr(client, "audio", None)
+    transcriptions = getattr(audio, "transcriptions", None)
+    translations = getattr(audio, "translations", None)
+    speech = getattr(audio, "speech", None)
+
+    _wrap_method(
+        completions,
+        "create",
+        provider="openai",
+    )
+    _wrap_method(
+        legacy_completions,
+        "create",
+        provider="openai",
+    )
+    _wrap_method(
+        responses,
+        "create",
+        provider="openai",
+    )
+    _wrap_method(
+        embeddings,
+        "create",
+        provider="openai",
+    )
+    _wrap_method(
+        images,
+        "generate",
+        provider="openai",
+    )
+    _wrap_method(
+        images,
+        "edit",
+        provider="openai",
+    )
+    _wrap_method(
+        images,
+        "create_variation",
+        provider="openai",
+    )
+    _wrap_method(
+        transcriptions,
+        "create",
+        provider="openai",
+    )
+    _wrap_method(
+        translations,
+        "create",
+        provider="openai",
+    )
+    _wrap_method(
+        speech,
+        "create",
+        provider="openai",
+    )
+    return client
+
+
+def instrument_anthropic(client: Any) -> Any:
+    messages = getattr(client, "messages", None)
+    beta = getattr(client, "beta", None)
+    beta_messages = getattr(beta, "messages", None)
+
+    _wrap_method(
+        messages,
+        "create",
+        provider="anthropic",
+    )
+    _wrap_method(
+        beta_messages,
+        "create",
+        provider="anthropic",
+    )
+    return client
+
+
+def instrument_google(client: Any) -> Any:
+    models = getattr(client, "models", None)
+
+    _wrap_method(
+        models,
+        "generate_content",
+        provider="google",
+    )
+    _wrap_method(
+        models,
+        "generate_images",
+        provider="google",
+    )
+    _wrap_method(
+        models,
+        "embed_content",
+        provider="google",
+    )
+    return client
+
+
+def instrument_client(client: Any) -> Any:
+    module_name = client.__class__.__module__.lower()
+    if "openai" in module_name:
+        return instrument_openai(client)
+    if "anthropic" in module_name:
+        return instrument_anthropic(client)
+    if "google" in module_name or "genai" in module_name:
+        return instrument_google(client)
+    return client

freesolo/sanitize.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+import base64
+import dataclasses
+import hashlib
+import re
+from collections.abc import Mapping, Sequence
+from typing import Any
+
+DATA_URL_RE = re.compile(r"^data:([^;,]+)?(;base64)?,(.*)$", re.DOTALL)
+MAX_STRING_LENGTH = 4000
+MAX_COLLECTION_ITEMS = 50
+MAX_DEPTH = 8
+
+
+def _truncate_text(value: str) -> str:
+    if len(value) <= MAX_STRING_LENGTH:
+        return value
+    omitted = len(value) - MAX_STRING_LENGTH
+    return f"{value[:MAX_STRING_LENGTH]}... <truncated {omitted} chars>"
+
+
+def _estimate_base64_bytes(payload: str) -> int:
+    padding = payload.count("=")
+    return max(0, (len(payload) * 3) // 4 - padding)
+
+
+def _summarize_data_url(value: str) -> dict[str, Any]:
+    match = DATA_URL_RE.match(value)
+    if not match:
+        return {"type": "string", "value": _truncate_text(value)}
+
+    media_type = match.group(1) or "application/octet-stream"
+    is_base64 = bool(match.group(2))
+    data = match.group(3)
+
+    if is_base64:
+        approx_bytes = _estimate_base64_bytes(data)
+        digest = hashlib.sha256(data[:8192].encode("utf-8")).hexdigest()
+        return {
+            "type": "data_url",
+            "media_type": media_type,
+            "encoding": "base64",
+            "approx_bytes": approx_bytes,
+            "sha256_prefix": digest,
+        }
+
+    return {
+        "type": "data_url",
+        "media_type": media_type,
+        "encoding": "urlencoded",
+        "approx_chars": len(data),
+    }
+
+
+def _summarize_bytes(value: bytes | bytearray | memoryview) -> dict[str, Any]:
+    raw = bytes(value)
+    return {
+        "type": "bytes",
+        "length": len(raw),
+        "sha256_prefix": hashlib.sha256(raw[:8192]).hexdigest(),
+        "base64_preview": base64.b64encode(raw[:24]).decode("ascii"),
+    }
+
+
+def sanitize_value(value: Any, *, _depth: int = 0) -> Any:
+    if _depth >= MAX_DEPTH:
+        return {"type": "max_depth_reached", "repr": repr(value)[:500]}
+
+    if value is None or isinstance(value, (bool, int, float)):
+        return value
+
+    if isinstance(value, str):
+        if value.startswith("data:"):
+            return _summarize_data_url(value)
+        return _truncate_text(value)
+
+    if isinstance(value, (bytes, bytearray, memoryview)):
+        return _summarize_bytes(value)
+
+    if dataclasses.is_dataclass(value):
+        return sanitize_value(dataclasses.asdict(value), _depth=_depth + 1)
+
+    if hasattr(value, "model_dump") and callable(value.model_dump):
+        try:
+            return sanitize_value(value.model_dump(), _depth=_depth + 1)
+        except Exception:
+            return {"type": "model_dump_error", "repr": repr(value)[:500]}
+
+    if hasattr(value, "dict") and callable(value.dict):
+        try:
+            return sanitize_value(value.dict(), _depth=_depth + 1)
+        except Exception:
+            return {"type": "dict_error", "repr": repr(value)[:500]}
+
+    if isinstance(value, Mapping):
+        items = list(value.items())[:MAX_COLLECTION_ITEMS]
+        output: dict[str, Any] = {}
+        for key, item_value in items:
+            output[str(key)] = sanitize_value(item_value, _depth=_depth + 1)
+        if len(value) > MAX_COLLECTION_ITEMS:
+            output["__truncated_items__"] = len(value) - MAX_COLLECTION_ITEMS
+        return output
+
+    if isinstance(value, Sequence) and not isinstance(value, (str, bytes, bytearray)):
+        items = list(value)[:MAX_COLLECTION_ITEMS]
+        output = [sanitize_value(item, _depth=_depth + 1) for item in items]
+        if len(value) > MAX_COLLECTION_ITEMS:
+            output.append(
+                {
+                    "type": "truncated_items",
+                    "count": len(value) - MAX_COLLECTION_ITEMS,
+                }
+            )
+        return output
+
+    if hasattr(value, "__dict__"):
+        try:
+            return sanitize_value(vars(value), _depth=_depth + 1)
+        except Exception:
+            return {"type": "object", "repr": repr(value)[:500]}
+
+    return {"type": "repr", "value": repr(value)[:500]}

freesolo-0.1.0.dist-info/METADATA

@@ -0,0 +1,100 @@
+Metadata-Version: 2.4
+Name: freesolo
+Version: 0.1.0
+Summary: Decorator-based LLM tracing package with OpenAI and Anthropic client instrumentation.
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27.0
+Provides-Extra: dev
+Requires-Dist: ruff>=0.11.0; extra == 'dev'
+Provides-Extra: examples
+Requires-Dist: anthropic>=0.40.0; extra == 'examples'
+Requires-Dist: openai>=1.0.0; extra == 'examples'
+Description-Content-Type: text/markdown
+
+# freesolo
+
+`freesolo` is a Python tracing package for the Reinforcement Labs app.
+
+It is designed for the lowest-friction integration possible:
+
+1. Install the package
+2. Configure one endpoint + API key
+3. Start a trace once
+4. Add `@trace()` to your functions
+5. Optionally wrap your OpenAI, Anthropic, or Google client for automatic provider spans
+
+## Install
+
+```bash
+cd tracing
+uv sync
+```
+
+To run the bundled example apps:
+
+```bash
+cd tracing
+uv sync --extra examples
+```
+
+## Environment
+
+The package reads these environment variables by default:
+
+- `FREESOLO_BASE_URL`
+- `FREESOLO_API_KEY`
+
+The frontend app must also have:
+
+- `FREESOLO_API_KEY`
+- `SUPABASE_SECRET_KEY`
+
+The canonical database schema lives in `frontend/supabase/migrations/`.
+There is no separate tracing-side migration folder because both the ingest API
+and the Supabase project are owned by the frontend app in this repo.
+
+Runnable examples live in [`examples/`](./examples/README.md). They will
+autoload env vars from `frontend/.env`, `tracing/.env`, or `tracing/examples/.env`.
+
+## Quickstart
+
+```python
+from openai import OpenAI
+from freesolo import configure, instrument_openai, start_trace, trace
+
+configure(
+    base_url="https://your-app.com",
+    api_key="freesolo_api_key",
+)
+
+client = instrument_openai(OpenAI())
+
+@trace()
+def run_agent(question: str) -> str:
+    result = client.chat.completions.create(
+        model="gpt-4.1",
+        messages=[
+            {"role": "user", "content": question},
+        ],
+    )
+    return result.choices[0].message.content or ""
+
+
+with start_trace("support-agent-run"):
+    print(run_agent("How do I reset my password?"))
+```
+
+## What Gets Stored
+
+- Trace metadata if you explicitly pass it to `start_trace(..., metadata=...)`
+- Spans from decorators
+- OpenAI / Anthropic / Google request + response payloads
+- Token usage when available
+- Image inputs summarized safely instead of storing full base64 blobs
+
+## Notes
+
+- If you do nothing except add `@trace()`, you still get useful spans.
+- Use `start_trace(trace_id=...)` when you want several decorated functions to land in one trace.
+- If you also wrap the LLM client, you get dedicated provider/model spans.
+- Delivery is best-effort by default. Trace ingestion failures do not break your app.

freesolo-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+freesolo/__init__.py,sha256=aGF-ixYiozElpTctZcn1Wz_m_2aB2nl6Yx-NSQKz8FM,464
+freesolo/client.py,sha256=hsBrFTUKVZESjSoblmshnUnyeavwgWp-oZwaxIWWYx0,11284
+freesolo/decorators.py,sha256=gI658oCLMvlsaGByUtl1VxIYnoqWwcDdc0BvnkM-n9E,2004
+freesolo/providers.py,sha256=u8UstFMBZj7fLKZfEDanlqts0fe33GiHO0iqOIMWqMU,4534
+freesolo/sanitize.py,sha256=tiHRuWne5E3_69taD59Ml00KV7oSEHeLHhlXODx10ug,4007
+freesolo-0.1.0.dist-info/METADATA,sha256=SBfTt2ECaz6kOOxN1Xn8mzXE4jTvbypBfAjNkIW0n50,2709
+freesolo-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+freesolo-0.1.0.dist-info/RECORD,,

freesolo-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any