mantisdk 0.1.2__tar.gz → 0.1.3__tar.gz

{mantisdk-0.1.2 → mantisdk-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mantisdk
-Version: 0.1.2
+Version: 0.1.3
 Summary: Mantisdk - AI Agent Training and Evaluation Platform
 Project-URL: Homepage, https://github.com/withmetis/mantis
 Project-URL: Documentation, https://withmetis.github.io/mantis/mantisdk/
@@ -19,7 +19,6 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Python: >=3.10
-Requires-Dist: agentops>=0.4.13
 Requires-Dist: aiohttp
 Requires-Dist: aiologic
 Requires-Dist: fastapi

{mantisdk-0.1.2 → mantisdk-0.1.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mantisdk"
-version = "0.1.2"
+version = "0.1.3"
 description = "Mantisdk - AI Agent Training and Evaluation Platform"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -28,7 +28,6 @@ dependencies = [
   "gpustat",
   "setproctitle",
   "flask",
-  "agentops>=0.4.13",
   "uvicorn",
   "fastapi",
   "aiohttp",
@@ -100,11 +99,9 @@ experiment = [
 ]
 
 core-legacy = [
-  "agentops<=0.4.18",
   "openai<2.0.0",
 ]
 core-stable = [
-  "agentops>=0.4.21",
   "openai>=2.0.0",
 ]
 
@@ -334,7 +331,6 @@ testpaths = ["tests"]
 markers = [
   "openai: tests that require OpenAI API",
   "gpu: tests that require GPU",
-  "agentops: tests that require AgentOps",
   "weave: tests that require Weave",
   "llmproxy: tests that require LiteLLM",
   "mongo: tests that require MongoDB",

{mantisdk-0.1.2 → mantisdk-0.1.3}/src/mantisdk/__init__.py

@@ -1,6 +1,6 @@
 # Copyright (c) Microsoft. All rights reserved.
 
-__version__ = "0.1.2"
+__version__ = "0.1.3"
 
 from .adapter import *
 from .algorithm import *

{mantisdk-0.1.2 → mantisdk-0.1.3}/src/mantisdk/tracing/__init__.py

@@ -3,25 +3,29 @@
 """Standalone tracing module for MantisDK.
 
 This module provides a "one-liner" entry point for instrumenting applications
-with OpenTelemetry, compatible with OpenInference and AgentOps ecosystems,
+with OpenTelemetry, compatible with OpenInference ecosystem,
 while natively supporting export to Mantis Insight.
 
 Example usage::
 
-    import mantisdk.tracing_claude as tracing
+    import mantisdk.tracing as tracing
 
     # Auto-detect Insight from environment variables
     tracing.init()
 
-    # Use context managers for manual spans
-    with tracing.trace("my-workflow"):
-        with tracing.span("step-1"):
-            do_work()
-
-    # Use decorators
+    # Use as a decorator (auto-captures input/output)
     @tracing.trace
-    def my_function():
-        pass
+    def my_function(query: str) -> dict:
+        return {"result": query.upper()}
+
+    # Use as a context manager (explicit input/output)
+    with tracing.trace("my-workflow", input=query) as span:
+        result = do_work()
+        span.set_attribute(tracing.semconv.TRACE_OUTPUT, result)
+
+    # Use semantic conventions for rich metadata
+    span.set_attribute(tracing.semconv.USER_ID, "user-123")
+    span.set_attribute(tracing.semconv.SESSION_ID, "session-456")
 
     # Ensure spans are flushed on shutdown
     tracing.shutdown()
@@ -34,7 +38,8 @@ Environment variables for Insight auto-detect:
 """
 
 from .init import init, instrument, shutdown, flush
-from .api import trace, span, tool, atrace, aspan
+from .api import trace, span, tool, atrace, aspan, get_current_span
+from . import semconv
 
 # Re-export exporter factory for explicit configuration
 from .exporters.insight import insight as insight_exporter
@@ -45,13 +50,17 @@ __all__ = [
     "instrument",
     "shutdown",
     "flush",
-    # Context managers (sync)
+    # Context managers / decorators (sync)
     "trace",
     "span",
     "tool",
     # Context managers (async)
     "atrace",
     "aspan",
+    # Span utilities
+    "get_current_span",
+    # Semantic conventions
+    "semconv",
     # Exporter factory
     "insight_exporter",
 ]

{mantisdk-0.1.2 → mantisdk-0.1.3}/src/mantisdk/tracing/api.py

@@ -14,12 +14,16 @@ from __future__ import annotations
 
 import asyncio
 import functools
+import inspect
+import json
 import logging
 from contextlib import asynccontextmanager, contextmanager
 from typing import Any, AsyncGenerator, Callable, Generator, Optional, TypeVar, Union
 
-from opentelemetry import trace
-from opentelemetry.trace import Span, SpanKind, Status, StatusCode
+from opentelemetry import trace as otel_trace
+from opentelemetry.trace import Span, SpanKind, Status, StatusCode, Tracer
+
+from . import semconv
 
 logger = logging.getLogger(__name__)
 
@@ -30,69 +34,246 @@ F = TypeVar("F", bound=Callable[..., Any])
 TRACER_NAME = "mantisdk.tracing"
 
 
-def _get_tracer() -> trace.Tracer:
-    """Get the MantisDK tracer instance."""
-    return trace.get_tracer(TRACER_NAME)
+# =============================================================================
+# Serialization helpers for I/O capture
+# =============================================================================
+
+
+def _safe_serialize(value: Any) -> Any:
+    """Recursively serialize a value to JSON-compatible format."""
+    if value is None or isinstance(value, (bool, int, float, str)):
+        return value
+    if isinstance(value, (list, tuple)):
+        return [_safe_serialize(v) for v in value]
+    if isinstance(value, dict):
+        return {str(k): _safe_serialize(v) for k, v in value.items()}
+    # Fallback for complex objects (Pydantic models, dataclasses, etc.)
+    if hasattr(value, "model_dump"):
+        return _safe_serialize(value.model_dump())
+    if hasattr(value, "__dict__"):
+        return _safe_serialize(vars(value))
+    return str(value)
+
+
+def _serialize_value(value: Any) -> str:
+    """Safely serialize a value to a JSON string for span attributes."""
+    if value is None:
+        return "null"
+    if isinstance(value, str):
+        return value
+    if isinstance(value, (bool, int, float)):
+        return json.dumps(value)
+    try:
+        return json.dumps(_safe_serialize(value))
+    except Exception:
+        return str(value)
+
+
+def _capture_function_input(fn: Callable[..., Any], args: tuple[Any, ...], kwargs: dict[str, Any]) -> str:
+    """Capture function arguments as a JSON string."""
+    try:
+        sig = inspect.signature(fn)
+        bound = sig.bind(*args, **kwargs)
+        bound.apply_defaults()
+
+        # Filter out 'self' and 'cls' parameters
+        input_dict = {
+            k: _safe_serialize(v)
+            for k, v in bound.arguments.items()
+            if k not in ("self", "cls")
+        }
 
+        return json.dumps(input_dict) if input_dict else "{}"
+    except Exception:
+        # Fallback: simple representation
+        return json.dumps({
+            "args": [str(a) for a in args],
+            "kwargs": {k: str(v) for k, v in kwargs.items()}
+        })
 
-@contextmanager
-def trace(
-    name: str,
-    *,
-    kind: SpanKind = SpanKind.INTERNAL,
-    attributes: Optional[dict[str, Any]] = None,
-    record_exception: bool = True,
-    set_status_on_exception: bool = True,
-    **extra_attributes: Any,
-) -> Generator[Span, None, None]:
-    """Context manager to create a trace (root span).
 
-    This creates a new span that will be the root of a trace tree.
-    Child spans created within this context will be linked to this root.
+def _get_tracer() -> Tracer:
+    """Get the MantisDK tracer instance."""
+    return otel_trace.get_tracer(TRACER_NAME)
 
-    Args:
-        name: The name of the trace/span.
-        kind: The span kind (default: INTERNAL).
-        attributes: Dictionary of attributes to set on the span.
-        record_exception: If True, exceptions are recorded on the span.
-        set_status_on_exception: If True, span status is set to ERROR on exception.
-        **extra_attributes: Additional attributes as keyword arguments.
 
-    Yields:
-        The OpenTelemetry Span object.
+class trace:
+    """Create a trace span - works as both a decorator and context manager.
 
-    Example::
+    As a decorator, automatically captures function inputs and outputs::
 
-        import mantisdk.tracing_claude as tracing
+        @tracing.trace
+        def my_function(query: str) -> dict:
+            return {"result": query.upper()}
+
+        @tracing.trace(name="custom-name", capture_output=False)
+        def another_function(data):
+            process(data)
 
-        tracing.init()
+    As a context manager, allows explicit input/output control::
 
-        with tracing.trace("my-workflow", user_id="123") as span:
-            span.set_attribute("step", "preprocessing")
+        with tracing.trace("my-workflow", input=query) as span:
             result = do_work()
-            span.set_attribute("result_count", len(result))
+            span.set_attribute(tracing.semconv.TRACE_OUTPUT, result)
+
+    Args:
+        name_or_func: Either the span name (str) or the function to decorate.
+        name: Explicit span name (for decorator with custom name).
+        input: Input value to capture (context manager mode).
+        kind: The span kind (default: INTERNAL).
+        attributes: Dictionary of attributes to set on the span.
+        capture_input: Auto-capture function input (decorator mode, default: True).
+        capture_output: Auto-capture function output (decorator mode, default: True).
+        record_exception: If True, exceptions are recorded on the span.
+        set_status_on_exception: If True, span status is set to ERROR on exception.
     """
-    tracer = _get_tracer()
-    all_attributes = {**(attributes or {}), **extra_attributes}
 
-    with tracer.start_as_current_span(
-        name=name,
-        kind=kind,
-        attributes=all_attributes if all_attributes else None,
-        record_exception=record_exception,
-        set_status_on_exception=set_status_on_exception,
-    ) as otel_span:
+    def __init__(
+        self,
+        name_or_func: Optional[Union[str, Callable[..., Any]]] = None,
+        *,
+        name: Optional[str] = None,
+        input: Optional[Any] = None,
+        kind: SpanKind = SpanKind.INTERNAL,
+        attributes: Optional[dict[str, Any]] = None,
+        capture_input: bool = True,
+        capture_output: bool = True,
+        record_exception: bool = True,
+        set_status_on_exception: bool = True,
+    ):
+        self._name_or_func = name_or_func
+        self._explicit_name = name
+        self._input = input
+        self._kind = kind
+        self._attributes = attributes
+        self._capture_input = capture_input
+        self._capture_output = capture_output
+        self._record_exception = record_exception
+        self._set_status_on_exception = set_status_on_exception
+        self._span: Optional[Span] = None
+        self._token: Optional[Any] = None
+
+        # If called as @trace without parentheses, name_or_func is the function
+        if callable(name_or_func):
+            self._func = name_or_func
+            self._span_name = name or name_or_func.__name__
+        else:
+            self._func = None
+            self._span_name = name_or_func or name or "trace"
+
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:
+        """Handle decorator invocation."""
+        # If we already have a function, this is the actual call
+        if self._func is not None:
+            return self._invoke_decorated(self._func, args, kwargs)
+
+        # If first arg is a callable, we're being used as @trace(...) decorator
+        if args and callable(args[0]) and not kwargs:
+            func = args[0]
+            self._func = func
+            self._span_name = self._explicit_name or func.__name__
+
+            # Return a wrapper that will be called when the function is invoked
+            if asyncio.iscoroutinefunction(func):
+                @functools.wraps(func)
+                async def async_wrapper(*a: Any, **kw: Any) -> Any:
+                    return await self._invoke_decorated_async(func, a, kw)
+                return async_wrapper
+            else:
+                @functools.wraps(func)
+                def sync_wrapper(*a: Any, **kw: Any) -> Any:
+                    return self._invoke_decorated(func, a, kw)
+                return sync_wrapper
+
+        raise TypeError("trace() requires a name string or a function")
+
+    def _invoke_decorated(self, func: Callable[..., Any], args: tuple[Any, ...], kwargs: dict[str, Any]) -> Any:
+        """Invoke a decorated sync function with tracing."""
+        tracer = _get_tracer()
+
+        with tracer.start_as_current_span(
+            name=self._span_name,
+            kind=self._kind,
+            attributes=self._attributes,
+            record_exception=self._record_exception,
+            set_status_on_exception=self._set_status_on_exception,
+        ) as span:
+            # Capture input
+            if self._capture_input:
+                input_val = _capture_function_input(func, args, kwargs)
+                span.set_attribute(semconv.OBSERVATION_INPUT, input_val)
+
+            result = func(*args, **kwargs)
+
+            # Capture output
+            if self._capture_output:
+                span.set_attribute(semconv.OBSERVATION_OUTPUT, _serialize_value(result))
+
+            return result
+
+    async def _invoke_decorated_async(self, func: Callable[..., Any], args: tuple[Any, ...], kwargs: dict[str, Any]) -> Any:
+        """Invoke a decorated async function with tracing."""
+        tracer = _get_tracer()
+
+        with tracer.start_as_current_span(
+            name=self._span_name,
+            kind=self._kind,
+            attributes=self._attributes,
+            record_exception=self._record_exception,
+            set_status_on_exception=self._set_status_on_exception,
+        ) as span:
+            # Capture input
+            if self._capture_input:
+                input_val = _capture_function_input(func, args, kwargs)
+                span.set_attribute(semconv.OBSERVATION_INPUT, input_val)
+
+            result = await func(*args, **kwargs)
+
+            # Capture output
+            if self._capture_output:
+                span.set_attribute(semconv.OBSERVATION_OUTPUT, _serialize_value(result))
+
+            return result
+
+    def __enter__(self) -> Span:
+        """Context manager entry - start the span."""
+        tracer = _get_tracer()
+        self._span = tracer.start_span(
+            name=self._span_name,
+            kind=self._kind,
+            attributes=self._attributes,
+            record_exception=self._record_exception,
+            set_status_on_exception=self._set_status_on_exception,
+        )
+        # Store the context manager to properly exit later
+        self._use_span_cm = otel_trace.use_span(self._span, end_on_exit=False)
+        self._use_span_cm.__enter__()
+
+        # Set input if provided
+        if self._input is not None:
+            self._span.set_attribute(semconv.TRACE_INPUT, _serialize_value(self._input))
+
+        return self._span
+
+    def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        """Context manager exit - end the span."""
         try:
-            yield otel_span
-        except Exception as e:
-            # Span context manager handles recording; we just re-raise
-            raise
+            if self._span is not None:
+                if exc_val is not None and self._record_exception:
+                    self._span.record_exception(exc_val)
+                if exc_val is not None and self._set_status_on_exception:
+                    self._span.set_status(Status(StatusCode.ERROR, str(exc_val)))
+                self._span.end()
+        finally:
+            if hasattr(self, '_use_span_cm') and self._use_span_cm is not None:
+                self._use_span_cm.__exit__(exc_type, exc_val, exc_tb)
 
 
 @contextmanager
 def span(
     name: str,
     *,
+    input: Optional[Any] = None,
     kind: SpanKind = SpanKind.INTERNAL,
     attributes: Optional[dict[str, Any]] = None,
     record_exception: bool = True,
@@ -106,6 +287,7 @@ def span(
 
     Args:
         name: The name of the span.
+        input: Input value to capture (displayed in Insight UI).
         kind: The span kind (default: INTERNAL).
         attributes: Dictionary of attributes to set on the span.
         record_exception: If True, exceptions are recorded on the span.
@@ -117,12 +299,12 @@ def span(
 
     Example::
 
-        import mantisdk.tracing_claude as tracing
+        import mantisdk.tracing as tracing
 
         with tracing.trace("my-workflow"):
-            with tracing.span("step.load_data", dataset="training") as s:
+            with tracing.span("step.load_data", input=dataset_name) as s:
                 data = load_data()
-                s.set_attribute("rows", len(data))
+                s.set_attribute(tracing.semconv.OBSERVATION_OUTPUT, str(len(data)))
 
             with tracing.span("step.process"):
                 process(data)
@@ -137,6 +319,9 @@ def span(
         record_exception=record_exception,
         set_status_on_exception=set_status_on_exception,
     ) as otel_span:
+        # Set input if provided
+        if input is not None:
+            otel_span.set_attribute(semconv.OBSERVATION_INPUT, _serialize_value(input))
         try:
             yield otel_span
         except Exception:
@@ -147,6 +332,7 @@ def span(
 def tool(
     name: str,
     *,
+    input: Optional[Any] = None,
     tool_name: Optional[str] = None,
     attributes: Optional[dict[str, Any]] = None,
     record_exception: bool = True,
@@ -160,6 +346,7 @@ def tool(
 
     Args:
         name: The span name (often the function/tool name).
+        input: Input value to capture (displayed in Insight UI).
         tool_name: Explicit tool name attribute (defaults to name).
         attributes: Dictionary of attributes to set on the span.
         record_exception: If True, exceptions are recorded on the span.
@@ -171,11 +358,11 @@ def tool(
 
     Example::
 
-        import mantisdk.tracing_claude as tracing
+        import mantisdk.tracing as tracing
 
-        with tracing.tool("search_database", query="SELECT *") as s:
+        with tracing.tool("search_database", input=query) as s:
             results = db.execute(query)
-            s.set_attribute("result_count", len(results))
+            s.set_attribute(tracing.semconv.OBSERVATION_OUTPUT, str(len(results)))
     """
     tracer = _get_tracer()
     all_attributes = {
@@ -192,6 +379,9 @@ def tool(
         record_exception=record_exception,
         set_status_on_exception=set_status_on_exception,
     ) as otel_span:
+        # Set input if provided
+        if input is not None:
+            otel_span.set_attribute(semconv.OBSERVATION_INPUT, _serialize_value(input))
         try:
             yield otel_span
         except Exception:
@@ -202,6 +392,7 @@ def tool(
 async def atrace(
     name: str,
     *,
+    input: Optional[Any] = None,
     kind: SpanKind = SpanKind.INTERNAL,
     attributes: Optional[dict[str, Any]] = None,
     record_exception: bool = True,
@@ -214,6 +405,7 @@ async def atrace(
 
     Args:
         name: The name of the trace/span.
+        input: Input value to capture (displayed in Insight UI).
         kind: The span kind (default: INTERNAL).
         attributes: Dictionary of attributes to set on the span.
         record_exception: If True, exceptions are recorded on the span.
@@ -225,10 +417,11 @@ async def atrace(
 
     Example::
 
-        import mantisdk.tracing_claude as tracing
+        import mantisdk.tracing as tracing
 
-        async with tracing.atrace("my-async-workflow") as span:
+        async with tracing.atrace("my-async-workflow", input=query) as span:
             result = await async_operation()
+            span.set_attribute(tracing.semconv.TRACE_OUTPUT, result)
     """
     tracer = _get_tracer()
     all_attributes = {**(attributes or {}), **extra_attributes}
@@ -240,6 +433,9 @@ async def atrace(
         record_exception=record_exception,
         set_status_on_exception=set_status_on_exception,
     ) as otel_span:
+        # Set input if provided
+        if input is not None:
+            otel_span.set_attribute(semconv.TRACE_INPUT, _serialize_value(input))
         try:
             yield otel_span
         except Exception:
@@ -250,6 +446,7 @@ async def atrace(
 async def aspan(
     name: str,
     *,
+    input: Optional[Any] = None,
     kind: SpanKind = SpanKind.INTERNAL,
     attributes: Optional[dict[str, Any]] = None,
     record_exception: bool = True,
@@ -262,6 +459,7 @@ async def aspan(
 
     Args:
         name: The name of the span.
+        input: Input value to capture (displayed in Insight UI).
         kind: The span kind (default: INTERNAL).
         attributes: Dictionary of attributes to set on the span.
         record_exception: If True, exceptions are recorded on the span.
@@ -273,12 +471,12 @@ async def aspan(
 
     Example::
 
-        import mantisdk.tracing_claude as tracing
+        import mantisdk.tracing as tracing
 
-        async with tracing.atrace("workflow"):
+        async with tracing.atrace("workflow", input=query):
             async with tracing.aspan("fetch_data") as s:
                 data = await fetch()
-                s.set_attribute("size", len(data))
+                s.set_attribute(tracing.semconv.OBSERVATION_OUTPUT, str(len(data)))
     """
     tracer = _get_tracer()
     all_attributes = {**(attributes or {}), **extra_attributes}
@@ -290,6 +488,9 @@ async def aspan(
         record_exception=record_exception,
         set_status_on_exception=set_status_on_exception,
     ) as otel_span:
+        # Set input if provided
+        if input is not None:
+            otel_span.set_attribute(semconv.OBSERVATION_INPUT, _serialize_value(input))
         try:
             yield otel_span
         except Exception:
@@ -537,7 +738,7 @@ def get_current_span() -> Span:
             span = tracing.get_current_span()
             span.set_attribute("inner_data", "value")
     """
-    return trace.get_current_span()
+    return otel_trace.get_current_span()
 
 
 # Convenience aliases for decorator-style usage

{mantisdk-0.1.2 → mantisdk-0.1.3}/src/mantisdk/tracing/init.py

@@ -35,8 +35,7 @@ def init(
     *,
     trace_name: Optional[str] = None,
     service_name: Optional[str] = None,
-    instrument_default: bool = True,
-    instrument_agentops: bool = False,
+    instrument_default: bool = False,
     exporters: Optional[List[SpanExporter]] = None,
     trace_config: Optional["TraceConfig"] = None,
     force: bool = False,
@@ -55,13 +54,11 @@ def init(
         - If force=True, replaces the existing TracerProvider.
 
     Args:
-        trace_name: Optional name for the trace (mostly for AgentOps compatibility).
+        trace_name: Optional name for the trace.
         service_name: Name of the service (mapped to resource attributes).
             Defaults to "mantisdk-tracing".
         instrument_default: Whether to automatically instrument the "core set"
             of libraries (OpenAI, Anthropic, LangChain, LlamaIndex) if installed.
-        instrument_agentops: Whether to enable AgentOps helpers (decorators)
-            without exporting to AgentOps platform.
         exporters: List of custom OpenTelemetry SpanExporters. If None and
             Insight env vars are configured, auto-creates an Insight exporter.
         trace_config: OpenInference TraceConfig for controlling capture behavior
@@ -69,7 +66,6 @@ def init(
         force: If True, replaces any existing global TracerProvider. If False
             (default), reuses the existing provider and appends processors.
         integrations: Dictionary for fine-grained control over integrations.
-            Example: {"agentops": {"enabled": True, "helpers_only": True}}
 
     Example::
 
@@ -143,9 +139,6 @@ def init(
         if instrument_default:
             instrument()
 
-        if instrument_agentops:
-            _setup_agentops_helpers(integrations)
-
         _initialized = True
         logger.info("MantisDK tracing initialized successfully")
 
@@ -336,26 +329,6 @@ def _get_exporter_id(exporter: SpanExporter) -> str:
     return class_name
 
 
-def _setup_agentops_helpers(integrations: Optional[Dict[str, Any]] = None) -> None:
-    """Enable AgentOps helpers (decorators) without AgentOps export.
-
-    This sets up AgentOps instrumentation in "helpers only" mode,
-    where spans are created but exported through MantisDK's exporter
-    rather than AgentOps's backend.
-    """
-    config = (integrations or {}).get("agentops", {})
-    if not config.get("enabled", True):
-        return
-
-    try:
-        import agentops
-        # AgentOps init with no API key = helpers only mode
-        # The spans will go through our TracerProvider
-        logger.debug("AgentOps helpers mode enabled")
-    except ImportError:
-        logger.debug("AgentOps not installed, skipping helpers setup")
-
-
 def get_tracer(name: str = "mantisdk.tracing") -> trace.Tracer:
     """Get a tracer instance for creating spans.