uipath-langchain 0.1.24__py3-none-any.whl → 0.1.34__py3-none-any.whl

uipath_langchain/runtime/schema.py

@@ -1,3 +1,4 @@
+from collections.abc import Iterable
 from dataclasses import dataclass
 from typing import Any, Callable, TypeVar
 
@@ -7,6 +8,8 @@ from langchain_core.runnables.base import Runnable
 from langchain_core.runnables.graph import Graph, Node
 from langgraph.graph.state import CompiledStateGraph
 from langgraph.prebuilt import ToolNode
+from langgraph.pregel._read import PregelNode
+from langgraph.pregel._write import ChannelWrite, ChannelWriteEntry
 from uipath.runtime.schema import (
     UiPathRuntimeEdge,
     UiPathRuntimeGraph,
@@ -29,28 +32,83 @@ class SchemaDetails:
 
 
 def _unwrap_runnable_callable(
-    runnable: Runnable[Any, Any], target_type: type[T]
+    runnable: Runnable[Any, Any],
+    target_type: type[T],
+    _seen: set[int] | None = None,
 ) -> T | None:
-    """Unwrap a RunnableCallable to find an instance of the target type.
-
-    Args:
-        runnable: The runnable to unwrap
-        target_type: The type to search for (e.g., BaseChatModel)
-
-    Returns:
-        Instance of target_type if found in the closure, None otherwise
+    """Try to find an instance of target_type (e.g., BaseChatModel)
+    inside a Runnable.
+
+    Handles:
+    - Direct model runnables
+    - LangGraph RunnableCallable
+    - LangChain function runnables (RunnableLambda, etc.)
+    - RunnableBinding / RunnableSequence with nested steps
     """
     if isinstance(runnable, target_type):
         return runnable
 
+    if _seen is None:
+        _seen = set()
+    obj_id = id(runnable)
+    if obj_id in _seen:
+        return None
+    _seen.add(obj_id)
+
+    func: Callable[..., Any] | None = None
+
+    # 1) LangGraph internal RunnableCallable
     if RunnableCallable is not None and isinstance(runnable, RunnableCallable):
-        func: Callable[..., Any] | None = getattr(runnable, "func", None)
-        if func is not None and hasattr(func, "__closure__") and func.__closure__:
-            for cell in func.__closure__:
-                if hasattr(cell, "cell_contents"):
-                    content = cell.cell_contents
-                    if isinstance(content, target_type):
-                        return content
+        func = getattr(runnable, "func", None)
+
+    # 2) Generic LangChain function-wrapping runnables
+    if func is None:
+        for attr_name in ("func", "_func", "afunc", "_afunc"):
+            maybe = getattr(runnable, attr_name, None)
+            if callable(maybe):
+                func = maybe
+                break
+
+    # 3) Look into the function closure for a model
+    if func is not None:
+        closure = getattr(func, "__closure__", None) or ()
+        for cell in closure:
+            content = getattr(cell, "cell_contents", None)
+            if isinstance(content, target_type):
+                return content
+            if isinstance(content, Runnable):
+                found = _unwrap_runnable_callable(content, target_type, _seen)
+                if found is not None:
+                    return found
+
+    # 4) Deep-scan attributes, including nested runnables / containers
+    def _scan_value(value: Any) -> T | None:
+        if isinstance(value, target_type):
+            return value
+        if isinstance(value, Runnable):
+            return _unwrap_runnable_callable(value, target_type, _seen)
+        if isinstance(value, dict):
+            for v in value.values():
+                found = _scan_value(v)
+                if found is not None:
+                    return found
+        # Handle lists, tuples, sets, etc. but avoid strings/bytes
+        if isinstance(value, Iterable) and not isinstance(value, (str, bytes)):
+            for item in value:
+                found = _scan_value(item)
+                if found is not None:
+                    return found
+        return None
+
+    try:
+        attrs = vars(runnable)
+    except TypeError:
+        attrs = {}
+
+    for value in attrs.values():
+        found = _scan_value(value)
+        if found is not None:
+            return found
 
     return None
 
@@ -193,7 +251,6 @@ def get_graph_schema(
     nodes: list[UiPathRuntimeNode] = []
     for node_id, node in graph.nodes.items():
         subgraph: UiPathRuntimeGraph | None = subgraphs_dict.get(node_id)
-
         nodes.append(
             UiPathRuntimeNode(
                 id=node.id,
@@ -204,15 +261,51 @@ def get_graph_schema(
             )
         )
 
+    # Use a set to track unique edges (source, target)
+    seen_edges: set[tuple[str, str]] = set()
     edges: list[UiPathRuntimeEdge] = []
+
+    # First, add edges from graph.edges (static edges)
     for edge in graph.edges:
-        edges.append(
-            UiPathRuntimeEdge(
-                source=edge.source,
-                target=edge.target,
-                label=getattr(edge, "data", None) or getattr(edge, "label", None),
+        edge_tuple = (edge.source, edge.target)
+        if edge_tuple not in seen_edges:
+            seen_edges.add(edge_tuple)
+            edges.append(
+                UiPathRuntimeEdge(
+                    source=edge.source,
+                    target=edge.target,
+                    label=getattr(edge, "data", None) or getattr(edge, "label", None),
+                )
             )
-        )
+
+    # Build a map of channel -> target node
+    channel_to_target: dict[str, str] = {}
+    node_spec: PregelNode
+    for node_name, node_spec in compiled_graph.nodes.items():
+        for trigger in node_spec.triggers:
+            if isinstance(trigger, str) and trigger.startswith("branch:to:"):
+                channel_to_target[trigger] = node_name
+
+    # Extract edges by looking at what each node writes to (dynamic edges from Command)
+    for source_name, node_spec in compiled_graph.nodes.items():
+        writer: Runnable[Any, Any]
+        for writer in node_spec.writers:
+            if isinstance(writer, ChannelWrite):
+                write_entry: Any
+                for write_entry in writer.writes:
+                    if isinstance(write_entry, ChannelWriteEntry) and isinstance(
+                        write_entry.channel, str
+                    ):
+                        target = channel_to_target.get(write_entry.channel)
+                        if target:
+                            edge_tuple = (source_name, target)
+                            if edge_tuple not in seen_edges:
+                                seen_edges.add(edge_tuple)
+                                edges.append(
+                                    UiPathRuntimeEdge(
+                                        source=source_name, target=target, label=None
+                                    )
+                                )
 
     return UiPathRuntimeGraph(nodes=nodes, edges=edges)
 

{uipath_langchain-0.1.24.dist-info → uipath_langchain-0.1.34.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: uipath-langchain
-Version: 0.1.24
-Summary: UiPath Langchain
+Version: 0.1.34
+Summary: Python SDK that enables developers to build and deploy LangGraph agents to the UiPath Cloud Platform
 Project-URL: Homepage, https://uipath.com
 Project-URL: Repository, https://github.com/UiPath/uipath-langchain-python
 Project-URL: Documentation, https://uipath.github.io/uipath-python/
@@ -13,29 +13,32 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Build Tools
 Requires-Python: >=3.11
+Requires-Dist: aiosqlite==0.21.0
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: jsonpath-ng>=1.7.0
 Requires-Dist: jsonschema-pydantic-converter>=0.1.5
 Requires-Dist: langchain-core<2.0.0,>=1.0.0
+Requires-Dist: langchain-mcp-adapters==0.2.1
 Requires-Dist: langchain-openai<2.0.0,>=1.0.0
 Requires-Dist: langchain<2.0.0,>=1.0.0
 Requires-Dist: langgraph-checkpoint-sqlite<4.0.0,>=3.0.0
 Requires-Dist: langgraph<2.0.0,>=1.0.0
+Requires-Dist: mcp==1.24.0
 Requires-Dist: openinference-instrumentation-langchain>=0.1.56
 Requires-Dist: pydantic-settings>=2.6.0
 Requires-Dist: python-dotenv>=1.0.1
-Requires-Dist: uipath<2.3.0,>=2.2.28
+Requires-Dist: uipath<2.3.0,>=2.2.35
 Provides-Extra: bedrock
 Requires-Dist: boto3-stubs>=1.41.4; extra == 'bedrock'
 Requires-Dist: langchain-aws>=0.2.35; extra == 'bedrock'
 Provides-Extra: vertex
-Requires-Dist: langchain-community>=0.4.1; extra == 'vertex'
-Requires-Dist: langchain-google-vertexai>=2.1.2; extra == 'vertex'
-Requires-Dist: types-protobuf>=6.32.1.20251105; extra == 'vertex'
+Requires-Dist: google-generativeai>=0.8.0; extra == 'vertex'
+Requires-Dist: langchain-google-genai>=2.0.0; extra == 'vertex'
 Description-Content-Type: text/markdown
 
 # UiPath LangChain Python SDK
 
+[![PyPI - Version](https://img.shields.io/pypi/v/uipath-langchain)](https://pypi.org/project/uipath-langchain/)
 [![PyPI downloads](https://img.shields.io/pypi/dm/uipath-langchain.svg)](https://pypi.org/project/uipath-langchain/)
 [![Python versions](https://img.shields.io/pypi/pyversions/uipath-langchain.svg)](https://pypi.org/project/uipath-langchain/)
 

{uipath_langchain-0.1.24.dist-info → uipath_langchain-0.1.34.dist-info}/RECORD

@@ -11,51 +11,54 @@ uipath_langchain/_resources/REQUIRED_STRUCTURE.md,sha256=BRmWWFtM0qNXj5uumALVxq9
 uipath_langchain/_tracing/__init__.py,sha256=C2dRvQ2ynxCmyICgE-rJHimWKEcFRME_o9gfX84Mb3Y,123
 uipath_langchain/_tracing/_instrument_traceable.py,sha256=cIxtDvlrPxVSZLOvpl571HxFO3wg7pNem4rLUuMI2Vg,4276
 uipath_langchain/_utils/__init__.py,sha256=-w-4TD9ZnJDCpj4VIPXhJciukrmDJJbmnOFnhAkAaEU,81
-uipath_langchain/_utils/_request_mixin.py,sha256=GvZruUGqL-8ykj9FK2XB5GFpkiV23nhfPKY1ozbguLA,30924
-uipath_langchain/_utils/_settings.py,sha256=RMVVOdskShghz6mNLmXhHMmdwOiceAYDe8C_qPKedSk,3071
+uipath_langchain/_utils/_request_mixin.py,sha256=VjOyH9fS8WhKEXufoAoSRhfaY1jumLacRwBsbaRsiy8,31307
+uipath_langchain/_utils/_settings.py,sha256=6E4yGzrEj3P3DcqCx_Y_lHQREQRfBm0yH1mSitiSJIU,3188
 uipath_langchain/_utils/_sleep_policy.py,sha256=e9pHdjmcCj4CVoFM1jMyZFelH11YatsgWfpyrfXzKBQ,1251
 uipath_langchain/agent/exceptions/__init__.py,sha256=GFh8mtsoKYghTHe93rRbIycWOW8dPt0okQjZuc2N-Hc,158
 uipath_langchain/agent/exceptions/exceptions.py,sha256=G7LdeQ9uMljLGTlixWBHvNJ1ULtUIDIkzApjfbsF6_0,216
-uipath_langchain/agent/guardrails/__init__.py,sha256=gWxPFhbxqiBM6phdYeuR2EMVb-qwB71Ny16SzNAQ5kw,610
-uipath_langchain/agent/guardrails/guardrail_nodes.py,sha256=Wkxb1hnxunjQHalPRQHOkGWIh4HPjFHPzYCByQyNUgE,3772
-uipath_langchain/agent/guardrails/guardrails_factory.py,sha256=gkOkNO5uyhNBt1y7j4V3Ao-u1fh1gpTji3-N2bRS_l4,2248
-uipath_langchain/agent/guardrails/guardrails_subgraph.py,sha256=nBOm2U07zPxoE699Iqe4YZECo43C3BQ4uXbj55oUUCE,8739
-uipath_langchain/agent/guardrails/types.py,sha256=Z5TS6EHnaanie3s1yfGhE4JXoFKuu01ESsbeFbbPie4,561
-uipath_langchain/agent/guardrails/actions/__init__.py,sha256=PiE5Eb39JYWrQG481aREV2I0tNMPEi7VtChBy7ZJqcc,253
-uipath_langchain/agent/guardrails/actions/base_action.py,sha256=7Q8ArFLYkbTVsKinCDoU1TAI-ki0JLwTc3XknE8dxgA,673
-uipath_langchain/agent/guardrails/actions/block_action.py,sha256=5qBlwqxJdIsTvJ2h5m0N2_p9cIAcWeWas30GsxiBte4,1330
-uipath_langchain/agent/guardrails/actions/escalate_action.py,sha256=O2IY0FiVBQyfiNszzR2JgP1dRJC7hb03eSUIqpW9BFo,9491
-uipath_langchain/agent/guardrails/actions/log_action.py,sha256=ADvP0Sbx3oRbgI5KQfXyZTBUB0CT40QAqY4q8KzswVw,1924
+uipath_langchain/agent/guardrails/__init__.py,sha256=2lM-DFLp8oHR6qpkZy8_E93RL_tXKhtzbbsL00_m6TA,114
+uipath_langchain/agent/guardrails/guardrail_nodes.py,sha256=GNfgz45RY2Ic_xchB7KvP3asURxAK9ZBbs8Z7VE_Pac,9491
+uipath_langchain/agent/guardrails/guardrails_factory.py,sha256=4_YvYi13CdVr5qxpwkDpnXjlGe6L4XNmnbMeu9_BVUM,8998
+uipath_langchain/agent/guardrails/types.py,sha256=guVi19x7x5atcaXTUWK_c9O3bP6HfmnX_1Er1ErsnSE,169
+uipath_langchain/agent/guardrails/utils.py,sha256=dmlfDG_tBzbGhfOJrfhysaCAuVHL0GEEzkXqFQDen1M,4652
+uipath_langchain/agent/guardrails/actions/__init__.py,sha256=o_xoSaqcaOM33CRldvmnmux66BIK9fbcv994lB0m1-U,313
+uipath_langchain/agent/guardrails/actions/base_action.py,sha256=89POG1KQ0x1KPXKP8jT42M04SYoizp5E_co2-Ykq8gc,710
+uipath_langchain/agent/guardrails/actions/block_action.py,sha256=AMgpeHG41XbRV6bdFX78OLLJ-CTJ1lez6ai6s60zG4M,1374
+uipath_langchain/agent/guardrails/actions/escalate_action.py,sha256=JAGIBLB9FHMa104pTa9ddKi6wW6Ll22qjSZBMzqsYvk,18050
+uipath_langchain/agent/guardrails/actions/filter_action.py,sha256=PbHzz8_vZZ4X-kbHs9-ab3RFBXESlS5GOBEs8vSB-Sg,2185
+uipath_langchain/agent/guardrails/actions/log_action.py,sha256=1nknvqYFBmBFACWLhtreU9Uun40_H2ETsg9c6-IacGM,1968
 uipath_langchain/agent/react/__init__.py,sha256=BhRWUMZ9yLtBr7SyRwS-XMKG9o84DROyedCMpE6j1RU,362
-uipath_langchain/agent/react/agent.py,sha256=A5edIf7C43wCZZzx3FSQoAFION7RBHaz5c4KE9iadSU,3788
-uipath_langchain/agent/react/constants.py,sha256=B2yqryh242DETslaRYacUPbVdpjvvApjsBira_qhQwk,61
+uipath_langchain/agent/react/agent.py,sha256=Foz9HagXh3lA-QDZSx6a302JAJnudL7YQ1njLShWSGA,4552
+uipath_langchain/agent/react/constants.py,sha256=yRi3sRxl2CSlshcn_ooWRN3TCcKdRMxJIwmiUQpAtFE,38
 uipath_langchain/agent/react/init_node.py,sha256=plhyTecBOBsm-YHfi73ZN3pJhe24tpCMr53IfRzN6SA,566
-uipath_langchain/agent/react/llm_node.py,sha256=4q8JcAwzELyyBaYTaFtx5HP9neq_5UolfFsuqsh4pso,1468
-uipath_langchain/agent/react/router.py,sha256=yEKTa8tAeZnDxh_7AsJRBmg7Ygb7mSk0b0g0gPrvTI8,3616
+uipath_langchain/agent/react/llm_node.py,sha256=Qy9A_s7L5IKfHXbhT8PChyUWYB-RRUjkW49C958wCRs,2484
+uipath_langchain/agent/react/router.py,sha256=-I3Ym0-FLQfg1J0v9Wibb0Xq7rTN73_FLsjVxa31aTQ,4080
 uipath_langchain/agent/react/terminate_node.py,sha256=G2k2xMgocfNC13RjF9A2Kea6KiPINmdnxiZHQCS_fAY,2734
-uipath_langchain/agent/react/types.py,sha256=Mr1LYP6pUwDdxZYdtwtmcic4w8RcMGkXSqm6BJon7QQ,909
-uipath_langchain/agent/react/utils.py,sha256=HVaTdEdARIbGhQ2hA1kWdacmtOERYipKiqaLmu06usA,1278
+uipath_langchain/agent/react/types.py,sha256=oZtWQiOwmghWUftrC0BzP5emNFq9uvWB2jUYFcWILPs,1417
+uipath_langchain/agent/react/utils.py,sha256=EhrbvnkrftR79LTKHBVBv9e7oBzs0xgGXhtk_bLF_fQ,1285
+uipath_langchain/agent/react/guardrails/guardrails_subgraph.py,sha256=NDtdngT6Z5amQzZMscX3rW2vupPSrY7hMlACukqQovk,11134
 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=4QVwzP8gFM8pPJwRsJIIVElPOrQLeGzhue-zv4aVCtM,464
+uipath_langchain/agent/tools/__init__.py,sha256=0ptYdkW3zIjdQljY7fsVKZKI-83lyprhCBoMJFlhgtg,527
 uipath_langchain/agent/tools/context_tool.py,sha256=oPvMVNxeb5q6xVlSScvMGcpT1wOUlFGOwsnFoP_dbuE,1772
 uipath_langchain/agent/tools/escalation_tool.py,sha256=VYNUEjfNMw3k2ESWMtn3RZ66WYRJcBvXpQaGzMXWCSw,3819
 uipath_langchain/agent/tools/integration_tool.py,sha256=EcCJ2g6NyyJj6sQeVyzLY1JL3sAtTAWu2dwVvWOkHgo,6555
+uipath_langchain/agent/tools/mcp_tool.py,sha256=NjSWoCYXixIheLWqYUCiYdnkI1umHIvTEBXJphg_WTM,3202
 uipath_langchain/agent/tools/process_tool.py,sha256=3RkqqeXzmm8mSNaesEQKST1SvB8UEl2H69Qyh0lBv1c,1696
 uipath_langchain/agent/tools/static_args.py,sha256=_bS-ENdVNxSQ74fi6H0bk7FG9QVZTqitM6es3eLsGq4,4521
 uipath_langchain/agent/tools/structured_tool_with_output_type.py,sha256=9EZB1WlVt7FFBf20jX3Av9vJf9MaDNCnKLUhMBIrtLQ,354
 uipath_langchain/agent/tools/tool_factory.py,sha256=o0bd_IMIIsVc0d6gODf3Lk-yiG6eXC9o9NYMgumY4GI,1419
 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=fAoK-hKuShWDV9tbinJU9TSKRBG2wQQwK3UKZTAyMVM,254
-uipath_langchain/chat/bedrock.py,sha256=eonXWnGh3m9cmMifP49fnXsjmrRQLd3Wda5fFa11568,5863
-uipath_langchain/chat/gemini.py,sha256=Zlz5KVoHdzlemzFTmFVjKCloaFo2lMiBbBq9MCJ9Lds,11903
+uipath_langchain/chat/__init__.py,sha256=YlbvzwZz2269kQK438YK8PDIpt5EoRukmpedazpSHHY,387
+uipath_langchain/chat/bedrock.py,sha256=-e1Spix8QizWJf7qLPTJ1-Bs6QLmAHF4VvZSb2kn_Uw,6662
 uipath_langchain/chat/mapper.py,sha256=XsWFbg6U4kW5Yj_ANvYUZ4HICybHcv9qWdfPPU8UTKA,11950
 uipath_langchain/chat/models.py,sha256=cbIRw-YhEvQcgt0DVTHc84lKIjeDhsQo5oxvBz9luD0,18168
-uipath_langchain/chat/openai.py,sha256=M36pSDeWwnfO5EXcCsYnjfZ5C5jfko6ng_87qS-Z5tA,4594
-uipath_langchain/chat/supported_models.py,sha256=KrTO8rex8sjC2NVUnuDoLLvz__ROKtxEtCXSk1xXTOU,1373
+uipath_langchain/chat/openai.py,sha256=laLJbSoviyD1HdHRGL7zmGuDZngFZvQb93yNcSoR3r4,5829
+uipath_langchain/chat/supported_models.py,sha256=KttS2PZZzh_-fPub-bAenq2V0LfqCUPMmBtQnRP0Lik,1561
+uipath_langchain/chat/vertex.py,sha256=KX584HDzW8x1x-BjfTXpYnl9ofAAVNsphto29O7uoD0,10428
 uipath_langchain/embeddings/__init__.py,sha256=QICtYB58ZyqFfDQrEaO8lTEgAU5NuEKlR7iIrS0OBtc,156
-uipath_langchain/embeddings/embeddings.py,sha256=MGUtnT0pkj97IjHKhROSd786g3ONwwkjgfQBSq3ayhc,6888
+uipath_langchain/embeddings/embeddings.py,sha256=EeVWEpG-DhfewiHJAHNrUMtzIS2oF6rLUPNRtfRg0_8,7137
 uipath_langchain/retrievers/__init__.py,sha256=rOn7PyyHgZ4pMnXWPkGqmuBmx8eGuo-Oyndo7Wm9IUU,108
 uipath_langchain/retrievers/context_grounding_retriever.py,sha256=eVDt49dcyBVM8wgBn5FmaXK8gfgsOaNBC8tYnebiQeQ,2201
 uipath_langchain/runtime/__init__.py,sha256=h4pDyPy8kAYWvSohG3qFmx-bTVTIj1spbMqc7kO674E,1017
@@ -65,12 +68,12 @@ uipath_langchain/runtime/errors.py,sha256=iepiILaDtanusvyYBQSRsPDmKB-6GB94OXKATw
 uipath_langchain/runtime/factory.py,sha256=_fbYViNg6uuApUZiEJjYHQU2noH5dqFBTXWEPy-Oj_k,11043
 uipath_langchain/runtime/graph.py,sha256=1h_eaXkyN0G43BS0WUMoK_UNDao8jrmcyJqGVgwVEjM,5513
 uipath_langchain/runtime/runtime.py,sha256=cK7hewu6Mv8rQbUir03JgPUgv-zqVtYQ1YOfoMLB89I,16904
-uipath_langchain/runtime/schema.py,sha256=sbgf4Z_2T_r2sv1e8uYsAExZ1PNeVCODB9Hm4HZ4gQc,11547
+uipath_langchain/runtime/schema.py,sha256=BKtWYVVpK2FfdWO75iQEc-md7qh5z8DqsRPsbHJ_WBI,15130
 uipath_langchain/runtime/storage.py,sha256=Vem6kz0yGIUgIhTByzguvNOkb6N40b_ba8jcbjGo_eY,3954
 uipath_langchain/vectorstores/__init__.py,sha256=w8qs1P548ud1aIcVA_QhBgf_jZDrRMK5Lono78yA8cs,114
 uipath_langchain/vectorstores/context_grounding_vectorstore.py,sha256=SfRvIenOzn4r7jng_I9GIyknyeDx2hdW63O1rZY-ZLQ,8407
-uipath_langchain-0.1.24.dist-info/METADATA,sha256=STmAiU3rEotgAApOuXj8bk4p3V6jOJcw3JVo7zEAOrA,5658
-uipath_langchain-0.1.24.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-uipath_langchain-0.1.24.dist-info/entry_points.txt,sha256=Wptt1FbvhcDzNQxDlu2Lt1ngBOdDIFPlM1p8WzXf6wQ,171
-uipath_langchain-0.1.24.dist-info/licenses/LICENSE,sha256=JDpt-uotAkHFmxpwxi6gwx6HQ25e-lG4U_Gzcvgp7JY,1063
-uipath_langchain-0.1.24.dist-info/RECORD,,
+uipath_langchain-0.1.34.dist-info/METADATA,sha256=Ntt7gH8D0fLKzbpKGWqW5iIu6O--cXe2J-eal5WPSDk,5890
+uipath_langchain-0.1.34.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+uipath_langchain-0.1.34.dist-info/entry_points.txt,sha256=Wptt1FbvhcDzNQxDlu2Lt1ngBOdDIFPlM1p8WzXf6wQ,171
+uipath_langchain-0.1.34.dist-info/licenses/LICENSE,sha256=JDpt-uotAkHFmxpwxi6gwx6HQ25e-lG4U_Gzcvgp7JY,1063
+uipath_langchain-0.1.34.dist-info/RECORD,,

uipath_langchain/chat/gemini.py

@@ -1,330 +0,0 @@
-import logging
-import os
-from typing import Optional, Union
-
-import aiohttp
-from pydantic import Field
-from uipath.utils import EndpointManager
-
-from .supported_models import GeminiModels
-
-logger = logging.getLogger(__name__)
-
-
-def _check_vertex_dependencies() -> None:
-    """Check if required dependencies for UiPathChatVertex are installed."""
-    import importlib.util
-
-    missing_packages = []
-
-    if importlib.util.find_spec("langchain_google_vertexai") is None:
-        missing_packages.append("langchain-google-vertexai")
-
-    if importlib.util.find_spec("langchain_community") is None:
-        missing_packages.append("langchain-community")
-
-    if missing_packages:
-        packages_str = ", ".join(missing_packages)
-        raise ImportError(
-            f"The following packages are required to use UiPathChatVertex: {packages_str}\n"
-            "Please install them using one of the following methods:\n\n"
-            "  # Using pip:\n"
-            f"  pip install uipath-langchain[vertex]\n\n"
-            "  # Using uv:\n"
-            f"  uv add 'uipath-langchain[vertex]'\n\n"
-        )
-
-
-_check_vertex_dependencies()
-
-from google.auth.credentials import AnonymousCredentials
-from google.cloud.aiplatform_v1.services.prediction_service import (
-    PredictionServiceAsyncClient as v1PredictionServiceAsyncClient,
-)
-from google.cloud.aiplatform_v1.services.prediction_service import (
-    PredictionServiceClient as v1PredictionServiceClient,
-)
-from google.cloud.aiplatform_v1beta1.services.prediction_service import (
-    PredictionServiceAsyncClient as v1beta1PredictionServiceAsyncClient,
-)
-from google.cloud.aiplatform_v1beta1.services.prediction_service import (
-    PredictionServiceClient as v1beta1PredictionServiceClient,
-)
-from google.cloud.aiplatform_v1beta1.services.prediction_service.transports.base import (
-    PredictionServiceTransport,
-)
-from google.cloud.aiplatform_v1beta1.services.prediction_service.transports.rest import (
-    PredictionServiceRestTransport,
-)
-from langchain_community.utilities.vertexai import (
-    get_client_info,
-)
-from langchain_google_vertexai import ChatVertexAI
-
-
-class CustomPredictionServiceRestTransport(PredictionServiceRestTransport):
-    def __init__(self, llmgw_url: str, custom_headers: dict[str, str], **kwargs):
-        self.llmgw_url = llmgw_url
-        self.custom_headers = custom_headers or {}
-
-        kwargs.setdefault("credentials", AnonymousCredentials())
-        super().__init__(**kwargs)
-
-        original_request = self._session.request
-
-        def redirected_request(method, url, **kwargs_inner):
-            headers = kwargs_inner.pop("headers", {})
-            headers.update(self.custom_headers)
-
-            is_streaming = kwargs_inner.get("stream", False)
-            headers["X-UiPath-Streaming-Enabled"] = "true" if is_streaming else "false"
-
-            return original_request(
-                method, self.llmgw_url, headers=headers, **kwargs_inner
-            )
-
-        self._session.request = redirected_request  # type: ignore[method-assign, assignment]
-
-
-class CustomPredictionServiceRestAsyncTransport:
-    """
-    Custom async transport for calling UiPath LLM Gateway.
-
-    Uses aiohttp for REST/HTTP communication instead of gRPC.
-    Handles both regular and streaming responses from the gateway.
-    """
-
-    def __init__(self, llmgw_url: str, custom_headers: dict[str, str], **kwargs):
-        self.llmgw_url = llmgw_url
-        self.custom_headers = custom_headers or {}
-
-    def _serialize_request(self, request) -> str:
-        """Convert proto-plus request to JSON string."""
-        import json
-
-        from proto import (  # type: ignore[import-untyped]
-            Message as ProtoMessage,
-        )
-
-        if isinstance(request, ProtoMessage):
-            request_dict = type(request).to_dict(
-                request, preserving_proto_field_name=False
-            )
-            return json.dumps(request_dict)
-        else:
-            from google.protobuf.json_format import MessageToJson
-
-            return MessageToJson(request, preserving_proto_field_name=False)
-
-    def _get_response_class(self, request):
-        """Get the response class corresponding to the request class."""
-        import importlib
-
-        response_class_name = request.__class__.__name__.replace("Request", "Response")
-        response_class = getattr(
-            request.__class__.__module__, response_class_name, None
-        )
-
-        if response_class is None:
-            module = importlib.import_module(request.__class__.__module__)
-            response_class = getattr(module, response_class_name, None)
-
-        return response_class
-
-    def _deserialize_response(self, response_json: str, request):
-        """Convert JSON string to proto-plus response object."""
-        import json
-
-        from proto import Message as ProtoMessage
-
-        response_class = self._get_response_class(request)
-
-        if response_class and isinstance(request, ProtoMessage):
-            return response_class.from_json(response_json, ignore_unknown_fields=True)
-        elif response_class:
-            from google.protobuf.json_format import Parse
-
-            return Parse(response_json, response_class(), ignore_unknown_fields=True)
-        else:
-            return json.loads(response_json)
-
-    async def _make_request(self, request_json: str, streaming: bool = False):
-        """Make HTTP POST request to UiPath gateway."""
-        headers = self.custom_headers.copy()
-        headers["Content-Type"] = "application/json"
-
-        if streaming:
-            headers["X-UiPath-Streaming-Enabled"] = "true"
-
-        connector = aiohttp.TCPConnector(ssl=True)
-        async with aiohttp.ClientSession(connector=connector) as session:
-            async with session.post(
-                self.llmgw_url, headers=headers, data=request_json
-            ) as response:
-                if response.status != 200:
-                    error_text = await response.text()
-                    raise Exception(f"HTTP {response.status}: {error_text}")
-
-                return await response.text()
-
-    async def generate_content(self, request, **kwargs):
-        """Handle non-streaming generate_content calls."""
-        request_json = self._serialize_request(request)
-        response_text = await self._make_request(request_json, streaming=False)
-        return self._deserialize_response(response_text, request)
-
-    def stream_generate_content(self, request, **kwargs):
-        """
-        Handle streaming generate_content calls.
-
-        Returns a coroutine that yields an async iterator.
-        """
-        return self._create_stream_awaitable(request)
-
-    async def _create_stream_awaitable(self, request):
-        """Awaitable wrapper that returns the async generator."""
-        return self._stream_implementation(request)
-
-    async def _stream_implementation(self, request):
-        """
-        Async generator that yields streaming response chunks.
-
-        Parses the array and yields each chunk individually.
-        """
-        import json
-
-        request_json = self._serialize_request(request)
-        response_text = await self._make_request(request_json, streaming=True)
-
-        try:
-            chunks_array = json.loads(response_text)
-            if isinstance(chunks_array, list):
-                logger.info(f"Streaming: yielding {len(chunks_array)} chunks")
-                for chunk_data in chunks_array:
-                    chunk_json = json.dumps(chunk_data)
-                    yield self._deserialize_response(chunk_json, request)
-                return
-        except Exception as e:
-            logger.info(f"Not a JSON array, trying single response: {e}")
-
-        try:
-            yield self._deserialize_response(response_text, request)
-        except Exception as e:
-            logger.error(f"Failed to parse streaming response: {e}")
-
-
-class UiPathChatVertex(ChatVertexAI):
-    transport: Optional[PredictionServiceTransport] = Field(default=None)
-    async_transport: Optional[CustomPredictionServiceRestAsyncTransport] = Field(
-        default=None
-    )
-    async_client: Optional[
-        Union[v1beta1PredictionServiceAsyncClient, v1PredictionServiceAsyncClient]
-    ] = Field(default=None)
-
-    def __init__(
-        self,
-        org_id: Optional[str] = None,
-        tenant_id: Optional[str] = None,
-        token: Optional[str] = None,
-        model_name: str = GeminiModels.gemini_2_5_flash,
-        **kwargs,
-    ):
-        org_id = org_id or os.getenv("UIPATH_ORGANIZATION_ID")
-        tenant_id = tenant_id or os.getenv("UIPATH_TENANT_ID")
-        token = token or os.getenv("UIPATH_ACCESS_TOKEN")
-
-        if not org_id:
-            raise ValueError(
-                "UIPATH_ORGANIZATION_ID environment variable or org_id parameter is required"
-            )
-        if not tenant_id:
-            raise ValueError(
-                "UIPATH_TENANT_ID environment variable or tenant_id parameter is required"
-            )
-        if not token:
-            raise ValueError(
-                "UIPATH_ACCESS_TOKEN environment variable or token parameter is required"
-            )
-
-        self._vendor = "vertexai"
-        self._model_name = model_name
-        self._url: Optional[str] = None
-
-        llmgw_url = self._build_base_url()
-
-        headers = self._build_headers(token)
-
-        super().__init__(
-            model=model_name,
-            project=os.getenv("VERTEXAI_PROJECT", "none"),
-            location=os.getenv("VERTEXAI_LOCATION", "us-central1"),
-            **kwargs,
-        )
-
-        self.transport = CustomPredictionServiceRestTransport(
-            llmgw_url=llmgw_url, custom_headers=headers
-        )
-
-        self.async_transport = CustomPredictionServiceRestAsyncTransport(
-            llmgw_url=llmgw_url, custom_headers=headers
-        )
-
-    @property
-    def prediction_client(
-        self,
-    ) -> Union[v1beta1PredictionServiceClient, v1PredictionServiceClient]:
-        if self.client is None:
-            if self.endpoint_version == "v1":
-                self.client = v1PredictionServiceClient(
-                    client_options=self.client_options,
-                    client_info=get_client_info(module=self._user_agent),
-                    transport=self.transport,  # type: ignore[arg-type]
-                )
-            else:
-                self.client = v1beta1PredictionServiceClient(
-                    client_options=self.client_options,
-                    client_info=get_client_info(module=self._user_agent),
-                    transport=self.transport,
-                )
-        return self.client
-
-    @property
-    def async_prediction_client(
-        self,
-    ) -> Union[
-        v1beta1PredictionServiceAsyncClient,
-        v1PredictionServiceAsyncClient,
-    ]:
-        return self.async_transport  # type: ignore[return-value]
-
-    @property
-    def endpoint(self) -> str:
-        vendor_endpoint = EndpointManager.get_vendor_endpoint()
-        formatted_endpoint = vendor_endpoint.format(
-            vendor=self._vendor,
-            model=self._model_name,
-        )
-        return formatted_endpoint
-
-    def _build_headers(self, token: str) -> dict[str, str]:
-        headers = {
-            # "X-UiPath-LlmGateway-ApiFlavor": "auto",
-            "Authorization": f"Bearer {token}",
-        }
-        if job_key := os.getenv("UIPATH_JOB_KEY"):
-            headers["X-UiPath-JobKey"] = job_key
-        if process_key := os.getenv("UIPATH_PROCESS_KEY"):
-            headers["X-UiPath-ProcessKey"] = process_key
-        return headers
-
-    def _build_base_url(self) -> str:
-        if not self._url:
-            env_uipath_url = os.getenv("UIPATH_URL")
-
-            if env_uipath_url:
-                self._url = f"{env_uipath_url.rstrip('/')}/{self.endpoint}"
-            else:
-                raise ValueError("UIPATH_URL environment variable is required")
-
-        return self._url