traceAI-minimax 0.1.0__py3-none-any.whl

traceai_minimax/__init__.py

@@ -0,0 +1,106 @@
+import logging
+from importlib import import_module
+from typing import Any, Collection
+
+logger = logging.getLogger(__name__)
+
+from fi_instrumentation import FITracer, TraceConfig
+from opentelemetry import trace as trace_api
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from wrapt import wrap_function_wrapper
+
+from traceai_minimax._wrappers import (
+    _AsyncChatCompletionWrapper,
+    _ChatCompletionWrapper,
+)
+from traceai_minimax.version import __version__
+
+logger = logging.getLogger(__name__)
+logger.addHandler(logging.NullHandler())
+
+_instruments = ("openai >= 1.0.0",)
+
+
+class MiniMaxInstrumentor(BaseInstrumentor):
+    """
+    OpenTelemetry instrumentor for MiniMax.
+
+    MiniMax uses the OpenAI SDK with a custom base_url (https://api.minimax.io/v1).
+    This instrumentor wraps OpenAI client methods and only instruments calls
+    when the client is configured with a MiniMax base URL.
+
+    Supports:
+    - MiniMax-M2.7 (latest flagship model with enhanced reasoning and coding)
+    - MiniMax-M2.7-highspeed (high-speed version of M2.7 for low-latency scenarios)
+    - MiniMax-M2.5 (204K context window)
+    - MiniMax-M2.5-highspeed (204K context window, faster inference)
+    - Streaming and non-streaming responses
+    - Function/tool calling
+    """
+
+    __slots__ = (
+        "_original_chat_create",
+        "_original_async_chat_create",
+        "_tracer",
+    )
+
+    def instrumentation_dependencies(self) -> Collection[str]:
+        return _instruments
+
+    def _instrument(self, **kwargs: Any) -> None:
+        if not (tracer_provider := kwargs.get("tracer_provider")):
+            tracer_provider = trace_api.get_tracer_provider()
+        if not (config := kwargs.get("config")):
+            config = TraceConfig()
+        else:
+            assert isinstance(config, TraceConfig)
+
+        self._tracer = FITracer(
+            trace_api.get_tracer(__name__, __version__, tracer_provider),
+            config=config,
+        )
+
+        # Import openai module
+        try:
+            openai_module = import_module("openai")
+        except ImportError:
+            logger.warning("openai package not installed, MiniMax instrumentation skipped")
+            return
+
+        # Wrap OpenAI client chat.completions.create
+        # The wrapper checks if the client is configured for MiniMax
+        try:
+            # Sync client
+            if hasattr(openai_module, "OpenAI"):
+                from openai.resources.chat import completions
+
+                self._original_chat_create = completions.Completions.create
+                wrap_function_wrapper(
+                    module="openai.resources.chat.completions",
+                    name="Completions.create",
+                    wrapper=_ChatCompletionWrapper(tracer=self._tracer),
+                )
+
+            # Async client
+            if hasattr(openai_module, "AsyncOpenAI"):
+                from openai.resources.chat import completions as async_completions
+
+                self._original_async_chat_create = async_completions.AsyncCompletions.create
+                wrap_function_wrapper(
+                    module="openai.resources.chat.completions",
+                    name="AsyncCompletions.create",
+                    wrapper=_AsyncChatCompletionWrapper(tracer=self._tracer),
+                )
+        except Exception as e:
+            logger.warning(f"Failed to instrument OpenAI for MiniMax: {e}")
+
+    def _uninstrument(self, **kwargs: Any) -> None:
+        try:
+            from openai.resources.chat import completions
+
+            if hasattr(self, "_original_chat_create"):
+                completions.Completions.create = self._original_chat_create
+            if hasattr(self, "_original_async_chat_create"):
+                completions.AsyncCompletions.create = self._original_async_chat_create
+        except Exception as e:
+            logger.warning(f"Failed to uninstrument: {e}")

traceai_minimax/_request_attributes_extractor.py

@@ -0,0 +1,115 @@
+import logging
+from typing import Any, Dict, Iterator, Mapping, Tuple
+
+from fi_instrumentation import safe_json_dumps
+from fi_instrumentation.fi_types import (
+    FiMimeTypeValues,
+    FiSpanKindValues,
+    MessageAttributes,
+    SpanAttributes,
+)
+from opentelemetry.util.types import AttributeValue
+
+logger = logging.getLogger(__name__)
+logger.addHandler(logging.NullHandler())
+
+
+class _ChatCompletionRequestAttributesExtractor:
+    """Extract span attributes from MiniMax chat completion request."""
+
+    def get_attributes_from_request(
+        self, request_parameters: Mapping[str, Any]
+    ) -> Iterator[Tuple[str, AttributeValue]]:
+        """Extract primary attributes from request."""
+        yield SpanAttributes.GEN_AI_SPAN_KIND, FiSpanKindValues.LLM.value
+        yield SpanAttributes.GEN_AI_PROVIDER_NAME, "minimax"
+
+        model = request_parameters.get("model", "MiniMax-M2.7")
+        yield SpanAttributes.GEN_AI_REQUEST_MODEL, model
+
+        yield SpanAttributes.INPUT_MIME_TYPE, FiMimeTypeValues.JSON.value
+        yield SpanAttributes.OUTPUT_MIME_TYPE, FiMimeTypeValues.JSON.value
+
+        # Invocation parameters
+        invocation_params = self._extract_invocation_parameters(request_parameters)
+        if invocation_params:
+            yield SpanAttributes.GEN_AI_REQUEST_PARAMETERS, safe_json_dumps(invocation_params)
+
+    def get_extra_attributes_from_request(
+        self, request_parameters: Mapping[str, Any]
+    ) -> Iterator[Tuple[str, AttributeValue]]:
+        """Extract extra attributes including messages."""
+        messages = request_parameters.get("messages", [])
+
+        # Track input messages
+        for i, msg in enumerate(messages):
+            role = msg.get("role", "")
+            content = msg.get("content", "")
+
+            # Handle content that might be a list (for multimodal)
+            if isinstance(content, list):
+                text_parts = []
+                for part in content:
+                    if isinstance(part, dict) and part.get("type") == "text":
+                        text_parts.append(part.get("text", ""))
+                content = "\n".join(text_parts)
+
+            yield f"{SpanAttributes.GEN_AI_INPUT_MESSAGES}.{i}.{MessageAttributes.MESSAGE_ROLE}", role
+            yield f"{SpanAttributes.GEN_AI_INPUT_MESSAGES}.{i}.{MessageAttributes.MESSAGE_CONTENT}", str(content)
+
+            # Handle tool calls in assistant messages
+            if role == "assistant" and "tool_calls" in msg:
+                tool_calls = msg.get("tool_calls", [])
+                for j, tc in enumerate(tool_calls):
+                    yield f"{SpanAttributes.GEN_AI_INPUT_MESSAGES}.{i}.tool_calls.{j}.id", tc.get("id", "")
+                    yield f"{SpanAttributes.GEN_AI_INPUT_MESSAGES}.{i}.tool_calls.{j}.type", tc.get("type", "function")
+                    if "function" in tc:
+                        yield f"{SpanAttributes.GEN_AI_INPUT_MESSAGES}.{i}.tool_calls.{j}.function.name", tc["function"].get("name", "")
+                        yield f"{SpanAttributes.GEN_AI_INPUT_MESSAGES}.{i}.tool_calls.{j}.function.arguments", tc["function"].get("arguments", "")
+
+        # System prompt extraction
+        for msg in messages:
+            if msg.get("role") == "system":
+                yield SpanAttributes.GEN_AI_PROVIDER_NAME_PROMPT, str(msg.get("content", ""))
+                break
+
+        # User input for display
+        for msg in reversed(messages):
+            if msg.get("role") == "user":
+                content = msg.get("content", "")
+                if isinstance(content, list):
+                    text_parts = [p.get("text", "") for p in content if isinstance(p, dict) and p.get("type") == "text"]
+                    content = "\n".join(text_parts)
+                yield SpanAttributes.INPUT_VALUE, str(content)
+                break
+
+        # Tools
+        if "tools" in request_parameters:
+            tools = request_parameters.get("tools", [])
+            yield "minimax.tools_count", len(tools)
+            for i, tool in enumerate(tools[:10]):  # Limit to first 10
+                if "function" in tool:
+                    func = tool["function"]
+                    yield f"minimax.tools.{i}.name", func.get("name", "")
+                    yield f"minimax.tools.{i}.description", func.get("description", "")[:200]  # Truncate
+
+        # Response format
+        if "response_format" in request_parameters:
+            resp_format = request_parameters.get("response_format", {})
+            if isinstance(resp_format, dict):
+                yield "minimax.response_format", resp_format.get("type", "text")
+
+    def _extract_invocation_parameters(
+        self, request_parameters: Mapping[str, Any]
+    ) -> Dict[str, Any]:
+        """Extract model invocation parameters."""
+        params = {}
+        param_keys = [
+            "temperature", "max_tokens", "top_p", "stop", "stream",
+            "frequency_penalty", "presence_penalty", "seed", "logprobs",
+            "top_logprobs", "n"
+        ]
+        for key in param_keys:
+            if key in request_parameters:
+                params[key] = request_parameters[key]
+        return params

traceai_minimax/_response_attributes_extractor.py

@@ -0,0 +1,190 @@
+import logging
+from typing import Any, Dict, Iterator, Mapping, Optional, Tuple
+
+from fi_instrumentation.fi_types import (
+    MessageAttributes,
+    SpanAttributes,
+)
+from opentelemetry.util.types import AttributeValue
+
+logger = logging.getLogger(__name__)
+logger.addHandler(logging.NullHandler())
+
+
+class _ChatCompletionResponseAttributesExtractor:
+    """Extract span attributes from MiniMax chat completion response."""
+
+    def get_attributes(
+        self,
+        response: Optional[Dict[str, Any]],
+        is_streaming: bool = False,
+    ) -> Iterator[Tuple[str, AttributeValue]]:
+        """Extract primary attributes from response."""
+        if response is None:
+            return
+
+        # Token usage
+        usage = response.get("usage", {})
+        if usage:
+            if "prompt_tokens" in usage:
+                yield SpanAttributes.GEN_AI_USAGE_INPUT_TOKENS, usage["prompt_tokens"]
+            if "completion_tokens" in usage:
+                yield SpanAttributes.GEN_AI_USAGE_OUTPUT_TOKENS, usage["completion_tokens"]
+            if "total_tokens" in usage:
+                yield SpanAttributes.GEN_AI_USAGE_TOTAL_TOKENS, usage["total_tokens"]
+
+        # Model info
+        if "model" in response:
+            yield SpanAttributes.GEN_AI_REQUEST_MODEL, response["model"]
+
+        # Response ID
+        if "id" in response:
+            yield "minimax.response_id", response["id"]
+
+    def get_extra_attributes(
+        self,
+        response: Optional[Dict[str, Any]],
+        request_parameters: Mapping[str, Any],
+        is_streaming: bool = False,
+    ) -> Iterator[Tuple[str, AttributeValue]]:
+        """Extract extra attributes including output."""
+        if response is None:
+            return
+
+        choices = response.get("choices", [])
+
+        for i, choice in enumerate(choices):
+            message = choice.get("message", {})
+
+            # Role
+            role = message.get("role", "assistant")
+            yield f"{SpanAttributes.GEN_AI_OUTPUT_MESSAGES}.{i}.{MessageAttributes.MESSAGE_ROLE}", role
+
+            # Content
+            content = message.get("content", "")
+            if content:
+                yield f"{SpanAttributes.GEN_AI_OUTPUT_MESSAGES}.{i}.{MessageAttributes.MESSAGE_CONTENT}", content
+
+            # Tool calls
+            tool_calls = message.get("tool_calls", [])
+            if tool_calls:
+                yield "minimax.tool_calls_count", len(tool_calls)
+                for j, tc in enumerate(tool_calls[:10]):  # Limit
+                    yield f"minimax.tool_calls.{j}.id", tc.get("id", "")
+                    yield f"minimax.tool_calls.{j}.type", tc.get("type", "function")
+                    if "function" in tc:
+                        yield f"minimax.tool_calls.{j}.function.name", tc["function"].get("name", "")
+                        yield f"minimax.tool_calls.{j}.function.arguments", tc["function"].get("arguments", "")
+
+            # Finish reason
+            finish_reason = choice.get("finish_reason", "")
+            if finish_reason:
+                yield "minimax.finish_reason", finish_reason
+
+            # Logprobs
+            if "logprobs" in choice and choice["logprobs"]:
+                yield "minimax.has_logprobs", True
+
+        # Primary output
+        if choices:
+            first_choice = choices[0]
+            message = first_choice.get("message", {})
+            content = message.get("content", "")
+            if content:
+                yield SpanAttributes.OUTPUT_VALUE, content
+
+
+class _StreamingChatCompletionResponseExtractor:
+    """Extract attributes from streaming MiniMax response chunks."""
+
+    def __init__(self):
+        self._content_parts = []
+        self._tool_calls = {}
+        self._finish_reason = None
+        self._usage = {}
+        self._model = None
+        self._response_id = None
+
+    def process_chunk(self, chunk: Dict[str, Any]) -> None:
+        """Process a single streaming chunk."""
+        if "id" in chunk and not self._response_id:
+            self._response_id = chunk["id"]
+
+        if "model" in chunk and not self._model:
+            self._model = chunk["model"]
+
+        # Handle usage in final chunk
+        if "usage" in chunk:
+            self._usage = chunk["usage"]
+
+        choices = chunk.get("choices", [])
+        for choice in choices:
+            delta = choice.get("delta", {})
+
+            # Content
+            if "content" in delta and delta["content"]:
+                self._content_parts.append(delta["content"])
+
+            # Tool calls
+            if "tool_calls" in delta:
+                for tc in delta["tool_calls"]:
+                    idx = tc.get("index", 0)
+                    if idx not in self._tool_calls:
+                        self._tool_calls[idx] = {
+                            "id": tc.get("id", ""),
+                            "type": tc.get("type", "function"),
+                            "function": {"name": "", "arguments": ""}
+                        }
+                    if "id" in tc and tc["id"]:
+                        self._tool_calls[idx]["id"] = tc["id"]
+                    if "function" in tc:
+                        if "name" in tc["function"] and tc["function"]["name"]:
+                            self._tool_calls[idx]["function"]["name"] = tc["function"]["name"]
+                        if "arguments" in tc["function"]:
+                            self._tool_calls[idx]["function"]["arguments"] += tc["function"]["arguments"]
+
+            # Finish reason
+            if "finish_reason" in choice and choice["finish_reason"]:
+                self._finish_reason = choice["finish_reason"]
+
+    def get_attributes(self) -> Iterator[Tuple[str, AttributeValue]]:
+        """Get attributes from accumulated stream data."""
+        # Token usage
+        if self._usage:
+            if "prompt_tokens" in self._usage:
+                yield SpanAttributes.GEN_AI_USAGE_INPUT_TOKENS, self._usage["prompt_tokens"]
+            if "completion_tokens" in self._usage:
+                yield SpanAttributes.GEN_AI_USAGE_OUTPUT_TOKENS, self._usage["completion_tokens"]
+            if "total_tokens" in self._usage:
+                yield SpanAttributes.GEN_AI_USAGE_TOTAL_TOKENS, self._usage["total_tokens"]
+
+        if self._model:
+            yield SpanAttributes.GEN_AI_REQUEST_MODEL, self._model
+
+        if self._response_id:
+            yield "minimax.response_id", self._response_id
+
+    def get_extra_attributes(
+        self, request_parameters: Mapping[str, Any]
+    ) -> Iterator[Tuple[str, AttributeValue]]:
+        """Get extra attributes from accumulated stream."""
+        content = "".join(self._content_parts)
+
+        # Output message
+        yield f"{SpanAttributes.GEN_AI_OUTPUT_MESSAGES}.0.{MessageAttributes.MESSAGE_ROLE}", "assistant"
+        if content:
+            yield f"{SpanAttributes.GEN_AI_OUTPUT_MESSAGES}.0.{MessageAttributes.MESSAGE_CONTENT}", content
+            yield SpanAttributes.OUTPUT_VALUE, content
+
+        # Tool calls
+        if self._tool_calls:
+            yield "minimax.tool_calls_count", len(self._tool_calls)
+            for idx, tc in self._tool_calls.items():
+                yield f"minimax.tool_calls.{idx}.id", tc["id"]
+                yield f"minimax.tool_calls.{idx}.type", tc["type"]
+                yield f"minimax.tool_calls.{idx}.function.name", tc["function"]["name"]
+                yield f"minimax.tool_calls.{idx}.function.arguments", tc["function"]["arguments"]
+
+        # Finish reason
+        if self._finish_reason:
+            yield "minimax.finish_reason", self._finish_reason

traceai_minimax/_utils.py

@@ -0,0 +1,91 @@
+import logging
+from enum import Enum
+from typing import Any, Dict, Iterator, Mapping, Optional, Tuple
+from urllib.parse import urlparse
+
+from fi_instrumentation import safe_json_dumps
+from opentelemetry import trace as trace_api
+from opentelemetry.util.types import AttributeValue
+
+from traceai_minimax._with_span import _WithSpan
+
+logger = logging.getLogger(__name__)
+logger.addHandler(logging.NullHandler())
+
+
+class MiniMaxBaseURL(str, Enum):
+    """MiniMax API base URL hostnames."""
+    API_IO = "api.minimax.io"
+    API_CHAT = "api.minimax.chat"
+
+
+def is_minimax_client(instance: Any) -> bool:
+    """Check if the OpenAI client is configured for MiniMax."""
+    try:
+        base_url = getattr(instance, "base_url", None)
+        if base_url is None:
+            # Check _client for wrapped clients
+            client = getattr(instance, "_client", None)
+            if client is not None:
+                base_url = getattr(client, "base_url", None)
+
+        if base_url is not None:
+            parsed = urlparse(str(base_url))
+            hostname = (parsed.hostname or "").lower()
+            return hostname in {url.value for url in MiniMaxBaseURL}
+    except Exception:
+        pass
+    return False
+
+
+def _to_dict(obj: Any) -> Dict[str, Any]:
+    """Convert an object to a dictionary."""
+    if obj is None:
+        return {}
+    if isinstance(obj, dict):
+        return obj
+    if hasattr(obj, "model_dump"):
+        return obj.model_dump()
+    if hasattr(obj, "dict"):
+        return obj.dict()
+    if hasattr(obj, "__dict__"):
+        return obj.__dict__
+    return {"value": str(obj)}
+
+
+def _flatten(
+    mapping: Mapping[str, Any], prefix: str = ""
+) -> Iterator[Tuple[str, AttributeValue]]:
+    """Flatten a nested dictionary into dot-separated keys."""
+    for key, value in mapping.items():
+        if value is None:
+            continue
+        full_key = f"{prefix}.{key}" if prefix else key
+        if isinstance(value, Mapping):
+            yield from _flatten(value, full_key)
+        elif isinstance(value, (list, tuple)):
+            if value and isinstance(value[0], Mapping):
+                for i, item in enumerate(value):
+                    yield from _flatten(item, f"{full_key}.{i}")
+            else:
+                yield full_key, safe_json_dumps(value)
+        else:
+            yield full_key, value
+
+
+def _finish_tracing(
+    status: trace_api.Status,
+    with_span: _WithSpan,
+    attributes: Optional[Iterator[Tuple[str, AttributeValue]]] = None,
+    extra_attributes: Optional[Iterator[Tuple[str, AttributeValue]]] = None,
+) -> None:
+    """Finish tracing with status and attributes."""
+    if attributes:
+        for key, value in attributes:
+            if value is not None:
+                with_span._span.set_attribute(key, value)
+    if extra_attributes:
+        for key, value in extra_attributes:
+            if value is not None:
+                with_span._span.set_attribute(key, value)
+    with_span.finish_tracing(status=status)

traceai_minimax/_with_span.py

@@ -0,0 +1,40 @@
+from typing import Any, Dict, Optional
+
+from opentelemetry import trace as trace_api
+
+
+class _WithSpan:
+    """Helper class to manage span lifecycle and attributes."""
+
+    __slots__ = ("_span", "_context_attributes", "_extra_attributes")
+
+    def __init__(
+        self,
+        span: trace_api.Span,
+        context_attributes: Optional[Dict[str, Any]] = None,
+        extra_attributes: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        self._span = span
+        self._context_attributes = context_attributes or {}
+        self._extra_attributes = extra_attributes or {}
+
+    def record_exception(self, exception: Exception) -> None:
+        """Record an exception on the span."""
+        if self._span.is_recording():
+            self._span.record_exception(exception)
+
+    def finish_tracing(
+        self,
+        status: Optional[trace_api.Status] = None,
+    ) -> None:
+        """Finish the span with optional status."""
+        if self._span.is_recording():
+            if status is not None:
+                self._span.set_status(status)
+            for key, value in self._context_attributes.items():
+                if value is not None:
+                    self._span.set_attribute(key, value)
+            for key, value in self._extra_attributes.items():
+                if value is not None:
+                    self._span.set_attribute(key, value)
+            self._span.end()

traceai_minimax/_wrappers.py

@@ -0,0 +1,274 @@
+import logging
+from abc import ABC
+from contextlib import contextmanager
+from typing import Any, Callable, Dict, Iterable, Iterator, List, Mapping, Tuple
+
+import opentelemetry.context as context_api
+from fi_instrumentation import get_attributes_from_context, safe_json_dumps
+from fi_instrumentation.fi_types import SpanAttributes
+from opentelemetry import trace as trace_api
+from opentelemetry.trace import INVALID_SPAN
+from opentelemetry.util.types import AttributeValue
+
+from traceai_minimax._request_attributes_extractor import (
+    _ChatCompletionRequestAttributesExtractor,
+)
+from traceai_minimax._response_attributes_extractor import (
+    _ChatCompletionResponseAttributesExtractor,
+    _StreamingChatCompletionResponseExtractor,
+)
+from traceai_minimax._utils import _finish_tracing, _to_dict, is_minimax_client
+from traceai_minimax._with_span import _WithSpan
+
+logger = logging.getLogger(__name__)
+logger.addHandler(logging.NullHandler())
+
+
+class _WithTracer(ABC):
+    """Base class for wrappers that need a tracer."""
+
+    def __init__(self, tracer: trace_api.Tracer, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self._tracer = tracer
+
+    @contextmanager
+    def _start_as_current_span(
+        self,
+        span_name: str,
+        attributes: Iterable[Tuple[str, AttributeValue]],
+        context_attributes: Iterable[Tuple[str, AttributeValue]],
+        extra_attributes: Iterable[Tuple[str, AttributeValue]],
+    ) -> Iterator[_WithSpan]:
+        try:
+            span = self._tracer.start_span(
+                name=span_name, attributes=dict(extra_attributes)
+            )
+        except Exception:
+            span = INVALID_SPAN
+        with trace_api.use_span(
+            span,
+            end_on_exit=False,
+            record_exception=False,
+            set_status_on_exception=False,
+        ) as span:
+            yield _WithSpan(
+                span=span,
+                context_attributes=dict(context_attributes),
+                extra_attributes=dict(attributes),
+            )
+
+
+class _ChatCompletionWrapper(_WithTracer):
+    """Wrapper for MiniMax chat completions (via OpenAI client)."""
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self._request_extractor = _ChatCompletionRequestAttributesExtractor()
+        self._response_extractor = _ChatCompletionResponseAttributesExtractor()
+
+    def __call__(
+        self,
+        wrapped: Callable[..., Any],
+        instance: Any,
+        args: Tuple[Any, ...],
+        kwargs: Mapping[str, Any],
+    ) -> Any:
+        if context_api.get_value(context_api._SUPPRESS_INSTRUMENTATION_KEY):
+            return wrapped(*args, **kwargs)
+
+        # Check if this is a MiniMax client
+        # Get the parent client from the completions instance
+        client = getattr(instance, "_client", None)
+        if client is None:
+            # Try to get from chat.completions structure
+            chat = getattr(instance, "_parent", None) or getattr(instance, "chat", None)
+            if chat:
+                client = getattr(chat, "_client", None)
+
+        if not is_minimax_client(client) and not is_minimax_client(instance):
+            return wrapped(*args, **kwargs)
+
+        request_parameters = dict(kwargs)
+        is_streaming = request_parameters.get("stream", False)
+
+        span_name = "minimax.chat.completions"
+
+        with self._start_as_current_span(
+            span_name=span_name,
+            attributes=self._request_extractor.get_attributes_from_request(request_parameters),
+            context_attributes=get_attributes_from_context(),
+            extra_attributes=self._request_extractor.get_extra_attributes_from_request(request_parameters),
+        ) as span:
+            try:
+                response = wrapped(*args, **kwargs)
+            except Exception as exception:
+                span.record_exception(exception)
+                status = trace_api.Status(
+                    status_code=trace_api.StatusCode.ERROR,
+                    description=f"{type(exception).__name__}: {exception}",
+                )
+                span.finish_tracing(status=status)
+                raise
+
+            if is_streaming:
+                return self._handle_streaming_response(span, response, request_parameters)
+
+            try:
+                response_dict = _to_dict(response)
+                _finish_tracing(
+                    status=trace_api.Status(status_code=trace_api.StatusCode.OK),
+                    with_span=span,
+                    attributes=self._response_extractor.get_attributes(response_dict),
+                    extra_attributes=self._response_extractor.get_extra_attributes(
+                        response_dict, request_parameters
+                    ),
+                )
+            except Exception:
+                logger.exception("Failed to finalize response")
+                span.finish_tracing()
+            return response
+
+    def _handle_streaming_response(
+        self, span: _WithSpan, response: Any, request_parameters: Dict[str, Any]
+    ):
+        """Handle streaming response."""
+        stream_extractor = _StreamingChatCompletionResponseExtractor()
+
+        def streaming_wrapper():
+            try:
+                for chunk in response:
+                    chunk_dict = _to_dict(chunk)
+                    stream_extractor.process_chunk(chunk_dict)
+                    yield chunk
+
+            except Exception as exception:
+                span.record_exception(exception)
+                status = trace_api.Status(
+                    status_code=trace_api.StatusCode.ERROR,
+                    description=f"{type(exception).__name__}: {exception}",
+                )
+                span.finish_tracing(status=status)
+                raise
+            else:
+                try:
+                    _finish_tracing(
+                        status=trace_api.Status(status_code=trace_api.StatusCode.OK),
+                        with_span=span,
+                        attributes=stream_extractor.get_attributes(),
+                        extra_attributes=stream_extractor.get_extra_attributes(request_parameters),
+                    )
+                except Exception:
+                    logger.exception("Failed to finalize streaming response")
+                    span.finish_tracing()
+            finally:
+                if span._span.is_recording():
+                    span.finish_tracing()
+
+        return streaming_wrapper()
+
+
+class _AsyncChatCompletionWrapper(_WithTracer):
+    """Async wrapper for MiniMax chat completions."""
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self._request_extractor = _ChatCompletionRequestAttributesExtractor()
+        self._response_extractor = _ChatCompletionResponseAttributesExtractor()
+
+    async def __call__(
+        self,
+        wrapped: Callable[..., Any],
+        instance: Any,
+        args: Tuple[Any, ...],
+        kwargs: Mapping[str, Any],
+    ) -> Any:
+        if context_api.get_value(context_api._SUPPRESS_INSTRUMENTATION_KEY):
+            return await wrapped(*args, **kwargs)
+
+        # Check if this is a MiniMax client
+        client = getattr(instance, "_client", None)
+        if client is None:
+            chat = getattr(instance, "_parent", None) or getattr(instance, "chat", None)
+            if chat:
+                client = getattr(chat, "_client", None)
+
+        if not is_minimax_client(client) and not is_minimax_client(instance):
+            return await wrapped(*args, **kwargs)
+
+        request_parameters = dict(kwargs)
+        is_streaming = request_parameters.get("stream", False)
+
+        span_name = "minimax.chat.completions"
+
+        with self._start_as_current_span(
+            span_name=span_name,
+            attributes=self._request_extractor.get_attributes_from_request(request_parameters),
+            context_attributes=get_attributes_from_context(),
+            extra_attributes=self._request_extractor.get_extra_attributes_from_request(request_parameters),
+        ) as span:
+            try:
+                response = await wrapped(*args, **kwargs)
+            except Exception as exception:
+                span.record_exception(exception)
+                status = trace_api.Status(
+                    status_code=trace_api.StatusCode.ERROR,
+                    description=f"{type(exception).__name__}: {exception}",
+                )
+                span.finish_tracing(status=status)
+                raise
+
+            if is_streaming:
+                return self._handle_async_streaming_response(span, response, request_parameters)
+
+            try:
+                response_dict = _to_dict(response)
+                _finish_tracing(
+                    status=trace_api.Status(status_code=trace_api.StatusCode.OK),
+                    with_span=span,
+                    attributes=self._response_extractor.get_attributes(response_dict),
+                    extra_attributes=self._response_extractor.get_extra_attributes(
+                        response_dict, request_parameters
+                    ),
+                )
+            except Exception:
+                logger.exception("Failed to finalize response")
+                span.finish_tracing()
+            return response
+
+    def _handle_async_streaming_response(
+        self, span: _WithSpan, response: Any, request_parameters: Dict[str, Any]
+    ):
+        """Handle async streaming response."""
+        stream_extractor = _StreamingChatCompletionResponseExtractor()
+
+        async def async_streaming_wrapper():
+            try:
+                async for chunk in response:
+                    chunk_dict = _to_dict(chunk)
+                    stream_extractor.process_chunk(chunk_dict)
+                    yield chunk
+
+            except Exception as exception:
+                span.record_exception(exception)
+                status = trace_api.Status(
+                    status_code=trace_api.StatusCode.ERROR,
+                    description=f"{type(exception).__name__}: {exception}",
+                )
+                span.finish_tracing(status=status)
+                raise
+            else:
+                try:
+                    _finish_tracing(
+                        status=trace_api.Status(status_code=trace_api.StatusCode.OK),
+                        with_span=span,
+                        attributes=stream_extractor.get_attributes(),
+                        extra_attributes=stream_extractor.get_extra_attributes(request_parameters),
+                    )
+                except Exception:
+                    logger.exception("Failed to finalize async streaming response")
+                    span.finish_tracing()
+            finally:
+                if span._span.is_recording():
+                    span.finish_tracing()
+
+        return async_streaming_wrapper()

traceai_minimax/version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"  # x-release-please-version

traceai_minimax-0.1.0.dist-info/METADATA

@@ -0,0 +1,291 @@
+Metadata-Version: 2.4
+Name: traceAI-minimax
+Version: 0.1.0
+Summary: OpenTelemetry instrumentation for MiniMax - chat completions via OpenAI-compatible API
+License: Apache-2.0
+Keywords: traceai,futureagi,opentelemetry,tracing,observability,llm,minimax
+Author: Future AGI
+Author-email: no-reply@futureagi.com
+Requires-Python: >=3.10,<3.14
+Classifier: Framework :: OpenTelemetry
+Classifier: Framework :: OpenTelemetry :: Instrumentations
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Monitoring
+Requires-Dist: fi-instrumentation-otel (>=0.1.11)
+Requires-Dist: openai (>=1.0.0)
+Project-URL: Changelog, https://github.com/future-agi/traceAI/releases
+Project-URL: Documentation, https://docs.futureagi.com/docs/tracing
+Project-URL: Homepage, https://futureagi.com
+Project-URL: Issues, https://github.com/future-agi/traceAI/issues
+Project-URL: Repository, https://github.com/future-agi/traceAI/tree/dev/python/frameworks/minimax
+Description-Content-Type: text/markdown
+
+# TraceAI MiniMax Instrumentation
+
+OpenTelemetry instrumentation for [MiniMax](https://www.minimax.io/) - chat completions via the OpenAI-compatible API.
+
+## Installation
+
+```bash
+pip install traceai-minimax
+```
+
+## Features
+
+- Automatic tracing of MiniMax API calls via OpenAI SDK
+- Support for MiniMax-M2.7, MiniMax-M2.7-highspeed, MiniMax-M2.5, and MiniMax-M2.5-highspeed models
+- Streaming response support
+- Token usage tracking
+- Function/tool calling support
+- Full OpenTelemetry semantic conventions compliance
+
+## Usage
+
+### Basic Setup
+
+```python
+from openai import OpenAI
+from opentelemetry import trace
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import ConsoleSpanExporter, SimpleSpanProcessor
+
+from traceai_minimax import MiniMaxInstrumentor
+
+# Set up tracing
+provider = TracerProvider()
+provider.add_span_processor(SimpleSpanProcessor(ConsoleSpanExporter()))
+trace.set_tracer_provider(provider)
+
+# Instrument MiniMax
+MiniMaxInstrumentor().instrument(tracer_provider=provider)
+
+# Use MiniMax via OpenAI SDK
+client = OpenAI(
+    api_key="your-minimax-api-key",
+    base_url="https://api.minimax.io/v1"
+)
+
+response = client.chat.completions.create(
+    model="MiniMax-M2.7",
+    messages=[{"role": "user", "content": "Hello!"}]
+)
+print(response.choices[0].message.content)
+```
+
+### MiniMax Chat
+
+```python
+from openai import OpenAI
+
+client = OpenAI(
+    api_key="your-minimax-api-key",
+    base_url="https://api.minimax.io/v1"
+)
+
+# Simple chat
+response = client.chat.completions.create(
+    model="MiniMax-M2.7",
+    messages=[
+        {"role": "system", "content": "You are a helpful assistant."},
+        {"role": "user", "content": "What is machine learning?"}
+    ],
+    temperature=0.7,
+    max_tokens=1024
+)
+print(response.choices[0].message.content)
+```
+
+### Streaming Responses
+
+```python
+from openai import OpenAI
+
+client = OpenAI(
+    api_key="your-minimax-api-key",
+    base_url="https://api.minimax.io/v1"
+)
+
+# Streaming chat
+stream = client.chat.completions.create(
+    model="MiniMax-M2.7",
+    messages=[{"role": "user", "content": "Tell me a story"}],
+    stream=True
+)
+
+for chunk in stream:
+    if chunk.choices[0].delta.content:
+        print(chunk.choices[0].delta.content, end="", flush=True)
+print()
+```
+
+### Function Calling / Tools
+
+```python
+from openai import OpenAI
+import json
+
+client = OpenAI(
+    api_key="your-minimax-api-key",
+    base_url="https://api.minimax.io/v1"
+)
+
+tools = [
+    {
+        "type": "function",
+        "function": {
+            "name": "get_weather",
+            "description": "Get the current weather for a location",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "location": {
+                        "type": "string",
+                        "description": "The city name"
+                    },
+                    "unit": {
+                        "type": "string",
+                        "enum": ["celsius", "fahrenheit"],
+                        "description": "Temperature unit"
+                    }
+                },
+                "required": ["location"]
+            }
+        }
+    }
+]
+
+response = client.chat.completions.create(
+    model="MiniMax-M2.7",
+    messages=[{"role": "user", "content": "What's the weather in Paris?"}],
+    tools=tools,
+    tool_choice="auto"
+)
+
+message = response.choices[0].message
+if message.tool_calls:
+    for tool_call in message.tool_calls:
+        print(f"Function: {tool_call.function.name}")
+        print(f"Arguments: {tool_call.function.arguments}")
+```
+
+### Async Usage
+
+```python
+import asyncio
+from openai import AsyncOpenAI
+
+async def main():
+    client = AsyncOpenAI(
+        api_key="your-minimax-api-key",
+        base_url="https://api.minimax.io/v1"
+    )
+
+    response = await client.chat.completions.create(
+        model="MiniMax-M2.7",
+        messages=[{"role": "user", "content": "Hello!"}]
+    )
+    print(response.choices[0].message.content)
+
+asyncio.run(main())
+```
+
+### JSON Mode
+
+```python
+from openai import OpenAI
+
+client = OpenAI(
+    api_key="your-minimax-api-key",
+    base_url="https://api.minimax.io/v1"
+)
+
+response = client.chat.completions.create(
+    model="MiniMax-M2.7",
+    messages=[
+        {"role": "system", "content": "Output valid JSON only."},
+        {"role": "user", "content": "List 3 programming languages with their main use cases"}
+    ],
+    response_format={"type": "json_object"}
+)
+
+import json
+data = json.loads(response.choices[0].message.content)
+print(data)
+```
+
+## Configuration Options
+
+### TraceConfig
+
+```python
+from fi_instrumentation import TraceConfig
+from traceai_minimax import MiniMaxInstrumentor
+
+config = TraceConfig(
+    hide_inputs=False,
+    hide_outputs=False,
+)
+
+MiniMaxInstrumentor().instrument(
+    tracer_provider=provider,
+    config=config
+)
+```
+
+## Captured Attributes
+
+### Common Attributes
+
+| Attribute | Description |
+|-----------|-------------|
+| `fi.span.kind` | "LLM" |
+| `llm.system` | "minimax" |
+| `llm.provider` | "minimax" |
+| `llm.model` | Model name (MiniMax-M2.7, MiniMax-M2.7-highspeed, MiniMax-M2.5, MiniMax-M2.5-highspeed) |
+| `llm.token_count.prompt` | Input token count |
+| `llm.token_count.completion` | Output token count |
+| `llm.token_count.total` | Total token count |
+
+### MiniMax-Specific Attributes
+
+| Attribute | Description |
+|-----------|-------------|
+| `minimax.response_id` | Unique response ID |
+| `minimax.finish_reason` | Response finish reason (stop, tool_calls, length) |
+| `minimax.tool_calls_count` | Number of tool calls |
+| `minimax.tools_count` | Number of tools provided |
+
+## Available Models
+
+| Model | Description |
+|-------|-------------|
+| `MiniMax-M2.7` | Latest flagship model with enhanced reasoning and coding |
+| `MiniMax-M2.7-highspeed` | High-speed version of M2.7 for low-latency scenarios |
+| `MiniMax-M2.5` | General-purpose model with 204K context window |
+| `MiniMax-M2.5-highspeed` | Faster inference variant with 204K context window |
+
+## Important Notes
+
+1. **OpenAI SDK Required**: MiniMax uses the OpenAI-compatible API, so you need the `openai` package installed.
+
+2. **Base URL**: Always set `base_url="https://api.minimax.io/v1"` when creating the client.
+
+3. **API Key**: Get your API key from the [MiniMax Platform](https://platform.minimax.chat/).
+
+4. **Selective Instrumentation**: The instrumentor only traces calls to MiniMax's API. Regular OpenAI API calls are not affected.
+
+5. **Temperature**: MiniMax requires temperature to be in the range (0.0, 1.0]. A value of exactly 0 is not accepted.
+
+## License
+
+Apache-2.0
+

traceai_minimax-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+traceai_minimax/__init__.py,sha256=N5ZpvSFDFzU136BFCrsh-BXcZrufGDxOYVOKCxTSVeE,3910
+traceai_minimax/_request_attributes_extractor.py,sha256=fp5k7KK5k4F133NQAnRrOi4KseBxzuWpJNeyWFJCtzQ,5141
+traceai_minimax/_response_attributes_extractor.py,sha256=zjrkkLGCp-LPjcYbCSQZ165Z4xeADqvh9O5yS7q_C1s,7550
+traceai_minimax/_utils.py,sha256=bu8GIPQyj_8xJqWUbsVmx45DphScGPcbLduncM7Sv7g,2985
+traceai_minimax/_with_span.py,sha256=SPzQfr85aprbb5Kdajk81Bbp71XRIF85DrjM4-RQwp4,1399
+traceai_minimax/_wrappers.py,sha256=-3F_W_WbyfdX2EKlJJYEpsaa_PH65J1ZD76tgVGbdGw,10882
+traceai_minimax/version.py,sha256=IOEzhCbX916JIkvZr03GFY4bl9YqSkfjdqLO4qJ2FOs,50
+traceai_minimax-0.1.0.dist-info/METADATA,sha256=RGZiocCInopTOmr_ZD567kCtwiF0gkp16cZ_w64rwY0,8082
+traceai_minimax-0.1.0.dist-info/WHEEL,sha256=L-WvLdSBvJWHXv5zrQxDvNRnIgoBzLUpcbuiw19KCuQ,88
+traceai_minimax-0.1.0.dist-info/RECORD,,

traceai_minimax-0.1.0.dist-info/WHEEL

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