uipath-langchain 0.0.142__py3-none-any.whl → 0.0.144__py3-none-any.whl

uipath_langchain/agent/react/state.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from enum import StrEnum
+
+from langgraph.graph import MessagesState
+
+
+class AgentGraphState(MessagesState):
+    """Agent Graph state for standard loop execution."""
+
+    pass
+
+
+class AgentGraphNode(StrEnum):
+    INIT = "init"
+    AGENT = "agent"
+    TOOLS = "tools"
+    TERMINATE = "terminate"

uipath_langchain/agent/react/terminate_node.py

@@ -0,0 +1,53 @@
+"""Termination node for the Agent graph."""
+
+from __future__ import annotations
+
+from langchain_core.messages import AIMessage
+from pydantic import BaseModel
+from uipath._cli._runtime._contracts import UiPathErrorCode
+from uipath.agent.react import END_EXECUTION_TOOL, RAISE_ERROR_TOOL
+
+from .exceptions import (
+    AgentNodeRoutingException,
+    AgentTerminationException,
+)
+from .state import AgentGraphState
+
+
+def create_terminate_node(
+    response_schema: type[BaseModel] | None = None,
+):
+    """Validates and returns end_execution args, or raises AgentTerminationException for raise_error."""
+
+    def terminate_node(state: AgentGraphState):
+        last_message = state["messages"][-1]
+        if not isinstance(last_message, AIMessage):
+            raise AgentNodeRoutingException(
+                f"Expected last message to be AIMessage, got {type(last_message).__name__}"
+            )
+
+        for tool_call in last_message.tool_calls:
+            tool_name = tool_call["name"]
+
+            if tool_name == END_EXECUTION_TOOL.name:
+                args = tool_call["args"]
+                output_schema = response_schema or END_EXECUTION_TOOL.args_schema
+                validated = output_schema.model_validate(args)
+                return validated.model_dump()
+
+            if tool_name == RAISE_ERROR_TOOL.name:
+                error_message = tool_call["args"].get(
+                    "message", "The LLM did not set the error message"
+                )
+                detail = tool_call["args"].get("details", "")
+                raise AgentTerminationException(
+                    code=UiPathErrorCode.EXECUTION_ERROR,
+                    title=error_message,
+                    detail=detail,
+                )
+
+        raise AgentNodeRoutingException(
+            "No control flow tool call found in terminate node. Unexpected state."
+        )
+
+    return terminate_node

uipath_langchain/agent/react/tools/__init__.py

@@ -0,0 +1,7 @@
+from .tools import (
+    create_flow_control_tools,
+)
+
+__all__ = [
+    "create_flow_control_tools",
+]

uipath_langchain/agent/react/tools/tools.py

@@ -0,0 +1,50 @@
+"""Control flow tools for agent execution."""
+
+from typing import Any
+
+from langchain_core.tools import BaseTool, StructuredTool
+from pydantic import BaseModel
+from uipath.agent.react import (
+    END_EXECUTION_TOOL,
+    RAISE_ERROR_TOOL,
+)
+
+
+def create_end_execution_tool(
+    agent_output_schema: type[BaseModel] | None = None,
+) -> StructuredTool:
+    """Never executed - routing intercepts and extracts args for successful termination."""
+    input_schema = agent_output_schema or END_EXECUTION_TOOL.args_schema
+
+    async def end_execution_fn(**kwargs: Any) -> dict[str, Any]:
+        return kwargs
+
+    return StructuredTool(
+        name=END_EXECUTION_TOOL.name,
+        description=END_EXECUTION_TOOL.description,
+        args_schema=input_schema,
+        coroutine=end_execution_fn,
+    )
+
+
+def create_raise_error_tool() -> StructuredTool:
+    """Never executed - routing intercepts and raises AgentTerminationException."""
+
+    async def raise_error_fn(**kwargs: Any) -> dict[str, Any]:
+        return kwargs
+
+    return StructuredTool(
+        name=RAISE_ERROR_TOOL.name,
+        description=RAISE_ERROR_TOOL.description,
+        args_schema=RAISE_ERROR_TOOL.args_schema,
+        coroutine=raise_error_fn,
+    )
+
+
+def create_flow_control_tools(
+    agent_output_schema: type[BaseModel] | None = None,
+) -> list[BaseTool]:
+    return [
+        create_end_execution_tool(agent_output_schema),
+        create_raise_error_tool(),
+    ]

uipath_langchain/agent/react/utils.py

@@ -0,0 +1,39 @@
+"""ReAct Agent loop utilities."""
+
+from typing import Any, Sequence
+
+from jsonschema_pydantic import jsonschema_to_pydantic  # type: ignore[import-untyped]
+from langchain_core.messages import AIMessage, BaseMessage
+from pydantic import BaseModel
+from uipath.agent.react import END_EXECUTION_TOOL
+
+
+def resolve_output_model(
+    output_schema: dict[str, Any] | None,
+) -> type[BaseModel]:
+    """Fallback to default end_execution tool schema when no agent output schema is provided."""
+    if output_schema:
+        return jsonschema_to_pydantic(output_schema)
+
+    return END_EXECUTION_TOOL.args_schema
+
+
+def count_successive_completions(messages: Sequence[BaseMessage]) -> int:
+    """Count consecutive AIMessages without tool calls at end of message history."""
+    if not messages:
+        return 0
+
+    count = 0
+    for message in reversed(messages):
+        if not isinstance(message, AIMessage):
+            break
+
+        if message.tool_calls:
+            break
+
+        if not message.content:
+            break
+
+        count += 1
+
+    return count

uipath_langchain/agent/tools/__init__.py

@@ -0,0 +1,8 @@
+"""Tool creation and management for LowCode agents."""
+
+from .tool_factory import (
+    create_tools_from_resources,
+)
+from .tool_node import create_tool_node
+
+__all__ = ["create_tools_from_resources", "create_tool_node"]

uipath_langchain/agent/tools/context_tool.py

@@ -0,0 +1,42 @@
+"""Context tool creation for semantic index retrieval."""
+
+from __future__ import annotations
+
+import json
+
+from langchain_core.tools import StructuredTool
+from pydantic import BaseModel, Field
+from uipath.agent.models.agent import AgentContextResourceConfig
+
+from uipath_langchain.retrievers import ContextGroundingRetriever
+
+from .utils import sanitize_tool_name
+
+
+def create_context_tool(resource: AgentContextResourceConfig) -> StructuredTool:
+    tool_name = sanitize_tool_name(resource.name)
+    retriever = ContextGroundingRetriever(
+        index_name=resource.index_name,
+        folder_path=resource.folder_path,
+        number_of_results=resource.settings.result_count,
+    )
+
+    async def context_tool_fn(query: str) -> str:
+        docs = await retriever.ainvoke(query)
+
+        if not docs:
+            return ""
+
+        return json.dumps([doc.model_dump() for doc in docs], indent=2)
+
+    class ContextInputSchemaModel(BaseModel):
+        query: str = Field(
+            ..., description="The query to search for in the knowledge base"
+        )
+
+    return StructuredTool(
+        name=tool_name,
+        description=resource.description,
+        args_schema=ContextInputSchemaModel,
+        coroutine=context_tool_fn,
+    )

uipath_langchain/agent/tools/process_tool.py

@@ -0,0 +1,51 @@
+"""Process tool creation for UiPath process execution."""
+
+from __future__ import annotations
+
+from typing import Any, Type
+
+from jsonschema_pydantic import jsonschema_to_pydantic  # type: ignore[import-untyped]
+from langchain_core.tools import StructuredTool
+from langgraph.types import interrupt
+from pydantic import BaseModel
+from uipath.agent.models.agent import AgentProcessToolResourceConfig
+from uipath.models import InvokeProcess
+
+from .utils import sanitize_tool_name
+
+
+def create_process_tool(resource: AgentProcessToolResourceConfig) -> StructuredTool:
+    """Uses interrupt() to suspend graph execution until process completes (handled by runtime)."""
+    tool_name: str = sanitize_tool_name(resource.name)
+    process_name = resource.properties.process_name
+    folder_path = resource.properties.folder_path
+
+    input_model: Type[BaseModel] = jsonschema_to_pydantic(resource.input_schema)
+    output_model: Type[BaseModel] = jsonschema_to_pydantic(resource.output_schema)
+
+    async def process_tool_fn(**kwargs: Any):
+        try:
+            result = interrupt(
+                InvokeProcess(
+                    name=process_name,
+                    input_arguments=kwargs,
+                    process_folder_path=folder_path,
+                    process_folder_key=None,
+                )
+            )
+        except Exception:
+            raise
+
+        return result
+
+    class ProcessTool(StructuredTool):
+        """Process tool with OutputType for schema compatibility."""
+
+        OutputType: Type[BaseModel] = output_model
+
+    return ProcessTool(
+        name=tool_name,
+        description=resource.description,
+        args_schema=input_model,
+        coroutine=process_tool_fn,
+    )

uipath_langchain/agent/tools/tool_factory.py

@@ -0,0 +1,39 @@
+"""Factory functions for creating tools from agent resources."""
+
+from __future__ import annotations
+
+from langchain_core.tools import BaseTool, StructuredTool
+from uipath.agent.models.agent import (
+    AgentContextResourceConfig,
+    AgentProcessToolResourceConfig,
+    BaseAgentResourceConfig,
+    LowCodeAgentDefinition,
+)
+
+from .context_tool import create_context_tool
+from .process_tool import create_process_tool
+
+
+async def create_tools_from_resources(
+    agent: LowCodeAgentDefinition,
+) -> list[BaseTool]:
+    tools: list[BaseTool] = []
+
+    for resource in agent.resources:
+        tool = await _build_tool_for_resource(resource)
+        if tool is not None:
+            tools.append(tool)
+
+    return tools
+
+
+async def _build_tool_for_resource(
+    resource: BaseAgentResourceConfig,
+) -> StructuredTool | None:
+    if isinstance(resource, AgentProcessToolResourceConfig):
+        return create_process_tool(resource)
+
+    elif isinstance(resource, AgentContextResourceConfig):
+        return create_context_tool(resource)
+
+    return None

uipath_langchain/agent/tools/tool_node.py

@@ -0,0 +1,22 @@
+"""Tool node factory wiring directly to LangGraph's ToolNode."""
+
+from collections.abc import Sequence
+
+from langchain_core.tools import BaseTool
+from langgraph.prebuilt import ToolNode
+
+
+def create_tool_node(tools: Sequence[BaseTool]) -> dict[str, ToolNode]:
+    """Create individual ToolNode for each tool.
+
+    Args:
+        tools: Sequence of tools to create nodes for.
+
+    Returns:
+        Dict mapping tool.name -> ToolNode([tool]).
+        Each tool gets its own dedicated node for middleware composition.
+
+    Note:
+        handle_tool_errors=False delegates error handling to LangGraph's error boundary.
+    """
+    return {tool.name: ToolNode([tool], handle_tool_errors=False) for tool in tools}

uipath_langchain/agent/tools/utils.py

@@ -0,0 +1,11 @@
+"""Tool-related utility functions."""
+
+import re
+
+
+def sanitize_tool_name(name: str) -> str:
+    """Sanitize tool name for LLM compatibility (alphanumeric, underscore, hyphen only, max 64 chars)."""
+    trim_whitespaces = "_".join(name.split())
+    sanitized_tool_name = re.sub(r"[^a-zA-Z0-9_-]", "", trim_whitespaces)
+    sanitized_tool_name = sanitized_tool_name[:64]
+    return sanitized_tool_name

{uipath_langchain-0.0.142.dist-info → uipath_langchain-0.0.144.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath-langchain
-Version: 0.0.142
+Version: 0.0.144
 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.101
+Requires-Dist: uipath<2.2.0,>=2.1.103
 Provides-Extra: langchain
 Description-Content-Type: text/markdown
 

uipath_langchain-0.0.144.dist-info/RECORD

@@ -0,0 +1,62 @@
+uipath_langchain/__init__.py,sha256=VBrvQn7d3nuOdN7zEnV2_S-uhmkjgEIlXiFVeZxZakQ,80
+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=zaB-W3_29FsCqF-YZ3EsayyxC957tg4tOjdcdX8ew-M,3311
+uipath_langchain/_cli/cli_dev.py,sha256=l3XFHrh-0OUFJq3zLMKuzedJAluGQBIZQTHP1KWOmpw,1725
+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=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=xHKeu8njByiMcObbggyZk0cXYXX5BjLLF9PtSJtB4_Q,1358
+uipath_langchain/_cli/_runtime/_graph_resolver.py,sha256=c-JrsX7rx_CflDPfKhz9q-PgBrgI2IOBcYwiffwddh8,5457
+uipath_langchain/_cli/_runtime/_input.py,sha256=HAJUxjNmOg9q7l_ebF1AzIKL5_ysXyjk1bWXHsjhEPI,5761
+uipath_langchain/_cli/_runtime/_output.py,sha256=2VvdW4olv7Vd0c4grtTQazXxfBbcuocgSSP6V2P8uHE,4887
+uipath_langchain/_cli/_runtime/_runtime.py,sha256=HFWU2h864Ifq0gK9-_Jy6sbg0CMxmFExSdSEiUArChE,18548
+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/_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/_utils.py,sha256=r_fiSk3HDDAcePY_UbbEYiSbNqzn5gFeMPYBDvGrFx0,902
+uipath_langchain/_utils/__init__.py,sha256=-w-4TD9ZnJDCpj4VIPXhJciukrmDJJbmnOFnhAkAaEU,81
+uipath_langchain/_utils/_request_mixin.py,sha256=_drxHTRpfyVn3g3ppKgn466EBaUWH83qyeGKLY41CGY,20142
+uipath_langchain/_utils/_settings.py,sha256=2fExMQJ88YptfldmzMfZIpsx-m1gfMkeYGf5t6KIe0A,3084
+uipath_langchain/_utils/_sleep_policy.py,sha256=e9pHdjmcCj4CVoFM1jMyZFelH11YatsgWfpyrfXzKBQ,1251
+uipath_langchain/agent/react/__init__.py,sha256=rfVB6PQWUhPHff3J1BnPMBKBMaHfgEkII1gXwjiqUMY,272
+uipath_langchain/agent/react/agent.py,sha256=cU9ZiXi7EfV1pMf9nZBO8LhjYUmRsncyBk9k1pEBRh8,2455
+uipath_langchain/agent/react/constants.py,sha256=B2yqryh242DETslaRYacUPbVdpjvvApjsBira_qhQwk,61
+uipath_langchain/agent/react/exceptions.py,sha256=b3lDhrIIHFljlLK3zXPznT7fYzfMRjSd8JfF4247tbI,226
+uipath_langchain/agent/react/init_node.py,sha256=zfPKgxi_mWsX7nBcK6wpqcDjHx8Q61TSnXFcTPLUd28,389
+uipath_langchain/agent/react/llm_node.py,sha256=jkbfzPNn6rNubgncPlPDQRNuk-sJbj08r95JfWxxWL8,1491
+uipath_langchain/agent/react/router.py,sha256=Ttq5O1_8t-z7pQ9tGhiaMmd_Da7_TWULLcgOED7gw_A,3626
+uipath_langchain/agent/react/state.py,sha256=EnkGXFlmMtJUy7BTZrbYlGBvvAZ70_HwKPW8n6uwjz0,330
+uipath_langchain/agent/react/terminate_node.py,sha256=Uuc-0z4qcPjHB_qZlaEaM2mK1ymCuJJludS7LopyCZg,1898
+uipath_langchain/agent/react/utils.py,sha256=0kZoEkGzddtTZSlGQcqbaPHH5MVtZegq0kBI5_vreGA,1060
+uipath_langchain/agent/react/tools/__init__.py,sha256=LGfG8Dc32ffKdXQyMI2oYzhNnTs1wbzsddXz6eU-0MY,102
+uipath_langchain/agent/react/tools/tools.py,sha256=vFBGnFrGocX__sotKisMJr2lxRRVqA0-uThzzhPADIw,1443
+uipath_langchain/agent/tools/__init__.py,sha256=GqQZLoMxkujjsButdLruxgzmQLX9k0YPtBaBAULSV2o,222
+uipath_langchain/agent/tools/context_tool.py,sha256=Xd2qvc52Ks2eFXF2n-i0d8QDnbHXls_V8jyyNXwdySI,1243
+uipath_langchain/agent/tools/process_tool.py,sha256=3OPxkIAJw_haohDeyDwSo8CIz9300XSvqIz5yjItspk,1715
+uipath_langchain/agent/tools/tool_factory.py,sha256=NfhUU7EWf-zkt4xglkzp8ReOYDvKmoOTiz-OBh3ACWs,1053
+uipath_langchain/agent/tools/tool_node.py,sha256=TnXsjoShvhsoBuV5RoUVoJCc2zYPKSnJYSC9MGJoeOk,707
+uipath_langchain/agent/tools/utils.py,sha256=DsFeZ7kDzFaZ0bGHQN6TlGMJ90wYr7P1Vo1rpHPHWws,401
+uipath_langchain/chat/__init__.py,sha256=WDcvy91ixvZ3Mq7Ae94g5CjyQwXovDBnEv1NlD5SXBE,116
+uipath_langchain/chat/models.py,sha256=PifcbDURqfttqVYKSnzdbOdbSiLiwHfQ6lWgVAtoLj8,16407
+uipath_langchain/embeddings/__init__.py,sha256=QICtYB58ZyqFfDQrEaO8lTEgAU5NuEKlR7iIrS0OBtc,156
+uipath_langchain/embeddings/embeddings.py,sha256=45gKyb6HVKigwE-0CXeZcAk33c0mteaEdPGa8hviqcw,4339
+uipath_langchain/retrievers/__init__.py,sha256=rOn7PyyHgZ4pMnXWPkGqmuBmx8eGuo-Oyndo7Wm9IUU,108
+uipath_langchain/retrievers/context_grounding_retriever.py,sha256=YLCIwy89LhLnNqcM0YJ5mZoeNyCs5UiKD3Wly8gnW1E,2239
+uipath_langchain/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+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.144.dist-info/METADATA,sha256=fnn1iHs-_Q0lyubeoDFTb6c5LGZaWZbpxDnMytjjbRg,4276
+uipath_langchain-0.0.144.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uipath_langchain-0.0.144.dist-info/entry_points.txt,sha256=FUtzqGOEntlJKMJIXhQUfT7ZTbQmGhke1iCmDWZaQZI,81
+uipath_langchain-0.0.144.dist-info/licenses/LICENSE,sha256=JDpt-uotAkHFmxpwxi6gwx6HQ25e-lG4U_Gzcvgp7JY,1063
+uipath_langchain-0.0.144.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,
-        )