uipath-langchain 0.0.142__tar.gz → 0.0.143__tar.gz

{uipath_langchain-0.0.142 → uipath_langchain-0.0.143}/PKG-INFO

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

{uipath_langchain-0.0.142 → uipath_langchain-0.0.143}/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "uipath-langchain"
-version = "0.0.142"
+version = "0.0.143"
 description = "UiPath Langchain"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.10"
 dependencies = [
-    "uipath>=2.1.101, <2.2.0",
+    "uipath>=2.1.103, <2.2.0",
     "langgraph>=0.5.0, <0.7.0",
     "langchain-core>=0.3.34",
     "langgraph-checkpoint-sqlite>=2.0.3",

{uipath_langchain-0.0.142 → uipath_langchain-0.0.143}/src/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-0.0.142 → uipath_langchain-0.0.143}/src/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-0.0.142 → uipath_langchain-0.0.143}/src/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-0.0.143/src/uipath_langchain/_tracing/__init__.py

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

uipath_langchain-0.0.143/testcases/common/trace_assert.py

@@ -0,0 +1,130 @@
+"""
+Simple trace assertion - just check that expected spans exist with required attributes.
+Much simpler than the tree-based approach.
+"""
+
+import json
+from typing import List, Dict, Any
+
+
+def load_traces(traces_file: str) -> List[Dict[str, Any]]:
+    """Load traces from a JSONL file."""
+    traces = []
+    with open(traces_file, 'r', encoding='utf-8') as f:
+        for line in f:
+            if line.strip():
+                traces.append(json.loads(line))
+    return traces
+
+
+def load_expected_traces(expected_file: str) -> List[Dict[str, Any]]:
+    """Load expected trace definitions from a JSON file."""
+    with open(expected_file, 'r', encoding='utf-8') as f:
+        data = json.load(f)
+    return data.get('required_spans', [])
+
+
+def get_attributes(span: Dict[str, Any]) -> Dict[str, Any]:
+    """Parse attributes from a span."""
+    attributes_str = span.get('Attributes', '{}')
+    try:
+        return json.loads(attributes_str)
+    except json.JSONDecodeError:
+        return {}
+
+
+def matches_value(expected_value: Any, actual_value: Any) -> bool:
+    """
+    Check if an actual value matches the expected value.
+
+    Supports:
+    - List of possible values: ["value1", "value2"]
+    - Wildcard: "*" (any value accepted)
+    - Exact match: "value"
+    """
+    # Wildcard - accept any value
+    if expected_value == "*":
+        return True
+
+    # List of possible values
+    if isinstance(expected_value, list):
+        return actual_value in expected_value
+
+    # Exact match
+    return expected_value == actual_value
+
+
+def matches_expected(span: Dict[str, Any], expected: Dict[str, Any]) -> bool:
+    """Check if a span matches the expected definition."""
+    # Check name - can be a string or list of possible names
+    expected_name = expected.get('name')
+    actual_name = span.get('Name')
+
+    if isinstance(expected_name, list):
+        if actual_name not in expected_name:
+            return False
+    elif expected_name != actual_name:
+        return False
+
+    # Check span type if specified
+    if 'span_type' in expected:
+        if span.get('SpanType') != expected['span_type']:
+            return False
+
+    # Check attributes if specified
+    if 'attributes' in expected:
+        actual_attrs = get_attributes(span)
+        for key, expected_value in expected['attributes'].items():
+            if key not in actual_attrs:
+                return False
+            # Use flexible value matching
+            if not matches_value(expected_value, actual_attrs[key]):
+                return False
+
+    return True
+
+
+def assert_traces(traces_file: str, expected_file: str) -> None:
+    """
+    Assert that all expected traces exist in the traces file.
+
+    Args:
+        traces_file: Path to the traces.jsonl file
+        expected_file: Path to the expected_traces.json file
+
+    Raises:
+        AssertionError: If any expected trace is not found
+    """
+    traces = load_traces(traces_file)
+    expected_spans = load_expected_traces(expected_file)
+
+    print(f"Loaded {len(traces)} traces from {traces_file}")
+    print(f"Checking {len(expected_spans)} expected spans...")
+
+    missing_spans = []
+
+    for expected in expected_spans:
+        # Find a matching span
+        found = False
+        for span in traces:
+            if matches_expected(span, expected):
+                found = True
+                print(f"✓ Found span: {expected['name']}")
+                break
+
+        if not found:
+            missing_spans.append(expected['name'])
+            print(f"✗ Missing span: {expected['name']}")
+
+    if missing_spans:
+        raise AssertionError(
+            f"Missing expected spans: {', '.join(missing_spans)}\n"
+            f"Expected {len(expected_spans)} spans, found {len(expected_spans) - len(missing_spans)}"
+        )
+
+    print(f"\n✓ All {len(expected_spans)} expected spans found!")
+
+
+if __name__ == "__main__":
+    # Example usage
+    assert_traces(".uipath/traces.jsonl", "expected_traces.json")

{uipath_langchain-0.0.142 → uipath_langchain-0.0.143}/testcases/common/validate_output.sh

@@ -22,14 +22,18 @@ debug_print_uipath_output() {
     fi
 }
 
-validate_output() {
-    echo "Printing output file for validation..."
-    debug_print_uipath_output
-
-    echo "Validating output..."
-    python src/assert.py || { echo "Validation failed!"; exit 1; }
-
-    echo "Testcase completed successfully."
+# Run assertions from the testcase's src directory
+run_assertions() {
+    echo "Running assertions..."
+    if [ -f "src/assert.py" ]; then
+        # Use the Python from the virtual environment
+        # Prepend the common directory to the python path so it can be resolved
+        PYTHONPATH="../common:$PYTHONPATH" python src/assert.py
+    else
+        echo "assert.py not found in src directory!"
+        exit 1
+    fi
 }
 
-validate_output
+debug_print_uipath_output
+run_assertions