Merge pull request #19 from UiPath/fix/samples

fix: send outgoing message via http

Author: cristipufu

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uipath-mcp"
-version = "0.0.14"
+version = "0.0.15"
 description = "UiPath MCP SDK"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.10"

src/uipath_mcp/_cli/_runtime/_runtime.py

@@ -52,16 +52,17 @@ async def execute(self) -> Optional[UiPathRuntimeResult]:
                 return None
 
             # Set up SignalR client
-            signalr_url = (
-                f"{os.environ.get('UIPATH_URL')}/mcp_/wsstunnel?slug={self.server.name}&sessionId={self.server.session_id}"
-            )
+            signalr_url = f"{os.environ.get('UIPATH_URL')}/mcp_/wsstunnel?slug={self.server.name}&sessionId={self.server.session_id}"
 
             self.cancel_event = asyncio.Event()
 
-            self.signalr_client = SignalRClient(signalr_url, headers={
-                "X-UiPath-Internal-TenantId": self.context.trace_context.tenant_id,
-                "X-UiPath-Internal-AccountId": self.context.trace_context.org_id,
-            })
+            self.signalr_client = SignalRClient(
+                signalr_url,
+                headers={
+                    "X-UiPath-Internal-TenantId": self.context.trace_context.tenant_id,
+                    "X-UiPath-Internal-AccountId": self.context.trace_context.org_id,
+                },
+            )
             self.signalr_client.on("MessageReceived", self.handle_signalr_message)
             self.signalr_client.on("SessionClosed", self.handle_signalr_session_closed)
             self.signalr_client.on_error(self.handle_signalr_error)
@@ -82,8 +83,7 @@ async def execute(self) -> Optional[UiPathRuntimeResult]:
 
             # Wait for either the run to complete or cancellation
             done, pending = await asyncio.wait(
-                [run_task, cancel_task],
-                return_when=asyncio.FIRST_COMPLETED
+                [run_task, cancel_task], return_when=asyncio.FIRST_COMPLETED
             )
 
             # Cancel any pending tasks
@@ -135,9 +135,7 @@ async def handle_signalr_session_closed(self, args: list) -> None:
             self.cancel_event.set()
 
         except Exception as e:
-            logger.error(
-                f"Error terminating session {session_id}: {str(e)}"
-            )
+            logger.error(f"Error terminating session {session_id}: {str(e)}")
 
     async def handle_signalr_message(self, args: list) -> None:
         """
@@ -158,13 +156,13 @@ async def handle_signalr_message(self, args: list) -> None:
                 # Create and start a new session server
                 session_server = SessionServer(self.server, session_id)
                 self.session_servers[session_id] = session_server
-                await session_server.start(self.signalr_client)
+                await session_server.start()
 
             # Get the session server for this session
             session_server = self.session_servers[session_id]
 
             # Forward the message to the session's MCP server
-            await session_server.get_messages()
+            await session_server.get_incoming_messages()
 
         except Exception as e:
             logger.error(
@@ -182,9 +180,9 @@ async def handle_signalr_open(self) -> None:
         if self.server.session_id:
             try:
                 session_server = SessionServer(self.server, self.server.session_id)
-                await session_server.start(self.signalr_client)
+                await session_server.start()
                 self.session_servers[self.server.session_id] = session_server
-                await session_server.get_messages()
+                await session_server.get_incoming_messages()
             except Exception as e:
                 logger.error(f"Error starting session server: {str(e)}")
 

src/uipath_mcp/_cli/_runtime/_session.py

@@ -4,7 +4,6 @@
 import mcp.types as types
 from mcp import StdioServerParameters
 from mcp.client.stdio import stdio_client
-from pysignalr.client import SignalRClient
 from uipath import UiPath
 
 from .._utils._config import McpServer
@@ -24,8 +23,9 @@ def __init__(self, server_config: McpServer, session_id: str):
         self.running = False
         self.context_task = None
         self._message_queue = asyncio.Queue()
+        self._uipath = UiPath()
 
-    async def start(self, signalr_client: SignalRClient) -> None:
+    async def start(self) -> None:
         """Start the server process in a separate task."""
         if self.running:
             logger.info(f"Session {self.session_id} already running")
@@ -41,9 +41,7 @@ async def start(self, signalr_client: SignalRClient) -> None:
 
             # Start the server process in a separate task
             self.running = True
-            self.context_task = asyncio.create_task(
-                self._run_server(server_params, signalr_client)
-            )
+            self.context_task = asyncio.create_task(self._run_server(server_params))
             self.context_task.add_done_callback(self._on_task_done)
 
         except Exception as e:
@@ -53,9 +51,7 @@ async def start(self, signalr_client: SignalRClient) -> None:
             await self.cleanup()
             raise
 
-    async def _run_server(
-        self, server_params: StdioServerParameters, signalr_client: SignalRClient
-    ) -> None:
+    async def _run_server(self, server_params: StdioServerParameters) -> None:
         """Run the server in proper context managers."""
         logger.info(f"Starting server process for session {self.session_id}")
         try:
@@ -75,12 +71,7 @@ async def _run_server(
                         message = await self.read_stream.receive()
                         json_str = message.model_dump_json()
                         print(f"Received message from local server: {json_str}")
-                        logger.debug(
-                            f"Session {self.session_id} - sending to SignalR: {json_str[:100]}..."
-                        )
-                        await signalr_client.send(
-                            "OnMessageReceived", [json_str]
-                        )
+                        await self.send_outgoing_message(message)
                 finally:
                     # Cancel the consumer when we exit the loop
                     consumer_task.cancel()
@@ -159,22 +150,34 @@ async def send_message(self, message: types.JSONRPCMessage) -> None:
         await self._message_queue.put(message)
         logger.debug(f"Session {self.session_id} - message queued for processing")
 
-    async def get_messages(self) -> None:
+    async def get_incoming_messages(self) -> None:
         """Get new messages from UiPath MCP Server."""
-        uipath = UiPath()
-        response = uipath.api_client.request(
+        response = self._uipath.api_client.request(
             "GET",
-            f"mcp_/mcp/{self.server_config.name}/messages?sessionId={self.session_id}",
+            f"mcp_/mcp/{self.server_config.name}/in/messages?sessionId={self.session_id}",
         )
         if response.status_code == 200:
             messages = response.json()
-            logger.info(f"Get messages from UiPath MCP Server: {type(messages)} {messages}")
             for message in messages:
-                logger.info(f"Get message from UiPath MCP Server: {type(message)} {message}")
+                logger.info(f"Incoming message from UiPath MCP Server: {message}")
                 json_message = types.JSONRPCMessage.model_validate(message)
                 logger.info(f"Forwarding message to local MCP Server: {message}")
                 await self.send_message(json_message)
 
+    async def send_outgoing_message(self, message: types.JSONRPCMessage) -> None:
+        """Send new message to UiPath MCP Server."""
+        response = self._uipath.api_client.request(
+            "POST",
+            f"mcp_/mcp/{self.server_config.name}/out/message?sessionId={self.session_id}",
+            json=message,
+        )
+        if response.status_code == 202:
+            logger.info(f"Outgoing message sent to UiPath MCP Server: {message}")
+        else:
+            logger.error(
+                f"Failed to send outgoing message to UiPath MCP Server: {response.status_code} {response.text}"
+            )
+
     async def cleanup(self) -> None:
         """Clean up resources and stop the server."""
         logger.info(f"Cleaning up session {self.session_id}")