agstack 1.6.0__tar.gz → 1.8.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agstack
-Version: 1.6.0
+Version: 1.8.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>
@@ -27,7 +27,7 @@ Requires-Dist: fastapi>=0.133.1
 Requires-Dist: jwcrypto>=1.5.6
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: nebula3-python>=3.8.3
-Requires-Dist: openai>=2.26.0
+Requires-Dist: openai>=2.28.0
 Requires-Dist: passlib[bcrypt]>=1.7.4
 Requires-Dist: pycasbin>=2.8.0
 Requires-Dist: pydantic>=2.12.4
@@ -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.4.0
+Requires-Dist: sqlobjects>=1.5.0
 Requires-Dist: tiktoken>=0.12.0
 Requires-Dist: uvicorn>=0.41.0
 Dynamic: license-file

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

@@ -18,13 +18,15 @@ 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 .nodes import NodeHandler
 from .records import Record, Status
 from .registry import registry
 from .state import FlowState
 from .tool import Tool, ToolResult
 
 
+register_node_handler = registry.register_node_handler
+
 __all__ = [
     # 核心抽象
     "Tool",

{agstack-1.6.0 → agstack-1.8.0}/agstack/llm/flow/agent.py

@@ -64,23 +64,29 @@ class Agent:
                 return tool
         return None
 
-    async def run(self, context: "FlowContext") -> str:
+    async def run(self, context: "FlowContext", inputs: dict[str, Any] | None = None) -> dict[str, Any]:
         """执行 Agent 逻辑"""
         content_parts = []
-        async for evt in self.stream(context):
+        async for evt in self.stream(context, inputs):
             # AG-UI 事件格式
             if isinstance(evt, dict):
                 if evt.get("type") == EventType.TEXT_MESSAGE_CONTENT:
                     content_parts.append(evt.get("delta", ""))
                 elif evt.get("type") == EventType.RUN_ERROR:
                     raise FlowError("AGENT_EXECUTION_FAILED", 500, {"error": evt.get("message")})
-        return "".join(content_parts)
+        return {"result": "".join(content_parts)}
 
-    async def stream(self, context: "FlowContext") -> AsyncIterator[dict[str, Any]]:
+    async def stream(
+        self, context: "FlowContext", inputs: dict[str, Any] | None = None
+    ) -> AsyncIterator[dict[str, Any]]:
         """流式执行 Agent，输出 AG-UI 标准事件"""
 
-        # 输入来源：优先 input（A2A 传入），回退到 query
-        user_input = context.get_variable("input") or context.get_variable("query", "")
+        # 输入来源：优先 inputs 参数，回退到 context.variables
+        user_input = ""
+        if inputs:
+            user_input = inputs.get("input", "")
+        if not user_input:
+            user_input = context.get_variable("input") or context.get_variable("query", "")
         msg_id = context.message_id or str(uuid4())
 
         # 添加用户消息（scoped by agent name）
@@ -214,7 +220,7 @@ class Agent:
             # 如果没有工具调用，结束循环
             if not tool_calls:
                 # 存储结果供 Flow/A2A 使用
-                context.set_node_result(self.name, assistant_content)
+                context.set_output(self.name, {"result": assistant_content})
                 # AG-UI: TEXT_MESSAGE_END
                 yield event.text_message_end(message_id=msg_id)
                 return
@@ -237,15 +243,14 @@ class Agent:
                     )
                     continue
 
-                # 解析 LLM 返回的工具参数并注入 context
+                # 解析 LLM 返回的工具参数
                 try:
                     tool_args = json.loads(tool_call["arguments"]) if tool_call["arguments"] else {}
                 except json.JSONDecodeError:
                     tool_args = {}
-                context.update_variables(tool_args)
 
-                # 执行工具
-                result = await tool.execute_async(context)
+                # 执行工具（传入 LLM 解析的参数作为 inputs）
+                result = await tool.execute_async(context, tool_args)
 
                 # 保存工具结果
                 result_content = json.dumps(result.result) if result.success else json.dumps({"error": result.error})

{agstack-1.6.0 → agstack-1.8.0}/agstack/llm/flow/context.py

@@ -50,7 +50,7 @@ class FlowContext:
     message_id: str | None = None
 
     # 图执行状态
-    node_results: dict[str, Any] = field(default_factory=dict)
+    outputs: dict[str, Any] = field(default_factory=dict)
     current_node: str | None = None
 
     # 执行记录（可选）
@@ -115,33 +115,31 @@ class FlowContext:
             self.messages.clear()
             self.turn_count = 0
 
-    def resolve_reference(self, ref: str) -> Any:
-        """解析变量引用 {node@variable.field} 或 {node_id}"""
-        if not isinstance(ref, str) or not ref.startswith("{"):
-            return ref
+    def resolve_reference(self, ref: Any) -> Any:
+        """解析变量引用
 
-        ref_content = ref[1:-1]  # 移除 {}
-        if "@" not in ref_content:
-            # 先从 variables 查找，回退到 node_results
-            result = self.variables.get(ref_content)
-            if result is None:
-                result = self.node_results.get(ref_content)
+        $o.node_id.field.subfield  → context.outputs["node_id"]["field"]["subfield"]
+        $v.key                     → context.variables["key"]
+        其他字符串                  → 原样返回（字面值）
+        """
+        if not isinstance(ref, str):
+            return ref
+        if ref.startswith("$o."):
+            parts = ref[3:].split(".")
+            result = self.outputs.get(parts[0])
+            for part in parts[1:]:
+                if isinstance(result, dict):
+                    result = result.get(part)
+                else:
+                    result = getattr(result, part, None)
             return result
+        if ref.startswith("$v."):
+            return self.variables.get(ref[3:])
+        return ref
 
-        node_id, var_path = ref_content.split("@", 1)
-        result = self.node_results.get(node_id)
-
-        # 支持嵌套字段访问 variable.field.subfield
-        for field_name in var_path.split("."):
-            if isinstance(result, dict):
-                result = result.get(field_name)
-            else:
-                result = getattr(result, field_name, None)
-        return result
-
-    def set_node_result(self, node_id: str, result: Any):
-        """设置节点执行结果"""
-        self.node_results[node_id] = result
+    def set_output(self, node_id: str, result: Any):
+        """设置节点输出"""
+        self.outputs[node_id] = result
 
     def add_execution_record(self, task_id: str, status: str, **kwargs) -> None:
         """添加执行记录"""

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

@@ -3,7 +3,6 @@
 """Flow 定义和执行"""
 
 import asyncio
-import json as _json
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, AsyncIterator
 from uuid import uuid4
@@ -47,12 +46,9 @@ class Flow:
     _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
+        from .registry import registry
 
-        for handler in builtin_handlers:
-            self._node_handlers[handler.node_type] = handler
-        # 全局注册的自定义 handler 可覆盖内置
-        self._node_handlers.update(_global_node_handlers)
+        self._node_handlers = dict(registry.get_all_node_handlers())
 
     # ── 重试策略 ──
 
@@ -82,27 +78,22 @@ class Flow:
 
     @staticmethod
     def _extract_route_key(result: Any) -> str:
-        """从节点执行结果中提取路由键。
+        """从节点输出 dict 中提取路由键。
 
-        支持 ``{"result": "qa"}`` 形式的 JSON 字符串，
-        以及纯字符串结果。
+        节点输出 dict 中若包含 ``choice`` 字段，即为路由键。
+        没有 ``choice`` 则默认 ``"done"``。
         """
-        if not isinstance(result, str):
-            return "done"
-        try:
-            parsed = _json.loads(result)
-            if isinstance(parsed, dict) and "result" in parsed:
-                return str(parsed["result"])
-        except (ValueError, TypeError):
-            pass
-        return result or "done"
+        if isinstance(result, dict):
+            return str(result.get("choice", "done"))
+        return "done"
 
     # ── message 节点 ──
 
     async def _emit_message(self, node: dict, context: "FlowContext") -> AsyncIterator[dict[str, Any]]:
-        """输出模板文本"""
+        """输出模板文本，支持 $v. 引用"""
         config = node.get("config", {})
         template = config.get("content", "")
+        # 用 variables 做 format_map 替换 {var} 占位符
         text = template.format_map(_SafeFormatDict(context.variables))
         msg_id = context.message_id or str(uuid4())
         yield event.text_message_start(message_id=msg_id, role="assistant")
@@ -180,7 +171,7 @@ class Flow:
                 handler = self._node_handlers.get(node_type)
                 if handler:
                     result = await handler.execute(node, context)
-                    context.set_node_result(node_id, result)
+                    context.set_output(node_id, result)
                 else:
                     raise NodeExecutionError("UNKNOWN_NODE_TYPE", args={"node_type": node_type})
         else:
@@ -197,7 +188,7 @@ class Flow:
                     config = node.get("config", {})
                     template = config.get("content", "")
                     text = template.format_map(_SafeFormatDict(context.variables))
-                    context.set_node_result(current_node_id, text)
+                    context.set_output(current_node_id, {"result": text})
                     current_node_id = self._resolve_next_node(current_node_id, "done")
 
                 elif node_type == "parallel":
@@ -213,25 +204,22 @@ class Flow:
                         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)
+                            context.set_output(branch_id, result)
 
                     await asyncio.gather(*[_run_branch(bid) for bid in branches])
-                    context.set_node_result(current_node_id, "done")
+                    context.set_output(current_node_id, {"choice": "done"})
                     current_node_id = self._resolve_next_node(current_node_id, "done")
 
                 elif node_type == "iteration":
                     config = node.get("config", {})
                     items_ref = config.get("items", "")
                     items = context.resolve_reference(items_ref) if isinstance(items_ref, str) else items_ref
-                    if isinstance(items, str):
-                        items = _json.loads(items)
                     if not isinstance(items, list):
                         items = [items]
 
                     item_var = config.get("item_variable", "item")
                     index_var = config.get("index_variable", "index")
                     body_nodes: list[str] = config.get("body", [])
-                    output_var = config.get("output_variable", "iteration_results")
                     results: list[Any] = []
 
                     for idx, item in enumerate(items):
@@ -245,12 +233,11 @@ class Flow:
                             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)
+                                context.set_output(body_node_id, body_result)
                         if body_nodes:
-                            results.append(context.node_results.get(body_nodes[-1]))
+                            results.append(context.outputs.get(body_nodes[-1]))
 
-                    context.set_variable(output_var, results)
-                    context.set_node_result(current_node_id, _json.dumps(results, ensure_ascii=False))
+                    context.set_output(current_node_id, {"results": results})
                     current_node_id = self._resolve_next_node(current_node_id, "done")
 
                 elif node_type == "loop":
@@ -271,26 +258,20 @@ class Flow:
                             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)
+                                context.set_output(body_node_id, body_result)
                         if condition_node_id:
-                            cond_result = context.node_results.get(condition_node_id, "")
-                            if isinstance(cond_result, str):
-                                try:
-                                    parsed = _json.loads(cond_result)
-                                    if isinstance(parsed, dict) and parsed.get("result") == break_cond:
-                                        break
-                                except (ValueError, TypeError):
-                                    if cond_result == break_cond:
-                                        break
-
-                    context.set_node_result(current_node_id, "done")
+                            cond_result = context.outputs.get(condition_node_id, {})
+                            if isinstance(cond_result, dict) and cond_result.get("choice") == break_cond:
+                                break
+
+                    context.set_output(current_node_id, {"choice": "done"})
                     current_node_id = self._resolve_next_node(current_node_id, "done")
 
                 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)
+                    context.set_output(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"
@@ -299,7 +280,7 @@ class Flow:
                 else:
                     raise NodeExecutionError("UNKNOWN_NODE_TYPE", args={"node_type": node_type})
 
-        return context.node_results
+        return context.outputs
 
     async def stream(self, context: "FlowContext") -> AsyncIterator[dict[str, Any]]:
         """流式执行 Flow（输出 AG-UI 标准事件）"""
@@ -371,10 +352,10 @@ class Flow:
                     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)
+                        context.set_output(branch_id, result)
 
                 await asyncio.gather(*[_exec_branch(bid) for bid in branches])
-                context.set_node_result(current_node_id, "done")
+                context.set_output(current_node_id, {"choice": "done"})
                 yield event.step_finished(step_name=f"parallel:{current_node_id}")
                 current_node_id = self._resolve_next_node(current_node_id, "done")
 
@@ -382,15 +363,12 @@ class Flow:
                 config = node.get("config", {})
                 items_ref = config.get("items", "")
                 items = context.resolve_reference(items_ref) if isinstance(items_ref, str) else items_ref
-                if isinstance(items, str):
-                    items = _json.loads(items)
                 if not isinstance(items, list):
                     items = [items]
 
                 item_var = config.get("item_variable", "item")
                 index_var = config.get("index_variable", "index")
                 body_nodes: list[str] = config.get("body", [])
-                output_var = config.get("output_variable", "iteration_results")
                 results: list[Any] = []
 
                 yield event.step_started(step_name=f"iteration:{current_node_id}")
@@ -405,12 +383,11 @@ class Flow:
                         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)
+                            context.set_output(body_node_id, body_result)
                     if body_nodes:
-                        results.append(context.node_results.get(body_nodes[-1]))
+                        results.append(context.outputs.get(body_nodes[-1]))
 
-                context.set_variable(output_var, results)
-                context.set_node_result(current_node_id, _json.dumps(results, ensure_ascii=False))
+                context.set_output(current_node_id, {"results": results})
                 yield event.step_finished(step_name=f"iteration:{current_node_id}")
                 current_node_id = self._resolve_next_node(current_node_id, "done")
 
@@ -433,20 +410,14 @@ class Flow:
                         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)
+                            context.set_output(body_node_id, body_result)
                     # 检查终止条件
                     if condition_node_id:
-                        cond_result = context.node_results.get(condition_node_id, "")
-                        if isinstance(cond_result, str):
-                            try:
-                                parsed = _json.loads(cond_result)
-                                if isinstance(parsed, dict) and parsed.get("result") == break_cond:
-                                    break
-                            except (ValueError, TypeError):
-                                if cond_result == break_cond:
-                                    break
-
-                context.set_node_result(current_node_id, "done")
+                        cond_result = context.outputs.get(condition_node_id, {})
+                        if isinstance(cond_result, dict) and cond_result.get("choice") == break_cond:
+                            break
+
+                context.set_output(current_node_id, {"choice": "done"})
                 yield event.step_finished(step_name=f"loop:{current_node_id}")
                 current_node_id = self._resolve_next_node(current_node_id, "done")
 
@@ -454,7 +425,7 @@ class Flow:
                 # 所有执行类节点统一分发
                 async for evt in self._execute_node_with_retry(node, context, current_node_id):
                     yield evt
-                result = context.node_results.get(current_node_id, "")
+                result = context.outputs.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"

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

@@ -23,17 +23,7 @@ builtin_handlers: list[NodeHandler] = [
     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-1.8.0}/agstack/llm/flow/nodes/agent_node.py

@@ -15,16 +15,10 @@ if TYPE_CHECKING:
 
 
 class AgentNodeHandler(NodeHandler):
-    """Agent 节点：通过 registry 查找 agent → ag.stream(context)"""
+    """Agent 节点：通过 registry 查找 agent → ag.stream(context, inputs)"""
 
     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:
@@ -36,20 +30,19 @@ class AgentNodeHandler(NodeHandler):
 
     async def execute(self, node: dict, context: "FlowContext") -> Any:
         config = node.get("config", {})
-        self._set_parameters(config, context)
+        resolved = self.resolve_inputs(config, context)
         ag = self._create_agent(config)
-        return await ag.run(context)
+        return await ag.run(context, inputs=resolved)
 
     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)
+        resolved = self.resolve_inputs(config, context)
         ag = self._create_agent(config)
-        async for evt in ag.stream(context):
+        async for evt in ag.stream(context, inputs=resolved):
             yield evt
         result = context.get_last_output(ag.name) or ""
-        context.set_node_result(node_id, result)
-        self.map_outputs(config, context, {"result": result})
+        context.set_output(node_id, {"result": result})
         yield event.step_finished(step_name=step_name)

{agstack-1.6.0 → agstack-1.8.0}/agstack/llm/flow/nodes/base.py

@@ -31,14 +31,8 @@ class NodeHandler:
         inputs_spec = config.get("inputs", {})
         return {k: context.resolve_reference(v) if isinstance(v, str) else v for k, v in inputs_spec.items()}
 
-    def map_outputs(self, config: dict, context: "FlowContext", result: dict) -> None:
-        """将结果映射到 context.variables"""
-        for key in config.get("outputs", {}):
-            if isinstance(result, dict) and key in result:
-                context.set_variable(key, result[key])
-
     async def execute(self, node: dict, context: "FlowContext") -> Any:
-        """执行节点，返回结果（将存入 node_results）
+        """执行节点，返回结果（将存入 context.outputs）
 
         子类必须实现此方法。
         """
@@ -53,7 +47,5 @@ class NodeHandler:
         step_name = self.get_step_name(node, node_id)
         yield event.step_started(step_name=step_name)
         result = await self.execute(node, context)
-        context.set_node_result(node_id, result)
-        config = node.get("config", {})
-        self.map_outputs(config, context, result)
+        context.set_output(node_id, result)
         yield event.step_finished(step_name=step_name)

{agstack-1.6.0 → agstack-1.8.0}/agstack/llm/flow/nodes/detect_node.py

@@ -2,7 +2,6 @@
 
 """Detect 节点 — 分类/检测，输出路由键"""
 
-import json as _json
 from typing import TYPE_CHECKING, Any
 
 from openai.types.chat import ChatCompletionMessageParam
@@ -19,10 +18,10 @@ if TYPE_CHECKING:
 class DetectNodeHandler(NodeHandler):
     """分类/检测节点
 
-    对输入文本进行分类，输出路由键。结果直接用于 _extract_route_key() 路由。
+    对输入文本进行分类，输出路由键。结果 dict 中的 ``choice`` 字段用于边路由。
 
     输入：query（待检测文本）+ instruction + options
-    输出：{"result": "<option>"} 的 JSON 字符串
+    输出：{"choice": "<option>"}
     """
 
     node_type = "detect"
@@ -76,18 +75,19 @@ class DetectNodeHandler(NodeHandler):
                 )
             )
 
-        # 尝试解析为 JSON，确保返回 {"result": "<option>"} 格式
+        # 从 LLM 响应中提取选项
+        import json as _json
+
+        option = result_text.strip()
         try:
-            parsed = _json.loads(result_text)
+            parsed = _json.loads(option)
             if isinstance(parsed, dict) and "result" in parsed:
-                return _json.dumps(parsed, ensure_ascii=False)
+                option = str(parsed["result"])
         except (ValueError, TypeError):
             pass
 
-        # 如果 LLM 返回的是纯文本选项，包装为标准格式
-        stripped = result_text.strip()
-        if stripped in options:
-            return _json.dumps({"result": stripped}, ensure_ascii=False)
+        # 如果提取的选项在合法列表中，使用它；否则用原始文本
+        if option not in options:
+            option = result_text.strip()
 
-        # 兜底：返回原始文本
-        return _json.dumps({"result": stripped}, ensure_ascii=False)
+        return {"choice": option}

{agstack-1.6.0 → agstack-1.8.0}/agstack/llm/flow/nodes/llm_chat_node.py

@@ -2,6 +2,7 @@
 
 """LLM Chat 节点 — 单轮 LLM 调用（支持流式/非流式）"""
 
+import json as _json
 from typing import TYPE_CHECKING, Any, AsyncIterator
 from uuid import uuid4
 
@@ -34,16 +35,17 @@ class LLMChatNodeHandler(NodeHandler):
 
     node_type = "llm_chat"
 
-    def _build_prompt(self, config: dict, resolved_inputs: dict[str, Any]) -> str:
-        """将 config.prompt 中的 {var} 占位符替换为 resolved 的输入值"""
-        template = config.get("prompt", "")
-        format_dict = _SafeFormatDict({k: str(v) if not isinstance(v, str) else v for k, v in resolved_inputs.items()})
+    def _build_prompt(self, template: str, resolved_inputs: dict[str, Any]) -> str:
+        """将模板中的 {var} 占位符替换为 resolved 的输入值"""
+        format_dict = _SafeFormatDict(
+            {k: v if isinstance(v, str) else _json.dumps(v, ensure_ascii=False) for k, v in resolved_inputs.items()}
+        )
         return template.format_map(format_dict)
 
     async def execute(self, node: dict, context: "FlowContext") -> Any:
         config = node.get("config", {})
         resolved_inputs = self.resolve_inputs(config, context)
-        prompt_text = self._build_prompt(config, resolved_inputs)
+        prompt_text = self._build_prompt(config.get("prompt", ""), resolved_inputs)
 
         model = config.get("model", "gpt-4o")
         temperature = config.get("temperature", 0.7)
@@ -52,10 +54,11 @@ class LLMChatNodeHandler(NodeHandler):
         client = get_llm_client()
         messages: list[ChatCompletionMessageParam] = [{"role": "user", "content": prompt_text}]
 
-        # 如果有 system_prompt，放在前面
+        # 如果有 system_prompt，支持变量替换并放在前面
         system_prompt = config.get("system_prompt")
         if system_prompt:
-            messages.insert(0, {"role": "system", "content": system_prompt})
+            system_text = self._build_prompt(system_prompt, resolved_inputs)
+            messages.insert(0, {"role": "system", "content": system_text})
 
         response = await client.chat(
             messages=messages,
@@ -78,9 +81,7 @@ class LLMChatNodeHandler(NodeHandler):
                 )
             )
 
-        result = {"result": result_text}
-        self.map_outputs(config, context, result)
-        return result_text
+        return {"result": result_text}
 
     async def stream(self, node: dict, context: "FlowContext", node_id: str) -> AsyncIterator[dict[str, Any]]:
         config = node.get("config", {})
@@ -91,7 +92,7 @@ class LLMChatNodeHandler(NodeHandler):
             step_name = self.get_step_name(node, node_id)
             yield event.step_started(step_name=step_name)
             result = await self.execute(node, context)
-            context.set_node_result(node_id, result)
+            context.set_output(node_id, result)
             yield event.step_finished(step_name=step_name)
             return
 
@@ -100,7 +101,7 @@ class LLMChatNodeHandler(NodeHandler):
         yield event.step_started(step_name=step_name)
 
         resolved_inputs = self.resolve_inputs(config, context)
-        prompt_text = self._build_prompt(config, resolved_inputs)
+        prompt_text = self._build_prompt(config.get("prompt", ""), resolved_inputs)
 
         model = config.get("model", "gpt-4o")
         temperature = config.get("temperature", 0.7)
@@ -111,7 +112,8 @@ class LLMChatNodeHandler(NodeHandler):
 
         system_prompt = config.get("system_prompt")
         if system_prompt:
-            messages.insert(0, {"role": "system", "content": system_prompt})
+            system_text = self._build_prompt(system_prompt, resolved_inputs)
+            messages.insert(0, {"role": "system", "content": system_text})
 
         msg_id = context.message_id or str(uuid4())
         yield event.text_message_start(message_id=msg_id, role="assistant")
@@ -145,8 +147,6 @@ class LLMChatNodeHandler(NodeHandler):
         yield event.text_message_end(message_id=msg_id)
 
         result_text = "".join(content_parts)
-        result = {"result": result_text}
-        self.map_outputs(config, context, result)
-        context.set_node_result(node_id, result_text)
+        context.set_output(node_id, {"result": result_text})
 
         yield event.step_finished(step_name=step_name)

{agstack-1.6.0 → agstack-1.8.0}/agstack/llm/flow/nodes/llm_embed_node.py

@@ -35,5 +35,4 @@ class LLMEmbedNodeHandler(NodeHandler):
         embeddings = await client.embed(texts=texts, model=model)
 
         result = {"embeddings": embeddings}
-        self.map_outputs(config, context, result)
         return result