pisama-auto 0.1.0__tar.gz

pisama_auto-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,32 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.10", "3.11", "3.12"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: |
+          pip install -e ".[dev]"
+
+      - name: Lint
+        run: ruff check src/
+
+      - name: Test
+        run: pytest tests/ -q --tb=short

pisama_auto-0.1.0/.gitignore

@@ -0,0 +1,114 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+/lib/
+/lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+venv/
+.venv/
+ENV/
+env/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+.tox/
+.nox/
+backend/backend/
+
+# Generated test results and runtime data
+detector_test_results_*.json
+backend/data/fix_feedback.jsonl
+backend/data/progress_log.jsonl
+backend/data/mast_test_results*.json
+backend/data/otel_test_results.json
+backend/data/calibration_history.jsonl
+backend/data/calibration_report.json
+backend/data/baselines/
+backend/app/data/
+
+# Playwright
+frontend/tests/auth/storage-state.json
+frontend/test-results/
+frontend/playwright-report/
+frontend/playwright/.cache/
+
+# Environment
+.env
+.env.*
+!.env.example
+!.env.test
+
+# Vercel
+.vercel
+
+# Scraped traces (large data files) - only at root level
+/traces/
+
+# macOS
+.DS_Store
+
+# Secrets - never commit
+deployment-env-vars.md
+frontend/.env.local
+
+# Secrets and credentials
+*.pem
+*.key
+*.crt
+credentials.json
+*.secret
+
+# Node (frontend)
+node_modules/
+.next/
+out/
+
+# Logs
+*.log
+logs/
+
+# Local config
+*.local
+models/
+_archived/
+
+# Sensitive environment files (never commit)
+frontend/.env.local
+frontend/.env.vercel.production
+.env.local
+
+# Confidential docs (strategy, pricing, competitive intel)
+docs-internal/
+
+# Terraform
+.terraform/
+*.tfstate
+*.tfstate.*
+.terraform.lock.hcl
+backend/models/

pisama_auto-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 Pisama (tn-pisama)
+
+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.

pisama_auto-0.1.0/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: pisama-auto
+Version: 0.1.0
+Summary: Zero-code auto-instrumentation for LLM applications — adds Pisama failure detection with one line
+Project-URL: Homepage, https://github.com/tn-pisama/pisama-auto
+Project-URL: Documentation, https://docs.pisama.ai/auto-instrumentation
+Author-email: Pisama Team <team@pisama.ai>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agents,ai,auto-instrumentation,llm,monitoring,observability,opentelemetry
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Requires-Dist: opentelemetry-api>=1.20.0
+Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.20.0
+Requires-Dist: opentelemetry-sdk>=1.20.0
+Requires-Dist: wrapt>=1.15.0
+Description-Content-Type: text/markdown
+
+# pisama-auto
+
+Zero-code auto-instrumentation for LLM applications. Add Pisama failure detection with one line.
+
+## Quick Start
+
+```bash
+pip install pisama-auto
+```
+
+```python
+import pisama_auto
+pisama_auto.init()  # traces locally; set PISAMA_API_KEY + PISAMA_ENDPOINT to export
+
+# All subsequent LLM calls are automatically traced
+import anthropic
+client = anthropic.Anthropic()
+response = client.messages.create(
+    model="claude-sonnet-4-6",
+    max_tokens=1024,
+    messages=[{"role": "user", "content": "Hello"}],
+)
+# ^ This call is automatically traced (and sent to Pisama if endpoint is configured)
+```
+
+## Supported Libraries
+
+| Library | Status | What's Traced |
+|---------|--------|---------------|
+| `anthropic` | GA | `messages.create()`, `messages.stream()` |
+| `openai` | GA | `chat.completions.create()` |
+
+## How It Works
+
+1. `pisama_auto.init()` sets up an OpenTelemetry tracer that exports to Pisama
+2. It then patches supported LLM libraries to emit spans with `gen_ai.*` semantic conventions
+3. Pisama's detection engine analyzes the traces for 44 failure modes
+4. Results appear in your Pisama dashboard
+
+## Configuration
+
+```python
+pisama_auto.init(
+    api_key="ps_...",                    # or set PISAMA_API_KEY env var
+    endpoint="https://your-instance/api/v1/traces/ingest",  # or PISAMA_ENDPOINT env var
+    service_name="my-agent",             # OTEL service name
+    auto_patch=True,                     # auto-patch all detected libraries
+)
+```
+
+Without an endpoint, traces are generated locally but not exported. Set `PISAMA_ENDPOINT` to send them to the Pisama platform.
+
+## Selective Patching
+
+```python
+import pisama_auto
+pisama_auto.init(auto_patch=False)  # don't auto-patch
+
+from pisama_auto.patches import patch
+patch("anthropic")  # only patch anthropic
+```

pisama_auto-0.1.0/README.md

@@ -0,0 +1,61 @@
+# pisama-auto
+
+Zero-code auto-instrumentation for LLM applications. Add Pisama failure detection with one line.
+
+## Quick Start
+
+```bash
+pip install pisama-auto
+```
+
+```python
+import pisama_auto
+pisama_auto.init()  # traces locally; set PISAMA_API_KEY + PISAMA_ENDPOINT to export
+
+# All subsequent LLM calls are automatically traced
+import anthropic
+client = anthropic.Anthropic()
+response = client.messages.create(
+    model="claude-sonnet-4-6",
+    max_tokens=1024,
+    messages=[{"role": "user", "content": "Hello"}],
+)
+# ^ This call is automatically traced (and sent to Pisama if endpoint is configured)
+```
+
+## Supported Libraries
+
+| Library | Status | What's Traced |
+|---------|--------|---------------|
+| `anthropic` | GA | `messages.create()`, `messages.stream()` |
+| `openai` | GA | `chat.completions.create()` |
+
+## How It Works
+
+1. `pisama_auto.init()` sets up an OpenTelemetry tracer that exports to Pisama
+2. It then patches supported LLM libraries to emit spans with `gen_ai.*` semantic conventions
+3. Pisama's detection engine analyzes the traces for 44 failure modes
+4. Results appear in your Pisama dashboard
+
+## Configuration
+
+```python
+pisama_auto.init(
+    api_key="ps_...",                    # or set PISAMA_API_KEY env var
+    endpoint="https://your-instance/api/v1/traces/ingest",  # or PISAMA_ENDPOINT env var
+    service_name="my-agent",             # OTEL service name
+    auto_patch=True,                     # auto-patch all detected libraries
+)
+```
+
+Without an endpoint, traces are generated locally but not exported. Set `PISAMA_ENDPOINT` to send them to the Pisama platform.
+
+## Selective Patching
+
+```python
+import pisama_auto
+pisama_auto.init(auto_patch=False)  # don't auto-patch
+
+from pisama_auto.patches import patch
+patch("anthropic")  # only patch anthropic
+```

pisama_auto-0.1.0/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "pisama-auto"
+version = "0.1.0"
+description = "Zero-code auto-instrumentation for LLM applications — adds Pisama failure detection with one line"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [
+    { name = "Pisama Team", email = "team@pisama.ai" }
+]
+keywords = [
+    "ai", "agents", "monitoring", "auto-instrumentation",
+    "opentelemetry", "observability", "llm"
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+dependencies = [
+    "opentelemetry-api>=1.20.0",
+    "opentelemetry-sdk>=1.20.0",
+    "opentelemetry-exporter-otlp-proto-http>=1.20.0",
+    "wrapt>=1.15.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/tn-pisama/pisama-auto"
+Documentation = "https://docs.pisama.ai/auto-instrumentation"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/pisama_auto"]

pisama_auto-0.1.0/src/pisama_auto/__init__.py

@@ -0,0 +1,79 @@
+"""Pisama Auto-Instrumentation.
+
+Zero-code instrumentation for LLM applications.
+Automatically patches supported libraries to emit OTEL traces
+that Pisama can analyze for failure detection.
+
+Usage:
+    import pisama_auto
+    pisama_auto.init(api_key="ps_...")
+
+    # All subsequent LLM calls are automatically traced
+    import anthropic
+    client = anthropic.Anthropic()
+    response = client.messages.create(...)  # <-- automatically traced
+"""
+
+import logging
+from typing import Optional
+
+logger = logging.getLogger("pisama_auto")
+
+_initialized = False
+
+
+def init(
+    api_key: Optional[str] = None,
+    endpoint: Optional[str] = None,
+    service_name: str = "pisama-auto",
+    auto_patch: bool = True,
+) -> None:
+    """Initialize Pisama auto-instrumentation.
+
+    Sets up OTEL tracing and patches supported LLM libraries to automatically
+    emit traces that Pisama can analyze.
+
+    Args:
+        api_key: Pisama API key (ps_...). Also reads PISAMA_API_KEY env var.
+        endpoint: Pisama OTEL ingestion endpoint. Also reads PISAMA_ENDPOINT env var.
+            If not set, traces are generated locally but not exported.
+        service_name: Service name for OTEL resource.
+        auto_patch: If True, automatically patch all detected libraries.
+    """
+    global _initialized
+    if _initialized:
+        logger.debug("Pisama auto-instrumentation already initialized")
+        return
+
+    import os
+    api_key = api_key or os.environ.get("PISAMA_API_KEY")
+    endpoint = endpoint or os.environ.get("PISAMA_ENDPOINT")
+
+    if not api_key:
+        logger.warning(
+            "No Pisama API key provided. Set PISAMA_API_KEY or pass api_key to init(). "
+            "Traces will be generated but not exported."
+        )
+
+    # Set up OTEL tracer
+    from ._tracer import setup_tracer
+    tracer_kwargs = {"api_key": api_key, "service_name": service_name}
+    if endpoint:
+        tracer_kwargs["endpoint"] = endpoint
+    setup_tracer(**tracer_kwargs)
+
+    # Auto-patch detected libraries
+    if auto_patch:
+        from .patches import patch_all
+        patched = patch_all()
+        if patched:
+            logger.info(f"Pisama: auto-instrumented {', '.join(patched)}")
+        else:
+            logger.info("Pisama: initialized (no patchable libraries detected yet)")
+
+    _initialized = True
+
+
+def is_initialized() -> bool:
+    """Check if Pisama auto-instrumentation is initialized."""
+    return _initialized

pisama_auto-0.1.0/src/pisama_auto/_tracer.py

@@ -0,0 +1,59 @@
+"""OTEL tracer setup for Pisama auto-instrumentation."""
+
+import logging
+from typing import Optional
+
+from opentelemetry import trace
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import BatchSpanProcessor, ConsoleSpanExporter
+from opentelemetry.sdk.resources import Resource
+
+logger = logging.getLogger("pisama_auto")
+
+_tracer: Optional[trace.Tracer] = None
+
+
+def setup_tracer(
+    api_key: Optional[str] = None,
+    endpoint: str = "https://pisama-api.fly.dev/api/v1/traces/ingest",
+    service_name: str = "pisama-auto",
+) -> trace.Tracer:
+    """Set up the OTEL tracer with Pisama exporter."""
+    global _tracer
+
+    resource = Resource.create({
+        "service.name": service_name,
+        "pisama.sdk": "pisama-auto",
+        "pisama.sdk.version": "0.1.0",
+    })
+
+    provider = TracerProvider(resource=resource)
+
+    if api_key:
+        try:
+            from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
+
+            exporter = OTLPSpanExporter(
+                endpoint=endpoint,
+                headers={"Authorization": f"Bearer {api_key}"},
+            )
+            provider.add_span_processor(BatchSpanProcessor(exporter))
+            logger.debug(f"Pisama OTEL exporter configured: {endpoint}")
+        except ImportError:
+            logger.warning("OTLP exporter not available, using console exporter")
+            provider.add_span_processor(BatchSpanProcessor(ConsoleSpanExporter()))
+    else:
+        # No API key — still trace locally for debugging
+        provider.add_span_processor(BatchSpanProcessor(ConsoleSpanExporter()))
+
+    trace.set_tracer_provider(provider)
+    _tracer = trace.get_tracer("pisama_auto", "0.1.0")
+    return _tracer
+
+
+def get_tracer() -> trace.Tracer:
+    """Get the Pisama tracer. Sets up a default if not initialized."""
+    global _tracer
+    if _tracer is None:
+        _tracer = trace.get_tracer("pisama_auto", "0.1.0")
+    return _tracer

pisama_auto-0.1.0/src/pisama_auto/patches/__init__.py

@@ -0,0 +1,70 @@
+"""Auto-patching for LLM libraries.
+
+Detects installed libraries and patches them to emit OTEL spans
+with gen_ai.* semantic conventions.
+"""
+
+import importlib
+import logging
+from typing import List
+
+logger = logging.getLogger("pisama_auto")
+
+# Map of library name -> patch module
+_PATCHABLE = {
+    "anthropic": ".anthropic_patch",
+    "openai": ".openai_patch",
+}
+
+_patched: List[str] = []
+
+
+def patch_all() -> List[str]:
+    """Patch all detected LLM libraries.
+
+    Returns:
+        List of library names that were successfully patched.
+    """
+    for lib_name, patch_module in _PATCHABLE.items():
+        if lib_name in _patched:
+            continue
+        try:
+            importlib.import_module(lib_name)
+        except ImportError:
+            continue
+
+        try:
+            mod = importlib.import_module(patch_module, package="pisama_auto.patches")
+            mod.patch()
+            _patched.append(lib_name)
+            logger.debug(f"Patched {lib_name}")
+        except Exception as e:
+            logger.warning(f"Failed to patch {lib_name}: {e}")
+
+    return list(_patched)
+
+
+def patch(library: str) -> bool:
+    """Patch a specific library.
+
+    Args:
+        library: Library name (anthropic, openai)
+
+    Returns:
+        True if patched successfully
+    """
+    if library in _patched:
+        return True
+
+    if library not in _PATCHABLE:
+        logger.warning(f"Unknown library: {library}. Supported: {list(_PATCHABLE.keys())}")
+        return False
+
+    try:
+        mod = importlib.import_module(_PATCHABLE[library], package="pisama_auto.patches")
+        mod.patch()
+        _patched.append(library)
+        return True
+    except Exception as e:
+        logger.warning(f"Failed to patch {library}: {e}")
+        return False

pisama_auto-0.1.0/src/pisama_auto/patches/anthropic_patch.py

@@ -0,0 +1,154 @@
+"""Auto-instrumentation patch for the Anthropic Python SDK.
+
+Wraps anthropic.Anthropic.messages.create() and .stream() to emit
+OTEL spans with gen_ai.* semantic conventions.
+"""
+
+import logging
+from typing import Any
+
+import wrapt
+from opentelemetry.trace import StatusCode
+
+logger = logging.getLogger("pisama_auto")
+
+_original_create = None
+_original_stream = None
+
+
+def patch() -> None:
+    """Patch the Anthropic SDK to emit OTEL spans."""
+    import anthropic
+
+    messages_cls = anthropic.resources.Messages
+
+    global _original_create, _original_stream
+    _original_create = messages_cls.create
+    _original_stream = getattr(messages_cls, "stream", None)
+
+    wrapt.wrap_function_wrapper(messages_cls, "create", _traced_create)
+
+    if _original_stream:
+        wrapt.wrap_function_wrapper(messages_cls, "stream", _traced_stream)
+
+    logger.debug("Anthropic SDK patched")
+
+
+def _traced_create(wrapped, instance, args, kwargs) -> Any:
+    """Wrapper for messages.create that adds OTEL tracing."""
+    from pisama_auto._tracer import get_tracer
+
+    tracer = get_tracer()
+    model = kwargs.get("model", "unknown")
+    span_name = f"gen_ai.chat {model}"
+
+    with tracer.start_as_current_span(span_name) as span:
+        # Set gen_ai.* attributes
+        span.set_attribute("gen_ai.system", "anthropic")
+        span.set_attribute("gen_ai.request.model", model)
+        span.set_attribute("gen_ai.operation.name", "chat")
+
+        max_tokens = kwargs.get("max_tokens")
+        if max_tokens:
+            span.set_attribute("gen_ai.request.max_tokens", max_tokens)
+
+        temperature = kwargs.get("temperature")
+        if temperature is not None:
+            span.set_attribute("gen_ai.request.temperature", temperature)
+
+        # Record input messages count
+        messages = kwargs.get("messages", [])
+        span.set_attribute("gen_ai.request.messages_count", len(messages))
+
+        system = kwargs.get("system")
+        if system:
+            span.set_attribute("gen_ai.request.has_system", True)
+
+        try:
+            response = wrapped(*args, **kwargs)
+
+            # Record response attributes
+            span.set_attribute("gen_ai.response.model", getattr(response, "model", model))
+            span.set_attribute("gen_ai.response.stop_reason", getattr(response, "stop_reason", ""))
+
+            usage = getattr(response, "usage", None)
+            if usage:
+                input_tokens = getattr(usage, "input_tokens", 0)
+                output_tokens = getattr(usage, "output_tokens", 0)
+                span.set_attribute("gen_ai.usage.input_tokens", input_tokens)
+                span.set_attribute("gen_ai.usage.output_tokens", output_tokens)
+                span.set_attribute("gen_ai.usage.total_tokens", input_tokens + output_tokens)
+
+            return response
+
+        except Exception as e:
+            span.set_attribute("error.type", type(e).__name__)
+            span.set_attribute("error.message", str(e)[:500])
+            span.set_status(StatusCode.ERROR, str(e)[:200])
+            raise
+
+
+class _TracedStream:
+    """Wrapper that ends the OTEL span when the stream is consumed or closed."""
+
+    def __init__(self, stream, span):
+        self._stream = stream
+        self._span = span
+
+    def __enter__(self):
+        self._stream.__enter__()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        try:
+            result = self._stream.__exit__(exc_type, exc_val, exc_tb)
+            if exc_type:
+                self._span.set_attribute("error.type", exc_type.__name__)
+                self._span.set_status(StatusCode.ERROR, str(exc_val)[:200])
+            return result
+        finally:
+            self._span.end()
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        try:
+            return next(self._stream)
+        except StopIteration:
+            self._span.end()
+            raise
+        except Exception as e:
+            self._span.set_attribute("error.type", type(e).__name__)
+            self._span.set_status(StatusCode.ERROR, str(e)[:200])
+            self._span.end()
+            raise
+
+    def __getattr__(self, name):
+        return getattr(self._stream, name)
+
+
+def _traced_stream(wrapped, instance, args, kwargs) -> Any:
+    """Wrapper for messages.stream that adds OTEL tracing."""
+    from pisama_auto._tracer import get_tracer
+
+    tracer = get_tracer()
+    model = kwargs.get("model", "unknown")
+    span_name = f"gen_ai.chat.stream {model}"
+
+    span = tracer.start_span(span_name)
+    span.set_attribute("gen_ai.system", "anthropic")
+    span.set_attribute("gen_ai.request.model", model)
+    span.set_attribute("gen_ai.operation.name", "chat.stream")
+
+    messages = kwargs.get("messages", [])
+    span.set_attribute("gen_ai.request.messages_count", len(messages))
+
+    try:
+        result = wrapped(*args, **kwargs)
+        return _TracedStream(result, span)
+    except Exception as e:
+        span.set_attribute("error.type", type(e).__name__)
+        span.set_status(StatusCode.ERROR, str(e)[:200])
+        span.end()
+        raise

pisama_auto-0.1.0/src/pisama_auto/patches/openai_patch.py

@@ -0,0 +1,83 @@
+"""Auto-instrumentation patch for the OpenAI Python SDK.
+
+Wraps openai.ChatCompletion.create() and the v1+ client to emit
+OTEL spans with gen_ai.* semantic conventions.
+"""
+
+import logging
+from typing import Any
+
+import wrapt
+
+logger = logging.getLogger("pisama_auto")
+
+
+def patch() -> None:
+    """Patch the OpenAI SDK to emit OTEL spans."""
+    import openai
+
+    # OpenAI v1+ uses client.chat.completions.create()
+    if hasattr(openai, "resources"):
+        completions_cls = openai.resources.chat.Completions
+        wrapt.wrap_function_wrapper(completions_cls, "create", _traced_create)
+        logger.debug("OpenAI SDK v1+ patched")
+    else:
+        logger.warning("OpenAI SDK version not supported for auto-patching")
+
+
+def _traced_create(wrapped, instance, args, kwargs) -> Any:
+    """Wrapper for chat.completions.create that adds OTEL tracing."""
+    from pisama_auto._tracer import get_tracer
+
+    tracer = get_tracer()
+    model = kwargs.get("model", "unknown")
+    span_name = f"gen_ai.chat {model}"
+
+    with tracer.start_as_current_span(span_name) as span:
+        span.set_attribute("gen_ai.system", "openai")
+        span.set_attribute("gen_ai.request.model", model)
+        span.set_attribute("gen_ai.operation.name", "chat")
+
+        max_tokens = kwargs.get("max_tokens")
+        if max_tokens:
+            span.set_attribute("gen_ai.request.max_tokens", max_tokens)
+
+        temperature = kwargs.get("temperature")
+        if temperature is not None:
+            span.set_attribute("gen_ai.request.temperature", temperature)
+
+        messages = kwargs.get("messages", [])
+        span.set_attribute("gen_ai.request.messages_count", len(messages))
+
+        stream = kwargs.get("stream", False)
+        if stream:
+            span.set_attribute("gen_ai.operation.name", "chat.stream")
+
+        try:
+            response = wrapped(*args, **kwargs)
+
+            if not stream and response:
+                resp_model = getattr(response, "model", model)
+                span.set_attribute("gen_ai.response.model", resp_model)
+
+                choices = getattr(response, "choices", [])
+                if choices:
+                    finish_reason = getattr(choices[0], "finish_reason", "")
+                    span.set_attribute("gen_ai.response.finish_reason", finish_reason or "")
+
+                usage = getattr(response, "usage", None)
+                if usage:
+                    input_tokens = getattr(usage, "prompt_tokens", 0)
+                    output_tokens = getattr(usage, "completion_tokens", 0)
+                    span.set_attribute("gen_ai.usage.input_tokens", input_tokens)
+                    span.set_attribute("gen_ai.usage.output_tokens", output_tokens)
+                    span.set_attribute("gen_ai.usage.total_tokens", input_tokens + output_tokens)
+
+            return response
+
+        except Exception as e:
+            span.set_attribute("error.type", type(e).__name__)
+            span.set_attribute("error.message", str(e)[:500])
+            from opentelemetry.trace import StatusCode
+            span.set_status(StatusCode.ERROR, str(e)[:200])
+            raise