fix(closes OPEN-11695): normalize LangChain provider/model and emit usageDetails so cost estimation stops returning $0

LangChain traces reported the raw class-name provider string (e.g.
"chat-google-generative-ai") and the Gemini Developer API "models/" model
prefix, neither recognized by the cost table -- so cost estimation silently
returned $0 with empty costDetails/usageDetails.

- Provider: prefer LangChain's standardized `ls_provider` metadata over the
  noisier `_type`, resolving both through a dual-keyed map that now covers the
  major LangChain chat providers (OpenAI, Azure, Anthropic, Google, Bedrock,
  Cohere, Ollama, Mistral, Groq, DeepSeek, Perplexity, xAI). Unknown
  identifiers fall through to the raw string (no regression, no wrong cost).
- Model: strip a leading "models/" prefix so Gemini names match the cost table.
- usageDetails: emit a per-category token map on the chat-completion step so the
  backend prices per category and populates costDetails. Granular categories
  from LangChain's usage_metadata are mapped to the cost table's keys
  (cache_read -> cached_tokens, cache_creation -> cache_creation_tokens,
  audio -> audio_input_tokens/audio_output_tokens) and subtracted from the
  input/output base to keep the partition non-overlapping; reasoning stays
  folded into output_tokens. ChatCompletionStep gains an optional usage_details
  field, serialized only when set -- other integrations are unaffected.

Verified end-to-end against the live pipeline with the customer's inputs:
- no caching: provider=Google, model=gemini-3.5-flash, cost=0.2003475,
  costDetails={input_tokens, output_tokens}.
- with 10000 cached input tokens: usageDetails={input_tokens:17131,
  cached_tokens:10000, output_tokens:17739}, costDetails prices cached tokens at
  the cheaper cached rate, cost=0.1868475 (< non-cached, reflecting the discount).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018t3JHc1kK6pPMdVBVwMbTs

Author: viniciusdsmello

src/openlayer/lib/integrations/langchain_callback.py

@@ -25,12 +25,54 @@
 from .. import utils
 from ..tracing import enums, steps, tracer, traces
 
+# Maps LangChain provider identifiers to canonical Openlayer provider names.
+# Keyed on BOTH LangChain's standardized ``ls_provider`` metadata value AND the
+# older ``_type`` (``_llm_type``) string, since either may be present depending
+# on the integration and LangChain version. Canonical names are chosen so their
+# lowercase form matches an Openlayer cost-table provider key (the backend
+# lowercases the provider before an exact lookup) -- which is what lets cost
+# estimation resolve a price. Unknown identifiers are left untouched, so an
+# unrecognized provider degrades to the raw string (previous behavior) rather
+# than a wrong, plausible-but-incorrect cost.
 LANGCHAIN_TO_OPENLAYER_PROVIDER_MAP = {
-    "azure-openai-chat": "Azure",
-    "openai-chat": "OpenAI",
-    "chat-ollama": "Ollama",
-    "vertexai": "Google",
-    "amazon_bedrock_converse_chat": "Bedrock",
+    # OpenAI
+    "openai": "OpenAI",  # ls_provider
+    "openai-chat": "OpenAI",  # _type
+    # Azure OpenAI
+    "azure": "Azure",  # ls_provider (+ _type on some models)
+    "azure-openai-chat": "Azure",  # _type
+    # Anthropic
+    "anthropic": "Anthropic",  # ls_provider
+    "anthropic-chat": "Anthropic",  # _type
+    "anthropic-llm": "Anthropic",  # _type
+    # Google -- Gemini Developer API, Vertex AI, PaLM
+    "google_genai": "Google",  # ls_provider (ChatGoogleGenerativeAI)
+    "google_vertexai": "Google",  # ls_provider (ChatVertexAI)
+    "vertexai": "Google",  # _type
+    "chat-google-generative-ai": "Google",  # _type (ChatGoogleGenerativeAI)
+    "google_gemini": "Google",  # _type
+    "google-palm-chat": "Google",  # _type
+    "google_palm": "Google",  # _type
+    # AWS Bedrock
+    "amazon_bedrock": "Bedrock",  # ls_provider + _type
+    "amazon_bedrock_chat": "Bedrock",  # _type
+    "amazon_bedrock_converse_chat": "Bedrock",  # _type
+    # Cohere
+    "cohere": "Cohere",  # ls_provider + _type
+    "cohere-chat": "Cohere",  # _type
+    # Ollama
+    "ollama": "Ollama",  # ls_provider
+    "chat-ollama": "Ollama",  # _type (older)
+    "ollama-chat": "Ollama",  # _type
+    "ollama-llm": "Ollama",  # _type
+    # The following ls_provider values are derived from LangChain's base-class
+    # naming rule (``ChatX`` -> ``x``); a wrong key is harmless (falls through),
+    # and each canonical target lowercases to a confirmed cost-table key.
+    "mistralai": "Mistral",  # ls_provider (ChatMistralAI)
+    "groq": "Groq",  # ls_provider (ChatGroq)
+    "deepseek": "DeepSeek",  # ls_provider (ChatDeepSeek)
+    "perplexity": "Perplexity",  # ls_provider (ChatPerplexity)
+    "xai": "xAI",  # ls_provider (ChatXAI)
 }
 
 # LiteLLM model prefixes to provider names.
@@ -399,9 +441,19 @@ def _extract_model_info(
         invocation_params = invocation_params or {}
         metadata = metadata or {}
 
-        provider = invocation_params.get("_type")
-        if provider in LANGCHAIN_TO_OPENLAYER_PROVIDER_MAP:
-            provider = LANGCHAIN_TO_OPENLAYER_PROVIDER_MAP[provider]
+        # Provider: prefer LangChain's standardized ``ls_provider`` metadata
+        # (set unconditionally by ``_get_ls_params``) over the noisier ``_type``
+        # string; normalize either to a canonical Openlayer provider via the map.
+        # Fall through to the raw identifier when unknown -- no regression, and
+        # never a fuzzy guess that could produce a wrong cost.
+        ls_provider = metadata.get("ls_provider")
+        raw_type = invocation_params.get("_type")
+        provider = (
+            LANGCHAIN_TO_OPENLAYER_PROVIDER_MAP.get(ls_provider)
+            or LANGCHAIN_TO_OPENLAYER_PROVIDER_MAP.get(raw_type)
+            or ls_provider
+            or raw_type
+        )
 
         model = (
             invocation_params.get("model_name")
@@ -410,6 +462,14 @@ def _extract_model_info(
             or serialized.get("name")
         )
 
+        # Strip the Google Gemini Developer API "models/" prefix
+        # (e.g. "models/gemini-3.5-flash" -> "gemini-3.5-flash"). The cost table
+        # stores bare Gemini names and no provider is named "models", so this is
+        # safe. Runs before the LiteLLM prefix handling below so the remaining
+        # name has no stray leading segment.
+        if model and model.startswith("models/"):
+            model = model[len("models/") :]
+
         # Handle LiteLLM model prefix (e.g. "gemini/gemini-2.5-flash"):
         # extract the actual provider and strip the prefix from the model name.
         if model and "/" in model:
@@ -471,14 +531,77 @@ def _extract_token_info(
                         "prompt_tokens": usage.get("input_tokens", 0),
                         "completion_tokens": usage.get("output_tokens", 0),
                         "total_tokens": usage.get("total_tokens", 0),
+                        "input_token_details": usage.get("input_token_details"),
+                        "output_token_details": usage.get("output_token_details"),
                     }
 
+        prompt_tokens = token_usage.get("prompt_tokens", 0)
+        completion_tokens = token_usage.get("completion_tokens", 0)
         return {
-            "prompt_tokens": token_usage.get("prompt_tokens", 0),
-            "completion_tokens": token_usage.get("completion_tokens", 0),
+            "prompt_tokens": prompt_tokens,
+            "completion_tokens": completion_tokens,
             "tokens": token_usage.get("total_tokens", 0),
+            "usage_details": self._build_usage_details(
+                prompt_tokens,
+                completion_tokens,
+                token_usage.get("input_token_details"),
+                token_usage.get("output_token_details"),
+            ),
         }
 
+    @staticmethod
+    def _build_usage_details(
+        prompt_tokens: int,
+        completion_tokens: int,
+        input_token_details: Optional[Dict[str, int]] = None,
+        output_token_details: Optional[Dict[str, int]] = None,
+    ) -> Optional[Dict[str, int]]:
+        """Build the per-category token map the cost backend prices by exact key.
+
+        The backend prices a **non-overlapping** partition: it sums a price for
+        each ``usageDetails`` key it recognizes. LangChain, however, reports the
+        granular categories (``cache_read``, ``cache_creation``, ``audio``) as
+        **subsets** of the ``input_tokens`` / ``output_tokens`` totals. So we
+        break each granular category out under the key the cost table uses and
+        subtract it from the input/output base, keeping the partition
+        non-overlapping and its sum equal to the total token count.
+
+        Key mapping (LangChain -> Openlayer cost table):
+          input  ``cache_read``     -> ``cached_tokens``
+          input  ``cache_creation`` -> ``cache_creation_tokens``
+          input  ``audio``          -> ``audio_input_tokens``
+          output ``audio``          -> ``audio_output_tokens``
+
+        ``reasoning`` is intentionally left folded into ``output_tokens`` -- it
+        is billed at the output rate and the cost table has no separate price for
+        it. Zero-valued categories are omitted; returns ``None`` when there are no
+        tokens so the ``usageDetails`` column is omitted rather than emitted empty.
+        """
+        input_token_details = input_token_details or {}
+        output_token_details = output_token_details or {}
+
+        cache_read = int(input_token_details.get("cache_read", 0) or 0)
+        cache_creation = int(input_token_details.get("cache_creation", 0) or 0)
+        audio_input = int(input_token_details.get("audio", 0) or 0)
+        audio_output = int(output_token_details.get("audio", 0) or 0)
+
+        # Base = total minus the granular categories broken out below.
+        input_base = prompt_tokens - cache_read - cache_creation - audio_input
+        output_base = completion_tokens - audio_output
+
+        usage_details: Dict[str, int] = {}
+        for key, value in (
+            ("input_tokens", input_base),
+            ("output_tokens", output_base),
+            ("cached_tokens", cache_read),
+            ("cache_creation_tokens", cache_creation),
+            ("audio_input_tokens", audio_input),
+            ("audio_output_tokens", audio_output),
+        ):
+            if value and value > 0:
+                usage_details[key] = value
+        return usage_details or None
+
     def _extract_output(self, response: "langchain_schema.LLMResult") -> str:
         """Extract output text from LLM response."""
         output = ""
@@ -919,10 +1042,18 @@ def _handle_llm_new_token(self, token: str, **kwargs: Any) -> Any:
                 run_id = kwargs.get("run_id")
                 if run_id and run_id in self.steps:
                     # Convert usage to the expected format like _extract_token_info does
+                    prompt_tokens = usage.get("input_tokens", 0)
+                    completion_tokens = usage.get("output_tokens", 0)
                     token_info = {
-                        "prompt_tokens": usage.get("input_tokens", 0),
-                        "completion_tokens": usage.get("output_tokens", 0),
+                        "prompt_tokens": prompt_tokens,
+                        "completion_tokens": completion_tokens,
                         "tokens": usage.get("total_tokens", 0),
+                        "usage_details": self._build_usage_details(
+                            prompt_tokens,
+                            completion_tokens,
+                            usage.get("input_token_details"),
+                            usage.get("output_token_details"),
+                        ),
                     }
 
                     # Update the step with token usage information

src/openlayer/lib/tracing/steps.py

@@ -187,6 +187,11 @@ def __init__(
         self.model: str = None
         self.model_parameters: Dict[str, Any] = None
         self.raw_output: str = None
+        # Optional per-category token map (e.g. {"input_tokens": ...,
+        # "output_tokens": ...}). When set, the backend prices each category by
+        # exact key match to populate ``costDetails``; when unset it is omitted
+        # so integrations that only report scalar tokens are unaffected.
+        self.usage_details: Optional[Dict[str, int]] = None
 
     def to_dict(self) -> Dict[str, Any]:
         """Dictionary representation of the ChatCompletionStep."""
@@ -203,6 +208,8 @@ def to_dict(self) -> Dict[str, Any]:
                 "rawOutput": self.raw_output,
             }
         )
+        if self.usage_details:
+            step_dict["usageDetails"] = self.usage_details
         return step_dict