lmnr 0.6.10__tar.gz → 0.6.12__tar.gz

{lmnr-0.6.10 → lmnr-0.6.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: lmnr
-Version: 0.6.10
+Version: 0.6.12
 Summary: Python SDK for Laminar
 License: Apache-2.0
 Author: lmnr.ai
@@ -46,61 +46,61 @@ Requires-Dist: httpx (>=0.25.0)
 Requires-Dist: opentelemetry-api (>=1.33.0)
 Requires-Dist: opentelemetry-exporter-otlp-proto-grpc (>=1.33.0)
 Requires-Dist: opentelemetry-exporter-otlp-proto-http (>=1.33.0)
-Requires-Dist: opentelemetry-instrumentation-alephalpha (>=0.40.8) ; extra == "alephalpha"
-Requires-Dist: opentelemetry-instrumentation-alephalpha (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-anthropic (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-anthropic (>=0.40.8) ; extra == "anthropic"
-Requires-Dist: opentelemetry-instrumentation-bedrock (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-bedrock (>=0.40.8) ; extra == "bedrock"
-Requires-Dist: opentelemetry-instrumentation-chromadb (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-chromadb (>=0.40.8) ; extra == "chromadb"
-Requires-Dist: opentelemetry-instrumentation-cohere (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-cohere (>=0.40.8) ; extra == "cohere"
-Requires-Dist: opentelemetry-instrumentation-crewai (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-crewai (>=0.40.8) ; extra == "crewai"
-Requires-Dist: opentelemetry-instrumentation-google-generativeai (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-google-generativeai (>=0.40.8) ; extra == "google-generativeai"
-Requires-Dist: opentelemetry-instrumentation-groq (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-groq (>=0.40.8) ; extra == "groq"
-Requires-Dist: opentelemetry-instrumentation-haystack (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-haystack (>=0.40.8) ; extra == "haystack"
-Requires-Dist: opentelemetry-instrumentation-lancedb (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-lancedb (>=0.40.8) ; extra == "lancedb"
-Requires-Dist: opentelemetry-instrumentation-langchain (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-langchain (>=0.40.8) ; extra == "langchain"
-Requires-Dist: opentelemetry-instrumentation-llamaindex (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-llamaindex (>=0.40.8) ; extra == "llamaindex"
-Requires-Dist: opentelemetry-instrumentation-marqo (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-marqo (>=0.40.8) ; extra == "marqo"
-Requires-Dist: opentelemetry-instrumentation-mcp (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-mcp (>=0.40.8) ; extra == "mcp"
-Requires-Dist: opentelemetry-instrumentation-milvus (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-milvus (>=0.40.8) ; extra == "milvus"
-Requires-Dist: opentelemetry-instrumentation-mistralai (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-mistralai (>=0.40.8) ; extra == "mistralai"
-Requires-Dist: opentelemetry-instrumentation-ollama (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-ollama (>=0.40.8) ; extra == "ollama"
-Requires-Dist: opentelemetry-instrumentation-openai (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-openai (>=0.40.8) ; extra == "openai"
-Requires-Dist: opentelemetry-instrumentation-pinecone (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-pinecone (>=0.40.8) ; extra == "pinecone"
-Requires-Dist: opentelemetry-instrumentation-qdrant (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-qdrant (>=0.40.8) ; extra == "qdrant"
-Requires-Dist: opentelemetry-instrumentation-replicate (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-replicate (>=0.40.8) ; extra == "replicate"
-Requires-Dist: opentelemetry-instrumentation-sagemaker (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-sagemaker (>=0.40.8) ; extra == "sagemaker"
+Requires-Dist: opentelemetry-instrumentation-alephalpha (>=0.40.12) ; extra == "alephalpha"
+Requires-Dist: opentelemetry-instrumentation-alephalpha (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-anthropic (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-anthropic (>=0.40.12) ; extra == "anthropic"
+Requires-Dist: opentelemetry-instrumentation-bedrock (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-bedrock (>=0.40.12) ; extra == "bedrock"
+Requires-Dist: opentelemetry-instrumentation-chromadb (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-chromadb (>=0.40.12) ; extra == "chromadb"
+Requires-Dist: opentelemetry-instrumentation-cohere (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-cohere (>=0.40.12) ; extra == "cohere"
+Requires-Dist: opentelemetry-instrumentation-crewai (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-crewai (>=0.40.12) ; extra == "crewai"
+Requires-Dist: opentelemetry-instrumentation-google-generativeai (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-google-generativeai (>=0.40.12) ; extra == "google-generativeai"
+Requires-Dist: opentelemetry-instrumentation-groq (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-groq (>=0.40.12) ; extra == "groq"
+Requires-Dist: opentelemetry-instrumentation-haystack (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-haystack (>=0.40.12) ; extra == "haystack"
+Requires-Dist: opentelemetry-instrumentation-lancedb (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-lancedb (>=0.40.12) ; extra == "lancedb"
+Requires-Dist: opentelemetry-instrumentation-langchain (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-langchain (>=0.40.12) ; extra == "langchain"
+Requires-Dist: opentelemetry-instrumentation-llamaindex (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-llamaindex (>=0.40.12) ; extra == "llamaindex"
+Requires-Dist: opentelemetry-instrumentation-marqo (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-marqo (>=0.40.12) ; extra == "marqo"
+Requires-Dist: opentelemetry-instrumentation-mcp (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-mcp (>=0.40.12) ; extra == "mcp"
+Requires-Dist: opentelemetry-instrumentation-milvus (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-milvus (>=0.40.12) ; extra == "milvus"
+Requires-Dist: opentelemetry-instrumentation-mistralai (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-mistralai (>=0.40.12) ; extra == "mistralai"
+Requires-Dist: opentelemetry-instrumentation-ollama (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-ollama (>=0.40.12) ; extra == "ollama"
+Requires-Dist: opentelemetry-instrumentation-openai (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-openai (>=0.40.12) ; extra == "openai"
+Requires-Dist: opentelemetry-instrumentation-pinecone (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-pinecone (>=0.40.12) ; extra == "pinecone"
+Requires-Dist: opentelemetry-instrumentation-qdrant (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-qdrant (>=0.40.12) ; extra == "qdrant"
+Requires-Dist: opentelemetry-instrumentation-replicate (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-replicate (>=0.40.12) ; extra == "replicate"
+Requires-Dist: opentelemetry-instrumentation-sagemaker (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-sagemaker (>=0.40.12) ; extra == "sagemaker"
 Requires-Dist: opentelemetry-instrumentation-threading (>=0.54b0)
-Requires-Dist: opentelemetry-instrumentation-together (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-together (>=0.40.8) ; extra == "together"
-Requires-Dist: opentelemetry-instrumentation-transformers (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-transformers (>=0.40.8) ; extra == "transformers"
-Requires-Dist: opentelemetry-instrumentation-vertexai (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-vertexai (>=0.40.8) ; extra == "vertexai"
-Requires-Dist: opentelemetry-instrumentation-watsonx (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-watsonx (>=0.40.8) ; extra == "watsonx"
-Requires-Dist: opentelemetry-instrumentation-weaviate (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-weaviate (>=0.40.8) ; extra == "weaviate"
+Requires-Dist: opentelemetry-instrumentation-together (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-together (>=0.40.12) ; extra == "together"
+Requires-Dist: opentelemetry-instrumentation-transformers (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-transformers (>=0.40.12) ; extra == "transformers"
+Requires-Dist: opentelemetry-instrumentation-vertexai (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-vertexai (>=0.40.12) ; extra == "vertexai"
+Requires-Dist: opentelemetry-instrumentation-watsonx (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-watsonx (>=0.40.12) ; extra == "watsonx"
+Requires-Dist: opentelemetry-instrumentation-weaviate (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-weaviate (>=0.40.12) ; extra == "weaviate"
 Requires-Dist: opentelemetry-sdk (>=1.33.0)
 Requires-Dist: opentelemetry-semantic-conventions (>=0.54b0)
 Requires-Dist: opentelemetry-semantic-conventions-ai (>=0.4.8)

lmnr-0.6.12/pyproject.toml

@@ -0,0 +1,143 @@
+# Laminar Python
+
+# If you are looking for information about possible extras installations,
+# i.e. what you can pass into `pip install 'lmnr[extra1,extra2]'`, please see the
+# `[project.optional-dependencies]` section below.
+
+[project]
+name = "lmnr"
+version = "0.6.12"
+description = "Python SDK for Laminar"
+authors = [
+  { name = "lmnr.ai", email = "founders@lmnr.ai" }
+]
+readme = "README.md"
+requires-python = ">=3.10,<4"
+license = "Apache-2.0"
+dependencies = [
+  "pydantic (>=2.0.3,<3.0.0)",
+  "python-dotenv (>=1.0)",
+  "opentelemetry-api (>=1.33.0)",
+  "opentelemetry-sdk (>=1.33.0)",
+  "opentelemetry-exporter-otlp-proto-http (>=1.33.0)",
+  "opentelemetry-exporter-otlp-proto-grpc (>=1.33.0)",
+  "opentelemetry-semantic-conventions (>=0.54b0)",
+  "opentelemetry-semantic-conventions-ai (>=0.4.8)",
+  "tqdm (>=4.0)",
+  "argparse (>=1.0)",
+  "tenacity (>=8.0)",
+  # Since 1.68.0, grpcio writes a warning message
+  # that looks scary, but is harmless.
+  # WARNING: All log messages before absl::InitializeLog() is called are written to STDERR
+  # E0000 00:00:1737439981.199902 9456033 init.cc:229] grpc_wait_for_shutdown_with_timeout() timed out.
+  #
+  # Remove this comment when we make sure that grpcio has resolved this.
+  # Related issue:
+  # https://discuss.ai.google.dev/t/warning-all-log-messages-before-absl-initializelog-is-called-are-written-to-stderr-e0000-001731955515-629532-17124-init-cc-229-grpc-wait-for-shutdown-with-timeout-timed-out/50020
+  # https://github.com/grpc/grpc/issues/38490
+  "grpcio>=1",
+  "httpx>=0.25.0",
+  "opentelemetry-instrumentation-threading>=0.54b0",
+]
+
+[project.scripts]
+lmnr = "lmnr.cli:cli"
+
+[project.optional-dependencies]
+# List of all possible extras. You can specify one or more of these extras
+# when installing the package, using any of the following examples:
+# `pip install 'lmnr[anthropic,openai]'`
+# `uv pip install 'lmnr[anthropic,openai]'`
+# `uv add lmnr --extra anthropic --extra openai`
+# `poetry add 'lmnr[anthropic,openai]'`
+
+alephalpha=["opentelemetry-instrumentation-alephalpha>=0.40.12"]
+anthropic=["opentelemetry-instrumentation-anthropic>=0.40.12"]
+bedrock=["opentelemetry-instrumentation-bedrock>=0.40.12"]
+chromadb=["opentelemetry-instrumentation-chromadb>=0.40.12"]
+cohere=["opentelemetry-instrumentation-cohere>=0.40.12"]
+crewai=["opentelemetry-instrumentation-crewai>=0.40.12"]
+google-generativeai=["opentelemetry-instrumentation-google-generativeai>=0.40.12"]
+groq=["opentelemetry-instrumentation-groq>=0.40.12"]
+haystack=["opentelemetry-instrumentation-haystack>=0.40.12"]
+lancedb=["opentelemetry-instrumentation-lancedb>=0.40.12"]
+langchain=["opentelemetry-instrumentation-langchain>=0.40.12"]
+llamaindex=["opentelemetry-instrumentation-llamaindex>=0.40.12"]
+marqo=["opentelemetry-instrumentation-marqo>=0.40.12"]
+mcp=["opentelemetry-instrumentation-mcp>=0.40.12"]
+milvus=["opentelemetry-instrumentation-milvus>=0.40.12"]
+mistralai=["opentelemetry-instrumentation-mistralai>=0.40.12"]
+ollama=["opentelemetry-instrumentation-ollama>=0.40.12"]
+openai=["opentelemetry-instrumentation-openai>=0.40.12"]
+pinecone=["opentelemetry-instrumentation-pinecone>=0.40.12"]
+qdrant=["opentelemetry-instrumentation-qdrant>=0.40.12"]
+replicate=["opentelemetry-instrumentation-replicate>=0.40.12"]
+sagemaker=["opentelemetry-instrumentation-sagemaker>=0.40.12"]
+together=["opentelemetry-instrumentation-together>=0.40.12"]
+transformers=["opentelemetry-instrumentation-transformers>=0.40.12"]
+vertexai=["opentelemetry-instrumentation-vertexai>=0.40.12"]
+watsonx=["opentelemetry-instrumentation-watsonx>=0.40.12"]
+weaviate=["opentelemetry-instrumentation-weaviate>=0.40.12"]
+# `all` is the group added for convenience, if you want to install all
+# the instrumentations.
+# we suggest using package-manager-specific commands instead,
+# like `uv add lmnr --all-extras`
+all = [
+  "opentelemetry-instrumentation-alephalpha>=0.40.12",
+  "opentelemetry-instrumentation-anthropic>=0.40.12",
+  "opentelemetry-instrumentation-bedrock>=0.40.12",
+  "opentelemetry-instrumentation-chromadb>=0.40.12",
+  "opentelemetry-instrumentation-cohere>=0.40.12",
+  "opentelemetry-instrumentation-crewai>=0.40.12",
+  "opentelemetry-instrumentation-google-generativeai>=0.40.12",
+  "opentelemetry-instrumentation-groq>=0.40.12",
+  "opentelemetry-instrumentation-haystack>=0.40.12",
+  "opentelemetry-instrumentation-lancedb>=0.40.12",
+  "opentelemetry-instrumentation-langchain>=0.40.12",
+  "opentelemetry-instrumentation-llamaindex>=0.40.12",
+  "opentelemetry-instrumentation-marqo>=0.40.12",
+  "opentelemetry-instrumentation-mcp>=0.40.12",
+  "opentelemetry-instrumentation-milvus>=0.40.12",
+  "opentelemetry-instrumentation-mistralai>=0.40.12",
+  "opentelemetry-instrumentation-ollama>=0.40.12",
+  "opentelemetry-instrumentation-openai>=0.40.12",
+  "opentelemetry-instrumentation-pinecone>=0.40.12",
+  "opentelemetry-instrumentation-qdrant>=0.40.12",
+  "opentelemetry-instrumentation-replicate>=0.40.12",
+  "opentelemetry-instrumentation-sagemaker>=0.40.12",
+  "opentelemetry-instrumentation-together>=0.40.12",
+  "opentelemetry-instrumentation-transformers>=0.40.12",
+  "opentelemetry-instrumentation-vertexai>=0.40.12",
+  "opentelemetry-instrumentation-watsonx>=0.40.12",
+  "opentelemetry-instrumentation-weaviate>=0.40.12"
+]
+
+[dependency-groups]
+dev = [
+  "autopep8>=2.3.2",
+  "flake8>=7.2.0",
+  "pytest>=8.3.5",
+  "pytest-sugar>=1.0.0",
+  "pytest-asyncio>=0.26.0",
+  "playwright>=1.52.0",
+  "vcrpy>=7.0.0",
+  "openai>=1.77.0",
+  "pytest-recording>=0.13.4",
+  "patchright>=1.52.3",
+  "google-genai>=1.19.0",
+  "langgraph>=0.4.8",
+  "langchain-core>=0.3.64",
+  "langchain>=0.3.25",
+  "litellm>=1.72.6",
+]
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.uv.workspace]
+members = ["examples/fastapi-app"]
+# we can move to uv_build, once it's more stable
+# https://github.com/astral-sh/uv/issues/3957
+# requires = ["uv_build>=0.6.16,<0.7"]
+# build-backend = "uv_build"

{lmnr-0.6.10 → lmnr-0.6.12}/src/lmnr/__init__.py

@@ -13,6 +13,7 @@ from .sdk.types import (
 )
 from .sdk.decorators import observe
 from .sdk.types import LaminarSpanContext
+from .opentelemetry_lib.litellm import LaminarLiteLLMCallback
 from .opentelemetry_lib.tracing.attributes import Attributes
 from .opentelemetry_lib.tracing.instruments import Instruments
 from .opentelemetry_lib.tracing.processor import LaminarSpanProcessor
@@ -30,6 +31,7 @@ __all__ = [
     "Laminar",
     "LaminarClient",
     "LaminarDataset",
+    "LaminarLiteLLMCallback",
     "LaminarSpanContext",
     "LaminarSpanProcessor",
     "RunAgentResponseChunk",

{lmnr-0.6.10 → lmnr-0.6.12}/src/lmnr/opentelemetry_lib/__init__.py

@@ -7,7 +7,7 @@ from opentelemetry.sdk.resources import SERVICE_NAME
 from lmnr.opentelemetry_lib.tracing.instruments import Instruments
 from lmnr.opentelemetry_lib.tracing import TracerWrapper
 
-MAX_MANUAL_SPAN_PAYLOAD_SIZE = 1024 * 1024  # 1MB
+MAX_MANUAL_SPAN_PAYLOAD_SIZE = 1024 * 1024 * 10  # 10MB
 
 
 class TracerManager:

lmnr-0.6.12/src/lmnr/opentelemetry_lib/litellm/__init__.py

@@ -0,0 +1,371 @@
+"""LiteLLM callback logger for Laminar"""
+
+import json
+from datetime import datetime
+
+from opentelemetry.trace import SpanKind, Status, StatusCode, Tracer
+from lmnr.opentelemetry_lib.litellm.utils import model_as_dict, set_span_attribute
+from lmnr.opentelemetry_lib.tracing import TracerWrapper
+
+from lmnr.opentelemetry_lib.utils.package_check import is_package_installed
+from lmnr.sdk.log import get_default_logger
+
+logger = get_default_logger(__name__)
+
+SUPPORTED_CALL_TYPES = ["completion", "acompletion"]
+
+# Try to import the necessary LiteLLM components and gracefully handle ImportError
+try:
+    if not is_package_installed("litellm"):
+        raise ImportError("LiteLLM is not installed")
+
+    from litellm.integrations.custom_batch_logger import CustomBatchLogger
+
+    class LaminarLiteLLMCallback(CustomBatchLogger):
+        """Custom LiteLLM logger that sends logs to Laminar via OpenTelemetry spans
+
+        Usage:
+            import litellm
+            from lmnr import Laminar, LaminarLiteLLMCallback
+
+            # make sure this comes first
+            Laminar.initialize()
+
+            # Add the logger to LiteLLM callbacks
+            litellm.callbacks = [LaminarLiteLLMCallback()]
+        """
+
+        def __init__(self, **kwargs):
+            super().__init__(**kwargs)
+            if not hasattr(TracerWrapper, "instance") or TracerWrapper.instance is None:
+                raise ValueError("Laminar must be initialized before LiteLLM callback")
+
+        def _get_tracer(self) -> Tracer:
+            if not hasattr(TracerWrapper, "instance") or TracerWrapper.instance is None:
+                raise ValueError("Laminar must be initialized before LiteLLM callback")
+            return TracerWrapper().get_tracer()
+
+        def log_success_event(
+            self, kwargs, response_obj, start_time: datetime, end_time: datetime
+        ):
+            if kwargs.get("call_type") not in SUPPORTED_CALL_TYPES:
+                return
+            try:
+                self._create_span(
+                    kwargs, response_obj, start_time, end_time, is_success=True
+                )
+            except Exception as e:
+                logger.error(f"Error in log_success_event: {e}")
+
+        def log_failure_event(
+            self, kwargs, response_obj, start_time: datetime, end_time: datetime
+        ):
+            if kwargs.get("call_type") not in SUPPORTED_CALL_TYPES:
+                return
+            try:
+                self._create_span(
+                    kwargs, response_obj, start_time, end_time, is_success=False
+                )
+            except Exception as e:
+                logger.error(f"Error in log_failure_event: {e}")
+
+        async def async_log_success_event(
+            self, kwargs, response_obj, start_time: datetime, end_time: datetime
+        ):
+            self.log_success_event(kwargs, response_obj, start_time, end_time)
+
+        async def async_log_failure_event(
+            self, kwargs, response_obj, start_time: datetime, end_time: datetime
+        ):
+            self.log_failure_event(kwargs, response_obj, start_time, end_time)
+
+        def _create_span(
+            self,
+            kwargs,
+            response_obj,
+            start_time: datetime,
+            end_time: datetime,
+            is_success: bool,
+        ):
+            """Create an OpenTelemetry span for the LiteLLM call"""
+            span_name = "litellm.completion"
+            try:
+                tracer = self._get_tracer()
+            except Exception as e:
+                logger.error(f"Error getting tracer: {e}")
+                return
+            span = tracer.start_span(
+                span_name,
+                kind=SpanKind.CLIENT,
+                start_time=int(start_time.timestamp() * 1e9),
+                attributes={
+                    "lmnr.internal.provider": "litellm",
+                },
+            )
+            try:
+                model = kwargs.get("model", "unknown")
+                if kwargs.get("custom_llm_provider"):
+                    set_span_attribute(
+                        span, "gen_ai.system", kwargs["custom_llm_provider"]
+                    )
+
+                messages = kwargs.get("messages", [])
+                self._process_input_messages(span, messages)
+
+                tools = kwargs.get("tools", [])
+                self._process_request_tool_definitions(span, tools)
+
+                set_span_attribute(span, "gen_ai.request.model", model)
+
+                # Add more attributes from kwargs
+                if "temperature" in kwargs:
+                    set_span_attribute(
+                        span, "gen_ai.request.temperature", kwargs["temperature"]
+                    )
+                if "max_tokens" in kwargs:
+                    set_span_attribute(
+                        span, "gen_ai.request.max_tokens", kwargs["max_tokens"]
+                    )
+                if "top_p" in kwargs:
+                    set_span_attribute(span, "gen_ai.request.top_p", kwargs["top_p"])
+
+                if is_success:
+                    span.set_status(Status(StatusCode.OK))
+                    if kwargs.get("complete_streaming_response"):
+                        self._process_success_response(
+                            span,
+                            kwargs.get("complete_streaming_response"),
+                        )
+                    else:
+                        self._process_success_response(span, response_obj)
+                else:
+                    span.set_status(Status(StatusCode.ERROR))
+                    if isinstance(response_obj, Exception):
+                        span.record_exception(response_obj)
+
+            except Exception as e:
+                span.record_exception(e)
+                logger.error(f"Error in Laminar LiteLLM instrumentation: {e}")
+            finally:
+                span.end(int(end_time.timestamp() * 1e9))
+
+        def _process_input_messages(self, span, messages):
+            """Process and set message attributes on the span"""
+            if not isinstance(messages, list):
+                return
+
+            for i, message in enumerate(messages):
+                message_dict = model_as_dict(message)
+                role = message_dict.get("role", "unknown")
+                set_span_attribute(span, f"gen_ai.prompt.{i}.role", role)
+
+                tool_calls = message_dict.get("tool_calls", [])
+                self._process_tool_calls(span, tool_calls, i, is_response=False)
+
+                content = message_dict.get("content", "")
+                if content is None:
+                    continue
+                if isinstance(content, str):
+                    set_span_attribute(span, f"gen_ai.prompt.{i}.content", content)
+                elif isinstance(content, list):
+                    set_span_attribute(
+                        span, f"gen_ai.prompt.{i}.content", json.dumps(content)
+                    )
+                else:
+                    set_span_attribute(
+                        span,
+                        f"gen_ai.prompt.{i}.content",
+                        json.dumps(model_as_dict(content)),
+                    )
+                if role == "tool":
+                    set_span_attribute(
+                        span,
+                        f"gen_ai.prompt.{i}.tool_call_id",
+                        message_dict.get("tool_call_id"),
+                    )
+
+        def _process_request_tool_definitions(self, span, tools):
+            """Process and set tool definitions attributes on the span"""
+            if not isinstance(tools, list):
+                return
+
+            for i, tool in enumerate(tools):
+                tool_dict = model_as_dict(tool)
+                if tool_dict.get("type") != "function":
+                    # TODO: parse other tool types
+                    continue
+
+                function_dict = tool_dict.get("function", {})
+                function_name = function_dict.get("name", "")
+                function_description = function_dict.get("description", "")
+                function_parameters = function_dict.get("parameters", {})
+                set_span_attribute(
+                    span,
+                    f"llm.request.functions.{i}.name",
+                    function_name,
+                )
+                set_span_attribute(
+                    span,
+                    f"llm.request.functions.{i}.description",
+                    function_description,
+                )
+                set_span_attribute(
+                    span,
+                    f"llm.request.functions.{i}.parameters",
+                    json.dumps(function_parameters),
+                )
+
+        def _process_response_usage(self, span, usage):
+            """Process and set usage attributes on the span"""
+            usage_dict = model_as_dict(usage)
+            if (
+                not usage_dict.get("prompt_tokens")
+                and not usage_dict.get("completion_tokens")
+                and not usage_dict.get("total_tokens")
+            ):
+                return
+
+            set_span_attribute(
+                span, "gen_ai.usage.input_tokens", usage_dict.get("prompt_tokens")
+            )
+            set_span_attribute(
+                span, "gen_ai.usage.output_tokens", usage_dict.get("completion_tokens")
+            )
+            set_span_attribute(
+                span, "llm.usage.total_tokens", usage_dict.get("total_tokens")
+            )
+
+            if usage_dict.get("prompt_tokens_details"):
+                details = usage_dict.get("prompt_tokens_details", {})
+                details = model_as_dict(details)
+                if details.get("cached_tokens"):
+                    set_span_attribute(
+                        span,
+                        "gen_ai.usage.cache_read_input_tokens",
+                        details.get("cached_tokens"),
+                    )
+                # TODO: add audio/image/text token details
+            # TODO: add completion tokens details (reasoning tokens)
+
+        def _process_tool_calls(self, span, tool_calls, choice_index, is_response=True):
+            """Process and set tool call attributes on the span"""
+            attr_prefix = "completion" if is_response else "prompt"
+            if not isinstance(tool_calls, list):
+                return
+
+            for j, tool_call in enumerate(tool_calls):
+                tool_call_dict = model_as_dict(tool_call)
+
+                tool_name = tool_call_dict.get(
+                    "name", tool_call_dict.get("function", {}).get("name", "")
+                )
+                set_span_attribute(
+                    span,
+                    f"gen_ai.{attr_prefix}.{choice_index}.tool_calls.{j}.name",
+                    tool_name,
+                )
+
+                call_id = tool_call_dict.get("id", "")
+                set_span_attribute(
+                    span,
+                    f"gen_ai.{attr_prefix}.{choice_index}.tool_calls.{j}.id",
+                    call_id,
+                )
+
+                tool_arguments = tool_call_dict.get(
+                    "arguments", tool_call_dict.get("function", {}).get("arguments", "")
+                )
+                if isinstance(tool_arguments, str):
+                    set_span_attribute(
+                        span,
+                        f"gen_ai.{attr_prefix}.{choice_index}.tool_calls.{j}.arguments",
+                        tool_arguments,
+                    )
+                else:
+                    set_span_attribute(
+                        span,
+                        f"gen_ai.{attr_prefix}.{choice_index}.tool_calls.{j}.arguments",
+                        json.dumps(model_as_dict(tool_arguments)),
+                    )
+
+        def _process_response_choices(self, span, choices):
+            """Process and set choice attributes on the span"""
+            if not isinstance(choices, list):
+                return
+
+            for i, choice in enumerate(choices):
+                choice_dict = model_as_dict(choice)
+                message = choice_dict.get("message", choice_dict)
+
+                role = message.get("role", "unknown")
+                set_span_attribute(span, f"gen_ai.completion.{i}.role", role)
+
+                tool_calls = message.get("tool_calls", [])
+                self._process_tool_calls(span, tool_calls, i, is_response=True)
+
+                content = message.get("content", "")
+                if content is None:
+                    continue
+                if isinstance(content, str):
+                    set_span_attribute(span, f"gen_ai.completion.{i}.content", content)
+                elif isinstance(content, list):
+                    set_span_attribute(
+                        span, f"gen_ai.completion.{i}.content", json.dumps(content)
+                    )
+                else:
+                    set_span_attribute(
+                        span,
+                        f"gen_ai.completion.{i}.content",
+                        json.dumps(model_as_dict(content)),
+                    )
+
+        def _process_success_response(self, span, response_obj):
+            """Process successful response attributes"""
+            response_dict = model_as_dict(response_obj)
+            set_span_attribute(span, "gen_ai.response.id", response_dict.get("id"))
+            set_span_attribute(
+                span, "gen_ai.response.model", response_dict.get("model")
+            )
+
+            if response_dict.get("usage"):
+                self._process_response_usage(span, response_dict.get("usage"))
+
+            if response_dict.get("cache_creation_input_tokens"):
+                set_span_attribute(
+                    span,
+                    "gen_ai.usage.cache_creation_input_tokens",
+                    response_dict.get("cache_creation_input_tokens"),
+                )
+            if response_dict.get("cache_read_input_tokens"):
+                set_span_attribute(
+                    span,
+                    "gen_ai.usage.cache_read_input_tokens",
+                    response_dict.get("cache_read_input_tokens"),
+                )
+
+            if response_dict.get("choices"):
+                self._process_response_choices(span, response_dict.get("choices"))
+
+except ImportError as e:
+    logger.warning(f"LiteLLM callback unavailable: {e}")
+
+    # Create a no-op logger when LiteLLM is not available
+    class LaminarLiteLLMCallback:
+        """No-op logger when LiteLLM is not available"""
+
+        def __init__(self, **kwargs):
+            logger.warning(
+                "LiteLLM is not installed. Install with: pip install litellm"
+            )
+
+        def log_success_event(self, *args, **kwargs):
+            pass
+
+        def log_failure_event(self, *args, **kwargs):
+            pass
+
+        async def async_log_success_event(self, *args, **kwargs):
+            pass
+
+        async def async_log_failure_event(self, *args, **kwargs):
+            pass