mantisdk 0.1.2__py3-none-any.whl → 0.1.3__py3-none-any.whl

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/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/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/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.
 

mantisdk/tracing/semconv.py

@@ -0,0 +1,82 @@
+# Copyright (c) Metis. All rights reserved.
+
+"""Mantisdk Semantic Conventions for Tracing.
+
+These attributes align with Insight's primary namespace for optimal
+display in the Insight UI. Insight also supports OpenInference,
+Langfuse, and other SDK conventions via its attribute alias system.
+
+See: insight/packages/shared/src/server/otel/attributeAliases.ts
+
+Usage::
+
+    import mantisdk.tracing as tracing
+
+    with tracing.trace("my-task", input=query) as span:
+        span.set_attribute(tracing.semconv.USER_ID, "user-123")
+        span.set_attribute(tracing.semconv.SESSION_ID, "session-456")
+        result = do_work()
+        span.set_attribute(tracing.semconv.TRACE_OUTPUT, result)
+"""
+
+# =============================================================================
+# Trace-level attributes (for root spans)
+# =============================================================================
+TRACE_NAME = "insight.trace.name"
+TRACE_INPUT = "insight.trace.input"
+TRACE_OUTPUT = "insight.trace.output"
+TRACE_METADATA = "insight.trace.metadata"
+TRACE_TAGS = "insight.trace.tags"
+TRACE_PUBLIC = "insight.trace.public"
+
+# =============================================================================
+# User & Session
+# =============================================================================
+USER_ID = "insight.user.id"
+SESSION_ID = "insight.session.id"
+
+# =============================================================================
+# Environment & Version
+# =============================================================================
+ENVIRONMENT = "insight.environment"
+RELEASE = "insight.release"
+VERSION = "insight.version"
+
+# =============================================================================
+# Observation-level attributes (for child spans)
+# =============================================================================
+OBSERVATION_TYPE = "insight.observation.type"
+OBSERVATION_INPUT = "insight.observation.input"
+OBSERVATION_OUTPUT = "insight.observation.output"
+OBSERVATION_METADATA = "insight.observation.metadata"
+OBSERVATION_LEVEL = "insight.observation.level"
+OBSERVATION_STATUS_MESSAGE = "insight.observation.status_message"
+
+# =============================================================================
+# Model & Generation attributes
+# =============================================================================
+MODEL_NAME = "insight.observation.model.name"
+MODEL_PARAMETERS = "insight.observation.model.parameters"
+
+
+# =============================================================================
+# Observation types (values for OBSERVATION_TYPE)
+# =============================================================================
+class ObservationType:
+    """Valid values for the OBSERVATION_TYPE attribute."""
+
+    SPAN = "span"
+    GENERATION = "generation"
+    EVENT = "event"
+
+
+# =============================================================================
+# Observation levels (values for OBSERVATION_LEVEL)
+# =============================================================================
+class ObservationLevel:
+    """Valid values for the OBSERVATION_LEVEL attribute."""
+
+    DEBUG = "DEBUG"
+    DEFAULT = "DEFAULT"
+    WARNING = "WARNING"
+    ERROR = "ERROR"

{mantisdk-0.1.2.dist-info → mantisdk-0.1.3.dist-info}/METADATA

@@ -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.dist-info → mantisdk-0.1.3.dist-info}/RECORD

@@ -1,4 +1,4 @@
-mantisdk/__init__.py,sha256=LsOsUrIvnZ8LtDNfw5o2rCqCJn0aDJk4JIAYB1Q5HQo,718
+mantisdk/__init__.py,sha256=iVsMd8gsA3K-KIIWr_GlCT-WXI-N5hYF41Ql8ukjFis,718
 mantisdk/client.py,sha256=QTH-0LDAKWLuLH7PSaZWj7XUcnbBGrJHH-w2dJiNmKM,17059
 mantisdk/config.py,sha256=9RAdsbTkSG_qnLvTwH0xTG5srLFaj1nk5Ufz1dQHGwc,14355
 mantisdk/env_var.py,sha256=OCb5CvZo5U7-HBnqC0ZmdsrS2giAh7dV85TTjz6wLqA,4372
@@ -158,10 +158,11 @@ mantisdk/tracer/base.py,sha256=icW8Xb-PFv_CJop71kGN8POujVCCZqn6K-jGja9hHlY,9454
 mantisdk/tracer/dummy.py,sha256=p-MO-sfS5t7J1Lae-ep7OW7y4rwklHUm_Jf0swM12RA,3399
 mantisdk/tracer/otel.py,sha256=-0NHS08BLFA3N2lbzecYwjz3SdCnrDS6psJaHxjBq1o,24430
 mantisdk/tracer/weave.py,sha256=UxEgESCI7bGIXhigW8YG6hCtr3ZhB86d9LOZPmFeOdc,26921
-mantisdk/tracing/__init__.py,sha256=8WSvcB62ogBo3oLyu6non4eoDTDh5NQyIYgbyq7ZXaI,1551
-mantisdk/tracing/api.py,sha256=bbBsABnfvp0B1fHbsW3pM-g2VY0AUZ2THx_tVXDLQXA,17273
+mantisdk/tracing/__init__.py,sha256=_EO6OSNBcsPZ0PBKyOoq4f494_ruoGitJMnEK7iXe-o,1990
+mantisdk/tracing/api.py,sha256=2p-M0oI_JSazAAeFN-Kig2lCzZ-1MIwbQvWB2Nb6stE,25741
 mantisdk/tracing/attributes.py,sha256=eCB1dmGol-OnFCOvMvVqdpgHDMNKTLIV7Y_w4ktTXxU,8617
-mantisdk/tracing/init.py,sha256=1AI92hS8HY96pfiApczb4_Ciu1g8YHwe2P8e-FLo3tQ,12472
+mantisdk/tracing/init.py,sha256=8RYpAv_gz2gfvkJuI_1SlomG2fzr7ReIZhjtdBzdLNk,11369
+mantisdk/tracing/semconv.py,sha256=3aulZ5Mlk1kJY1XdHXH1SJmr4g4Ut-1hij6gedshrm8,3205
 mantisdk/tracing/exporters/__init__.py,sha256=Y2cnRuApIc34dJpoJGLakZfrzyzyFrr0dchHuTiDpmw,191
 mantisdk/tracing/exporters/insight.py,sha256=kVq7syVpT06nD6Lu8-tjthnIqALuBGkFb6ICOAajLy8,6753
 mantisdk/tracing/instrumentors/__init__.py,sha256=NXwK6SYJgrEg9zQM8uvthL43a2lyfRgx0gYAzcEnFNg,392
@@ -193,8 +194,8 @@ mantisdk/verl/daemon.py,sha256=cvIGDkotN6MPp-DubCeKBfD9hSoZCgRyIACI9X7D7uw,54493
 mantisdk/verl/dataset.py,sha256=Hr0K9oXuj7q8pf08BuvNRTbIgyNo0XY_N_JVA5jHUvI,1175
 mantisdk/verl/entrypoint.py,sha256=dnZ7TwCe9hC1kRXm_ypRTrSR9cPXz3LcxXYjtPVuOHs,8627
 mantisdk/verl/trainer.py,sha256=TCaVXo65iNcEEGujuIbx2yQ_cMfBYyU5Uudx9gOBSNI,25447
-mantisdk-0.1.2.dist-info/METADATA,sha256=P2Skwi3Cf5XLGN0un6XEgc5NHgKi-fvNTZ3V9f99VpE,3418
-mantisdk-0.1.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-mantisdk-0.1.2.dist-info/entry_points.txt,sha256=yDYe8wx2pXbBXBaRPtRwt6OL01VPHf6GiFsfauISW3M,42
-mantisdk-0.1.2.dist-info/licenses/LICENSE,sha256=j3Flk3DFJo2aHclipGIyVA6PymNGJYbY76qVqrSSogg,1046
-mantisdk-0.1.2.dist-info/RECORD,,
+mantisdk-0.1.3.dist-info/METADATA,sha256=eaJbnQsPVqpKZXwfkBwqCGFYPWf7TlSm9sUVpPglD8c,3386
+mantisdk-0.1.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+mantisdk-0.1.3.dist-info/entry_points.txt,sha256=yDYe8wx2pXbBXBaRPtRwt6OL01VPHf6GiFsfauISW3M,42
+mantisdk-0.1.3.dist-info/licenses/LICENSE,sha256=j3Flk3DFJo2aHclipGIyVA6PymNGJYbY76qVqrSSogg,1046
+mantisdk-0.1.3.dist-info/RECORD,,