Add files via upload

internal/workflow/runner.go

@@ -4,82 +4,16 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"regexp"
-	"sort"
 	"strings"
 	"time"
 
-	"cyberstrike-ai/internal/agent"
 	"cyberstrike-ai/internal/config"
 	"cyberstrike-ai/internal/database"
-	"cyberstrike-ai/internal/multiagent"
 
 	"github.com/google/uuid"
 	"go.uber.org/zap"
 )
 
-type RunArgs struct {
-	DB                 *database.DB
-	Logger             *zap.Logger
-	Role               config.RoleConfig
-	AppCfg             *config.Config
-	Agent              *agent.Agent
-	ConversationID     string
-	ProjectID          string
-	UserMessage        string
-	History            []agent.ChatMessage
-	RoleTools          []string
-	AgentsMarkdownDir  string
-	SystemPromptExtra  string
-	AssistantMessageID string
-	Progress           agent.ProgressCallback
-}
-
-type RunResult struct {
-	Response string
-	RunID    string
-}
-
-type graphDef struct {
-	Nodes  []graphNode    `json:"nodes"`
-	Edges  []graphEdge    `json:"edges"`
-	Config map[string]any `json:"config"`
-}
-
-type graphNode struct {
-	ID       string         `json:"id"`
-	Type     string         `json:"type"`
-	Label    string         `json:"label"`
-	Position graphPosition  `json:"position"`
-	Config   map[string]any `json:"config"`
-}
-
-type graphEdge struct {
-	ID     string         `json:"id"`
-	Source string         `json:"source"`
-	Target string         `json:"target"`
-	Label  string         `json:"label"`
-	Config map[string]any `json:"config"`
-}
-
-type graphPosition struct {
-	X float64 `json:"x"`
-	Y float64 `json:"y"`
-}
-
-type workflowExecState struct {
-	inputs      map[string]any
-	outputs     map[string]any
-	nodeOutputs map[string]map[string]any
-	lastOutput  map[string]any
-	executed    []string
-	skipped     []string
-	workflowRunID string
-	// 图编排内多个 Agent 节点各自从第 1 轮上报 iteration；累计偏移避免对话页迭代序号回跳与流式条目复用错乱。
-	mainIterationOffset int
-	segmentMaxIteration int
-}
-
 // ShouldAutoRunRoleWorkflow returns true when a role explicitly binds a workflow
 // and does not turn it off. Empty policy defaults to auto to keep role UX simple.
 func ShouldAutoRunRoleWorkflow(role config.RoleConfig) bool {
@@ -90,10 +24,7 @@ func ShouldAutoRunRoleWorkflow(role config.RoleConfig) bool {
 	return policy == "" || policy == "auto"
 }
 
-// RunRoleBoundWorkflow executes the persisted role-bound workflow graph.
-// Control nodes are interpreted locally, tool nodes call the existing MCP bridge,
-// and agent nodes reuse the existing Eino ADK runners so role-bound flows share
-// the same model/tool/session behavior as the chat page.
+// RunRoleBoundWorkflow executes the persisted role-bound workflow via cached Eino Workflow.
 func RunRoleBoundWorkflow(ctx context.Context, args RunArgs) (*RunResult, error) {
 	if args.DB == nil {
 		return nil, fmt.Errorf("workflow db is nil")
@@ -150,6 +81,7 @@ func RunRoleBoundWorkflow(ctx context.Context, args RunArgs) (*RunResult, error)
 			"workflowVersion": wf.Version,
 			"workflowRunId":   runID,
 			"conversationId":  args.ConversationID,
+			"engine":          "eino_workflow",
 		})
 	}
 
@@ -158,13 +90,44 @@ func RunRoleBoundWorkflow(ctx context.Context, args RunArgs) (*RunResult, error)
 		_ = args.DB.FinishWorkflowRun(runID, "failed", "", err.Error())
 		return nil, err
 	}
-	state := &workflowExecState{
-		inputs:        input,
-		outputs:       make(map[string]any),
-		nodeOutputs:   make(map[string]map[string]any),
-		workflowRunID: runID,
-	}
-	if err := executeGraph(ctx, args, runID, graph, state); err != nil {
+	state := newWorkflowLocalState(input, runID)
+	if err := executeEinoGraph(ctx, args, runID, wf.ID, wf.Version, graph, state); err != nil {
+		if IsAwaitingHITL(err) {
+			hitl := err.(*AwaitingHITLError)
+			partial := map[string]interface{}{
+				"workflowId":      wf.ID,
+				"workflowName":    wf.Name,
+				"workflowVersion": wf.Version,
+				"workflowRunId":   runID,
+				"status":          "awaiting_hitl",
+				"outputs":         state.Outputs,
+				"executedNodes":   state.Executed,
+				"skippedNodes":    state.Skipped,
+				"pendingHitl": map[string]interface{}{
+					"nodeId": hitl.NodeID,
+					"label":  hitl.NodeLabel,
+					"prompt": hitl.Prompt,
+				},
+				"engine": "eino_workflow",
+			}
+			partialJSON, _ := json.Marshal(partial)
+			_ = args.DB.SetWorkflowRunAwaitingHITL(runID, hitl.NodeID, string(partialJSON))
+			response := fmt.Sprintf("工作流「%s」已在节点「%s」暂停，等待人工审批。\n运行 ID：%s", wf.Name, firstNonEmpty(hitl.NodeLabel, hitl.NodeID), runID)
+			if args.Progress != nil {
+				args.Progress("workflow_paused", response, map[string]interface{}{
+					"workflowRunId": runID,
+					"status":        "awaiting_hitl",
+					"nodeId":        hitl.NodeID,
+					"resumeApi":     fmt.Sprintf("/api/workflows/runs/%s/resume", runID),
+				})
+			}
+			return &RunResult{
+				Response:     response,
+				RunID:        runID,
+				Status:       "awaiting_hitl",
+				AwaitingHITL: true,
+			}, nil
+		}
 		_ = args.DB.FinishWorkflowRun(runID, "failed", "", err.Error())
 		return nil, err
 	}
@@ -175,9 +138,10 @@ func RunRoleBoundWorkflow(ctx context.Context, args RunArgs) (*RunResult, error)
 		"workflowVersion": wf.Version,
 		"workflowRunId":   runID,
 		"status":          "completed",
-		"outputs":         state.outputs,
-		"executedNodes":   state.executed,
-		"skippedNodes":    state.skipped,
+		"outputs":         state.Outputs,
+		"executedNodes":   state.Executed,
+		"skippedNodes":    state.Skipped,
+		"engine":          "eino_workflow",
 	}
 	outputJSON, _ := json.Marshal(output)
 
@@ -189,8 +153,9 @@ func RunRoleBoundWorkflow(ctx context.Context, args RunArgs) (*RunResult, error)
 		args.Progress("workflow_done", fmt.Sprintf("流程「%s」运行完成", wf.Name), map[string]interface{}{
 			"workflowRunId": runID,
 			"workflowId":    wf.ID,
-			"outputs":       state.outputs,
+			"outputs":       state.Outputs,
 			"response":      response,
+			"engine":        "eino_workflow",
 		})
 	}
 	if args.Logger != nil {
@@ -199,746 +164,8 @@ func RunRoleBoundWorkflow(ctx context.Context, args RunArgs) (*RunResult, error)
 			zap.String("workflow_run_id", runID),
 			zap.String("conversation_id", args.ConversationID),
 			zap.String("role", args.Role.Name),
+			zap.String("engine", "eino_workflow"),
 		)
 	}
-	return &RunResult{Response: response, RunID: runID}, nil
-}
-
-func parseGraph(raw string) (*graphDef, error) {
-	var g graphDef
-	if err := json.Unmarshal([]byte(strings.TrimSpace(raw)), &g); err != nil {
-		return nil, fmt.Errorf("解析工作流图失败: %w", err)
-	}
-	if len(g.Nodes) == 0 {
-		return nil, fmt.Errorf("工作流没有节点")
-	}
-	if g.Config == nil {
-		g.Config = make(map[string]any)
-	}
-	return &g, nil
-}
-
-func executeGraph(ctx context.Context, args RunArgs, runID string, g *graphDef, state *workflowExecState) error {
-	nodes := make(map[string]graphNode, len(g.Nodes))
-	inDegree := make(map[string]int, len(g.Nodes))
-	outgoing := make(map[string][]graphEdge)
-	for _, node := range g.Nodes {
-		node.ID = strings.TrimSpace(node.ID)
-		if node.ID == "" {
-			continue
-		}
-		if strings.TrimSpace(node.Type) == "" {
-			node.Type = "tool"
-		}
-		if node.Config == nil {
-			node.Config = make(map[string]any)
-		}
-		nodes[node.ID] = node
-		inDegree[node.ID] = 0
-	}
-	for _, edge := range g.Edges {
-		if _, ok := nodes[edge.Source]; !ok {
-			continue
-		}
-		if _, ok := nodes[edge.Target]; !ok {
-			continue
-		}
-		outgoing[edge.Source] = append(outgoing[edge.Source], edge)
-		inDegree[edge.Target]++
-	}
-	for source := range outgoing {
-		sort.SliceStable(outgoing[source], func(i, j int) bool {
-			a := nodes[outgoing[source][i].Target]
-			b := nodes[outgoing[source][j].Target]
-			if a.Position.Y != b.Position.Y {
-				return a.Position.Y < b.Position.Y
-			}
-			if a.Position.X != b.Position.X {
-				return a.Position.X < b.Position.X
-			}
-			return outgoing[source][i].Target < outgoing[source][j].Target
-		})
-	}
-
-	var queue []string
-	for id, node := range nodes {
-		if strings.EqualFold(node.Type, "start") {
-			queue = append(queue, id)
-		}
-	}
-	if len(queue) == 0 {
-		for id, deg := range inDegree {
-			if deg == 0 {
-				queue = append(queue, id)
-			}
-		}
-	}
-	sortNodeIDsByCanvas(queue, nodes)
-	seen := make(map[string]bool)
-	remainingIncoming := make(map[string]int, len(inDegree))
-	for id, deg := range inDegree {
-		remainingIncoming[id] = deg
-	}
-	for len(queue) > 0 {
-		select {
-		case <-ctx.Done():
-			return ctx.Err()
-		default:
-		}
-		id := queue[0]
-		queue = queue[1:]
-		if seen[id] {
-			continue
-		}
-		seen[id] = true
-		node := nodes[id]
-		result, proceed, err := executeNode(ctx, args, runID, node, state)
-		if err != nil {
-			return err
-		}
-		state.nodeOutputs[id] = result
-		state.lastOutput = result
-		if proceed {
-			edges := outgoing[id]
-			if strings.EqualFold(node.Type, "condition") {
-				emitConditionBranchProgress(args, runID, node, edges, nodes, state)
-			}
-			for edgeIdx, edge := range edges {
-				if !edgeAllowed(edge, node, edgeIdx, state) {
-					continue
-				}
-				remainingIncoming[edge.Target]--
-				if remainingIncoming[edge.Target] > 0 {
-					continue
-				}
-				queue = append(queue, edge.Target)
-			}
-			sortNodeIDsByCanvas(queue, nodes)
-		}
-	}
-	return nil
-}
-
-func sortNodeIDsByCanvas(ids []string, nodes map[string]graphNode) {
-	sort.SliceStable(ids, func(i, j int) bool {
-		a := nodes[ids[i]]
-		b := nodes[ids[j]]
-		if a.Position.Y != b.Position.Y {
-			return a.Position.Y < b.Position.Y
-		}
-		if a.Position.X != b.Position.X {
-			return a.Position.X < b.Position.X
-		}
-		return ids[i] < ids[j]
-	})
-}
-
-func executeNode(ctx context.Context, args RunArgs, runID string, node graphNode, state *workflowExecState) (map[string]any, bool, error) {
-	label := node.Label
-	if strings.TrimSpace(label) == "" {
-		label = node.ID
-	}
-	nodeRunID := uuid.NewString()
-	input := map[string]any{
-		"nodeId":   node.ID,
-		"nodeType": node.Type,
-		"label":    label,
-		"inputs":   state.inputs,
-		"previous": state.lastOutput,
-	}
-	inputJSON, _ := json.Marshal(input)
-	if err := args.DB.CreateWorkflowNodeRun(&database.WorkflowNodeRun{
-		ID:        nodeRunID,
-		RunID:     runID,
-		NodeID:    node.ID,
-		Status:    "running",
-		InputJSON: string(inputJSON),
-		StartedAt: time.Now(),
-	}); err != nil {
-		return nil, false, err
-	}
-	if args.Progress != nil {
-		args.Progress("workflow_node_start", fmt.Sprintf("开始节点：%s", label), map[string]any{
-			"workflowRunId": runID,
-			"nodeRunId":     nodeRunID,
-			"nodeId":        node.ID,
-			"nodeType":      node.Type,
-			"label":         label,
-		})
-	}
-
-	result, proceed, status, errText := runBuiltinNode(ctx, args, node, state)
-	outputJSON, _ := json.Marshal(result)
-	if err := args.DB.FinishWorkflowNodeRun(nodeRunID, status, string(outputJSON), errText); err != nil {
-		return nil, false, err
-	}
-	if status == "skipped" {
-		state.skipped = append(state.skipped, label)
-	} else {
-		state.executed = append(state.executed, label)
-	}
-	if args.Progress != nil {
-		progressData := map[string]any{
-			"workflowRunId": runID,
-			"nodeRunId":     nodeRunID,
-			"nodeId":        node.ID,
-			"nodeType":      node.Type,
-			"label":         label,
-			"status":        status,
-			"output":        result,
-		}
-		progressMsg := fmt.Sprintf("节点完成：%s（%s）", label, status)
-		if strings.EqualFold(node.Type, "condition") {
-			matched := false
-			if v, ok := result["matched"].(bool); ok {
-				matched = v
-			}
-			expr := cfgString(node.Config, "expression")
-			if matched {
-				progressMsg = fmt.Sprintf("条件判断：%s → 是", label)
-			} else {
-				progressMsg = fmt.Sprintf("条件判断：%s → 否", label)
-			}
-			progressData["expression"] = expr
-			progressData["matched"] = matched
-		}
-		args.Progress("workflow_node_result", progressMsg, progressData)
-	}
-	return result, proceed, nil
-}
-
-func runBuiltinNode(ctx context.Context, args RunArgs, node graphNode, state *workflowExecState) (map[string]any, bool, string, string) {
-	cfg := node.Config
-	switch strings.ToLower(strings.TrimSpace(node.Type)) {
-	case "start":
-		out := map[string]any{
-			"output":         state.inputs["message"],
-			"message":        state.inputs["message"],
-			"conversationId": state.inputs["conversationId"],
-			"projectId":      state.inputs["projectId"],
-		}
-		return out, true, "completed", ""
-	case "condition":
-		expr := cfgString(cfg, "expression")
-		ok := evalCondition(expr, state)
-		out := map[string]any{"output": ok, "condition": expr, "matched": ok}
-		// 条件节点始终继续，由出边条件（或连线标签/顺序）决定走「是/否」分支。
-		return out, true, "completed", ""
-	case "output":
-		key := cfgString(cfg, "output_key")
-		if key == "" {
-			key = "result"
-		}
-		value := resolveTemplate(cfgString(cfg, "source"), state)
-		state.outputs[key] = value
-		return map[string]any{"output": value, "outputs": map[string]any{key: value}}, true, "completed", ""
-	case "end":
-		value := resolveTemplate(cfgString(cfg, "result_template"), state)
-		return map[string]any{"output": value}, false, "completed", ""
-	case "tool":
-		return runToolNode(ctx, args, node, state)
-	case "agent":
-		return runAgentNode(ctx, args, node, state)
-	case "hitl":
-		return runHITLNode(args, node, state)
-	default:
-		reason := "未知节点类型"
-		return map[string]any{"output": "", "skipped": true, "reason": reason, "node_type": node.Type}, true, "skipped", reason
-	}
-}
-
-func runToolNode(ctx context.Context, args RunArgs, node graphNode, state *workflowExecState) (map[string]any, bool, string, string) {
-	toolName := cfgString(node.Config, "tool_name")
-	if toolName == "" {
-		errText := "工具节点未选择 MCP 工具"
-		return map[string]any{"output": "", "error": errText}, false, "failed", errText
-	}
-	if args.Agent == nil {
-		errText := "工具节点执行失败：Agent 为空"
-		return map[string]any{"output": "", "tool_name": toolName, "error": errText}, false, "failed", errText
-	}
-	toolArgs, err := parseToolArguments(cfgString(node.Config, "arguments"), state)
-	if err != nil {
-		errText := fmt.Sprintf("工具参数不是合法 JSON：%v", err)
-		return map[string]any{"output": "", "tool_name": toolName, "error": errText}, false, "failed", errText
-	}
-	if args.Progress != nil {
-		args.Progress("workflow_tool_start", fmt.Sprintf("调用工具：%s", toolName), map[string]any{
-			"nodeId": node.ID,
-			"tool":   toolName,
-			"args":   toolArgs,
-		})
-	}
-	result, err := args.Agent.ExecuteMCPToolForConversation(ctx, args.ConversationID, toolName, toolArgs)
-	if err != nil {
-		errText := err.Error()
-		return map[string]any{"output": "", "tool_name": toolName, "arguments": toolArgs, "error": errText}, false, "failed", errText
-	}
-	output := ""
-	executionID := ""
-	isError := false
-	if result != nil {
-		output = result.Result
-		executionID = result.ExecutionID
-		isError = result.IsError
-	}
-	out := map[string]any{
-		"output":       output,
-		"tool_name":    toolName,
-		"arguments":    toolArgs,
-		"execution_id": executionID,
-		"is_error":     isError,
-	}
-	if key := cfgString(node.Config, "output_key"); key != "" {
-		state.outputs[key] = output
-	}
-	if isError {
-		errText := strings.TrimSpace(output)
-		if errText == "" {
-			errText = "工具返回错误"
-		}
-		return out, false, "failed", errText
-	}
-	return out, true, "completed", ""
-}
-
-func runAgentNode(ctx context.Context, args RunArgs, node graphNode, state *workflowExecState) (map[string]any, bool, string, string) {
-	if args.AppCfg == nil || args.Agent == nil {
-		errText := "Agent 节点执行失败：应用配置或 Agent 为空"
-		return map[string]any{"output": "", "error": errText}, false, "failed", errText
-	}
-	mode := strings.ToLower(cfgString(node.Config, "agent_mode"))
-	if mode == "" {
-		mode = "eino_single"
-	}
-	inputSource := cfgString(node.Config, "input_source")
-	if inputSource == "" {
-		inputSource = "{{previous.output}}"
-	}
-	upstreamInput := strings.TrimSpace(resolveTemplate(inputSource, state))
-	message := buildAgentNodeMessage(node, state)
-	var result *multiagent.RunResult
-	var err error
-	state.segmentMaxIteration = 0
-	agentProgress := workflowAgentProgress(args.Progress, state, node)
-	switch mode {
-	case "eino_single", "single", "chat":
-		result, err = multiagent.RunEinoSingleChatModelAgent(
-			ctx,
-			args.AppCfg,
-			&args.AppCfg.MultiAgent,
-			args.Agent,
-			args.DB,
-			args.Logger,
-			args.ConversationID,
-			args.ProjectID,
-			message,
-			args.History,
-			args.RoleTools,
-			agentProgress,
-			nil,
-			args.SystemPromptExtra,
-		)
-	default:
-		result, err = multiagent.RunDeepAgent(
-			ctx,
-			args.AppCfg,
-			&args.AppCfg.MultiAgent,
-			args.Agent,
-			args.DB,
-			args.Logger,
-			args.ConversationID,
-			args.ProjectID,
-			message,
-			args.History,
-			args.RoleTools,
-			agentProgress,
-			args.AgentsMarkdownDir,
-			mode,
-			nil,
-			args.SystemPromptExtra,
-		)
-	}
-	if err != nil {
-		errText := err.Error()
-		state.mainIterationOffset += state.segmentMaxIteration
-		return map[string]any{"output": "", "mode": mode, "error": errText}, false, "failed", errText
-	}
-	state.mainIterationOffset += state.segmentMaxIteration
-	response := ""
-	mcpIDs := []string{}
-	if result != nil {
-		response = result.Response
-		mcpIDs = result.MCPExecutionIDs
-	}
-	if args.Progress != nil {
-		args.Progress("workflow_agent_output", response, map[string]any{
-			"nodeId":          node.ID,
-			"label":           firstNonEmpty(node.Label, node.ID),
-			"mode":            mode,
-			"inputSource":     inputSource,
-			"inputPreview":    truncateWorkflowPreview(upstreamInput, 500),
-			"mcpExecutionIds": mcpIDs,
-		})
-	}
-	if key := cfgString(node.Config, "output_key"); key != "" {
-		state.outputs[key] = response
-	}
-	return map[string]any{
-		"output":            response,
-		"mode":              mode,
-		"mcp_execution_ids": mcpIDs,
-	}, true, "completed", ""
-}
-
-func buildAgentNodeMessage(node graphNode, state *workflowExecState) string {
-	instruction := strings.TrimSpace(resolveTemplate(cfgString(node.Config, "instruction"), state))
-	inputSource := cfgString(node.Config, "input_source")
-	if inputSource == "" {
-		inputSource = "{{previous.output}}"
-	}
-	upstreamInput := strings.TrimSpace(resolveTemplate(inputSource, state))
-	if instruction == "" {
-		if upstreamInput != "" {
-			return fmt.Sprintf("请基于上游节点输出继续处理：\n%s", upstreamInput)
-		}
-		return fmt.Sprintf("请基于上游节点输出继续处理：\n%v", state.lastOutput["output"])
-	}
-	if upstreamInput == "" {
-		return instruction
-	}
-	return strings.TrimSpace(fmt.Sprintf("上游输入：\n%s\n\n节点指令：\n%s", upstreamInput, instruction))
-}
-
-func workflowAgentProgress(progress agent.ProgressCallback, state *workflowExecState, node graphNode) agent.ProgressCallback {
-	if progress == nil {
-		return nil
-	}
-	return func(eventType, message string, data interface{}) {
-		switch eventType {
-		case "response_start", "response_delta", "response", "done":
-			return
-		default:
-			enrichWorkflowAgentEventData(data, state, node)
-			if eventType == "iteration" {
-				applyWorkflowMainIterationOffset(data, state)
-			}
-			progress(eventType, message, data)
-		}
-	}
-}
-
-func enrichWorkflowAgentEventData(data interface{}, state *workflowExecState, node graphNode) {
-	m, ok := data.(map[string]interface{})
-	if !ok || m == nil {
-		return
-	}
-	if node.ID != "" {
-		m["workflowNodeId"] = node.ID
-	}
-	if state != nil && strings.TrimSpace(state.workflowRunID) != "" {
-		m["workflowRunId"] = state.workflowRunID
-	}
-}
-
-func applyWorkflowMainIterationOffset(data interface{}, state *workflowExecState) {
-	if state == nil {
-		return
-	}
-	m, ok := data.(map[string]interface{})
-	if !ok || m == nil {
-		return
-	}
-	scope, _ := m["einoScope"].(string)
-	if strings.TrimSpace(scope) != "main" {
-		return
-	}
-	raw := iterationNumberFromProgressData(m)
-	if raw <= 0 {
-		return
-	}
-	if raw > state.segmentMaxIteration {
-		state.segmentMaxIteration = raw
-	}
-	m["iteration"] = raw + state.mainIterationOffset
-}
-
-func iterationNumberFromProgressData(m map[string]interface{}) int {
-	switch v := m["iteration"].(type) {
-	case int:
-		return v
-	case int32:
-		return int(v)
-	case int64:
-		return int(v)
-	case float64:
-		return int(v)
-	case float32:
-		return int(v)
-	default:
-		return 0
-	}
-}
-
-func runHITLNode(args RunArgs, node graphNode, state *workflowExecState) (map[string]any, bool, string, string) {
-	prompt := resolveTemplate(cfgString(node.Config, "prompt"), state)
-	reviewer := cfgString(node.Config, "reviewer")
-	if args.Progress != nil {
-		args.Progress("workflow_hitl_checkpoint", "人工确认节点已记录", map[string]any{
-			"nodeId":   node.ID,
-			"prompt":   prompt,
-			"reviewer": reviewer,
-			"mode":     "record_only",
-		})
-	}
-	return map[string]any{
-		"output":   prompt,
-		"prompt":   prompt,
-		"reviewer": reviewer,
-		"approved": true,
-		"mode":     "record_only",
-	}, true, "completed", ""
-}
-
-func parseToolArguments(raw string, state *workflowExecState) (map[string]interface{}, error) {
-	if raw == "" {
-		return map[string]interface{}{}, nil
-	}
-	raw = strings.TrimSpace(resolveTemplate(raw, state))
-	if raw == "" {
-		return map[string]interface{}{}, nil
-	}
-	var args map[string]interface{}
-	if err := json.Unmarshal([]byte(raw), &args); err != nil {
-		return nil, err
-	}
-	if args == nil {
-		args = map[string]interface{}{}
-	}
-	return args, nil
-}
-
-func edgeAllowed(edge graphEdge, sourceNode graphNode, edgeIndex int, state *workflowExecState) bool {
-	cond := firstNonEmpty(cfgString(edge.Config, "condition"), cfgString(edge.Config, "expression"))
-	if cond != "" {
-		return evalCondition(cond, state)
-	}
-	if strings.EqualFold(strings.TrimSpace(sourceNode.Type), "condition") {
-		return conditionBranchAllowed(edge, edgeIndex, state)
-	}
-	return true
-}
-
-func conditionBranchAllowed(edge graphEdge, edgeIndex int, state *workflowExecState) bool {
-	matched := conditionMatched(state)
-	if branch := conditionBranchHint(edge); branch != "" {
-		return (branch == "true" && matched) || (branch == "false" && !matched)
-	}
-	switch edgeIndex {
-	case 0:
-		return matched
-	case 1:
-		return !matched
-	default:
-		return false
-	}
-}
-
-func conditionMatched(state *workflowExecState) bool {
-	v := strings.ToLower(cleanComparable(fmt.Sprint(valueFromPath("previous.matched", state))))
-	return v == "true" || v == "1"
-}
-
-func conditionBranchHint(edge graphEdge) string {
-	if edge.Config != nil {
-		switch strings.ToLower(strings.TrimSpace(cfgString(edge.Config, "branch"))) {
-		case "true", "yes", "y", "是":
-			return "true"
-		case "false", "no", "n", "否":
-			return "false"
-		}
-	}
-	switch strings.ToLower(strings.TrimSpace(edge.Label)) {
-	case "true", "yes", "y", "是":
-		return "true"
-	case "false", "no", "n", "否":
-		return "false"
-	}
-	return ""
-}
-
-func emitConditionBranchProgress(args RunArgs, runID string, node graphNode, edges []graphEdge, nodes map[string]graphNode, state *workflowExecState) {
-	if args.Progress == nil || len(edges) == 0 {
-		return
-	}
-	for edgeIdx, edge := range edges {
-		allowed := edgeAllowed(edge, node, edgeIdx, state)
-		target := nodes[edge.Target]
-		targetLabel := strings.TrimSpace(target.Label)
-		if targetLabel == "" {
-			targetLabel = edge.Target
-		}
-		branchLabel := strings.TrimSpace(edge.Label)
-		if branchLabel == "" {
-			switch edgeIdx {
-			case 0:
-				branchLabel = "是"
-			case 1:
-				branchLabel = "否"
-			default:
-				branchLabel = fmt.Sprintf("分支 %d", edgeIdx+1)
-			}
-		}
-		cond := firstNonEmpty(cfgString(edge.Config, "condition"), cfgString(edge.Config, "expression"))
-		eventType := "workflow_branch_skipped"
-		msg := fmt.Sprintf("跳过分支「%s」→ %s", branchLabel, targetLabel)
-		if allowed {
-			eventType = "workflow_branch_taken"
-			msg = fmt.Sprintf("执行分支「%s」→ %s", branchLabel, targetLabel)
-		}
-		args.Progress(eventType, msg, map[string]any{
-			"workflowRunId": runID,
-			"nodeId":        node.ID,
-			"nodeType":      node.Type,
-			"label":         node.Label,
-			"branchLabel":   branchLabel,
-			"targetId":      edge.Target,
-			"targetLabel":   targetLabel,
-			"edgeCondition": cond,
-			"matched":       conditionMatched(state),
-		})
-	}
-}
-
-func cfgString(cfg map[string]any, key string) string {
-	if cfg == nil {
-		return ""
-	}
-	if v, ok := cfg[key]; ok {
-		return strings.TrimSpace(fmt.Sprint(v))
-	}
-	return ""
-}
-
-func firstNonEmpty(values ...string) string {
-	for _, value := range values {
-		if s := strings.TrimSpace(value); s != "" {
-			return s
-		}
-	}
-	return ""
-}
-
-func truncateWorkflowPreview(s string, limit int) string {
-	s = strings.TrimSpace(s)
-	if limit <= 0 || len([]rune(s)) <= limit {
-		return s
-	}
-	runes := []rune(s)
-	return string(runes[:limit]) + "..."
-}
-
-var templateVarRe = regexp.MustCompile(`\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}`)
-
-func resolveTemplate(s string, state *workflowExecState) string {
-	if strings.TrimSpace(s) == "" {
-		return fmt.Sprint(valueFromPath("previous.output", state))
-	}
-	return templateVarRe.ReplaceAllStringFunc(s, func(match string) string {
-		m := templateVarRe.FindStringSubmatch(match)
-		if len(m) != 2 {
-			return match
-		}
-		return fmt.Sprint(valueFromPath(m[1], state))
-	})
-}
-
-func valueFromPath(path string, state *workflowExecState) any {
-	parts := strings.Split(path, ".")
-	if len(parts) == 0 {
-		return ""
-	}
-	var cur any
-	switch parts[0] {
-	case "inputs", "input":
-		cur = state.inputs
-	case "previous", "prev":
-		cur = state.lastOutput
-	case "outputs":
-		cur = state.outputs
-	default:
-		if v, ok := state.inputs[parts[0]]; ok {
-			cur = v
-		} else if v, ok := state.nodeOutputs[parts[0]]; ok {
-			cur = v
-		} else {
-			return ""
-		}
-	}
-	for _, p := range parts[1:] {
-		m, ok := cur.(map[string]any)
-		if !ok {
-			return ""
-		}
-		cur = m[p]
-	}
-	if cur == nil {
-		return ""
-	}
-	return cur
-}
-
-func evalCondition(expr string, state *workflowExecState) bool {
-	expr = strings.TrimSpace(expr)
-	if expr == "" {
-		return true
-	}
-	resolved := strings.TrimSpace(resolveTemplate(expr, state))
-	switch {
-	case strings.Contains(resolved, "!="):
-		parts := strings.SplitN(resolved, "!=", 2)
-		return cleanComparable(parts[0]) != cleanComparable(parts[1])
-	case strings.Contains(resolved, "=="):
-		parts := strings.SplitN(resolved, "==", 2)
-		return cleanComparable(parts[0]) == cleanComparable(parts[1])
-	default:
-		v := strings.ToLower(cleanComparable(resolved))
-		return v != "" && v != "false" && v != "0" && v != "null"
-	}
-}
-
-func cleanComparable(s string) string {
-	s = strings.TrimSpace(s)
-	s = strings.Trim(s, `"'`)
-	return s
-}
-
-func renderWorkflowResponse(roleName, workflowName string, version int, runID string, state *workflowExecState) string {
-	var sb strings.Builder
-	sb.WriteString(fmt.Sprintf("角色「%s」已完成工作流「%s」（版本 %d）。\n\n", roleName, workflowName, version))
-	sb.WriteString(fmt.Sprintf("运行 ID：%s\n", runID))
-	sb.WriteString(fmt.Sprintf("已执行节点：%d", len(state.executed)))
-	if len(state.skipped) > 0 {
-		sb.WriteString(fmt.Sprintf("，跳过节点：%d", len(state.skipped)))
-	}
-	sb.WriteString("\n\n")
-	if len(state.outputs) > 0 {
-		sb.WriteString("输出：\n")
-		keys := make([]string, 0, len(state.outputs))
-		for k := range state.outputs {
-			keys = append(keys, k)
-		}
-		sort.Strings(keys)
-		for _, k := range keys {
-			sb.WriteString(fmt.Sprintf("- %s：%v\n", k, state.outputs[k]))
-		}
-	} else {
-		sb.WriteString("暂无输出。请检查是否配置了输出节点，或条件分支是否命中。\n")
-	}
-	if len(state.skipped) > 0 {
-		sb.WriteString("\n未执行的节点类型仍会保留运行记录：")
-		sb.WriteString(strings.Join(state.skipped, "、"))
-		sb.WriteString("。")
-	}
-	return strings.TrimSpace(sb.String())
+	return &RunResult{Response: response, RunID: runID, Status: "completed"}, nil
 }