puvinoise-sdk 0.2.0__tar.gz

puvinoise_sdk-0.2.0/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: puvinoise-sdk
+Version: 0.2.0
+Summary: Independent OpenTelemetry SDK for AI agents (Anthropic, OpenAI, Ollama)
+Author-email: Sarvesh Sahane <sarvesh.sahane@puvilabs.com>
+License: Proprietary
+Project-URL: Homepage, https://puvilabs.com
+Keywords: puvinoise,opentelemetry,otel,tracing,llm,agents,observability
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: opentelemetry-api>=1.20
+Requires-Dist: opentelemetry-sdk>=1.20
+Requires-Dist: opentelemetry-exporter-otlp>=1.20
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.20; extra == "anthropic"
+Provides-Extra: openai
+Requires-Dist: openai>=1.0; extra == "openai"
+Provides-Extra: all
+Requires-Dist: anthropic>=0.20; extra == "all"
+Requires-Dist: openai>=1.0; extra == "all"

puvinoise_sdk-0.2.0/puvinoise/__init__.py

@@ -0,0 +1,52 @@
+"""
+Puvinoise - Independent OpenTelemetry SDK for AI agents
+Supports Anthropic Claude, OpenAI, Ollama, and other LLM providers.
+"""
+
+from puvinoise.bootstrap import bootstrap
+from puvinoise.tracer import run_with_trace
+from puvinoise.hooks import (
+    # Anthropic
+    instrument_anthropic_call,
+    instrument_anthropic_stream,
+    # OpenAI
+    instrument_openai_call,
+    instrument_openai_stream,
+    # Generic / Ollama
+    instrument_llm_call,
+    # Agent internals
+    instrument_memory_operation,
+    instrument_tool_call,
+    # Span utilities
+    add_span_attribute,
+    add_span_event,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    # Bootstrap
+    "bootstrap",
+
+    # Core tracing
+    "run_with_trace",
+
+    # Anthropic hooks
+    "instrument_anthropic_call",
+    "instrument_anthropic_stream",
+
+    # OpenAI hooks
+    "instrument_openai_call",
+    "instrument_openai_stream",
+
+    # Generic / Ollama hooks
+    "instrument_llm_call",
+
+    # Agent internals
+    "instrument_memory_operation",
+    "instrument_tool_call",
+
+    # Span utilities
+    "add_span_attribute",
+    "add_span_event",
+]

puvinoise_sdk-0.2.0/puvinoise/bootstrap.py

@@ -0,0 +1,131 @@
+from opentelemetry import trace
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import BatchSpanProcessor, ConsoleSpanExporter
+from opentelemetry.sdk.resources import Resource
+from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
+import logging
+import os
+
+logger = logging.getLogger(__name__)
+
+_initialized = False
+
+
+def bootstrap(
+    service_name: str,
+    otlp_endpoint: str = None,
+    console_export: bool = False,
+    batch_config: dict = None
+):
+    """
+    Initialize OpenTelemetry tracing for the agent.
+    
+    Args:
+        service_name: Name of the service (e.g., "blog-agent")
+        otlp_endpoint: OTLP collector endpoint (defaults to env var or hardcoded)
+        console_export: If True, also export spans to console for debugging
+        batch_config: Custom batch processor configuration
+        
+    Returns:
+        Tracer instance
+    """
+    global _initialized
+    
+    # Prevent double initialization
+    if _initialized:
+        logger.info(f"Tracer already initialized for service: {service_name}")
+        return trace.get_tracer(service_name)
+    
+    # Get endpoint from parameter, env var, or default
+    endpoint = (
+    otlp_endpoint
+    or os.getenv("OTEL_EXPORTER_OTLP_ENDPOINT")
+    # or "http://13.235.48.96:4318/v1/traces"
+    )
+    if not endpoint.endswith("/v1/traces"):
+        endpoint = endpoint.rstrip("/") + "/v1/traces"
+
+    
+    tenant_id = os.getenv("TENANT_ID")
+
+    if not tenant_id:
+        raise ValueError("TENANT_ID environment variable must be set")
+
+    resource = Resource.create({
+        "service.name": service_name,
+        "service.version": os.getenv("SERVICE_VERSION", "0.1.0"),
+        "deployment.environment": os.getenv("ENVIRONMENT", "development"),
+        "tenant.id": tenant_id,
+    })
+
+
+    
+    # Create tracer provider
+    provider = TracerProvider(resource=resource)
+    trace.set_tracer_provider(provider)
+    
+    # Default batch configuration
+    default_batch_config = {
+        "schedule_delay_millis": 1000,      # Export every 1 second
+        "max_export_batch_size": 64,        # Max 64 spans per batch
+        "export_timeout_millis": 30000,     # 30 second timeout
+        "max_queue_size": 2048,             # Queue up to 2048 spans
+    }
+    
+    # Merge with custom config if provided
+    if batch_config:
+        default_batch_config.update(batch_config)
+    
+    # Configure OTLP exporter
+    try:
+        otlp_exporter = OTLPSpanExporter(endpoint=endpoint)
+        provider.add_span_processor(
+            BatchSpanProcessor(otlp_exporter, **default_batch_config)
+        )
+        logger.info(f"✅ OTLP exporter configured: {endpoint}")
+    except Exception as e:
+        logger.error(f"❌ Failed to configure OTLP exporter: {e}")
+        # Continue with console exporter as fallback
+        console_export = True
+    
+    # Optional console exporter for debugging
+    if console_export:
+        console_exporter = ConsoleSpanExporter()
+        provider.add_span_processor(
+            BatchSpanProcessor(console_exporter, **default_batch_config)
+        )
+        logger.info("✅ Console exporter configured for debugging")
+    
+    _initialized = True
+    logger.info(f"🚀 OpenTelemetry initialized for service: {service_name}")
+    
+    return trace.get_tracer(service_name)
+
+
+def shutdown():
+    """
+    Gracefully shutdown the tracer provider.
+    Call this when your application is terminating to ensure all spans are exported.
+    """
+    provider = trace.get_tracer_provider()
+    if isinstance(provider, TracerProvider):
+        provider.shutdown()
+        logger.info("OpenTelemetry tracer provider shut down successfully")
+
+
+def force_flush(timeout_millis: int = 30000):
+    """
+    Force flush all pending spans.
+    
+    Args:
+        timeout_millis: Maximum time to wait for flush in milliseconds
+    """
+    provider = trace.get_tracer_provider()
+    if isinstance(provider, TracerProvider):
+        success = provider.force_flush(timeout_millis)
+        if success:
+            logger.info("Successfully flushed all pending spans")
+        else:
+            logger.warning("Flush timed out or failed")
+        return success
+    return False

puvinoise_sdk-0.2.0/puvinoise/context.py

@@ -0,0 +1,76 @@
+import uuid
+import contextvars
+from typing import Optional
+
+# Context variables automatically propagate across async calls
+_run_id = contextvars.ContextVar("run_id", default=None)
+_agent_name = contextvars.ContextVar("agent_name", default=None)
+
+
+class AgentContext:
+    """
+    Holds metadata for a single agent execution.
+    Uses contextvars for thread-safe and async-safe context propagation.
+    """
+    
+    def __init__(self, agent_name: str, run_id: Optional[str] = None):
+        """
+        Initialize agent context.
+        
+        Args:
+            agent_name: Name of the agent
+            run_id: Optional custom run ID (generates UUID if not provided)
+        """
+        self.run_id = run_id or str(uuid.uuid4())
+        self.agent_name = agent_name
+        self._tokens = []
+    
+    def activate(self):
+        """Activate this context for the current execution."""
+        self._tokens = [
+            _run_id.set(self.run_id),
+            _agent_name.set(self.agent_name)
+        ]
+    
+    def deactivate(self):
+        """Deactivate this context and restore previous values."""
+        for token in reversed(self._tokens):
+            try:
+                if token:
+                    token.var.reset(token)
+            except Exception:
+                pass  # Token may have already been reset
+        self._tokens.clear()
+    
+    def __enter__(self):
+        """Context manager support."""
+        self.activate()
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager cleanup."""
+        self.deactivate()
+        return False
+    
+    @staticmethod
+    def get_run_id() -> Optional[str]:
+        """Get the current run ID from context."""
+        return _run_id.get()
+    
+    @staticmethod
+    def get_agent_name() -> Optional[str]:
+        """Get the current agent name from context."""
+        return _agent_name.get()
+    
+    @staticmethod
+    def get_context() -> dict:
+        """Get all current context values as a dictionary."""
+        return {
+            "run_id": _run_id.get(),
+            "agent_name": _agent_name.get()
+        }
+    
+    @staticmethod
+    def is_active() -> bool:
+        """Check if there's an active agent context."""
+        return _run_id.get() is not None

puvinoise_sdk-0.2.0/puvinoise/hooks.py

@@ -0,0 +1,469 @@
+"""
+Multi-provider instrumentation hooks for puvinoise SDK.
+Supports Anthropic, OpenAI, Ollama, and generic LLM providers.
+"""
+
+from opentelemetry import trace
+from opentelemetry.trace import Status, StatusCode
+from puvinoise.context import AgentContext
+import functools
+
+_tracer = trace.get_tracer("agent.hooks")
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+def _attach_agent_context(span):
+    """Attach run_id and agent_name from AgentContext to span (if active)."""
+    run_id = AgentContext.get_run_id()
+    agent_name = AgentContext.get_agent_name()
+    if run_id:
+        span.set_attribute("agent.run_id", run_id)
+    if agent_name:
+        span.set_attribute("agent.name", agent_name)
+
+
+def _extract_openai_response(result, span):
+    """
+    Parse an OpenAI ChatCompletion response object and record span attributes.
+    Works for openai>=1.0 (the openai.types.chat.ChatCompletion object).
+    """
+    try:
+        # Model actually used (may differ from requested)
+        if hasattr(result, "model"):
+            span.set_attribute("llm.response_model", result.model)
+
+        choices = getattr(result, "choices", None)
+        if choices:
+            first = choices[0]
+            # finish_reason
+            finish_reason = getattr(first, "finish_reason", None)
+            if finish_reason:
+                span.set_attribute("llm.stop_reason", finish_reason)
+            # message content
+            message = getattr(first, "message", None)
+            if message:
+                content = getattr(message, "content", None) or ""
+                span.set_attribute("llm.response", content[:500])
+                span.set_attribute("llm.response_length", len(content))
+
+        # Token usage
+        usage = getattr(result, "usage", None)
+        if usage:
+            if hasattr(usage, "prompt_tokens"):
+                span.set_attribute("llm.input_tokens", usage.prompt_tokens)
+            if hasattr(usage, "completion_tokens"):
+                span.set_attribute("llm.output_tokens", usage.completion_tokens)
+    except Exception:
+        pass  # Never let telemetry crash the caller
+
+
+def _extract_anthropic_response(result, span):
+    """Parse an Anthropic MessageResponse and record span attributes."""
+    try:
+        if hasattr(result, "model"):
+            span.set_attribute("llm.response_model", result.model)
+
+        if hasattr(result, "content") and result.content:
+            if isinstance(result.content, list):
+                text_blocks = [b.text for b in result.content if hasattr(b, "text")]
+                response_text = " ".join(text_blocks)
+            else:
+                response_text = str(result.content)
+            span.set_attribute("llm.response", response_text[:500])
+            span.set_attribute("llm.response_length", len(response_text))
+
+        if hasattr(result, "stop_reason"):
+            span.set_attribute("llm.stop_reason", result.stop_reason)
+
+        usage = getattr(result, "usage", None)
+        if usage:
+            if hasattr(usage, "input_tokens"):
+                span.set_attribute("llm.input_tokens", usage.input_tokens)
+            if hasattr(usage, "output_tokens"):
+                span.set_attribute("llm.output_tokens", usage.output_tokens)
+    except Exception:
+        pass
+
+
+def _extract_openai_messages(kwargs, span):
+    """Extract prompt info from OpenAI-style messages kwarg."""
+    messages = kwargs.get("messages")
+    if not messages:
+        return
+    span.set_attribute("llm.message_count", len(messages))
+    user_msgs = [m for m in messages if m.get("role") == "user"]
+    if user_msgs:
+        content = user_msgs[0].get("content", "")
+        if isinstance(content, str):
+            span.set_attribute("llm.prompt", content[:500])
+        elif isinstance(content, list):
+            texts = [b.get("text", "") for b in content if b.get("type") == "text"]
+            if texts:
+                span.set_attribute("llm.prompt", texts[0][:500])
+
+
+# ---------------------------------------------------------------------------
+# Anthropic hooks
+# ---------------------------------------------------------------------------
+
+def instrument_anthropic_call(func):
+    """
+    Decorator to automatically trace synchronous Anthropic API calls.
+
+    Usage::
+
+        @instrument_anthropic_call
+        def call_claude(prompt, model="claude-sonnet-4-5-20250929"):
+            response = client.messages.create(...)
+            return response
+    """
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        with _tracer.start_as_current_span("llm.anthropic") as span:
+            _attach_agent_context(span)
+            span.set_attribute("llm.provider", "anthropic")
+
+            model = kwargs.get("model")
+            if model:
+                span.set_attribute("llm.model", model)
+
+            _extract_openai_messages(kwargs, span)  # same shape for Anthropic
+
+            if "temperature" in kwargs:
+                span.set_attribute("llm.temperature", float(kwargs["temperature"]))
+            if "max_tokens" in kwargs:
+                span.set_attribute("llm.max_tokens", int(kwargs["max_tokens"]))
+
+            try:
+                result = func(*args, **kwargs)
+                _extract_anthropic_response(result, span)
+                span.set_status(Status(StatusCode.OK))
+                return result
+            except Exception as e:
+                span.set_status(Status(StatusCode.ERROR, str(e)))
+                span.record_exception(e)
+                span.set_attribute("error.type", type(e).__name__)
+                raise
+
+    return wrapper
+
+
+def instrument_anthropic_stream(func):
+    """
+    Decorator for *generator* streaming Anthropic API calls.
+
+    The span stays open for the entire stream duration (bug fix: previously
+    the span closed before iteration completed).
+
+    Usage::
+
+        @instrument_anthropic_stream
+        def stream_claude(prompt):
+            with client.messages.stream(...) as stream:
+                for text in stream.text_stream:
+                    yield text
+    """
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        span = _tracer.start_span("llm.anthropic.stream")
+        ctx = trace.use_span(span, end_on_exit=False)
+        ctx.__enter__()
+
+        _attach_agent_context(span)
+        span.set_attribute("llm.provider", "anthropic")
+        span.set_attribute("llm.streaming", True)
+
+        model = kwargs.get("model")
+        if model:
+            span.set_attribute("llm.model", model)
+
+        chunk_count = 0
+        total_length = 0
+
+        try:
+            for chunk in func(*args, **kwargs):
+                chunk_count += 1
+                if isinstance(chunk, str):
+                    total_length += len(chunk)
+                yield chunk
+
+            span.set_attribute("llm.chunks_received", chunk_count)
+            span.set_attribute("llm.total_length", total_length)
+            span.set_status(Status(StatusCode.OK))
+        except Exception as e:
+            span.set_status(Status(StatusCode.ERROR, str(e)))
+            span.record_exception(e)
+            raise
+        finally:
+            span.end()
+
+    return wrapper
+
+
+# ---------------------------------------------------------------------------
+# OpenAI hook
+# ---------------------------------------------------------------------------
+
+def instrument_openai_call(func):
+    """
+    Decorator to automatically trace OpenAI API calls (openai>=1.0).
+
+    API keys are read by the openai library itself (``OPENAI_API_KEY`` env var
+    or ``openai.api_key``).  The SDK never touches credentials.
+
+    Usage::
+
+        @instrument_openai_call
+        def call_gpt(prompt, model="gpt-4o"):
+            response = client.chat.completions.create(
+                model=model,
+                messages=[{"role": "user", "content": prompt}],
+            )
+            return response
+    """
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        with _tracer.start_as_current_span("llm.openai") as span:
+            _attach_agent_context(span)
+            span.set_attribute("llm.provider", "openai")
+
+            model = kwargs.get("model")
+            if model:
+                span.set_attribute("llm.model", model)
+
+            _extract_openai_messages(kwargs, span)
+
+            if "temperature" in kwargs:
+                span.set_attribute("llm.temperature", float(kwargs["temperature"]))
+            if "max_tokens" in kwargs:
+                span.set_attribute("llm.max_tokens", int(kwargs["max_tokens"]))
+
+            try:
+                result = func(*args, **kwargs)
+                _extract_openai_response(result, span)
+                span.set_status(Status(StatusCode.OK))
+                return result
+            except Exception as e:
+                span.set_status(Status(StatusCode.ERROR, str(e)))
+                span.record_exception(e)
+                span.set_attribute("error.type", type(e).__name__)
+                raise
+
+    return wrapper
+
+
+def instrument_openai_stream(func):
+    """
+    Decorator for streaming OpenAI calls using ``stream=True``.
+
+    Usage::
+
+        @instrument_openai_stream
+        def stream_gpt(prompt, model="gpt-4o"):
+            for chunk in client.chat.completions.create(
+                model=model,
+                messages=[{"role": "user", "content": prompt}],
+                stream=True,
+            ):
+                delta = chunk.choices[0].delta.content or ""
+                yield delta
+    """
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        span = _tracer.start_span("llm.openai.stream")
+        ctx = trace.use_span(span, end_on_exit=False)
+        ctx.__enter__()
+
+        _attach_agent_context(span)
+        span.set_attribute("llm.provider", "openai")
+        span.set_attribute("llm.streaming", True)
+
+        model = kwargs.get("model")
+        if model:
+            span.set_attribute("llm.model", model)
+
+        chunk_count = 0
+        total_length = 0
+
+        try:
+            for chunk in func(*args, **kwargs):
+                chunk_count += 1
+                if isinstance(chunk, str):
+                    total_length += len(chunk)
+                yield chunk
+
+            span.set_attribute("llm.chunks_received", chunk_count)
+            span.set_attribute("llm.total_length", total_length)
+            span.set_status(Status(StatusCode.OK))
+        except Exception as e:
+            span.set_status(Status(StatusCode.ERROR, str(e)))
+            span.record_exception(e)
+            raise
+        finally:
+            span.end()
+
+    return wrapper
+
+
+# ---------------------------------------------------------------------------
+# Generic / Ollama hook
+# ---------------------------------------------------------------------------
+
+def instrument_llm_call(provider="unknown"):
+    """
+    Generic LLM call instrumentation (works with any provider: Ollama, Cohere, etc.).
+
+    Unlike the old version this is now a *parameterised* decorator so you can
+    tag the provider name cleanly::
+
+        @instrument_llm_call(provider="ollama")
+        def call_ollama(prompt, model="llama3"):
+            ...
+
+    For backward-compat, calling without parentheses still works (provider="unknown").
+    """
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            with _tracer.start_as_current_span("llm.call") as span:
+                _attach_agent_context(span)
+                span.set_attribute("llm.provider", provider)
+
+                model = kwargs.get("model", "unknown")
+                span.set_attribute("llm.model", model)
+
+                # Accept a plain prompt string as first positional arg or kwarg
+                prompt = kwargs.get("prompt") or (
+                    args[0] if args and isinstance(args[0], str) else None
+                )
+                if prompt:
+                    span.set_attribute("llm.prompt", prompt[:500])
+
+                if "temperature" in kwargs:
+                    span.set_attribute("llm.temperature", float(kwargs["temperature"]))
+
+                try:
+                    result = func(*args, **kwargs)
+
+                    if isinstance(result, str):
+                        span.set_attribute("llm.response", result[:500])
+                        span.set_attribute("llm.response_length", len(result))
+                    elif isinstance(result, dict):
+                        # Ollama /api/chat returns a dict
+                        msg = (
+                            result.get("message", {}).get("content")
+                            or result.get("response", "")
+                        )
+                        if msg:
+                            span.set_attribute("llm.response", msg[:500])
+                            span.set_attribute("llm.response_length", len(msg))
+                        # Ollama token counts
+                        if "prompt_eval_count" in result:
+                            span.set_attribute("llm.input_tokens", result["prompt_eval_count"])
+                        if "eval_count" in result:
+                            span.set_attribute("llm.output_tokens", result["eval_count"])
+
+                    span.set_status(Status(StatusCode.OK))
+                    return result
+                except Exception as e:
+                    span.set_status(Status(StatusCode.ERROR, str(e)))
+                    span.record_exception(e)
+                    span.set_attribute("error.type", type(e).__name__)
+                    raise
+
+        return wrapper
+
+    # Allow @instrument_llm_call (no parens) for backward compat
+    if callable(provider):
+        func, provider = provider, "unknown"
+        return decorator(func)
+
+    return decorator
+
+
+# ---------------------------------------------------------------------------
+# Memory & tool hooks (unchanged API, small robustness improvements)
+# ---------------------------------------------------------------------------
+
+def instrument_memory_operation(operation_type="query"):
+    """
+    Decorator to trace memory operations (retrieval, storage, delete, etc.).
+
+    Usage::
+
+        @instrument_memory_operation("retrieve")
+        def retrieve_memory(query):
+            ...
+    """
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            with _tracer.start_as_current_span(f"memory.{operation_type}") as span:
+                _attach_agent_context(span)
+                span.set_attribute("memory.operation", operation_type)
+
+                try:
+                    result = func(*args, **kwargs)
+                    if isinstance(result, (list, tuple)):
+                        span.set_attribute("memory.result_count", len(result))
+                    span.set_status(Status(StatusCode.OK))
+                    return result
+                except Exception as e:
+                    span.set_status(Status(StatusCode.ERROR, str(e)))
+                    span.record_exception(e)
+                    raise
+
+        return wrapper
+    return decorator
+
+
+def instrument_tool_call(tool_name=None):
+    """
+    Decorator to trace agent tool usage.
+
+    Usage::
+
+        @instrument_tool_call("web_search")
+        def search_web(query):
+            ...
+    """
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            name = tool_name or func.__name__
+            with _tracer.start_as_current_span(f"tool.{name}") as span:
+                _attach_agent_context(span)
+                span.set_attribute("tool.name", name)
+
+                try:
+                    result = func(*args, **kwargs)
+                    span.set_status(Status(StatusCode.OK))
+                    return result
+                except Exception as e:
+                    span.set_status(Status(StatusCode.ERROR, str(e)))
+                    span.record_exception(e)
+                    raise
+
+        return wrapper
+    return decorator
+
+
+# ---------------------------------------------------------------------------
+# Span utilities
+# ---------------------------------------------------------------------------
+
+def add_span_attribute(key: str, value):
+    """Add a custom attribute to the current active span."""
+    span = trace.get_current_span()
+    if span and span.is_recording():
+        span.set_attribute(key, value)
+
+
+def add_span_event(name: str, attributes: dict = None):
+    """Add an event to the current active span."""
+    span = trace.get_current_span()
+    if span and span.is_recording():
+        span.add_event(name, attributes or {})

puvinoise_sdk-0.2.0/puvinoise/tracer.py

@@ -0,0 +1,87 @@
+from opentelemetry import trace
+from opentelemetry.trace import Status, StatusCode
+from puvinoise.context import AgentContext
+import functools
+import os
+
+_tracer = trace.get_tracer("agent.runtime")
+
+
+def run_with_trace(fn, agent_name="default-agent", *args, **kwargs):
+    """
+    Wraps a function execution with OpenTelemetry tracing and agent context.
+    
+    Args:
+        fn: The function to execute
+        agent_name: Name of the agent for this execution
+        *args, **kwargs: Arguments to pass to the function
+        
+    Returns:
+        The result of the function execution
+    """
+    ctx = AgentContext(agent_name)
+    ctx.activate()
+    
+    with _tracer.start_as_current_span("agent.run") as span:
+        span.set_attribute("agent.run_id", ctx.run_id)
+        span.set_attribute("agent.name", ctx.agent_name)
+
+        tenant_id = os.getenv("TENANT_ID")
+        if tenant_id:
+            span.set_attribute("tenant.id", tenant_id)
+    
+        try:
+            # Execute the function
+            result = fn(*args, **kwargs)
+            
+            # Mark span as successful
+            span.set_status(Status(StatusCode.OK))
+            
+            return result
+            
+        except Exception as e:
+            # Record the error
+            span.set_status(Status(StatusCode.ERROR, str(e)))
+            span.record_exception(e)
+            raise
+        
+        finally:
+            # Cleanup happens automatically when span exits
+            pass
+
+
+def trace_function(operation_name=None):
+    """
+    Decorator to trace individual functions within an agent run.
+    
+    Usage:
+        @trace_function("search_memory")
+        def search_memory(query):
+            ...
+    """
+    def decorator(fn):
+        @functools.wraps(fn)
+        def wrapper(*args, **kwargs):
+            span_name = operation_name or f"{fn.__module__}.{fn.__name__}"
+            
+            with _tracer.start_as_current_span(span_name) as span:
+                # Add context from AgentContext if available
+                run_id = AgentContext.get_run_id()
+                agent_name = AgentContext.get_agent_name()
+                
+                if run_id:
+                    span.set_attribute("agent.run_id", run_id)
+                if agent_name:
+                    span.set_attribute("agent.name", agent_name)
+                
+                try:
+                    result = fn(*args, **kwargs)
+                    span.set_status(Status(StatusCode.OK))
+                    return result
+                except Exception as e:
+                    span.set_status(Status(StatusCode.ERROR, str(e)))
+                    span.record_exception(e)
+                    raise
+        
+        return wrapper
+    return decorator

puvinoise_sdk-0.2.0/puvinoise_sdk.egg-info/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: puvinoise-sdk
+Version: 0.2.0
+Summary: Independent OpenTelemetry SDK for AI agents (Anthropic, OpenAI, Ollama)
+Author-email: Sarvesh Sahane <sarvesh.sahane@puvilabs.com>
+License: Proprietary
+Project-URL: Homepage, https://puvilabs.com
+Keywords: puvinoise,opentelemetry,otel,tracing,llm,agents,observability
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: opentelemetry-api>=1.20
+Requires-Dist: opentelemetry-sdk>=1.20
+Requires-Dist: opentelemetry-exporter-otlp>=1.20
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.20; extra == "anthropic"
+Provides-Extra: openai
+Requires-Dist: openai>=1.0; extra == "openai"
+Provides-Extra: all
+Requires-Dist: anthropic>=0.20; extra == "all"
+Requires-Dist: openai>=1.0; extra == "all"

puvinoise_sdk-0.2.0/puvinoise_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+pyproject.toml
+puvinoise/__init__.py
+puvinoise/bootstrap.py
+puvinoise/context.py
+puvinoise/hooks.py
+puvinoise/tracer.py
+puvinoise_sdk.egg-info/PKG-INFO
+puvinoise_sdk.egg-info/SOURCES.txt
+puvinoise_sdk.egg-info/dependency_links.txt
+puvinoise_sdk.egg-info/requires.txt
+puvinoise_sdk.egg-info/top_level.txt

puvinoise_sdk-0.2.0/puvinoise_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

puvinoise_sdk-0.2.0/puvinoise_sdk.egg-info/requires.txt

@@ -0,0 +1,13 @@
+opentelemetry-api>=1.20
+opentelemetry-sdk>=1.20
+opentelemetry-exporter-otlp>=1.20
+
+[all]
+anthropic>=0.20
+openai>=1.0
+
+[anthropic]
+anthropic>=0.20
+
+[openai]
+openai>=1.0

puvinoise_sdk-0.2.0/puvinoise_sdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+puvinoise

puvinoise_sdk-0.2.0/pyproject.toml

@@ -0,0 +1,52 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "puvinoise-sdk"
+version = "0.2.0"
+description = "Independent OpenTelemetry SDK for AI agents (Anthropic, OpenAI, Ollama)"
+readme = { file = "README.md", content-type = "text/markdown" }
+requires-python = ">=3.9"
+
+authors = [
+  { name = "Sarvesh Sahane", email = "sarvesh.sahane@puvilabs.com" }
+]
+
+license = { text = "Proprietary" }
+
+keywords = ["puvinoise", "opentelemetry", "otel", "tracing", "llm", "agents", "observability"]
+
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Operating System :: OS Independent",
+  "Intended Audience :: Developers",
+  "Topic :: Software Development :: Libraries",
+  "Topic :: System :: Monitoring",
+]
+
+# Core deps — always required
+dependencies = [
+    "opentelemetry-api>=1.20",
+    "opentelemetry-sdk>=1.20",
+    "opentelemetry-exporter-otlp>=1.20",
+]
+
+[project.urls]
+Homepage = "https://puvilabs.com"
+
+# Optional per-provider deps — install only what you need:
+#   pip install puvinoise[anthropic]
+#   pip install puvinoise[openai]
+#   pip install puvinoise[all]
+[project.optional-dependencies]
+anthropic = ["anthropic>=0.20"]
+openai    = ["openai>=1.0"]
+all       = ["anthropic>=0.20", "openai>=1.0"]
+
+[tool.setuptools.packages.find]
+where   = ["."]
+include = ["puvinoise*"]

puvinoise_sdk-0.2.0/setup.cfg

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