fix: add mock template runtime with chat events

Author: cristipufu

src/uipath/dev/_demo/__init__.py demo/__init__.pysrc/uipath/dev/_demo/__init__.py renamed to demo/__init__.py

@@ -1,31 +1,50 @@
 """Minimal demo script to run UiPathDevTerminal with mock runtimes."""
 
 import logging
+from pathlib import Path
 
 from uipath.runtime import (
     UiPathRuntimeProtocol,
 )
 
-from uipath.dev._demo.mock_context_runtime import ENTRYPOINT_CONTEXT, MockContextRuntime
-from uipath.dev._demo.mock_greeting_runtime import (
+from demo.mock_greeting_runtime import (
     ENTRYPOINT_GREETING,
     MockGreetingRuntime,
 )
-from uipath.dev._demo.mock_numbers_runtime import (
+from demo.mock_numbers_runtime import (
     ENTRYPOINT_ANALYZE_NUMBERS,
     MockNumberAnalyticsRuntime,
 )
-from uipath.dev._demo.mock_support_runtime import (
+from demo.mock_support_runtime import (
     ENTRYPOINT_SUPPORT_CHAT,
     MockSupportChatRuntime,
 )
+from demo.mock_telemetry_runtime import (
+    ENTRYPOINT_TELEMETRY,
+    MockTelemetryRuntime,
+)
+from demo.mock_template_runtime import (
+    create_template_runtime,
+)
 
 logger = logging.getLogger(__name__)
 
+# Template mappings: entrypoint -> (events_file, schema_file)
+TEMPLATE_RUNTIMES = {
+    "chat/movies.py:graph": (
+        "chat_agent/events.json",
+        "chat_agent/entry-points.json",
+    ),
+}
+
 
 class MockRuntimeFactory:
     """Runtime factory compatible with UiPathRuntimeFactoryProtocol."""
 
+    def __init__(self):
+        """Initialize the mock runtime factory."""
+        self.demo_dir = Path(__file__).parent
+
     async def new_runtime(
         self, entrypoint: str, runtime_id: str
     ) -> UiPathRuntimeProtocol:
@@ -36,8 +55,19 @@ async def new_runtime(
             return MockNumberAnalyticsRuntime(entrypoint=entrypoint)
         if entrypoint == ENTRYPOINT_SUPPORT_CHAT:
             return MockSupportChatRuntime(entrypoint=entrypoint)
-        if entrypoint == ENTRYPOINT_CONTEXT:
-            return MockContextRuntime(entrypoint=entrypoint)
+        if entrypoint == ENTRYPOINT_TELEMETRY:
+            return MockTelemetryRuntime(entrypoint=entrypoint)
+
+        if entrypoint in TEMPLATE_RUNTIMES:
+            events_file, schema_file = TEMPLATE_RUNTIMES[entrypoint]
+
+            events_path = self.demo_dir / events_file
+            schema_path = self.demo_dir / schema_file
+
+            return create_template_runtime(
+                events_json=events_path,
+                schema_json=schema_path,
+            )
 
         # Fallback: still return something so the demo doesn't explode
         logger.warning(
@@ -47,20 +77,32 @@ async def new_runtime(
 
     async def discover_runtimes(self) -> list[UiPathRuntimeProtocol]:
         """Return prototype instances for discovery (not really used by the UI)."""
-        return [
+        runtimes: list[UiPathRuntimeProtocol] = [
             MockGreetingRuntime(entrypoint=ENTRYPOINT_GREETING),
             MockNumberAnalyticsRuntime(entrypoint=ENTRYPOINT_ANALYZE_NUMBERS),
             MockSupportChatRuntime(entrypoint=ENTRYPOINT_SUPPORT_CHAT),
-            MockContextRuntime(entrypoint=ENTRYPOINT_CONTEXT),
+            MockTelemetryRuntime(entrypoint=ENTRYPOINT_TELEMETRY),
         ]
 
+        for entrypoint in TEMPLATE_RUNTIMES.keys():
+            try:
+                runtime: UiPathRuntimeProtocol = await self.new_runtime(
+                    entrypoint, runtime_id="discovery"
+                )
+                runtimes.append(runtime)
+            except Exception as e:
+                logger.error(f"Failed to load template runtime '{entrypoint}': {e}")
+
+        return runtimes
+
     def discover_entrypoints(self) -> list[str]:
         """Return all available entrypoints."""
         return [
-            ENTRYPOINT_CONTEXT,
+            ENTRYPOINT_TELEMETRY,
             ENTRYPOINT_GREETING,
             ENTRYPOINT_ANALYZE_NUMBERS,
             ENTRYPOINT_SUPPORT_CHAT,
+            *TEMPLATE_RUNTIMES.keys(),
         ]
 
     async def dispose(self) -> None:

demo/chat_agent/entry-points.json

@@ -1,3 +1,5 @@
+"""Mock Greeting Runtime for demonstration purposes."""
+
 import asyncio
 import logging
 from typing import Any, AsyncGenerator
@@ -21,10 +23,12 @@ class MockGreetingRuntime:
     """Mock runtime that builds a greeting and simulates a small pipeline."""
 
     def __init__(self, entrypoint: str = ENTRYPOINT_GREETING) -> None:
+        """Initialize the MockGreetingRuntime."""
         self.entrypoint = entrypoint
         self.tracer = trace.get_tracer("uipath.dev.mock.greeting")
 
     async def get_schema(self) -> UiPathRuntimeSchema:
+        """Get the schema for the greeting runtime."""
         return UiPathRuntimeSchema(
             filePath=self.entrypoint,
             uniqueId="mock-greeting-runtime",
@@ -62,6 +66,7 @@ async def execute(
         input: dict[str, Any] | None = None,
         options: UiPathExecuteOptions | None = None,
     ) -> UiPathRuntimeResult:
+        """Execute the greeting runtime."""
         payload = input or {}
         name = str(payload.get("name", "world")).strip() or "world"
         excited = bool(payload.get("excited", True))
@@ -124,8 +129,10 @@ async def stream(
         input: dict[str, Any] | None = None,
         options: UiPathStreamOptions | None = None,
     ) -> AsyncGenerator[UiPathRuntimeEvent, None]:
+        """Stream events from the greeting runtime."""
         logger.info("GreetingRuntime: stream() invoked")
         yield await self.execute(input=input, options=options)
 
     async def dispose(self) -> None:
+        """Dispose of any resources used by the greeting runtime."""
         logger.info("GreetingRuntime: dispose() invoked")

demo/chat_agent/events.json

@@ -1,3 +1,5 @@
+"""An example mock runtime that analyzes numbers."""
+
 import asyncio
 import logging
 from typing import Any, AsyncGenerator
@@ -12,7 +14,7 @@
 )
 from uipath.runtime.schema import UiPathRuntimeSchema
 
-ENTRYPOINT_ANALYZE_NUMBERS = "analytics/numbers.py:analyze"
+ENTRYPOINT_ANALYZE_NUMBERS = "agent/numbers.py:analyze"
 
 logger = logging.getLogger(__name__)
 
@@ -21,10 +23,12 @@ class MockNumberAnalyticsRuntime:
     """Mock runtime that analyzes a list of numbers."""
 
     def __init__(self, entrypoint: str = ENTRYPOINT_ANALYZE_NUMBERS) -> None:
+        """Initialize the MockNumberAnalyticsRuntime."""
         self.entrypoint = entrypoint
         self.tracer = trace.get_tracer("uipath.dev.mock.number-analytics")
 
     async def get_schema(self) -> UiPathRuntimeSchema:
+        """Get the schema for the number analytics runtime."""
         return UiPathRuntimeSchema(
             filePath=self.entrypoint,
             uniqueId="mock-number-analytics-runtime",
@@ -61,6 +65,7 @@ async def execute(
         input: dict[str, Any] | None = None,
         options: UiPathExecuteOptions | None = None,
     ) -> UiPathRuntimeResult:
+        """Execute the number analytics runtime."""
         payload = input or {}
         numbers = payload.get("numbers") or []
         operation = str(payload.get("operation", "sum")).lower()
@@ -137,8 +142,10 @@ async def stream(
         input: dict[str, Any] | None = None,
         options: UiPathStreamOptions | None = None,
     ) -> AsyncGenerator[UiPathRuntimeEvent, None]:
+        """Stream events from the number analytics runtime."""
         logger.info("NumberAnalyticsRuntime: stream() invoked")
         yield await self.execute(input=input, options=options)
 
     async def dispose(self) -> None:
+        """Dispose of any resources used by the number analytics runtime."""
         logger.info("NumberAnalyticsRuntime: dispose() invoked")

src/uipath/dev/_demo/mock_runtime.py demo/mock_factory.pysrc/uipath/dev/_demo/mock_runtime.py renamed to demo/mock_factory.py

@@ -1,3 +1,5 @@
+"""Mock runtime that simulates a support chat agent."""
+
 import asyncio
 import logging
 from typing import Any, AsyncGenerator
@@ -12,7 +14,7 @@
 )
 from uipath.runtime.schema import UiPathRuntimeSchema
 
-ENTRYPOINT_SUPPORT_CHAT = "agent/support.py:chat"
+ENTRYPOINT_SUPPORT_CHAT = "agent/support.py:main"
 
 logger = logging.getLogger(__name__)
 
@@ -21,10 +23,12 @@ class MockSupportChatRuntime:
     """Mock runtime that simulates a tiny support agent."""
 
     def __init__(self, entrypoint: str = ENTRYPOINT_SUPPORT_CHAT) -> None:
+        """Initialize the MockSupportChatRuntime."""
         self.entrypoint = entrypoint
         self.tracer = trace.get_tracer("uipath.dev.mock.support-chat")
 
     async def get_schema(self) -> UiPathRuntimeSchema:
+        """Get the schema for the support chat runtime."""
         return UiPathRuntimeSchema(
             filePath=self.entrypoint,
             uniqueId="mock-support-chat-runtime",
@@ -60,6 +64,7 @@ async def execute(
         input: dict[str, Any] | None = None,
         options: UiPathExecuteOptions | None = None,
     ) -> UiPathRuntimeResult:
+        """Execute the support chat runtime."""
         payload = input or {}
         message = str(payload.get("message", "")).strip()
         previous = payload.get("previousIssues") or []
@@ -139,8 +144,10 @@ async def stream(
         input: dict[str, Any] | None = None,
         options: UiPathStreamOptions | None = None,
     ) -> AsyncGenerator[UiPathRuntimeEvent, None]:
+        """Stream events from the support chat runtime."""
         logger.info("SupportChatRuntime: stream() invoked")
         yield await self.execute(input=input, options=options)
 
     async def dispose(self) -> None:
+        """Dispose of any resources used by the support chat runtime."""
         logger.info("SupportChatRuntime: dispose() invoked")

…ipath/dev/_demo/mock_greeting_runtime.py demo/mock_greeting_runtime.pysrc/uipath/dev/_demo/mock_greeting_runtime.py renamed to demo/mock_greeting_runtime.py src/uipath/dev/_demo/mock_greeting_runtime.py renamed to demo/mock_greeting_runtime.py

@@ -1,3 +1,5 @@
+"""Mock runtime that simulates a multi-step workflow with rich telemetry."""
+
 import asyncio
 import logging
 from typing import Any, AsyncGenerator
@@ -10,17 +12,19 @@
     UiPathRuntimeStatus,
     UiPathStreamOptions,
 )
+from uipath.runtime.debug import UiPathBreakpointResult
 from uipath.runtime.schema import UiPathRuntimeSchema
 
-ENTRYPOINT_CONTEXT = "agent/context.py:run"
+ENTRYPOINT_TELEMETRY = "agent/telemetry.py:run"
 
 logger = logging.getLogger(__name__)
 
 
-class MockContextRuntime:
+class MockTelemetryRuntime:
     """A mock runtime that simulates a multi-step workflow with rich telemetry."""
 
-    def __init__(self, entrypoint: str = ENTRYPOINT_CONTEXT) -> None:
+    def __init__(self, entrypoint: str = ENTRYPOINT_TELEMETRY) -> None:
+        """Initialize the MockTelemetryRuntime."""
         self.entrypoint = entrypoint
         self.tracer = trace.get_tracer("uipath.dev.mock.context")
         # State tracking for breakpoints
@@ -39,6 +43,7 @@ def __init__(self, entrypoint: str = ENTRYPOINT_CONTEXT) -> None:
         ]
 
     async def get_schema(self) -> UiPathRuntimeSchema:
+        """Get the schema for the mock telemetry runtime."""
         return UiPathRuntimeSchema(
             filePath=self.entrypoint,
             uniqueId="mock-runtime",
@@ -60,8 +65,7 @@ async def execute(
         input: dict[str, Any] | None = None,
         options: UiPathExecuteOptions | None = None,
     ) -> UiPathRuntimeResult:
-        from uipath.runtime.debug import UiPathBreakpointResult
-
+        """Execute the mock telemetry runtime."""
         payload = input or {}
         entrypoint = "mock-entrypoint"
         message = str(payload.get("message", ""))
@@ -454,10 +458,12 @@ async def stream(
         input: dict[str, Any] | None = None,
         options: UiPathStreamOptions | None = None,
     ) -> AsyncGenerator[UiPathRuntimeEvent, None]:
+        """Stream events from the mock telemetry runtime."""
         logger.info("MockRuntime: stream() invoked")
         print("[MockRuntime] stream() invoked")
         yield await self.execute(input=input, options=options)
 
     async def dispose(self) -> None:
+        """Dispose of any resources used by the mock telemetry runtime."""
         logger.info("MockRuntime: dispose() invoked")
         print("[MockRuntime] dispose() invoked")