uipath-langchain 0.0.131__py3-none-any.whl → 0.0.132__py3-none-any.whl

uipath_langchain/_cli/_runtime/_input.py

@@ -2,7 +2,6 @@ import logging
 from typing import Any, Optional, cast
 
 from langgraph.types import Command
-from uipath import UiPath
 from uipath._cli._runtime._contracts import (
     UiPathApiTrigger,
     UiPathErrorCategory,
@@ -32,7 +31,6 @@ class LangGraphInputProcessor:
             context: The runtime context for the graph execution.
         """
         self.context = context
-        self.uipath = UiPath()
 
     async def process(self) -> Any:
         """

uipath_langchain/_cli/_runtime/_runtime.py

@@ -6,7 +6,6 @@ from typing import Any, Dict, List, Optional, Tuple, Union
 from langchain_core.callbacks.base import BaseCallbackHandler
 from langchain_core.messages import BaseMessage
 from langchain_core.runnables.config import RunnableConfig
-from langchain_core.tracers.langchain import wait_for_all_tracers
 from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
 from langgraph.errors import EmptyInputError, GraphRecursionError, InvalidUpdateError
 from langgraph.graph.state import CompiledStateGraph
@@ -16,8 +15,6 @@ from uipath._cli._runtime._contracts import (
     UiPathRuntimeResult,
 )
 
-from ..._utils import _instrument_traceable_attributes
-from ...tracers import AsyncUiPathTracer
 from .._utils._graph import LangGraphConfig
 from ._context import LangGraphRuntimeContext
 from ._conversation import map_message
@@ -48,13 +45,10 @@ class LangGraphRuntime(UiPathBaseRuntime):
         Raises:
             LangGraphRuntimeError: If execution fails
         """
-        _instrument_traceable_attributes()
 
         if self.context.state_graph is None:
             return None
 
-        tracer = None
-
         try:
             async with AsyncSqliteSaver.from_conn_string(
                 self.state_file_path
@@ -71,13 +65,8 @@ class LangGraphRuntime(UiPathBaseRuntime):
 
                 processed_input = await input_processor.process()
 
-                # Set up tracing if available
                 callbacks: List[BaseCallbackHandler] = []
 
-                if self.context.job_id and self.context.tracing_enabled:
-                    tracer = AsyncUiPathTracer(context=self.context.trace_context)
-                    callbacks = [tracer]
-
                 graph_config: RunnableConfig = {
                     "configurable": {
                         "thread_id": (
@@ -185,11 +174,7 @@ class LangGraphRuntime(UiPathBaseRuntime):
                 UiPathErrorCategory.USER,
             ) from e
         finally:
-            if tracer is not None:
-                await tracer.wait_for_all_tracers()
-
-            if self.context.langsmith_tracing_enabled:
-                wait_for_all_tracers()
+            pass
 
     async def validate(self) -> None:
         """Validate runtime inputs."""

uipath_langchain/_cli/cli_dev.py

@@ -10,6 +10,7 @@ from uipath._cli._runtime._contracts import UiPathRuntimeFactory
 from uipath._cli._utils._console import ConsoleLogger
 from uipath._cli.middlewares import MiddlewareResult
 
+from .._tracing import _instrument_traceable_attributes
 from ._runtime._context import LangGraphRuntimeContext
 from ._runtime._runtime import LangGraphRuntime
 
@@ -24,6 +25,8 @@ def langgraph_dev_middleware(interface: Optional[str]) -> MiddlewareResult:
             runtime_factory = UiPathRuntimeFactory(
                 LangGraphRuntime, LangGraphRuntimeContext
             )
+
+            _instrument_traceable_attributes()
             runtime_factory.add_instrumentor(LangChainInstrumentor, get_current_span)
             app = UiPathDevTerminal(runtime_factory)
             asyncio.run(app.run_async())

uipath_langchain/_cli/cli_eval.py

@@ -1,7 +1,10 @@
 import asyncio
-from os import environ as env
 from typing import List, Optional
 
+from openinference.instrumentation.langchain import (
+    LangChainInstrumentor,
+    get_current_span,
+)
 from uipath._cli._evals._runtime import UiPathEvalContext, UiPathEvalRuntime
 from uipath._cli._runtime._contracts import (
     UiPathRuntimeFactory,
@@ -13,15 +16,15 @@ from uipath.eval._helpers import auto_discover_entrypoint
 from uipath_langchain._cli._runtime._context import LangGraphRuntimeContext
 from uipath_langchain._cli._runtime._runtime import LangGraphRuntime
 from uipath_langchain._cli._utils._graph import LangGraphConfig
+from uipath_langchain._tracing import (
+    LangChainExporter,
+    _instrument_traceable_attributes,
+)
 
 
 def langgraph_eval_middleware(
     entrypoint: Optional[str], eval_set: Optional[str], eval_ids: List[str], **kwargs
 ) -> MiddlewareResult:
-    # Add default env variables
-    env["UIPATH_REQUESTING_PRODUCT"] = "uipath-python-sdk"
-    env["UIPATH_REQUESTING_FEATURE"] = "langgraph-agent"
-
     config = LangGraphConfig()
     if not config.exists:
         return MiddlewareResult(
@@ -33,6 +36,8 @@ def langgraph_eval_middleware(
     eval_context.eval_ids = eval_ids
 
     try:
+        _instrument_traceable_attributes()
+
         runtime_entrypoint = entrypoint or auto_discover_entrypoint()
 
         def generate_runtime_context(
@@ -53,6 +58,11 @@ def langgraph_eval_middleware(
             ),
         )
 
+        if eval_context.job_id:
+            runtime_factory.add_span_exporter(LangChainExporter())
+
+        runtime_factory.add_instrumentor(LangChainInstrumentor, get_current_span)
+
         async def execute():
             async with UiPathEvalRuntime.from_eval_context(
                 factory=runtime_factory, context=eval_context

uipath_langchain/_cli/cli_run.py

@@ -1,10 +1,17 @@
 import asyncio
 import os
-from os import environ as env
 from typing import Optional
 
+from openinference.instrumentation.langchain import (
+    LangChainInstrumentor,
+    get_current_span,
+)
+from uipath._cli._runtime._contracts import (
+    UiPathRuntimeFactory,
+)
 from uipath._cli.middlewares import MiddlewareResult
 
+from .._tracing import LangChainExporter, _instrument_traceable_attributes
 from ._runtime._exception import LangGraphRuntimeError
 from ._runtime._runtime import (  # type: ignore[attr-defined]
     LangGraphRuntime,
@@ -24,23 +31,35 @@ def langgraph_run_middleware(
         )  # Continue with normal flow if no langgraph.json
 
     try:
-        # Add default env variables
-        env["UIPATH_REQUESTING_PRODUCT"] = "uipath-python-sdk"
-        env["UIPATH_REQUESTING_FEATURE"] = "langgraph-agent"
-
         context = LangGraphRuntimeContext.with_defaults(**kwargs)
         context.langgraph_config = config
         context.entrypoint = entrypoint
         context.input = input
         context.resume = resume
 
+        _instrument_traceable_attributes()
+
+        def generate_runtime(ctx: LangGraphRuntimeContext) -> LangGraphRuntime:
+            runtime = LangGraphRuntime(ctx)
+            # If not resuming and no job id, delete the previous state file
+            if not ctx.resume and ctx.job_id is None:
+                if os.path.exists(runtime.state_file_path):
+                    os.remove(runtime.state_file_path)
+            return runtime
+
         async def execute():
-            async with LangGraphRuntime.from_context(context) as runtime:
-                if context.resume is False and context.job_id is None:
-                    # Delete the previous graph state file at debug time
-                    if os.path.exists(runtime.state_file_path):
-                        os.remove(runtime.state_file_path)
-                await runtime.execute()
+            runtime_factory = UiPathRuntimeFactory(
+                LangGraphRuntime,
+                LangGraphRuntimeContext,
+                runtime_generator=generate_runtime,
+            )
+
+            if context.job_id:
+                runtime_factory.add_span_exporter(LangChainExporter())
+
+            runtime_factory.add_instrumentor(LangChainInstrumentor, get_current_span)
+
+            await runtime_factory.execute(context)
 
         asyncio.run(execute())
 

uipath_langchain/_tracing/__init__.py

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

uipath_langchain/_tracing/_instrument_traceable.py

@@ -0,0 +1,135 @@
+import importlib
+import logging
+import sys
+from typing import Any, Callable, Dict, List, Optional
+
+from uipath.tracing import traced
+
+# Original module and traceable function references
+original_langsmith: Any = None
+original_traceable: Any = None
+
+logger = logging.getLogger(__name__)
+
+
+# Apply the patch
+def _map_traceable_to_traced_args(
+    run_type: Optional[str] = None,
+    name: Optional[str] = None,
+    tags: Optional[List[str]] = None,
+    metadata: Optional[Dict[str, Any]] = None,
+    **kwargs: Any,
+) -> Dict[str, Any]:
+    """
+    Map LangSmith @traceable arguments to UiPath @traced() arguments.
+
+    Args:
+        run_type: Function type (tool, chain, llm, retriever, etc.)
+        name: Custom name for the traced function
+        tags: List of tags for categorization
+        metadata: Additional metadata dictionary
+        **kwargs: Additional arguments (ignored)
+
+    Returns:
+        Dict containing mapped arguments for @traced()
+    """
+    traced_args = {}
+
+    # Direct mappings
+    if name is not None:
+        traced_args["name"] = name
+
+    # Pass through run_type directly to UiPath @traced()
+    if run_type:
+        traced_args["run_type"] = run_type
+
+    # For span_type, we can derive from run_type or use a default
+    if run_type:
+        # Map run_type to appropriate span_type for OpenTelemetry
+        span_type_mapping = {
+            "tool": "tool_call",
+            "chain": "chain_execution",
+            "llm": "llm_call",
+            "retriever": "retrieval",
+            "embedding": "embedding",
+            "prompt": "prompt_template",
+            "parser": "output_parser",
+        }
+        traced_args["span_type"] = span_type_mapping.get(run_type, run_type)
+
+    # Note: UiPath @traced() doesn't support custom attributes directly
+    # Tags and metadata information is lost in the current mapping
+    # This could be enhanced in future versions
+
+    return traced_args
+
+
+def otel_traceable_adapter(
+    func: Optional[Callable[..., Any]] = None,
+    *,
+    run_type: Optional[str] = None,
+    name: Optional[str] = None,
+    tags: Optional[List[str]] = None,
+    metadata: Optional[Dict[str, Any]] = None,
+    **kwargs: Any,
+):
+    """
+    OTEL-based adapter that converts LangSmith @traceable decorator calls to UiPath @traced().
+
+    This function maintains the same interface as LangSmith's @traceable but uses
+    UiPath's OpenTelemetry-based tracing system underneath.
+
+    Args:
+        func: Function to be decorated (when used without parentheses)
+        run_type: Type of function (tool, chain, llm, etc.)
+        name: Custom name for tracing
+        tags: List of tags for categorization
+        metadata: Additional metadata dictionary
+        **kwargs: Additional arguments (for future compatibility)
+
+    Returns:
+        Decorated function or decorator function
+    """
+
+    def decorator(f: Callable[..., Any]) -> Callable[..., Any]:
+        # Map arguments to @traced() format
+        traced_args = _map_traceable_to_traced_args(
+            run_type=run_type, name=name, tags=tags, metadata=metadata, **kwargs
+        )
+
+        # Apply UiPath @traced() decorator
+        return traced(**traced_args)(f)
+
+    # Handle both @traceable and @traceable(...) usage patterns
+    if func is None:
+        # Called as @traceable(...) - return decorator
+        return decorator
+    else:
+        # Called as @traceable - apply decorator directly
+        return decorator(func)
+
+
+def _instrument_traceable_attributes():
+    """Apply the patch to langsmith module at import time."""
+    global original_langsmith, original_traceable
+
+    # Import the original module if not already done
+    if original_langsmith is None:
+        # Temporarily remove our custom module from sys.modules
+        if "langsmith" in sys.modules:
+            original_langsmith = sys.modules["langsmith"]
+            del sys.modules["langsmith"]
+
+        # Import the original module
+        original_langsmith = importlib.import_module("langsmith")
+
+        # Store the original traceable
+        original_traceable = original_langsmith.traceable
+
+        # Replace the traceable function with our patched version
+        original_langsmith.traceable = otel_traceable_adapter
+
+        # Put our modified module back
+        sys.modules["langsmith"] = original_langsmith
+
+    return original_langsmith

uipath_langchain/_tracing/_oteladapter.py

@@ -0,0 +1,222 @@
+import json
+import logging
+from typing import Any, Dict, List
+
+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
+    }
+
+    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 _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
+
+        logger.info(f"Processing span: {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)
+
+        logger.info(f"Transformed span: {span_data}")
+        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,
+        )

uipath_langchain/{tracers → _tracing}/_utils.py

@@ -1,6 +1,4 @@
-import datetime
 import logging
-from zoneinfo import ZoneInfo
 
 
 class IgnoreSpecificUrl(logging.Filter):
@@ -28,25 +26,3 @@ def _setup_tracer_httpx_logging(url: str):
     # Create a custom logger for httpx
     # Add the custom filter to the root logger
     logging.getLogger("httpx").addFilter(IgnoreSpecificUrl(url))
-
-
-def _simple_serialize_defaults(obj):
-    if hasattr(obj, "model_dump"):
-        return obj.model_dump(exclude_none=True, mode="json")
-    if hasattr(obj, "dict"):
-        return obj.dict()
-    if hasattr(obj, "to_dict"):
-        return obj.to_dict()
-
-    if isinstance(obj, (set, tuple)):
-        if hasattr(obj, "_asdict") and callable(obj._asdict):
-            return obj._asdict()
-        return list(obj)
-
-    if isinstance(obj, datetime.datetime):
-        return obj.isoformat()
-
-    if isinstance(obj, (datetime.timezone, ZoneInfo)):
-        return obj.tzname(None)
-
-    return str(obj)

uipath_langchain/_utils/__init__.py

@@ -1,4 +1,3 @@
-from ..tracers._instrument_traceable import _instrument_traceable_attributes
 from ._request_mixin import UiPathRequestMixin
 
-__all__ = ["UiPathRequestMixin", "_instrument_traceable_attributes"]
+__all__ = ["UiPathRequestMixin"]

{uipath_langchain-0.0.131.dist-info → uipath_langchain-0.0.132.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath-langchain
-Version: 0.0.131
+Version: 0.0.132
 Summary: UiPath Langchain
 Project-URL: Homepage, https://uipath.com
 Project-URL: Repository, https://github.com/UiPath/uipath-langchain-python
@@ -25,7 +25,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.54
+Requires-Dist: uipath<2.2.0,>=2.1.56
 Provides-Extra: langchain
 Description-Content-Type: text/markdown