uipath-langchain 0.0.141__py3-none-any.whl → 0.0.143__py3-none-any.whl

uipath_langchain/_cli/cli_debug.py

@@ -12,8 +12,9 @@ from uipath._cli._runtime._contracts import (
     UiPathRuntimeFactory,
 )
 from uipath._cli.middlewares import MiddlewareResult
+from uipath.tracing import LlmOpsHttpExporter
 
-from .._tracing import LangChainExporter, _instrument_traceable_attributes
+from .._tracing import _instrument_traceable_attributes
 from ._runtime._exception import LangGraphRuntimeError
 from ._runtime._runtime import (  # type: ignore[attr-defined]
     LangGraphRuntimeContext,
@@ -61,7 +62,9 @@ def langgraph_debug_middleware(
             )
 
             if context.job_id:
-                runtime_factory.add_span_exporter(LangChainExporter())
+                runtime_factory.add_span_exporter(
+                    LlmOpsHttpExporter(extra_process_spans=True)
+                )
 
             runtime_factory.add_instrumentor(LangChainInstrumentor, get_current_span)
 

uipath_langchain/_cli/cli_eval.py

@@ -15,12 +15,12 @@ from uipath._cli._utils._eval_set import EvalHelpers
 from uipath._cli.middlewares import MiddlewareResult
 from uipath._events._event_bus import EventBus
 from uipath.eval._helpers import auto_discover_entrypoint
+from uipath.tracing import LlmOpsHttpExporter
 
 from uipath_langchain._cli._runtime._context import LangGraphRuntimeContext
 from uipath_langchain._cli._runtime._runtime import LangGraphScriptRuntime
 from uipath_langchain._cli._utils._graph import LangGraphConfig
 from uipath_langchain._tracing import (
-    LangChainExporter,
     _instrument_traceable_attributes,
 )
 
@@ -41,7 +41,7 @@ def langgraph_eval_middleware(
 
         if kwargs.get("register_progress_reporter", False):
             progress_reporter = StudioWebProgressReporter(
-                spans_exporter=LangChainExporter()
+                spans_exporter=LlmOpsHttpExporter(extra_process_spans=True)
             )
             asyncio.run(progress_reporter.subscribe_to_eval_runtime_events(event_bus))
         console_reporter = ConsoleProgressReporter()
@@ -76,7 +76,9 @@ def langgraph_eval_middleware(
         )
 
         if eval_context.job_id:
-            runtime_factory.add_span_exporter(LangChainExporter())
+            runtime_factory.add_span_exporter(
+                LlmOpsHttpExporter(extra_process_spans=True)
+            )
 
         runtime_factory.add_instrumentor(LangChainInstrumentor, get_current_span)
 

uipath_langchain/_cli/cli_init.py

@@ -1,9 +1,14 @@
 import asyncio
+import importlib.resources
 import json
 import os
+import shutil
 import uuid
+from collections.abc import Generator
+from enum import Enum
 from typing import Any, Callable, Dict, overload
 
+import click
 from langgraph.graph.state import CompiledStateGraph
 from uipath._cli._utils._console import ConsoleLogger
 from uipath._cli._utils._parse_ast import generate_bindings_json  # type: ignore
@@ -14,6 +19,14 @@ from ._utils._graph import LangGraphConfig
 console = ConsoleLogger()
 
 
+class FileOperationStatus(str, Enum):
+    """Status of a file operation."""
+
+    CREATED = "created"
+    UPDATED = "updated"
+    SKIPPED = "skipped"
+
+
 def resolve_refs(schema, root=None):
     """Recursively resolves $ref references in a JSON schema."""
     if root is None:
@@ -96,6 +109,120 @@ def generate_schema_from_graph(
     return schema
 
 
+def generate_agent_md_file(
+    target_directory: str,
+    file_name: str,
+    resource_name: str,
+    no_agents_md_override: bool,
+) -> tuple[str, FileOperationStatus] | None:
+    """Generate an agent-specific file from the packaged resource.
+
+    Args:
+        target_directory: The directory where the file should be created.
+        file_name: The name of the file should be created.
+        resource_name: The name of the resource folder where should be the file.
+        no_agents_md_override: Whether to override existing files.
+
+    Returns:
+        A tuple of (file_name, status) where status is a FileOperationStatus:
+        - CREATED: File was created
+        - UPDATED: File was overwritten
+        - SKIPPED: File exists and no_agents_md_override is True
+        Returns None if an error occurred.
+    """
+    target_path = os.path.join(target_directory, file_name)
+    will_override = os.path.exists(target_path)
+
+    if will_override and no_agents_md_override:
+        return file_name, FileOperationStatus.SKIPPED
+    try:
+        source_path = importlib.resources.files(resource_name).joinpath(file_name)
+
+        with importlib.resources.as_file(source_path) as s_path:
+            shutil.copy(s_path, target_path)
+
+        return (
+            file_name,
+            FileOperationStatus.UPDATED
+            if will_override
+            else FileOperationStatus.CREATED,
+        )
+
+    except Exception as e:
+        console.warning(f"Could not create {file_name}: {e}")
+        return None
+
+
+def generate_specific_agents_md_files(
+    target_directory: str, no_agents_md_override: bool
+) -> Generator[tuple[str, FileOperationStatus], None, None]:
+    """Generate agent-specific files from the packaged resource.
+
+    Args:
+        target_directory: The directory where the files should be created.
+        no_agents_md_override: Whether to override existing files.
+
+    Yields:
+        Tuple of (file_name, status) for each file operation, where status is a FileOperationStatus:
+        - CREATED: File was created
+        - UPDATED: File was overwritten
+        - SKIPPED: File exists and was not overwritten
+    """
+    agent_dir = os.path.join(target_directory, ".agent")
+    os.makedirs(agent_dir, exist_ok=True)
+
+    file_configs = [
+        (target_directory, "CLAUDE.md", "uipath._resources"),
+        (agent_dir, "CLI_REFERENCE.md", "uipath._resources"),
+        (agent_dir, "SDK_REFERENCE.md", "uipath._resources"),
+        (target_directory, "AGENTS.md", "uipath_langchain._resources"),
+        (agent_dir, "REQUIRED_STRUCTURE.md", "uipath_langchain._resources"),
+    ]
+
+    for directory, file_name, resource_name in file_configs:
+        result = generate_agent_md_file(
+            directory, file_name, resource_name, no_agents_md_override
+        )
+        if result:
+            yield result
+
+
+def generate_agents_md_files(options: dict[str, Any]) -> None:
+    """Generate agent MD files and log categorized summary.
+
+    Args:
+        options: Options dictionary
+    """
+    current_directory = os.getcwd()
+    no_agents_md_override = options.get("no_agents_md_override", False)
+
+    created_files = []
+    updated_files = []
+    skipped_files = []
+
+    for file_name, status in generate_specific_agents_md_files(
+        current_directory, no_agents_md_override
+    ):
+        if status == FileOperationStatus.CREATED:
+            created_files.append(file_name)
+        elif status == FileOperationStatus.UPDATED:
+            updated_files.append(file_name)
+        elif status == FileOperationStatus.SKIPPED:
+            skipped_files.append(file_name)
+
+    if created_files:
+        files_str = ", ".join(click.style(f, fg="cyan") for f in created_files)
+        console.success(f"Created: {files_str}")
+
+    if updated_files:
+        files_str = ", ".join(click.style(f, fg="cyan") for f in updated_files)
+        console.success(f"Updated: {files_str}")
+
+    if skipped_files:
+        files_str = ", ".join(click.style(f, fg="yellow") for f in skipped_files)
+        console.info(f"Skipped (already exist): {files_str}")
+
+
 async def langgraph_init_middleware_async(
     entrypoint: str,
     options: dict[str, Any] | None = None,
@@ -185,7 +312,9 @@ async def langgraph_init_middleware_async(
             try:
                 with open(mermaid_file_path, "w") as f:
                     f.write(mermaid_content)
-                console.success(f" Created '{mermaid_file_path}' file.")
+                console.success(
+                    f"Created {click.style(mermaid_file_path, fg='cyan')} file."
+                )
             except Exception as write_error:
                 console.error(
                     f"Error writing mermaid file for '{graph_name}': {str(write_error)}"
@@ -194,7 +323,10 @@ async def langgraph_init_middleware_async(
                     should_continue=False,
                     should_include_stacktrace=True,
                 )
-        console.success(f" Created '{config_path}' file.")
+        console.success(f"Created {click.style(config_path, fg='cyan')} file.")
+
+        generate_agents_md_files(options)
+
         return MiddlewareResult(should_continue=False)
 
     except Exception as e:

uipath_langchain/_cli/cli_run.py

@@ -13,8 +13,11 @@ from uipath._cli._runtime._contracts import (
 )
 from uipath._cli.middlewares import MiddlewareResult
 from uipath._events._events import UiPathAgentStateEvent
+from uipath.tracing import JsonLinesFileExporter, LlmOpsHttpExporter
 
-from .._tracing import LangChainExporter, _instrument_traceable_attributes
+from .._tracing import (
+    _instrument_traceable_attributes,
+)
 from ._runtime._exception import LangGraphRuntimeError
 from ._runtime._runtime import (  # type: ignore[attr-defined]
     LangGraphRuntimeContext,
@@ -24,7 +27,11 @@ from ._utils._graph import LangGraphConfig
 
 
 def langgraph_run_middleware(
-    entrypoint: Optional[str], input: Optional[str], resume: bool, **kwargs
+    entrypoint: Optional[str],
+    input: Optional[str],
+    resume: bool,
+    trace_file: Optional[str] = None,
+    **kwargs,
 ) -> MiddlewareResult:
     """Middleware to handle LangGraph execution"""
     config = LangGraphConfig()
@@ -61,8 +68,13 @@ def langgraph_run_middleware(
 
             runtime_factory.add_instrumentor(LangChainInstrumentor, get_current_span)
 
+            if trace_file:
+                runtime_factory.add_span_exporter(JsonLinesFileExporter(trace_file))
+
             if context.job_id:
-                runtime_factory.add_span_exporter(LangChainExporter())
+                runtime_factory.add_span_exporter(
+                    LlmOpsHttpExporter(extra_process_spans=True)
+                )
                 await runtime_factory.execute(context)
             else:
                 debug_bridge: UiPathDebugBridge = ConsoleDebugBridge()

uipath_langchain/_resources/AGENTS.md

@@ -0,0 +1,21 @@
+# Agent Code Patterns Reference
+
+This document provides practical code patterns for building UiPath coded agents using LangGraph and the UiPath Python SDK.
+
+---
+
+## Documentation Structure
+
+This documentation is split into multiple files for efficient context loading. Load only the files you need:
+
+1. **@.agent/REQUIRED_STRUCTURE.md** - Agent structure patterns and templates
+   - **When to load:** Creating a new agent or understanding required patterns
+   - **Contains:** Required Pydantic models (Input, State, Output), LLM initialization patterns, standard agent template
+
+2. **@.agent/SDK_REFERENCE.md** - Complete SDK API reference
+   - **When to load:** Calling UiPath SDK methods, working with services (actions, assets, jobs, etc.)
+   - **Contains:** All SDK services and methods with full signatures and type annotations
+
+3. **@.agent/CLI_REFERENCE.md** - CLI commands documentation
+   - **When to load:** Working with `uipath init`, `uipath run`, or `uipath eval` commands
+   - **Contains:** Command syntax, options, usage examples, and workflows

uipath_langchain/_resources/REQUIRED_STRUCTURE.md

@@ -0,0 +1,92 @@
+## Required Agent Structure
+
+**IMPORTANT**: All UiPath coded agents MUST follow this standard structure unless explicitly specified otherwise by the user.
+
+### Required Components
+
+Every agent implementation MUST include these three Pydantic models:
+
+```python
+from pydantic import BaseModel
+
+class Input(BaseModel):
+    """Define input fields that the agent accepts"""
+    # Add your input fields here
+    pass
+
+class State(BaseModel):
+    """Define the agent's internal state that flows between nodes"""
+    # Add your state fields here
+    pass
+
+class Output(BaseModel):
+    """Define output fields that the agent returns"""
+    # Add your output fields here
+    pass
+```
+
+### Required LLM Initialization
+
+Unless the user explicitly requests a different LLM provider, always use `UiPathChat`:
+
+```python
+from uipath_langchain.chat import UiPathChat
+
+llm = UiPathChat(model="gpt-4o-2024-08-06", temperature=0.7)
+```
+
+**Alternative LLMs** (only use if explicitly requested):
+- `ChatOpenAI` from `langchain_openai`
+- `ChatAnthropic` from `langchain_anthropic`
+- Other LangChain-compatible LLMs
+
+### Standard Agent Template
+
+Every agent should follow this basic structure:
+
+```python
+from langchain_core.messages import SystemMessage, HumanMessage
+from langgraph.graph import START, StateGraph, END
+from uipath_langchain.chat import UiPathChat
+from pydantic import BaseModel
+
+# 1. Define Input, State, and Output models
+class Input(BaseModel):
+    field: str
+
+class State(BaseModel):
+    field: str
+    result: str = ""
+
+class Output(BaseModel):
+    result: str
+
+# 2. Initialize UiPathChat LLM
+llm = UiPathChat(model="gpt-4o-2024-08-06", temperature=0.7)
+
+# 3. Define agent nodes (async functions)
+async def process_node(state: State) -> State:
+    response = await llm.ainvoke([HumanMessage(state.field)])
+    return State(field=state.field, result=response.content)
+
+async def output_node(state: State) -> Output:
+    return Output(result=state.result)
+
+# 4. Build the graph
+builder = StateGraph(State, input=Input, output=Output)
+builder.add_node("process", process_node)
+builder.add_node("output", output_node)
+builder.add_edge(START, "process")
+builder.add_edge("process", "output")
+builder.add_edge("output", END)
+
+# 5. Compile the graph
+graph = builder.compile()
+```
+
+**Key Rules**:
+1. Always use async/await for all node functions
+2. All nodes (except output) must accept and return `State`
+3. The final output node must return `Output`
+4. Use `StateGraph(State, input=Input, output=Output)` for initialization
+5. Always compile with `graph = builder.compile()`

uipath_langchain/_tracing/__init__.py

@@ -1,4 +1,5 @@
 from ._instrument_traceable import _instrument_traceable_attributes
-from ._oteladapter import LangChainExporter
 
-__all__ = ["LangChainExporter", "_instrument_traceable_attributes"]
+__all__ = [
+    "_instrument_traceable_attributes",
+]

{uipath_langchain-0.0.141.dist-info → uipath_langchain-0.0.143.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath-langchain
-Version: 0.0.141
+Version: 0.0.143
 Summary: UiPath Langchain
 Project-URL: Homepage, https://uipath.com
 Project-URL: Repository, https://github.com/UiPath/uipath-langchain-python
@@ -26,7 +26,7 @@ Requires-Dist: openai>=1.65.5
 Requires-Dist: openinference-instrumentation-langchain>=0.1.50
 Requires-Dist: pydantic-settings>=2.6.0
 Requires-Dist: python-dotenv>=1.0.1
-Requires-Dist: uipath<2.2.0,>=2.1.96
+Requires-Dist: uipath<2.2.0,>=2.1.103
 Provides-Extra: langchain
 Description-Content-Type: text/markdown
 

{uipath_langchain-0.0.141.dist-info → uipath_langchain-0.0.143.dist-info}/RECORD

@@ -2,12 +2,12 @@ uipath_langchain/__init__.py,sha256=VBrvQn7d3nuOdN7zEnV2_S-uhmkjgEIlXiFVeZxZakQ,
 uipath_langchain/middlewares.py,sha256=x3U_tmDIyMXPLzq6n-oNRAnpAF6pKa9wfkPYwE-oUfo,848
 uipath_langchain/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 uipath_langchain/_cli/__init__.py,sha256=juqd9PbXs4yg45zMJ7BHAOPQjb7sgEbWE9InBtGZhfo,24
-uipath_langchain/_cli/cli_debug.py,sha256=RQqBVne3OdXYPvgl5f7kIrV5zztA8W8LMXWex7oOQeU,3221
+uipath_langchain/_cli/cli_debug.py,sha256=zaB-W3_29FsCqF-YZ3EsayyxC957tg4tOjdcdX8ew-M,3311
 uipath_langchain/_cli/cli_dev.py,sha256=l3XFHrh-0OUFJq3zLMKuzedJAluGQBIZQTHP1KWOmpw,1725
-uipath_langchain/_cli/cli_eval.py,sha256=r8mGlKh-ymxfKrvrU4n0Hg3pQv36c_NhTNR_eokyQEM,3650
-uipath_langchain/_cli/cli_init.py,sha256=xhxJ8tuMSrVUNHvltgyPpOrvgMA-wq9shHeYYwvHILs,8199
+uipath_langchain/_cli/cli_eval.py,sha256=yzxOz-JOMMl1fejZNVQYlBSo-yUIxArtfp2EW1Ow6j4,3753
+uipath_langchain/_cli/cli_init.py,sha256=B-Ht1lz4HNlpYELZU7DLNhSrhGJbsaCdU9UMO2iHUgM,12654
 uipath_langchain/_cli/cli_new.py,sha256=KKLxCzz7cDQ__rRr_a496IHWlSQXhmrBNgmKHnXAnTY,2336
-uipath_langchain/_cli/cli_run.py,sha256=-k7QsfHWRQUAvVB6l533SCC9Xcxm7NSWq_oR0iy6THY,3426
+uipath_langchain/_cli/cli_run.py,sha256=DIsAKsbQ8gTRz44q9ZV3jBjrbM8bhS6lEQ3dd4joDFU,3712
 uipath_langchain/_cli/_runtime/_context.py,sha256=mjmGEogKiO8tUV878BgV9rFIeA9MCmEH6hgs5W_dm4g,328
 uipath_langchain/_cli/_runtime/_conversation.py,sha256=ayghRqhyLeVUZg1WHnpeOYtPNhRwDOl4z8OSYiJkWSU,11529
 uipath_langchain/_cli/_runtime/_exception.py,sha256=USKkLYkG-dzjX3fEiMMOHnVUpiXJs_xF0OQXCCOvbYM,546
@@ -18,9 +18,10 @@ uipath_langchain/_cli/_runtime/_runtime.py,sha256=ImDBluxga_WbIm9lnljjm7jGl1tZBP
 uipath_langchain/_cli/_templates/langgraph.json.template,sha256=eeh391Gta_hoRgaNaZ58nW1LNvCVXA7hlAH6l7Veous,107
 uipath_langchain/_cli/_templates/main.py.template,sha256=GpSblGH2hwS9ibqQmX2iB2nsmOA5zDfEEF4ChLiMxbQ,875
 uipath_langchain/_cli/_utils/_graph.py,sha256=nMJWy8FmaD9rqPUY2lHc5uVpUzbXD1RO12uJnhe0kdo,6803
-uipath_langchain/_tracing/__init__.py,sha256=UqrLc_WimpzKY82M0LJsgJ-HFQUQFjOmOlD1XQ8V-R4,181
+uipath_langchain/_resources/AGENTS.md,sha256=5VmIfaQ6H91VxInnxFmJklURXeWIIQpGQTYBEmvvoVA,1060
+uipath_langchain/_resources/REQUIRED_STRUCTURE.md,sha256=BRmWWFtM0qNXj5uumALVxq9h6pifJDGh5NzuyctuH1Q,2569
+uipath_langchain/_tracing/__init__.py,sha256=C2dRvQ2ynxCmyICgE-rJHimWKEcFRME_o9gfX84Mb3Y,123
 uipath_langchain/_tracing/_instrument_traceable.py,sha256=8f9FyAKWE6kH1N8ErbpwqZHAzNjGwbLjQn7jdX5yAgA,4343
-uipath_langchain/_tracing/_oteladapter.py,sha256=PD0gsC39ZNvrm0gsfnt1ti6DEy56sBA9sIoxaAbHFFM,8887
 uipath_langchain/_tracing/_utils.py,sha256=r_fiSk3HDDAcePY_UbbEYiSbNqzn5gFeMPYBDvGrFx0,902
 uipath_langchain/_utils/__init__.py,sha256=-w-4TD9ZnJDCpj4VIPXhJciukrmDJJbmnOFnhAkAaEU,81
 uipath_langchain/_utils/_request_mixin.py,sha256=sYvvn3_fUJxtF893xFpVGwJx2YoEbw1m5gp_U_lWjR8,20092
@@ -36,8 +37,8 @@ uipath_langchain/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3
 uipath_langchain/tools/preconfigured.py,sha256=SyvrLrM1kezZxVVytgScVO8nBfVYfFGobWjY7erzsYU,7490
 uipath_langchain/vectorstores/__init__.py,sha256=w8qs1P548ud1aIcVA_QhBgf_jZDrRMK5Lono78yA8cs,114
 uipath_langchain/vectorstores/context_grounding_vectorstore.py,sha256=TncIXG-YsUlO0R5ZYzWsM-Dj1SVCZbzmo2LraVxXelc,9559
-uipath_langchain-0.0.141.dist-info/METADATA,sha256=0dPnBY1gLeS7U_f-Hth1UNYGJnlvmFnuA-I72J5Fmw8,4275
-uipath_langchain-0.0.141.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-uipath_langchain-0.0.141.dist-info/entry_points.txt,sha256=FUtzqGOEntlJKMJIXhQUfT7ZTbQmGhke1iCmDWZaQZI,81
-uipath_langchain-0.0.141.dist-info/licenses/LICENSE,sha256=JDpt-uotAkHFmxpwxi6gwx6HQ25e-lG4U_Gzcvgp7JY,1063
-uipath_langchain-0.0.141.dist-info/RECORD,,
+uipath_langchain-0.0.143.dist-info/METADATA,sha256=lh7djtB3vKXf2xB6b8BT9IksQGlun2fj2UiNFIver-E,4276
+uipath_langchain-0.0.143.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uipath_langchain-0.0.143.dist-info/entry_points.txt,sha256=FUtzqGOEntlJKMJIXhQUfT7ZTbQmGhke1iCmDWZaQZI,81
+uipath_langchain-0.0.143.dist-info/licenses/LICENSE,sha256=JDpt-uotAkHFmxpwxi6gwx6HQ25e-lG4U_Gzcvgp7JY,1063
+uipath_langchain-0.0.143.dist-info/RECORD,,

uipath_langchain/_tracing/_oteladapter.py

@@ -1,234 +0,0 @@
-import json
-import logging
-from typing import Any, Dict, List, Optional
-
-from opentelemetry.sdk.trace.export import SpanExportResult
-from uipath.tracing import LlmOpsHttpExporter
-
-logger = logging.getLogger(__name__)
-
-
-def _safe_parse_json(s: Any) -> Any:
-    """Safely parse a JSON string, returning the original if not a string or on error."""
-    if not isinstance(s, str):
-        return s
-    try:
-        return json.loads(s)
-    except (json.JSONDecodeError, TypeError):
-        return s
-
-
-def _get_llm_messages(attributes: Dict[str, Any], prefix: str) -> List[Dict[str, Any]]:
-    """Extracts and reconstructs LLM messages from flattened attributes."""
-    messages: dict[int, dict[str, Any]] = {}
-    message_prefix = f"{prefix}."
-
-    for key, value in attributes.items():
-        if key.startswith(message_prefix):
-            parts = key[len(message_prefix) :].split(".")
-            if len(parts) >= 2 and parts[0].isdigit():
-                index = int(parts[0])
-                if index not in messages:
-                    messages[index] = {}
-                current: Any = messages[index]
-
-                for i, part in enumerate(parts[1:-1]):
-                    key_part: str | int = part
-                    if part.isdigit() and (
-                        i + 2 < len(parts) and parts[i + 2].isdigit()
-                    ):
-                        key_part = int(part)
-
-                    if isinstance(current, dict):
-                        if key_part not in current:
-                            current[key_part] = {}
-                        current = current[key_part]
-                    elif isinstance(current, list) and isinstance(key_part, int):
-                        if key_part >= len(current):
-                            current.append({})
-                        current = current[key_part]
-
-                current[parts[-1]] = value
-
-    # Convert dict to list, ordered by index
-    return [messages[i] for i in sorted(messages.keys())]
-
-
-class LangChainExporter(LlmOpsHttpExporter):
-    # Mapping of old attribute names to new attribute names or (new name, function)
-    ATTRIBUTE_MAPPING: dict[str, str | tuple[str, Any]] = {
-        "input.value": ("input", _safe_parse_json),
-        "output.value": ("output", _safe_parse_json),
-        "llm.model_name": "model",
-    }
-
-    # Mapping of span types
-    SPAN_TYPE_MAPPING: dict[str, str] = {
-        "LLM": "completion",
-        "TOOL": "toolCall",
-        # Add more mappings as needed
-    }
-
-    class Status:
-        SUCCESS = 1
-        ERROR = 2
-        INTERRUPTED = 3
-
-    def __init__(self, *args: Any, **kwargs: Any) -> None:
-        super().__init__(*args, **kwargs)
-
-    def _map_llm_call_attributes(self, attributes: Dict[str, Any]) -> Dict[str, Any]:
-        """Maps attributes for LLM calls, handling flattened keys."""
-        result = attributes.copy()  # Keep original attributes including basic mappings
-
-        # Token Usage
-        token_keys = {
-            "llm.token_count.prompt": "promptTokens",
-            "llm.token_count.completion": "completionTokens",
-            "llm.token_count.total": "totalTokens",
-        }
-        usage = {
-            new_key: attributes.get(old_key)
-            for old_key, new_key in token_keys.items()
-            if old_key in attributes
-        }
-        if usage:
-            result["usage"] = usage
-
-        # Input/Output Messages
-        result["input"] = _get_llm_messages(attributes, "llm.input_messages")
-        output_messages = _get_llm_messages(attributes, "llm.output_messages")
-        result["output"] = output_messages
-
-        # Invocation Parameters
-        invocation_params = _safe_parse_json(
-            attributes.get("llm.invocation_parameters", "{}")
-        )
-        if isinstance(invocation_params, dict):
-            result["model"] = invocation_params.get("model", result.get("model"))
-            settings: dict[str, Any] = {}
-            if "max_tokens" in invocation_params:
-                settings["maxTokens"] = invocation_params["max_tokens"]
-            if "temperature" in invocation_params:
-                settings["temperature"] = invocation_params["temperature"]
-            if settings:
-                result["settings"] = settings
-
-        # Tool Calls
-        tool_calls: list[dict[str, Any]] = []
-        for msg in output_messages:
-            # Ensure msg is a dictionary before proceeding
-            if not isinstance(msg, dict):
-                continue
-            msg_tool_calls = msg.get("message", {}).get("tool_calls", [])
-
-            # Ensure msg_tool_calls is a list
-            if not isinstance(msg_tool_calls, list):
-                continue
-
-            for tc in msg_tool_calls:
-                if not isinstance(tc, dict):
-                    continue
-                tool_call_data = tc.get("tool_call", {})
-                if not isinstance(tool_call_data, dict):
-                    continue
-                tool_calls.append(
-                    {
-                        "id": tool_call_data.get("id"),
-                        "name": tool_call_data.get("function", {}).get("name"),
-                        "arguments": _safe_parse_json(
-                            tool_call_data.get("function", {}).get("arguments", "{}")
-                        ),
-                    }
-                )
-        if tool_calls:
-            result["toolCalls"] = tool_calls
-
-        return result
-
-    def _map_tool_call_attributes(self, attributes: Dict[str, Any]) -> Dict[str, Any]:
-        """Maps attributes for tool calls."""
-        result = attributes.copy()  # Keep original attributes
-
-        result["type"] = "toolCall"
-        result["callId"] = attributes.get("call_id") or attributes.get("id")
-        result["toolName"] = attributes.get("tool.name")
-        result["arguments"] = _safe_parse_json(
-            attributes.get("input", attributes.get("input.value", "{}"))
-        )
-        result["toolType"] = "Integration"
-        result["result"] = _safe_parse_json(
-            attributes.get("output", attributes.get("output.value"))
-        )
-        result["error"] = None
-
-        return result
-
-    def _determine_status(self, error: Optional[str]) -> int:
-        if error:
-            if error and error.startswith("GraphInterrupt("):
-                return self.Status.INTERRUPTED
-            return self.Status.ERROR
-        return self.Status.SUCCESS
-
-    def _process_span_attributes(self, span_data: Dict[str, Any]) -> Dict[str, Any]:
-        """Extracts, transforms, and maps attributes for a span."""
-        if "Attributes" not in span_data:
-            return span_data
-
-        attributes_val = span_data["Attributes"]
-        if isinstance(attributes_val, str):
-            try:
-                attributes: Dict[str, Any] = json.loads(attributes_val)
-            except json.JSONDecodeError as e:
-                logger.warning(f"Failed to parse attributes JSON: {e}")
-                return span_data
-        elif isinstance(attributes_val, dict):
-            attributes = attributes_val
-        else:
-            return span_data
-
-        # Determine SpanType
-        if "openinference.span.kind" in attributes:
-            span_type = attributes["openinference.span.kind"]
-            span_data["SpanType"] = self.SPAN_TYPE_MAPPING.get(span_type, span_type)
-
-        # Apply basic attribute mapping
-        for old_key, mapping in self.ATTRIBUTE_MAPPING.items():
-            if old_key in attributes:
-                if isinstance(mapping, tuple):
-                    new_key, func = mapping
-                    attributes[new_key] = func(attributes[old_key])
-                else:
-                    new_key = mapping
-                    attributes[new_key] = attributes[old_key]
-
-        # Apply detailed mapping based on SpanType
-        span_type = span_data.get("SpanType")
-        if span_type == "completion":
-            processed_attributes = self._map_llm_call_attributes(attributes)
-        elif span_type == "toolCall":
-            processed_attributes = self._map_tool_call_attributes(attributes)
-        else:
-            processed_attributes = attributes.copy()
-
-        span_data["Attributes"] = json.dumps(processed_attributes)
-
-        # Determine status based on error information
-        error = attributes.get("error") or attributes.get("exception.message")
-        status = self._determine_status(error)
-        span_data["Status"] = status
-
-        return span_data
-
-    def _send_with_retries(
-        self, url: str, payload: List[Dict[str, Any]], max_retries: int = 4
-    ) -> SpanExportResult:
-        # Transform attributes in each span's payload before sending
-        transformed_payload = [self._process_span_attributes(span) for span in payload]
-
-        return super()._send_with_retries(
-            url=url,
-            payload=transformed_payload,
-            max_retries=max_retries,
-        )