machinaos 0.0.78 → 0.0.80

package/server/services/temporal/workflow.py

@@ -12,10 +12,11 @@ This enables massive horizontal scaling and multi-tenant distribution.
 """
 
 from datetime import timedelta
-from typing import Any, Dict, List, Set
+from typing import Any, Dict, List, Optional, Set
 
 from temporalio import workflow
-from temporalio.common import RetryPolicy
+
+from ._retry_policies import DEFAULT_ACTIVITY_RETRY
 
 # Config handles - nodes connecting via these are config nodes (not executed)
 # AI Agent handles: input-memory, input-tools, input-model, input-task, input-teammates
@@ -38,6 +39,38 @@ SKILL_NODE_TYPES = {
     "masterSkill",
 }
 
+# F4.B: agent types that migrate to AgentWorkflow (Temporal child workflow).
+# When ``temporal_agent_workflow_enabled`` is True the orchestrator schedules
+# AgentWorkflow for these node types instead of an activity. Tool calls
+# inside the agent loop become per-type activities (F4.A path).
+#
+# Excluded: ``rlm_agent``, ``claude_code_agent``. Their internal session
+# state (RLM REPL / Claude CLI --resume with stable cwd) requires
+# single-process continuity and breaks across activity boundaries. They
+# continue via F4.A per-type activities.
+AGENT_WORKFLOW_TYPES = frozenset(
+    [
+        "aiAgent",
+        "chatAgent",
+        # Specialized agents (12)
+        "android_agent",
+        "coding_agent",
+        "web_agent",
+        "task_agent",
+        "social_agent",
+        "travel_agent",
+        "tool_agent",
+        "productivity_agent",
+        "payments_agent",
+        "consumer_agent",
+        "autonomous_agent",
+        # Team leads (2)
+        "orchestrator_agent",
+        "ai_employee",
+    ]
+)
+
+
 @workflow.defn(sandboxed=False)
 class MachinaWorkflow:
     """Distributed workflow orchestrator.
@@ -50,8 +83,95 @@ class MachinaWorkflow:
     - Per-node retry policies
     - Config node filtering (tools, memory, services)
     - Multi-tenant support via tenant_id in context
+    - Wave 12 A7: event-framework signal handler — receives Temporal
+      Signals from ``services/events/dispatch.py:emit`` and parks
+      pending events in ``_matched_events`` for trigger nodes to
+      consume via ``workflow.wait_condition(_has_event_matching, ...)``.
+      Per-run dedup via ``_seen_event_ids`` (reconstructed
+      deterministically from Event History on replay).
     """
 
+    def __init__(self) -> None:
+        # Wave 12 A7: per-run event-framework state. Populated by the
+        # ``on_event`` signal handler; consumed by Phase C1's
+        # ``wait_condition`` predicate in the trigger-waiter rewrite.
+        # Today these stay empty unless the event-framework feature
+        # flag is on AND a producer signals this workflow.
+        self._seen_event_ids: Set[str] = set()
+        self._matched_events: List[Dict[str, Any]] = []
+
+    @workflow.signal
+    async def on_event(self, event_payload: Dict[str, Any]) -> None:
+        """Wave 12 A7: receive an event from ``services.events.dispatch.emit``.
+
+        Drops duplicates by ``event.id`` (per-run dedup — the set is
+        reconstructed deterministically from Event History on replay).
+        Matching events are queued for the workflow body to consume via
+        :meth:`_has_event_matching` in a ``wait_condition`` (wired in
+        Phase C1).
+        """
+        event_id = event_payload.get("id")
+        if not event_id:
+            workflow.logger.warning("on_event: skipping malformed envelope without 'id'")
+            return
+        if event_id in self._seen_event_ids:
+            workflow.logger.debug(f"on_event: dedup hit for event.id={event_id}")
+            return
+        self._seen_event_ids.add(event_id)
+        self._matched_events.append(event_payload)
+        workflow.logger.info(
+            f"on_event: queued event.id={event_id} " f"type={event_payload.get('type', '?')} " f"(matched={len(self._matched_events)})"
+        )
+
+    def _has_event_matching(self, predicate=None) -> bool:
+        """Wave 12 A7: ``wait_condition`` predicate for trigger nodes.
+
+        Returns True when at least one queued event matches the optional
+        ``predicate(event_payload) -> bool``. Defaults to "any event
+        queued" — most trigger nodes filter further by inspecting the
+        envelope after pop.
+
+        Used by Phase C1's trigger-waiter rewrite to replace the
+        in-process ``asyncio.Future`` waiter:
+
+            await workflow.wait_condition(
+                lambda: self._has_event_matching(my_filter),
+                timeout=...,
+            )
+            event = self._pop_matching_event(my_filter)
+        """
+        if not self._matched_events:
+            return False
+        if predicate is None:
+            return True
+        return any(predicate(e) for e in self._matched_events)
+
+    def _pop_matching_event(self, predicate=None) -> Optional[Dict[str, Any]]:
+        """Wave 12 A7: dequeue the first event that satisfies ``predicate``.
+
+        Pairs with :meth:`_has_event_matching` — Phase C1 trigger
+        waiters call ``wait_condition`` on the predicate, then pop the
+        actual envelope here. FIFO order: the predicate is evaluated
+        against the head of ``_matched_events`` first, so events
+        arrive in the order Temporal delivered the signals (and on
+        replay, the order Event History records them — deterministic).
+
+        Returns ``None`` if no queued event matches; callers should
+        only reach this method after ``wait_condition`` resolves, in
+        which case at least one match exists. The ``None`` return path
+        exists for defensive symmetry — never silently raises mid-
+        replay.
+
+        Determinism note: list mutation inside a workflow is safe per
+        Temporal's Python SDK contract (the workflow's local state is
+        rebuilt from Event History on replay; the same signals deliver
+        the same envelopes, so the same pops happen in the same order).
+        """
+        for idx, event in enumerate(self._matched_events):
+            if predicate is None or predicate(event):
+                return self._matched_events.pop(idx)
+        return None
+
     @workflow.run
     async def run(self, workflow_data: Dict[str, Any]) -> Dict[str, Any]:
         """Execute workflow by orchestrating node activities.
@@ -73,9 +193,7 @@ class MachinaWorkflow:
         workflow_id = workflow_data.get("workflow_id")
         tenant_id = workflow_data.get("tenant_id")
 
-        workflow.logger.info(
-            f"Starting workflow orchestration: {len(nodes)} nodes, {len(edges)} edges"
-        )
+        workflow.logger.info(f"Starting workflow orchestration: {len(nodes)} nodes, {len(edges)} edges")
 
         if not nodes:
             return {
@@ -89,8 +207,7 @@ class MachinaWorkflow:
         exec_nodes, exec_edges = self._filter_executable_graph(nodes, edges)
 
         workflow.logger.info(
-            f"After filtering: {len(exec_nodes)} executable nodes "
-            f"(filtered {len(nodes) - len(exec_nodes)} config nodes)"
+            f"After filtering: {len(exec_nodes)} executable nodes " f"(filtered {len(nodes) - len(exec_nodes)} config nodes)"
         )
 
         # 2. Build dependency maps
@@ -108,9 +225,10 @@ class MachinaWorkflow:
         for node in exec_nodes:
             if node.get("_pre_executed"):
                 node_id = node["id"]
+                trigger_output = node.get("_trigger_output", {})
                 outputs[node_id] = {
                     "success": True,
-                    "result": node.get("_trigger_output", {}),
+                    "result": trigger_output,
                     "pre_executed": True,
                 }
                 completed.add(node_id)
@@ -118,14 +236,35 @@ class MachinaWorkflow:
                 pre_executed_count += 1
                 workflow.logger.info(f"Pre-executed trigger: {node_id}")
 
+                # Persist the trigger output to the workflow output
+                # store so ParameterResolver can resolve
+                # ``{{triggerNodeName.field}}`` in downstream nodes.
+                # Pre-executed nodes bypass NodeExecutor.execute (the
+                # normal write site), so without this activity the
+                # legacy path's ``_store_output(trigger_node_id, ...)``
+                # behaviour is missing on the canary path and templates
+                # against the trigger silently resolve to empty.
+                # Skip the persist for non-firing siblings — their
+                # ``_trigger_output`` is ``{not_triggered: True}``, no
+                # downstream template should resolve against them.
+                if not trigger_output.get("not_triggered"):
+                    await workflow.execute_activity(
+                        "store_node_output_activity",
+                        {
+                            "node_id": node_id,
+                            "session_id": session_id,
+                            "result": trigger_output,
+                        },
+                        start_to_close_timeout=timedelta(seconds=10),
+                    )
+
         workflow.logger.info(f"Pre-executed: {pre_executed_count}, To execute: {len(node_map) - pre_executed_count}")
 
-        # 5. Retry policy for node activities
-        retry_policy = RetryPolicy(
-            initial_interval=timedelta(seconds=1),
-            maximum_interval=timedelta(seconds=30),
-            maximum_attempts=3,
-        )
+        # 5. Retry policy for node activities. Wave 12 D1: imported
+        # shared constant declares ``non_retryable_error_types`` so
+        # NodeUserError fails fast instead of burning 3 retries on
+        # user-correctable failures.
+        retry_policy = DEFAULT_ACTIVITY_RETRY
 
         # 6. Continuous scheduling loop
         loop_count = 0
@@ -144,9 +283,7 @@ class MachinaWorkflow:
                 # Trigger nodes are event listeners - scheduling them as activities
                 # would block indefinitely waiting for external events.
                 if node_type in TRIGGER_NODE_TYPES and not node.get("_pre_executed"):
-                    workflow.logger.warning(
-                        f"Skipping non-pre-executed trigger: {node_id} ({node_type})"
-                    )
+                    workflow.logger.warning(f"Skipping non-pre-executed trigger: {node_id} ({node_type})")
                     outputs[node_id] = {
                         "success": True,
                         "result": {"not_triggered": True},
@@ -172,18 +309,47 @@ class MachinaWorkflow:
                     "trigger_output": node.get("_trigger_output"),
                 }
 
-                # Schedule activity by name (for class-based activities)
-                # The activity is registered as NodeExecutionActivities.execute_node_activity
-                handle = workflow.start_activity(
-                    "execute_node_activity",
-                    args=[context],
-                    start_to_close_timeout=timedelta(minutes=10),
-                    heartbeat_timeout=timedelta(minutes=2),
-                    retry_policy=retry_policy,
-                )
-                running[node_id] = handle
-
-                workflow.logger.info(f"Scheduled activity for node: {node_id}")
+                # F4.B: agent-as-child-workflow takes precedence over the
+                # activity path for the 15 migrating agent types when its
+                # flag is on. Tool calls inside the agent loop become
+                # per-type activities (F4.A path) automatically.
+                dispatch = self._resolve_dispatch(node_type)
+                if dispatch["kind"] == "child_workflow":
+                    # ``workflow.start_child_workflow`` is ``async def`` —
+                    # awaiting it returns the ``ChildWorkflowHandle`` once
+                    # the child has been started by the server (fast; not
+                    # blocking on child completion). The handle is a
+                    # Task-like with ``.done()`` so it slots into the same
+                    # FIRST_COMPLETED loop as activity handles.
+                    handle = await workflow.start_child_workflow(
+                        dispatch["name"],
+                        args=[context],
+                        # Child workflow execution timeout: agent loops can run
+                        # 10+ minutes with multiple LLM turns. Set generously.
+                        execution_timeout=timedelta(hours=1),
+                        run_timeout=timedelta(hours=1),
+                    )
+                    running[node_id] = handle
+                    workflow.logger.info(f"Scheduled child workflow for node: {node_id} " f"(workflow={dispatch['name']})")
+                else:
+                    # F4.A activity path: per-type when the plugin class is
+                    # registered AND the per-type flag is on; legacy
+                    # execute_node_activity otherwise.
+                    start_kwargs: Dict[str, Any] = dict(
+                        args=[context],
+                        start_to_close_timeout=timedelta(minutes=10),
+                        heartbeat_timeout=timedelta(minutes=2),
+                        retry_policy=retry_policy,
+                    )
+                    if dispatch.get("queue") is not None:
+                        start_kwargs["task_queue"] = dispatch["queue"]
+
+                    handle = workflow.start_activity(dispatch["name"], **start_kwargs)
+                    running[node_id] = handle
+                    workflow.logger.info(
+                        f"Scheduled activity for node: {node_id} "
+                        f"(activity={dispatch['name']}, queue={dispatch.get('queue') or 'default'})"
+                    )
 
             # Exit if nothing running and nothing ready
             if not running:
@@ -213,10 +379,7 @@ class MachinaWorkflow:
         # Build final result
         success = len(errors) == 0 and len(completed) == len(node_map)
 
-        workflow.logger.info(
-            f"Workflow complete: success={success}, "
-            f"executed={len(execution_trace)}/{len(node_map)}"
-        )
+        workflow.logger.info(f"Workflow complete: success={success}, " f"executed={len(execution_trace)}/{len(node_map)}")
 
         return {
             "success": success,
@@ -238,6 +401,65 @@ class MachinaWorkflow:
                 inputs[dep_id] = outputs[dep_id].get("result", {})
         return inputs
 
+    def _resolve_dispatch(self, node_type: str) -> Dict[str, Any]:
+        """Resolve dispatch kind for a node type.
+
+        Returns one of:
+          - ``{"kind": "child_workflow", "name": "AgentWorkflow"}`` — when
+            F4.B is enabled AND node_type is in ``AGENT_WORKFLOW_TYPES``.
+          - ``{"kind": "activity", "name": <activity_name>, "queue": <queue|None>}``
+            — F4.A per-type activity OR legacy fallback, depending on
+            ``temporal_per_type_dispatch``.
+
+        Deterministic: all lookups go through frozen dicts (Settings,
+        _NODE_CLASS_REGISTRY, AGENT_WORKFLOW_TYPES). Safe inside
+        ``MachinaWorkflow.run`` per the workflow-definition contract.
+        """
+        from core.config import Settings
+
+        settings = Settings()
+        if getattr(settings, "temporal_agent_workflow_enabled", False) and node_type in AGENT_WORKFLOW_TYPES:
+            return {"kind": "child_workflow", "name": "AgentWorkflow"}
+
+        name, queue = self._resolve_activity(node_type)
+        return {"kind": "activity", "name": name, "queue": queue}
+
+    def _resolve_activity(self, node_type: str) -> tuple[str, str | None]:
+        """Resolve (activity_name, task_queue) for a node type.
+
+        F4.A: when ``settings.temporal_per_type_dispatch`` is on AND the
+        plugin class is registered, returns
+        ``("node.{type}.v{version}", None)`` so the activity is scheduled
+        by per-type name but stays on the workflow's default task queue.
+        The default queue is what ``TemporalWorkerManager`` polls today;
+        per-queue routing (``cls.task_queue``) becomes meaningful only
+        once ``TemporalWorkerPool`` is wired with one worker per queue
+        — until then, returning ``cls.task_queue`` would schedule the
+        activity to a queue no worker polls and the workflow would hang.
+
+        Falls back to ``("execute_node_activity", None)`` when:
+          - the flag is off (preserves pre-F4.A behavior exactly), OR
+          - the node type isn't registered as a BaseNode subclass
+            (covers legacy types still on the metadata-only path).
+
+        Determinism: lookups go through frozen module-level dicts
+        (``_NODE_CLASS_REGISTRY``, ``Settings``) — no I/O. Safe inside
+        ``MachinaWorkflow.run`` per the workflow-definition contract.
+        Imports are inside the method to keep the workflow module's
+        top-level import set minimal and to avoid import-cycle drift.
+        """
+        from core.config import Settings
+        from services.node_registry import get_node_class
+
+        if not Settings().temporal_per_type_dispatch:
+            return "execute_node_activity", None
+
+        cls = get_node_class(node_type)
+        if cls is None:
+            return "execute_node_activity", None
+
+        return f"node.{cls.type}.v{cls.version}", None
+
     async def _wait_any_complete(self, running: Dict[str, Any]) -> tuple:
         """Wait for any activity to complete, return (node_id, result).
 
@@ -260,9 +482,7 @@ class MachinaWorkflow:
         [h for _, h in items]
 
         # Use asyncio.wait pattern via workflow.wait
-        await workflow.wait_condition(
-            lambda: any(h.done() for _, h in items)
-        )
+        await workflow.wait_condition(lambda: any(h.done() for _, h in items))
 
         # Find the completed one
         for node_id, handle in items:
@@ -313,10 +533,9 @@ class MachinaWorkflow:
         # Filter nodes and edges
         exec_nodes = [n for n in nodes if n["id"] not in config_ids]
         exec_edges = [
-            e for e in edges
-            if e.get("source") not in config_ids
-            and e.get("target") not in config_ids
-            and e.get("targetHandle", "") not in CONFIG_HANDLES
+            e
+            for e in edges
+            if e.get("source") not in config_ids and e.get("target") not in config_ids and e.get("targetHandle", "") not in CONFIG_HANDLES
         ]
 
         return exec_nodes, exec_edges

package/server/services/temporal/ws_client.py

@@ -22,11 +22,15 @@ from core.config import Settings
 
 logger = get_logger(__name__)
 
-# Load settings
-_settings = Settings()
-WS_URL = f"ws://{_settings.host}:{_settings.port}/ws/internal"
 
-print(f"[Temporal WS Client] WebSocket URL configured: {WS_URL}")
+def _default_ws_url() -> str:
+    """Resolve the activity-side WS URL from current ``Settings``.
+
+    Deferred to first call so module import doesn't require the full env
+    surface — same rationale as ``activities._resolve_urls``.
+    """
+    settings = Settings()
+    return f"ws://{settings.host}:{settings.port}/ws/internal"
 
 
 class WSConnectionPool:
@@ -41,8 +45,8 @@ class WSConnectionPool:
     avoiding the ConcurrencyError that occurs when sharing a single connection.
     """
 
-    def __init__(self, url: str = WS_URL, pool_size: int = 100):
-        self.url = url
+    def __init__(self, url: Optional[str] = None, pool_size: int = 100):
+        self.url = url if url is not None else _default_ws_url()
         self.pool_size = pool_size
         self._session: Optional[aiohttp.ClientSession] = None
         self._lock = asyncio.Lock()
@@ -65,7 +69,10 @@ class WSConnectionPool:
                         connector=connector,
                         timeout=timeout,
                     )
-                    print(f"[WS Pool] Created session with pool_size={self.pool_size}")
+                    logger.info(
+                        "Created shared session",
+                        pool_size=self.pool_size,
+                    )
         return self._session
 
     @asynccontextmanager
@@ -115,7 +122,7 @@ class WSConnectionPool:
         try:
             async with self.connection() as ws:
                 await ws.send_json(message)
-                print(f"[WS Pool] Sent execute_node for {node_id}")
+                logger.debug("Sent execute_node", node_id=node_id)
 
                 # Wait for response with matching request_id
                 async with asyncio.timeout(timeout):
@@ -123,7 +130,11 @@ class WSConnectionPool:
                         if msg.type == aiohttp.WSMsgType.TEXT:
                             response = json.loads(msg.data)
                             if response.get("request_id") == request_id:
-                                print(f"[WS Pool] Received response for {node_id}: success={response.get('success')}")
+                                logger.debug(
+                                    "Received response",
+                                    node_id=node_id,
+                                    success=response.get("success"),
+                                )
                                 return response
                         elif msg.type == aiohttp.WSMsgType.ERROR:
                             raise Exception(f"WebSocket error: {ws.exception()}")
@@ -141,7 +152,7 @@ class WSConnectionPool:
         """Close the connection pool."""
         if self._session and not self._session.closed:
             await self._session.close()
-            print("[WS Pool] Session closed")
+            logger.info("Session closed")
 
 
 # Global connection pool instance
@@ -206,7 +217,7 @@ async def close_ws_client() -> None:
 class TemporalWSClient:
     """Backwards compatibility wrapper around WSConnectionPool."""
 
-    def __init__(self, url: str = WS_URL):
+    def __init__(self, url: Optional[str] = None):
         self._pool = WSConnectionPool(url=url)
 
     @property

package/server/services/text.py

@@ -20,24 +20,15 @@ class TextService:
         start_time = time.time()
 
         try:
-            text = parameters.get('text', 'Hello World')
-            include_timestamp = parameters.get('include_timestamp', True)
+            text = parameters.get("text", "Hello World")
+            include_timestamp = parameters.get("include_timestamp", True)
 
-            result_data = {
-                "text": text,
-                "length": len(text),
-                "nodeId": node_id
-            }
+            result_data = {"text": text, "length": len(text), "nodeId": node_id}
 
             if include_timestamp:
                 result_data["timestamp"] = datetime.now().isoformat()
 
-            result = {
-                "type": "text",
-                "data": result_data,
-                "nodeId": node_id,
-                "timestamp": datetime.now().isoformat()
-            }
+            result = {"type": "text", "data": result_data, "nodeId": node_id, "timestamp": datetime.now().isoformat()}
 
             log_execution_time(logger, "text_generator", start_time, time.time())
 
@@ -47,7 +38,7 @@ class TextService:
                 "node_type": "textGenerator",
                 "result": result,
                 "execution_time": time.time() - start_time,
-                "timestamp": datetime.now().isoformat()
+                "timestamp": datetime.now().isoformat(),
             }
 
         except Exception as e:
@@ -58,7 +49,7 @@ class TextService:
                 "node_type": "textGenerator",
                 "error": str(e),
                 "execution_time": time.time() - start_time,
-                "timestamp": datetime.now().isoformat()
+                "timestamp": datetime.now().isoformat(),
             }
 
     async def execute_file_handler(self, node_id: str, parameters: Dict[str, Any]) -> Dict[str, Any]:
@@ -66,9 +57,9 @@ class TextService:
         start_time = time.time()
 
         try:
-            file_type = parameters.get('file_type', 'generic')
-            file_content = parameters.get('content', '')
-            file_name = parameters.get('file_name', 'untitled.txt')
+            file_type = parameters.get("file_type", "generic")
+            file_content = parameters.get("content", "")
+            file_name = parameters.get("file_name", "untitled.txt")
 
             # Basic file processing
             result_data = {
@@ -78,16 +69,11 @@ class TextService:
                 "size": len(file_content),
                 "processed": True,
                 "processingType": file_type,
-                "nodeId": node_id
-            }
-
-            result = {
-                "type": "file",
-                "data": result_data,
                 "nodeId": node_id,
-                "timestamp": datetime.now().isoformat()
             }
 
+            result = {"type": "file", "data": result_data, "nodeId": node_id, "timestamp": datetime.now().isoformat()}
+
             log_execution_time(logger, "file_handler", start_time, time.time())
 
             return {
@@ -96,7 +82,7 @@ class TextService:
                 "node_type": "fileHandler",
                 "result": result,
                 "execution_time": time.time() - start_time,
-                "timestamp": datetime.now().isoformat()
+                "timestamp": datetime.now().isoformat(),
             }
 
         except Exception as e:
@@ -107,5 +93,5 @@ class TextService:
                 "node_type": "fileHandler",
                 "error": str(e),
                 "execution_time": time.time() - start_time,
-                "timestamp": datetime.now().isoformat()
-            }
+                "timestamp": datetime.now().isoformat(),
+            }