agstack 1.4.0__tar.gz → 1.6.0__tar.gz

{agstack-1.4.0 → agstack-1.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agstack
-Version: 1.4.0
+Version: 1.6.0
 Summary: Production-ready toolkit for building FastAPI and LLM applications
 Author-email: XtraVisions <gitadmin@xtravisions.com>, Chen Hao <chenhao@xtravisions.com>
 Maintainer-email: XtraVisions <gitadmin@xtravisions.com>, Chen Hao <chenhao@xtravisions.com>
@@ -35,7 +35,7 @@ Requires-Dist: python-multipart>=0.0.20
 Requires-Dist: requests>=2.32.5
 Requires-Dist: RestrictedPython>=7.0
 Requires-Dist: sqlalchemy[asyncio]>=2.0.48
-Requires-Dist: sqlobjects>=1.3.0
+Requires-Dist: sqlobjects>=1.4.0
 Requires-Dist: tiktoken>=0.12.0
 Requires-Dist: uvicorn>=0.41.0
 Dynamic: license-file

{agstack-1.4.0 → agstack-1.6.0}/agstack/llm/flow/__init__.py

@@ -18,6 +18,7 @@ from .exceptions import (
 from .factory import create_agent, create_tool
 from .flow import Flow
 from .loader import FlowLoader
+from .nodes import NodeHandler, register_node_handler
 from .records import Record, Status
 from .registry import registry
 from .state import FlowState
@@ -32,6 +33,9 @@ __all__ = [
     "Flow",
     "FlowContext",
     "Usage",
+    # 节点处理器
+    "NodeHandler",
+    "register_node_handler",
     # AG-UI 协议
     "EventType",
     "event",

{agstack-1.4.0 → agstack-1.6.0}/agstack/llm/flow/flow.py

@@ -1,4 +1,4 @@
-#  Copyright (c) 2020-2025 XtraVisions, All rights reserved.
+#  Copyright (c) 2020-2026 XtraVisions, All rights reserved.
 
 """Flow 定义和执行"""
 
@@ -9,12 +9,21 @@ from typing import TYPE_CHECKING, Any, AsyncIterator
 from uuid import uuid4
 
 from . import event
-from .exceptions import FlowError
-from .registry import registry
+from .exceptions import NodeExecutionError
 
 
 if TYPE_CHECKING:
     from .context import FlowContext
+    from .nodes.base import NodeHandler
+
+
+@dataclass
+class RetryPolicy:
+    """节点重试策略"""
+
+    max_retries: int = 0  # 0 = 不重试
+    delay: float = 1.0  # 初始延迟（秒）
+    backoff: float = 2.0  # 退避倍数
 
 
 class _SafeFormatDict(dict):
@@ -35,6 +44,31 @@ class Flow:
     edges: list[dict[str, Any]] = field(default_factory=list)
     variables: dict[str, Any] = field(default_factory=dict)
 
+    _node_handlers: dict[str, "NodeHandler"] = field(default_factory=dict, init=False, repr=False)
+
+    def __post_init__(self) -> None:
+        from .nodes import _global_node_handlers, builtin_handlers
+
+        for handler in builtin_handlers:
+            self._node_handlers[handler.node_type] = handler
+        # 全局注册的自定义 handler 可覆盖内置
+        self._node_handlers.update(_global_node_handlers)
+
+    # ── 重试策略 ──
+
+    @staticmethod
+    def _get_retry_policy(node: dict) -> RetryPolicy:
+        """从节点 config 解析重试策略"""
+        config = node.get("config", {})
+        retry_cfg = config.get("retry", {})
+        if not retry_cfg:
+            return RetryPolicy()
+        return RetryPolicy(
+            max_retries=retry_cfg.get("max_retries", 0),
+            delay=retry_cfg.get("delay", 1.0),
+            backoff=retry_cfg.get("backoff", 2.0),
+        )
+
     # ── 边驱动路由 ──
 
     def _resolve_next_node(self, current_id: str, result: str | None = None) -> str | None:
@@ -46,33 +80,22 @@ class Flow:
                     return edge.get("target")
         return None
 
-    # ── condition 节点 ──
-
-    async def _evaluate_condition(self, node: dict, context: "FlowContext") -> str:
-        """调用 LLM 判断条件是否匹配"""
-        config = node.get("config", {})
-        topic = config.get("topic", "")
-        query = context.get_variable("query", "")
-
-        prompt = (
-            f"判断以下问题是否属于「{topic}」相关问题。\n"
-            f"问题：{query}\n"
-            f'仅回复 JSON：{{"result": "match"}} 或 {{"result": "reject"}}'
-        )
-
-        from ..client import get_llm_client
+    @staticmethod
+    def _extract_route_key(result: Any) -> str:
+        """从节点执行结果中提取路由键。
 
-        client = get_llm_client()
-        response = await client.chat(
-            messages=[{"role": "user", "content": prompt}],
-            model=config.get("model", "gpt-4o-mini"),
-            temperature=0,
-        )
-        text = response.choices[0].message.content or ""
+        支持 ``{"result": "qa"}`` 形式的 JSON 字符串，
+        以及纯字符串结果。
+        """
+        if not isinstance(result, str):
+            return "done"
         try:
-            return _json.loads(text).get("result", "reject")
-        except Exception:
-            return "match" if "match" in text.lower() else "reject"
+            parsed = _json.loads(result)
+            if isinstance(parsed, dict) and "result" in parsed:
+                return str(parsed["result"])
+        except (ValueError, TypeError):
+            pass
+        return result or "done"
 
     # ── message 节点 ──
 
@@ -86,6 +109,62 @@ class Flow:
         yield event.text_message_content(message_id=msg_id, delta=text)
         yield event.text_message_end(message_id=msg_id)
 
+    # ── 带重试的节点执行（统一走 NodeHandler） ──
+
+    async def _execute_node_with_retry(
+        self,
+        node: dict,
+        context: "FlowContext",
+        node_id: str,
+    ) -> AsyncIterator[dict[str, Any]]:
+        """执行节点，带重试策略，产出 AG-UI 事件"""
+        node_type: str = node.get("type", "")
+        handler = self._node_handlers.get(node_type)
+        if not handler:
+            yield event.run_error(
+                message=f"Unknown node type: {node_type}",
+                code="UNKNOWN_NODE_TYPE",
+            )
+            raise NodeExecutionError("UNKNOWN_NODE_TYPE", args={"node_type": node_type})
+
+        policy = self._get_retry_policy(node)
+        label = handler.get_step_name(node, node_id)
+        last_error: Exception | None = None
+
+        for attempt in range(policy.max_retries + 1):
+            try:
+                if attempt > 0:
+                    wait = policy.delay * (policy.backoff ** (attempt - 1))
+                    await asyncio.sleep(wait)
+                    yield event.custom(
+                        name="node_retry",
+                        value={
+                            "nodeId": node_id,
+                            "nodeType": node_type,
+                            "label": label,
+                            "attempt": attempt + 1,
+                            "maxAttempts": policy.max_retries + 1,
+                            "error": str(last_error),
+                        },
+                    )
+
+                async for evt in handler.stream(node, context, node_id):
+                    yield evt
+                return
+
+            except Exception as e:
+                last_error = e
+                if attempt < policy.max_retries:
+                    continue
+                yield event.run_error(
+                    message=str(e),
+                    code=type(e).__name__,
+                )
+                raise NodeExecutionError(
+                    "NODE_EXECUTION_FAILED",
+                    args={"node_id": node_id, "error": str(e)},
+                ) from e
+
     # ── 执行入口 ──
 
     async def run(self, context: "FlowContext") -> dict[str, Any]:
@@ -97,8 +176,13 @@ class Flow:
                 if not node_id:
                     continue
                 context.current_node = node_id
-                result = await self._execute_node(node, context)
-                context.set_node_result(node_id, result)
+                node_type: str = node.get("type", "")
+                handler = self._node_handlers.get(node_type)
+                if handler:
+                    result = await handler.execute(node, context)
+                    context.set_node_result(node_id, result)
+                else:
+                    raise NodeExecutionError("UNKNOWN_NODE_TYPE", args={"node_type": node_type})
         else:
             # edge 驱动执行
             current_node_id: str | None = self.nodes[0]["id"] if self.nodes else None
@@ -107,22 +191,14 @@ class Flow:
                 if not node:
                     break
                 context.current_node = current_node_id
-                node_type = node.get("type")
+                node_type: str = node.get("type", "")
 
-                if node_type == "condition":
-                    result = await self._evaluate_condition(node, context)
-                    context.set_node_result(current_node_id, result)
-                    current_node_id = self._resolve_next_node(current_node_id, result)
-                elif node_type == "message":
+                if node_type == "message":
                     config = node.get("config", {})
                     template = config.get("content", "")
                     text = template.format_map(_SafeFormatDict(context.variables))
                     context.set_node_result(current_node_id, text)
                     current_node_id = self._resolve_next_node(current_node_id, "done")
-                elif node_type in ("agent", "tool"):
-                    result = await self._execute_node(node, context)
-                    context.set_node_result(current_node_id, result)
-                    current_node_id = self._resolve_next_node(current_node_id, "done")
 
                 elif node_type == "parallel":
                     config = node.get("config", {})
@@ -133,9 +209,11 @@ class Flow:
                         if not branch_node:
                             return
                         context.current_node = branch_id
-                        self._set_parameters(branch_node.get("config", {}), context)
-                        result = await self._execute_node(branch_node, context)
-                        context.set_node_result(branch_id, result)
+                        branch_type: str = branch_node.get("type", "")
+                        branch_handler = self._node_handlers.get(branch_type)
+                        if branch_handler:
+                            result = await branch_handler.execute(branch_node, context)
+                            context.set_node_result(branch_id, result)
 
                     await asyncio.gather(*[_run_branch(bid) for bid in branches])
                     context.set_node_result(current_node_id, "done")
@@ -163,9 +241,11 @@ class Flow:
                             body_node = self.get_node_config(body_node_id)
                             if not body_node:
                                 continue
-                            self._set_parameters(body_node.get("config", {}), context)
-                            body_result = await self._execute_node(body_node, context)
-                            context.set_node_result(body_node_id, body_result)
+                            body_type: str = body_node.get("type", "")
+                            body_handler = self._node_handlers.get(body_type)
+                            if body_handler:
+                                body_result = await body_handler.execute(body_node, context)
+                                context.set_node_result(body_node_id, body_result)
                         if body_nodes:
                             results.append(context.node_results.get(body_nodes[-1]))
 
@@ -187,9 +267,11 @@ class Flow:
                             body_node = self.get_node_config(body_node_id)
                             if not body_node:
                                 continue
-                            self._set_parameters(body_node.get("config", {}), context)
-                            body_result = await self._execute_node(body_node, context)
-                            context.set_node_result(body_node_id, body_result)
+                            body_type: str = body_node.get("type", "")
+                            body_handler = self._node_handlers.get(body_type)
+                            if body_handler:
+                                body_result = await body_handler.execute(body_node, context)
+                                context.set_node_result(body_node_id, body_result)
                         if condition_node_id:
                             cond_result = context.node_results.get(condition_node_id, "")
                             if isinstance(cond_result, str):
@@ -204,27 +286,18 @@ class Flow:
                     context.set_node_result(current_node_id, "done")
                     current_node_id = self._resolve_next_node(current_node_id, "done")
 
-                elif node_type == "python":
-                    config = node.get("config", {})
-                    inputs_spec: dict[str, Any] = config.get("inputs", {})
-                    resolved_inputs: dict[str, Any] = {}
-                    for key, ref in inputs_spec.items():
-                        resolved_inputs[key] = context.resolve_reference(ref) if isinstance(ref, str) else ref
-
-                    from .sandbox import execute_python_node
-
-                    code_str = config.get("code", "")
-                    py_result = execute_python_node(code_str, resolved_inputs)
-
-                    outputs_spec: dict[str, Any] = config.get("outputs", {})
-                    for key in outputs_spec:
-                        if key in py_result:
-                            context.set_variable(key, py_result[key])
+                elif node_type in self._node_handlers:
+                    # 所有执行类节点统一分发
+                    handler = self._node_handlers[node_type]
+                    result = await handler.execute(node, context)
+                    context.set_node_result(current_node_id, result)
+                    route_key = self._extract_route_key(result)
+                    current_node_id = self._resolve_next_node(current_node_id, route_key) or self._resolve_next_node(
+                        current_node_id, "done"
+                    )
 
-                    context.set_node_result(current_node_id, _json.dumps(py_result, ensure_ascii=False))
-                    current_node_id = self._resolve_next_node(current_node_id, "done")
                 else:
-                    break
+                    raise NodeExecutionError("UNKNOWN_NODE_TYPE", args={"node_type": node_type})
 
         return context.node_results
 
@@ -251,24 +324,17 @@ class Flow:
                 continue
 
             context.current_node = node_id
-            yield event.step_started(step_name=f"node:{node_id}")
-
-            if node.get("type") == "agent":
-                agent_name = node.get("config", {}).get("agent_name", "")
-                yield event.step_started(step_name=f"agent:{agent_name}")
-                self._set_parameters(node.get("config", {}), context)
-                ag = self._create_agent(node.get("config", {}))
-                async for evt in ag.stream(context):
+            node_type: str = node.get("type", "")
+
+            if node_type in self._node_handlers:
+                async for evt in self._execute_node_with_retry(node, context, node_id):
                     yield evt
-                result = context.get_last_output(ag.name) or ""
-                context.set_node_result(node_id, result)
-                yield event.step_finished(step_name=f"agent:{agent_name}")
             else:
-                tool_name = node.get("config", {}).get("tool_name", "")
-                yield event.step_started(step_name=f"tool:{tool_name}")
-                result = await self._execute_node(node, context)
-                context.set_node_result(node_id, result)
-                yield event.step_finished(step_name=f"tool:{tool_name}")
+                yield event.run_error(
+                    message=f"Unknown node type: {node_type}",
+                    code="UNKNOWN_NODE_TYPE",
+                )
+                raise NodeExecutionError("UNKNOWN_NODE_TYPE", args={"node_type": node_type})
 
     async def _stream_edge_driven(self, context: "FlowContext") -> AsyncIterator[dict[str, Any]]:
         """边驱动流式执行"""
@@ -277,41 +343,20 @@ class Flow:
         while current_node_id:
             node = self.get_node_config(current_node_id)
             if not node:
-                break
+                yield event.run_error(
+                    message=f"Node not found: {current_node_id}",
+                    code="NODE_NOT_FOUND",
+                )
+                raise NodeExecutionError("NODE_NOT_FOUND", args={"node_id": current_node_id})
 
             context.current_node = current_node_id
-            node_type = node.get("type")
+            node_type: str = node.get("type", "")
 
-            if node_type == "condition":
-                result = await self._evaluate_condition(node, context)
-                context.set_node_result(current_node_id, result)
-                current_node_id = self._resolve_next_node(current_node_id, result)
-
-            elif node_type == "message":
+            if node_type == "message":
                 async for evt in self._emit_message(node, context):
                     yield evt
                 current_node_id = self._resolve_next_node(current_node_id, "done")
 
-            elif node_type == "agent":
-                agent_name = node.get("config", {}).get("agent_name", "")
-                yield event.step_started(step_name=f"agent:{agent_name}")
-                self._set_parameters(node.get("config", {}), context)
-                ag = self._create_agent(node.get("config", {}))
-                async for evt in ag.stream(context):
-                    yield evt
-                result = context.get_last_output(ag.name) or ""
-                context.set_node_result(current_node_id, result)
-                yield event.step_finished(step_name=f"agent:{agent_name}")
-                current_node_id = self._resolve_next_node(current_node_id, "done")
-
-            elif node_type == "tool":
-                tool_name = node.get("config", {}).get("tool_name", "")
-                yield event.step_started(step_name=f"tool:{tool_name}")
-                result = await self._execute_node(node, context)
-                context.set_node_result(current_node_id, result)
-                yield event.step_finished(step_name=f"tool:{tool_name}")
-                current_node_id = self._resolve_next_node(current_node_id, "done")
-
             elif node_type == "parallel":
                 config = node.get("config", {})
                 branches = config.get("branches", [])
@@ -322,9 +367,11 @@ class Flow:
                     if not branch_node:
                         return
                     context.current_node = branch_id
-                    self._set_parameters(branch_node.get("config", {}), context)
-                    result = await self._execute_node(branch_node, context)
-                    context.set_node_result(branch_id, result)
+                    branch_type = branch_node.get("type", "")
+                    branch_handler = self._node_handlers.get(branch_type)
+                    if branch_handler:
+                        result = await branch_handler.execute(branch_node, context)
+                        context.set_node_result(branch_id, result)
 
                 await asyncio.gather(*[_exec_branch(bid) for bid in branches])
                 context.set_node_result(current_node_id, "done")
@@ -354,9 +401,11 @@ class Flow:
                         body_node = self.get_node_config(body_node_id)
                         if not body_node:
                             continue
-                        self._set_parameters(body_node.get("config", {}), context)
-                        body_result = await self._execute_node(body_node, context)
-                        context.set_node_result(body_node_id, body_result)
+                        body_type = body_node.get("type", "")
+                        body_handler = self._node_handlers.get(body_type)
+                        if body_handler:
+                            body_result = await body_handler.execute(body_node, context)
+                            context.set_node_result(body_node_id, body_result)
                     if body_nodes:
                         results.append(context.node_results.get(body_nodes[-1]))
 
@@ -380,9 +429,11 @@ class Flow:
                         body_node = self.get_node_config(body_node_id)
                         if not body_node:
                             continue
-                        self._set_parameters(body_node.get("config", {}), context)
-                        body_result = await self._execute_node(body_node, context)
-                        context.set_node_result(body_node_id, body_result)
+                        body_type = body_node.get("type", "")
+                        body_handler = self._node_handlers.get(body_type)
+                        if body_handler:
+                            body_result = await body_handler.execute(body_node, context)
+                            context.set_node_result(body_node_id, body_result)
                     # 检查终止条件
                     if condition_node_id:
                         cond_result = context.node_results.get(condition_node_id, "")
@@ -399,84 +450,22 @@ class Flow:
                 yield event.step_finished(step_name=f"loop:{current_node_id}")
                 current_node_id = self._resolve_next_node(current_node_id, "done")
 
-            elif node_type == "python":
-                config = node.get("config", {})
-                yield event.step_started(step_name=f"python:{current_node_id}")
-
-                # 解析 inputs
-                inputs_spec: dict[str, Any] = config.get("inputs", {})
-                resolved_inputs: dict[str, Any] = {}
-                for key, ref in inputs_spec.items():
-                    resolved_inputs[key] = context.resolve_reference(ref) if isinstance(ref, str) else ref
-
-                # 沙箱执行
-                from .sandbox import execute_python_node
-
-                code_str = config.get("code", "")
-                py_result = execute_python_node(code_str, resolved_inputs)
-
-                # 映射 outputs 到 context.variables
-                outputs_spec: dict[str, Any] = config.get("outputs", {})
-                for key in outputs_spec:
-                    if key in py_result:
-                        context.set_variable(key, py_result[key])
-
-                context.set_node_result(current_node_id, _json.dumps(py_result, ensure_ascii=False))
-                yield event.step_finished(step_name=f"python:{current_node_id}")
-                current_node_id = self._resolve_next_node(current_node_id, "done")
+            elif node_type in self._node_handlers:
+                # 所有执行类节点统一分发
+                async for evt in self._execute_node_with_retry(node, context, current_node_id):
+                    yield evt
+                result = context.node_results.get(current_node_id, "")
+                route_key = self._extract_route_key(result)
+                current_node_id = self._resolve_next_node(current_node_id, route_key) or self._resolve_next_node(
+                    current_node_id, "done"
+                )
 
             else:
-                break
-
-    async def _execute_node(self, node_config: dict, context: "FlowContext") -> Any:
-        """执行节点"""
-        node_type = node_config.get("type")
-        config = node_config.get("config", {})
-
-        # 设置参数到 context
-        self._set_parameters(config, context)
-
-        # 创建并执行 runnable
-        if node_type == "agent":
-            runnable = self._create_agent(config)
-        elif node_type == "tool":
-            runnable = self._create_tool(config)
-        else:
-            raise FlowError("UNKNOWN_NODE_TYPE", 400, {"type": node_type})
-
-        return await runnable.run(context)
-
-    def _set_parameters(self, config: dict, context: "FlowContext") -> None:
-        """设置参数到 context"""
-        parameters = config.get("parameters", {})
-
-        for key, value in parameters.items():
-            resolved_value = context.resolve_reference(value) if isinstance(value, str) else value
-            context.set_variable(key, resolved_value)
-
-    def _create_agent(self, config: dict):
-        """创建 Agent"""
-        agent_name = config.get("agent_name")
-        if not agent_name:
-            raise FlowError("MISSING_AGENT_NAME", 400)
-
-        agent = registry.create_agent(agent_name)
-        if not agent:
-            raise FlowError("AGENT_NOT_FOUND", 404, {"agent_name": agent_name})
-
-        return agent
-
-    def _create_tool(self, config: dict):
-        """创建 Tool"""
-        tool_name = config.get("tool_name")
-        if not tool_name:
-            raise FlowError("MISSING_TOOL_NAME", 400)
-
-        tool = registry.create_tool(tool_name)
-        if not tool:
-            raise FlowError("TOOL_NOT_FOUND", 404, {"tool_name": tool_name})
-
-        return tool
+                yield event.run_error(
+                    message=f"Unknown node type: {node_type}",
+                    code="UNKNOWN_NODE_TYPE",
+                )
+                raise NodeExecutionError("UNKNOWN_NODE_TYPE", args={"node_type": node_type})
 
     def get_node_config(self, node_id: str) -> dict[str, Any] | None:
         """获取节点配置"""

agstack-1.6.0/agstack/llm/flow/nodes/__init__.py

@@ -0,0 +1,39 @@
+#  Copyright (c) 2020-2026 XtraVisions, All rights reserved.
+
+"""内置节点处理器注册"""
+
+from .agent_node import AgentNodeHandler
+from .base import NodeHandler
+from .detect_node import DetectNodeHandler
+from .llm_chat_node import LLMChatNodeHandler
+from .llm_embed_node import LLMEmbedNodeHandler
+from .llm_rerank_node import LLMRerankNodeHandler
+from .python_node import PythonNodeHandler
+from .tool_node import ToolNodeHandler
+
+
+# 所有内置 handler 实例
+builtin_handlers: list[NodeHandler] = [
+    AgentNodeHandler(),
+    ToolNodeHandler(),
+    PythonNodeHandler(),
+    LLMChatNodeHandler(),
+    LLMEmbedNodeHandler(),
+    LLMRerankNodeHandler(),
+    DetectNodeHandler(),
+]
+
+# 全局自定义节点注册
+_global_node_handlers: dict[str, NodeHandler] = {}
+
+
+def register_node_handler(node_type: str, handler: NodeHandler) -> None:
+    """注册自定义节点处理器（全局，所有 Flow 实例共享）"""
+    _global_node_handlers[node_type] = handler
+
+
+__all__ = [
+    "NodeHandler",
+    "builtin_handlers",
+    "register_node_handler",
+]

agstack-1.6.0/agstack/llm/flow/nodes/agent_node.py

@@ -0,0 +1,55 @@
+#  Copyright (c) 2020-2026 XtraVisions, All rights reserved.
+
+"""Agent 节点处理器 — 从 flow.py 提取"""
+
+from typing import TYPE_CHECKING, Any, AsyncIterator
+
+from .. import event
+from ..exceptions import FlowError
+from ..registry import registry
+from .base import NodeHandler
+
+
+if TYPE_CHECKING:
+    from ..context import FlowContext
+
+
+class AgentNodeHandler(NodeHandler):
+    """Agent 节点：通过 registry 查找 agent → ag.stream(context)"""
+
+    node_type = "agent"
+
+    def _set_parameters(self, config: dict, context: "FlowContext") -> None:
+        parameters = config.get("parameters", {})
+        for key, value in parameters.items():
+            resolved = context.resolve_reference(value) if isinstance(value, str) else value
+            context.set_variable(key, resolved)
+
+    def _create_agent(self, config: dict):
+        agent_name = config.get("agent_name")
+        if not agent_name:
+            raise FlowError("MISSING_AGENT_NAME", 400)
+        agent = registry.create_agent(agent_name)
+        if not agent:
+            raise FlowError("AGENT_NOT_FOUND", 404, {"agent_name": agent_name})
+        return agent
+
+    async def execute(self, node: dict, context: "FlowContext") -> Any:
+        config = node.get("config", {})
+        self._set_parameters(config, context)
+        ag = self._create_agent(config)
+        return await ag.run(context)
+
+    async def stream(self, node: dict, context: "FlowContext", node_id: str) -> AsyncIterator[dict[str, Any]]:
+        config = node.get("config", {})
+        step_name = self.get_step_name(node, node_id)
+
+        yield event.step_started(step_name=step_name)
+        self._set_parameters(config, context)
+        ag = self._create_agent(config)
+        async for evt in ag.stream(context):
+            yield evt
+        result = context.get_last_output(ag.name) or ""
+        context.set_node_result(node_id, result)
+        self.map_outputs(config, context, {"result": result})
+        yield event.step_finished(step_name=step_name)