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

uipath_langchain/tools/preconfigured.py

@@ -0,0 +1,191 @@
+import json
+import logging
+from typing import Iterable, Optional, Type
+
+import httpx
+from jsonschema_pydantic import jsonschema_to_pydantic as create_model  # type: ignore
+from langchain_core.caches import BaseCache
+from langchain_core.runnables.utils import Output
+from langchain_core.tools import BaseTool, StructuredTool
+from langgraph.types import interrupt
+from pydantic import BaseModel
+from uipath import UiPath
+from uipath.agent.models.agent import (
+    AgentDefinition,
+    AgentEscalationChannel,
+    AgentEscalationResourceConfig,
+    AgentIntegrationToolResourceConfig,
+    AgentProcessToolResourceConfig,
+    AgentResourceConfig,
+)
+from uipath.models import CreateAction, InvokeProcess
+
+logger = logging.getLogger(__name__)
+
+
+def create_process_tool(resource: AgentProcessToolResourceConfig) -> Iterable[BaseTool]:
+    async def process(**kwargs) -> BaseModel:
+        return interrupt(
+            InvokeProcess(
+                name=resource.name,
+                input_arguments=kwargs,
+                process_folder_path=resource.properties.folder_path,
+            )
+        )
+
+    input_schema = create_model(resource.input_schema)
+
+    class ProcessTool(StructuredTool):
+        @property
+        def OutputType(self) -> type[Output]:
+            return create_model(resource.output_schema)
+
+    yield ProcessTool(
+        name=resource.name,
+        args_schema=input_schema,
+        description=resource.description,
+        coroutine=process,
+    )
+
+
+def create_escalation_tool_from_channel(channel: AgentEscalationChannel) -> BaseTool:
+    async def escalate(**kwargs) -> BaseModel:
+        recipients = channel.recipients
+        if len(recipients) > 1:
+            logger.warning(
+                "Received more than one recipient. Defaulting to first recipient."
+            )
+        assignee = recipients[0].value if recipients else None
+        return interrupt(
+            CreateAction(
+                title=channel.description,
+                data=kwargs,
+                assignee=assignee,
+                app_name=channel.properties.app_name,
+                app_folder_path=None,  # Channels specify folder name but not folder path.
+                app_folder_key=channel.properties.resource_key,
+                app_key=channel.properties.resource_key,
+                app_version=channel.properties.app_version,
+            )
+        )
+
+    input_schema = create_model(channel.input_schema)
+
+    class EscalationTool(StructuredTool):
+        @property
+        def OutputType(self) -> type[Output]:
+            return create_model(channel.output_schema)
+
+    return EscalationTool(
+        name=channel.name,
+        args_schema=input_schema,
+        description=channel.description,
+        coroutine=escalate,
+    )
+
+
+def create_escalation_tool(
+    resource: AgentEscalationResourceConfig,
+) -> Iterable[BaseTool]:
+    for channel in resource.channels:
+        yield create_escalation_tool_from_channel(channel)
+
+
+def create_integration_tool(
+    resource: AgentIntegrationToolResourceConfig,
+) -> Iterable[BaseTool]:
+    async def integration(**kwargs) -> BaseModel:
+        uipath = UiPath()
+        remote_connection = await uipath.connections.retrieve_async(
+            resource.properties.connection.id
+        )
+        token = await uipath.connections.retrieve_token_async(
+            resource.properties.connection.id
+        )
+        tool_url = f"{remote_connection.api_base_uri}/v3/element/instances/{remote_connection.element_instance_id}{resource.properties.tool_path}"
+
+        response = await httpx.AsyncClient().request(
+            resource.properties.method,
+            tool_url,
+            headers={"Authorization": f"Bearer {token.access_token}"},
+            content=json.dumps(kwargs),
+        )
+        return response.json()
+
+    input_schema = create_model(resource.input_schema)
+
+    class IntegrationTool(StructuredTool):
+        @property
+        def OutputType(self) -> type[Output]:
+            return create_model({})
+
+    yield IntegrationTool(
+        name=resource.name,
+        args_schema=input_schema,
+        description=resource.description,
+        coroutine=integration,
+    )
+
+
+def create_cached_wrapper_from_tool(
+    wrapped: BaseTool, cache: Optional[BaseCache]
+) -> BaseTool:
+    if cache is None:
+        return wrapped
+    else:
+
+        async def cached_invocation(**kwargs) -> BaseModel:
+            namespace = f"{wrapped.name}.tool_invoke"
+            key = str(kwargs)
+            cached = cache.lookup(namespace, key)
+            if cached:
+                return cached[0]
+            response = await wrapped.ainvoke(input=kwargs)
+            cache.update(namespace, key, [response])
+            return response
+
+        input_schema = wrapped.args_schema
+
+        class CachedTool(StructuredTool):
+            OutputType: Type[BaseModel] = wrapped.OutputType
+
+        return CachedTool(
+            name=wrapped.name,
+            args_schema=input_schema,
+            description=wrapped.description,
+            coroutine=cached_invocation,
+        )
+
+
+def create_cached_wrapper(
+    tools: Iterable[BaseTool], cache: Optional[BaseCache]
+) -> Iterable[BaseTool]:
+    for wrapped in tools:
+        yield create_cached_wrapper_from_tool(wrapped, cache)
+
+
+def create_resource_tool(
+    resource: AgentResourceConfig, cache: Optional[BaseCache] = None
+) -> Iterable[BaseTool]:
+    match resource:
+        case AgentProcessToolResourceConfig():
+            return create_cached_wrapper(create_process_tool(resource), cache)
+        case AgentIntegrationToolResourceConfig():
+            return create_cached_wrapper(create_integration_tool(resource), cache)
+        case AgentEscalationResourceConfig():
+            return create_cached_wrapper(create_escalation_tool(resource), cache)
+        case _:
+            raise NotImplementedError()
+
+
+def safe_extract_tools(
+    agent_definition: AgentDefinition, cache: Optional[BaseCache] = None
+) -> list[BaseTool]:
+    tools = []
+    for resource in agent_definition.resources:
+        try:
+            for structured_tool in create_resource_tool(resource, cache):
+                tools.append(structured_tool)
+        except NotImplementedError:
+            logger.warning(f"Unable to convert {resource.name} into a tool.")
+    return tools

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath-langchain
-Version: 0.0.131
+Version: 0.0.133
 Summary: UiPath Langchain
 Project-URL: Homepage, https://uipath.com
 Project-URL: Repository, https://github.com/UiPath/uipath-langchain-python
@@ -15,6 +15,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Build Tools
 Requires-Python: >=3.10
 Requires-Dist: httpx>=0.27.0
+Requires-Dist: jsonschema-pydantic>=0.6
 Requires-Dist: langchain-community>=0.3.21
 Requires-Dist: langchain-core>=0.3.34
 Requires-Dist: langchain-openai>=0.3.3
@@ -25,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.54
+Requires-Dist: uipath<2.2.0,>=2.1.60
 Provides-Extra: langchain
 Description-Content-Type: text/markdown
 

{uipath_langchain-0.0.131.dist-info → uipath_langchain-0.0.133.dist-info}/RECORD

@@ -1,21 +1,25 @@
 uipath_langchain/__init__.py,sha256=VBrvQn7d3nuOdN7zEnV2_S-uhmkjgEIlXiFVeZxZakQ,80
 uipath_langchain/middlewares.py,sha256=6ljfbtWekrYc5G9KWDLSaViJ1DVIaNM-4qeB1BfHywE,731
 uipath_langchain/_cli/__init__.py,sha256=juqd9PbXs4yg45zMJ7BHAOPQjb7sgEbWE9InBtGZhfo,24
-uipath_langchain/_cli/cli_dev.py,sha256=VlI8qgCw-63I97tp_9lbXs-CVcNSjpd2sC13YNZAIuU,1401
-uipath_langchain/_cli/cli_eval.py,sha256=eGhvenAKJDdt9zIYWO7k01zJ7T1tGte7a6zz06iO6cw,2539
+uipath_langchain/_cli/cli_dev.py,sha256=3e9RldNGirIk9184NdLK6kDuGeeqZjekTxbSZRtXjBE,1505
+uipath_langchain/_cli/cli_eval.py,sha256=mvaKRF-pvxdNa2mk_ude9SYSd_kmMBo-hChlXokXOcw,2795
 uipath_langchain/_cli/cli_init.py,sha256=xhxJ8tuMSrVUNHvltgyPpOrvgMA-wq9shHeYYwvHILs,8199
 uipath_langchain/_cli/cli_new.py,sha256=KKLxCzz7cDQ__rRr_a496IHWlSQXhmrBNgmKHnXAnTY,2336
-uipath_langchain/_cli/cli_run.py,sha256=FT4ilVCBNSYllB-wS6__0E0fWKlrQEhO9N74wNHPffs,2056
+uipath_langchain/_cli/cli_run.py,sha256=hRcoXJgOIFceCswzTfZKyzqVee3j-oSh-13EfuQmmE8,2614
 uipath_langchain/_cli/_runtime/_context.py,sha256=yyzYJDmk2fkH4T5gm4cLGRyXtjLESrpzHBT9euqluTA,817
 uipath_langchain/_cli/_runtime/_conversation.py,sha256=S1KTx_q-La7ikPRT3nBcIp8t-J9CF0QB0DCduQIIB28,11149
 uipath_langchain/_cli/_runtime/_exception.py,sha256=USKkLYkG-dzjX3fEiMMOHnVUpiXJs_xF0OQXCCOvbYM,546
-uipath_langchain/_cli/_runtime/_input.py,sha256=3IKrZR9xmxYg6l_1TbFpaLOWPDvK8d3nSKIHPGEEGzE,5715
+uipath_langchain/_cli/_runtime/_input.py,sha256=Zx-8ZEr5Z796gdd3NnrlNObMIuXJobAV9mZwOql67Lo,5658
 uipath_langchain/_cli/_runtime/_output.py,sha256=yJOZPWv2FRUJWv1NRs9JmpB4QMTDXu8jrxoaKrfJvzw,9078
-uipath_langchain/_cli/_runtime/_runtime.py,sha256=ai-r6cYp4YbJqGhxWGvL68BHtJGhYhAZF-MEhKT7ceY,14955
+uipath_langchain/_cli/_runtime/_runtime.py,sha256=cVt0TlsEBmKv6EcFTtCOT9ITsguzLDqFGMdhPOiBPRc,14318
 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/_utils/__init__.py,sha256=WoY66enCygRXTh6v5B1UrRcFCnQYuPJ8oqDkwomXzLc,194
+uipath_langchain/_tracing/__init__.py,sha256=UqrLc_WimpzKY82M0LJsgJ-HFQUQFjOmOlD1XQ8V-R4,181
+uipath_langchain/_tracing/_instrument_traceable.py,sha256=8f9FyAKWE6kH1N8ErbpwqZHAzNjGwbLjQn7jdX5yAgA,4343
+uipath_langchain/_tracing/_oteladapter.py,sha256=bhbLLTBwZ1rLDL-BgbvB8oR11y1Tp8jEw2mrAuVJ5go,8433
+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=ddKFs_0mjoFCmvPTiOTPJh1IIqYUo5CUka-B7zAZphE,19695
 uipath_langchain/_utils/_settings.py,sha256=2fExMQJ88YptfldmzMfZIpsx-m1gfMkeYGf5t6KIe0A,3084
 uipath_langchain/_utils/_sleep_policy.py,sha256=e9pHdjmcCj4CVoFM1jMyZFelH11YatsgWfpyrfXzKBQ,1251
@@ -26,15 +30,12 @@ uipath_langchain/embeddings/__init__.py,sha256=QICtYB58ZyqFfDQrEaO8lTEgAU5NuEKlR
 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/tracers/AsyncUiPathTracer.py,sha256=SgFLVU8ZtRaUjIiiM5jjYqlKc-4ec3tAXwZVceDM2ng,9147
-uipath_langchain/tracers/__init__.py,sha256=bMmqGCC4DsuLUdDVM4zvmVbRLPeULZ8K9ity0GAfy_4,197
-uipath_langchain/tracers/_events.py,sha256=CJri76SSdu7rGJIkXurJ2C5sQahfSK4E5UWwWYdEAtE,922
-uipath_langchain/tracers/_instrument_traceable.py,sha256=0e841zVzcPWjOGtmBx0GeHbq3JoqsmWv6gVPzDOKNTM,13496
-uipath_langchain/tracers/_utils.py,sha256=JOT1tKMdvqjMDtj2WbmbOWMeMlTXBWavxWpogX7KlRA,1543
+uipath_langchain/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+uipath_langchain/tools/preconfigured.py,sha256=Ucl9mta_su66j-5uOC-vZzyc3V2-Em6q9WO1qsmQv48,6291
 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.131.dist-info/METADATA,sha256=1T4chCHDVrMR97PZYal-X_kCCLeLlcb6hawfHgkpebM,4235
-uipath_langchain-0.0.131.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-uipath_langchain-0.0.131.dist-info/entry_points.txt,sha256=FUtzqGOEntlJKMJIXhQUfT7ZTbQmGhke1iCmDWZaQZI,81
-uipath_langchain-0.0.131.dist-info/licenses/LICENSE,sha256=JDpt-uotAkHFmxpwxi6gwx6HQ25e-lG4U_Gzcvgp7JY,1063
-uipath_langchain-0.0.131.dist-info/RECORD,,
+uipath_langchain-0.0.133.dist-info/METADATA,sha256=zcSdl4I5iJsBi0jOf7IUUprBv39KfQZyrM1EzVH1OCQ,4275
+uipath_langchain-0.0.133.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uipath_langchain-0.0.133.dist-info/entry_points.txt,sha256=FUtzqGOEntlJKMJIXhQUfT7ZTbQmGhke1iCmDWZaQZI,81
+uipath_langchain-0.0.133.dist-info/licenses/LICENSE,sha256=JDpt-uotAkHFmxpwxi6gwx6HQ25e-lG4U_Gzcvgp7JY,1063
+uipath_langchain-0.0.133.dist-info/RECORD,,

uipath_langchain/tracers/AsyncUiPathTracer.py

@@ -1,274 +0,0 @@
-import asyncio
-import json
-import logging
-import queue
-import uuid
-import warnings
-from os import environ as env
-from typing import Any, Dict, Optional
-
-import httpx
-from langchain_core.tracers.base import AsyncBaseTracer
-from langchain_core.tracers.schemas import Run
-from pydantic import PydanticDeprecationWarning
-from uipath._cli._runtime._contracts import UiPathTraceContext
-
-from ._events import CustomTraceEvents, FunctionCallEventData
-from ._utils import _setup_tracer_httpx_logging, _simple_serialize_defaults
-
-logger = logging.getLogger(__name__)
-
-_setup_tracer_httpx_logging("/llmops_/api/Agent/trace/")
-
-
-class Status:
-    SUCCESS = 1
-    ERROR = 2
-    INTERRUPTED = 3
-
-
-class AsyncUiPathTracer(AsyncBaseTracer):
-    def __init__(
-        self,
-        context: Optional[UiPathTraceContext] = None,
-        client: Optional[httpx.AsyncClient] = None,
-        **kwargs,
-    ):
-        super().__init__(**kwargs)
-
-        self.client = client or httpx.AsyncClient()
-        self.retries = 3
-        self.log_queue: queue.Queue[dict[str, Any]] = queue.Queue()
-
-        self.context = context or UiPathTraceContext()
-
-        self.base_url = self._get_base_url()
-
-        auth_token = env.get("UNATTENDED_USER_ACCESS_TOKEN") or env.get(
-            "UIPATH_ACCESS_TOKEN"
-        )
-
-        self.headers = {"Authorization": f"Bearer {auth_token}"}
-
-        self.running = True
-        self.worker_task = asyncio.create_task(self._worker())
-        self.function_call_run_map: Dict[str, Run] = {}
-
-    async def on_custom_event(
-        self,
-        name: str,
-        data: Any,
-        *,
-        run_id: uuid.UUID,
-        tags=None,
-        metadata=None,
-        **kwargs: Any,
-    ) -> None:
-        if name == CustomTraceEvents.UIPATH_TRACE_FUNCTION_CALL:
-            # only handle the function call event
-
-            if not isinstance(data, FunctionCallEventData):
-                logger.warning(
-                    f"Received unexpected data type for function call event: {type(data)}"
-                )
-                return
-
-            if data.event_type == "call":
-                run = self.run_map[str(run_id)]
-                child_run = run.create_child(
-                    name=data.function_name,
-                    run_type=data.run_type,
-                    tags=data.tags,
-                    inputs=data.inputs,
-                )
-
-                if data.metadata is not None:
-                    run.add_metadata(data.metadata)
-
-                call_uuid = data.call_uuid
-                self.function_call_run_map[call_uuid] = child_run
-
-                self._send_span(run)
-
-            if data.event_type == "completion":
-                call_uuid = data.call_uuid
-                previous_run = self.function_call_run_map.pop(call_uuid, None)
-
-                if previous_run:
-                    previous_run.end(
-                        outputs=self._safe_dict_dump(data.output), error=data.error
-                    )
-                    self._send_span(previous_run)
-
-    async def wait_for_all_tracers(self) -> None:
-        """
-        Wait for all pending log requests to complete
-        """
-        self.running = False
-        if self.worker_task:
-            await self.worker_task
-
-    async def _worker(self):
-        """Worker loop that processes logs from the queue."""
-        while self.running:
-            try:
-                if self.log_queue.empty():
-                    await asyncio.sleep(1)
-                    continue
-
-                span_data = self.log_queue.get_nowait()
-
-                url = self._build_url(self.context.trace_id)
-
-                for attempt in range(self.retries):
-                    response = await self.client.post(
-                        url,
-                        headers=self.headers,
-                        json=[span_data],  # api expects a list of spans
-                        timeout=10,
-                    )
-
-                    if response.is_success:
-                        break
-
-                    await asyncio.sleep(0.5 * (2**attempt))  # Exponential backoff
-
-                    if 400 <= response.status_code < 600:
-                        logger.warning(
-                            f"Error when sending trace: {response}. Body is: {response.text}"
-                        )
-            except Exception as e:
-                logger.warning(f"Exception when sending trace: {e}", exc_info=e)
-
-        # wait for a bit to ensure all logs are sent
-        await asyncio.sleep(1)
-
-        # try to send any remaining logs in the queue
-        while True:
-            try:
-                if self.log_queue.empty():
-                    break
-
-                span_data = self.log_queue.get_nowait()
-                url = self._build_url(self.context.trace_id)
-
-                response = await self.client.post(
-                    url,
-                    headers=self.headers,
-                    json=[span_data],  # api expects a list of spans
-                    timeout=10,
-                )
-            except Exception as e:
-                logger.warning(f"Exception when sending trace: {e}", exc_info=e)
-
-    async def _persist_run(self, run: Run) -> None:
-        # Determine if this is a start or end trace based on whether end_time is set
-        self._send_span(run)
-
-    def _send_span(self, run: Run) -> None:
-        """Send span data for a run to the API"""
-        run_id = str(run.id)
-
-        try:
-            start_time = (
-                run.start_time.isoformat() if run.start_time is not None else None
-            )
-            end_time = (
-                run.end_time.isoformat() if run.end_time is not None else start_time
-            )
-
-            parent_id = (
-                str(run.parent_run_id)
-                if run.parent_run_id is not None
-                else self.context.parent_span_id
-            )
-            attributes = self._safe_jsons_dump(self._run_to_dict(run))
-            status = self._determine_status(run.error)
-
-            span_data = {
-                "id": run_id,
-                "parentId": parent_id,
-                "traceId": self.context.trace_id,
-                "name": run.name,
-                "startTime": start_time,
-                "endTime": end_time,
-                "referenceId": self.context.reference_id,
-                "attributes": attributes,
-                "organizationId": self.context.org_id,
-                "tenantId": self.context.tenant_id,
-                "spanType": "LangGraphRun",
-                "status": status,
-                "jobKey": self.context.job_id,
-                "folderKey": self.context.folder_key,
-                "processKey": self.context.folder_key,
-                "expiryTimeUtc": None,
-            }
-
-            self.log_queue.put(span_data)
-        except Exception as e:
-            logger.warning(f"Exception when adding trace to queue: {e}.")
-
-    async def _start_trace(self, run: Run) -> None:
-        await super()._start_trace(run)
-        await self._persist_run(run)
-
-    async def _end_trace(self, run: Run) -> None:
-        await super()._end_trace(run)
-        await self._persist_run(run)
-
-    def _determine_status(self, error: Optional[str]):
-        if error:
-            if error.startswith("GraphInterrupt("):
-                return Status.INTERRUPTED
-
-            return Status.ERROR
-
-        return Status.SUCCESS
-
-    def _safe_jsons_dump(self, obj) -> str:
-        try:
-            json_str = json.dumps(obj, default=_simple_serialize_defaults)
-            return json_str
-        except Exception as e:
-            logger.warning(f"Error serializing object to JSON: {e}")
-            return "{ }"
-
-    def _safe_dict_dump(self, obj) -> Dict[str, Any]:
-        try:
-            serialized = json.loads(json.dumps(obj, default=_simple_serialize_defaults))
-            return serialized
-        except Exception as e:
-            # Last resort - string representation
-            logger.warning(f"Error serializing object to JSON: {e}")
-            return {"raw": str(obj)}
-
-    def _run_to_dict(self, run: Run):
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore", category=PydanticDeprecationWarning)
-
-            # Helper function to safely copy values
-            def safe_copy(value):
-                if value is None:
-                    return None
-                if hasattr(value, "copy") and callable(value.copy):
-                    return value.copy()
-                return value
-
-            return {
-                **run.dict(exclude={"child_runs", "inputs", "outputs", "serialized"}),
-                "inputs": safe_copy(run.inputs),
-                "outputs": safe_copy(run.outputs),
-            }
-
-    def _get_base_url(self) -> str:
-        uipath_url = (
-            env.get("UIPATH_URL") or "https://cloud.uipath.com/dummyOrg/dummyTennant/"
-        )
-
-        uipath_url = uipath_url.rstrip("/")
-
-        return uipath_url
-
-    def _build_url(self, trace_id: Optional[str]) -> str:
-        """Construct the URL for the API request."""
-        return f"{self.base_url}/llmopstenant_/api/Traces/spans?traceId={trace_id}&source=Robots"

uipath_langchain/tracers/__init__.py

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

uipath_langchain/tracers/_events.py

@@ -1,33 +0,0 @@
-from typing import Any, Dict, List, Literal, Optional
-
-RUN_TYPE_T = Literal[
-    "tool", "chain", "llm", "retriever", "embedding", "prompt", "parser"
-]
-
-
-class CustomTraceEvents:
-    UIPATH_TRACE_FUNCTION_CALL = "__uipath_trace_function_call"
-
-
-class FunctionCallEventData:
-    def __init__(
-        self,
-        function_name: str,
-        event_type: str,
-        inputs: Dict[str, Any],
-        call_uuid: str,
-        output: Any,
-        error: Optional[str] = None,
-        run_type: Optional[RUN_TYPE_T] = None,
-        tags: Optional[List[str]] = None,
-        metadata: Optional[Dict[str, Any]] = None,
-    ):
-        self.function_name = function_name
-        self.event_type = event_type
-        self.inputs = inputs
-        self.call_uuid = call_uuid
-        self.output = output
-        self.error = error
-        self.run_type = run_type or "chain"
-        self.tags = tags
-        self.metadata = metadata