Skip to content

Self-hosted workflows for coding-agent delivery. Orchestrate CodeBuddy, Codex and Claude Code with scripts and human approval gates. Includes Local workflows for coding assistants.

7.9 KB
Raw Blame
package engine

import (
	"fmt"
	"os"
	"path/filepath"
	"strings"

	"agentflow/internal/domain"
)

func clarifyProcessLog(event *domain.TelemetryEvent) {
	if event == nil {
		return
	}
	if event.Category == "verification" {
		return
	}
	if event.Category != "process" || event.Name != "process.finished" {
		return
	}
	if event.Level == "error" {
		event.Message = "执行器失败:" + event.Message
		return
	}
	if event.Message == "process exited successfully" {
		event.Message = "执行器退出 0"
	}
}

func applyUsage(run *domain.Run, nr *domain.NodeRun, sessionID string, snap domain.TokenUsage) {
	if run == nil || nr == nil {
		return
	}
	if sessionID == "" {
		sessionID = nr.SessionID
	}
	if sessionID != "" && nr.UsageSessionID != sessionID {
		nr.UsageSessionID = sessionID
		nr.UsageCursor = domain.TokenUsage{}
	}
	delta := subUsage(snap, nr.UsageCursor)
	// 成本识别状态与 token 数值变化解耦:跟随最近一次带状态的快照,
	// 让"真实零成本"与"成本未识别"在 run 级汇总上也可区分。
	if snap.CostStatus != "" {
		run.Usage.CostStatus = snap.CostStatus
		nr.Usage.CostStatus = snap.CostStatus
	}
	if !usageHasValues(delta) {
		nr.UsageCursor = snap
		return
	}
	addUsage(&run.Usage, delta)
	addUsage(&nr.Usage, delta)
	nr.UsageCursor = snap
	run.Usage.TotalTokens = billedTokens(run.Usage)
	nr.Usage.TotalTokens = billedTokens(nr.Usage)
}

func billedTokens(usage domain.TokenUsage) int64 {
	return usage.InputTokens + usage.OutputTokens
}

func usageHasValues(usage domain.TokenUsage) bool {
	return usage.InputTokens > 0 || usage.OutputTokens > 0 || usage.CacheReadTokens > 0 || usage.CacheWriteTokens > 0 || usage.ReasoningTokens > 0 || usage.CostUSD != 0
}

func addUsage(dst *domain.TokenUsage, src domain.TokenUsage) {
	dst.InputTokens += src.InputTokens
	dst.OutputTokens += src.OutputTokens
	dst.CacheReadTokens += src.CacheReadTokens
	dst.CacheWriteTokens += src.CacheWriteTokens
	dst.ReasoningTokens += src.ReasoningTokens
	dst.CostUSD += src.CostUSD
}

func subUsage(cur, prev domain.TokenUsage) domain.TokenUsage {
	return domain.TokenUsage{
		InputTokens:      clampNonNeg(cur.InputTokens - prev.InputTokens),
		OutputTokens:     clampNonNeg(cur.OutputTokens - prev.OutputTokens),
		CacheReadTokens:  clampNonNeg(cur.CacheReadTokens - prev.CacheReadTokens),
		CacheWriteTokens: clampNonNeg(cur.CacheWriteTokens - prev.CacheWriteTokens),
		ReasoningTokens:  clampNonNeg(cur.ReasoningTokens - prev.ReasoningTokens),
		CostUSD:          cur.CostUSD - prev.CostUSD,
	}
}

func clampNonNeg(v int64) int64 {
	if v < 0 {
		return 0
	}
	return v
}

func shouldSelfCorrect(onFailure string) bool {
	return resolveGateOnFailure(onFailure, "") == "loop"
}

// loopRetroSignals counts one node's telemetry for the loop retro.
type loopRetroSignals struct {
	completed, missingResult, gatePass, gateFail, loopStarts, toolFinishes int
	// loopIssues holds one "- Loop:" line per agent.loop event, in order.
	loopIssues []string
}

func collectLoopRetroSignals(run domain.Run, nodeID string) loopRetroSignals {
	var s loopRetroSignals
	for _, event := range run.Telemetry {
		if event.NodeID != nodeID {
			continue
		}
		switch {
		case event.Name == "agent.completed":
			s.completed++
		case event.Category == "process" && event.Name == "process.finished" && event.Source.Layer == "executor" && !strings.Contains(event.Message, "失败"):
			if s.completed == 0 {
				s.missingResult++
			}
		case event.Category == "verification" && event.Name == "process.finished" && event.Level != "error":
			s.gatePass++
		case event.Category == "verification" && event.Name == "process.finished" && event.Level == "error":
			s.gateFail++
		case event.Name == "agent.loop":
			s.loopStarts++
			s.loopIssues = append(s.loopIssues, "- Loop:"+event.Message)
		case event.Category == "tool" && event.Name == "tool.call" && event.Phase == "finish":
			s.toolFinishes++
		}
	}
	return s
}

func buildLoopRetro(run domain.Run, nodeID string, iterations int, lastErr error, onFailure string) string {
	var b strings.Builder
	fmt.Fprintf(&b, "# Loop 复盘 — `%s`\n\n", nodeID)
	fmt.Fprintf(&b, "- 自修正轮次:%d\n", iterations)
	if lastErr != nil {
		fmt.Fprintf(&b, "- 最终结果:未通过\n- 最后错误:`%s`\n\n", strings.ReplaceAll(lastErr.Error(), "\n", " "))
	} else {
		b.WriteString("- 最终结果:通过\n\n")
	}
	signals := collectLoopRetroSignals(run, nodeID)
	issues := signals.loopIssues
	if signals.missingResult > 0 {
		if lastErr != nil && strings.Contains(lastErr.Error(), "without a terminal result") {
			issues = append(issues, "- 执行器退出 0,但 stream-json 没有 `type:result` / `agent.completed`(协议中断,不是门禁失败,也不要先当成 max-turns)")
		} else {
			issues = append(issues, "- 执行器有退出 0 但没有 `agent.completed`(可能撞 max-turns / 协议中断)")
		}
	}
	if lastErr != nil && onFailure == "reject" {
		issues = append(issues, "- 按门禁 onFailure=reject:打回上游,不在本节点自修正")
	} else if lastErr != nil && onFailure == "fail" {
		issues = append(issues, "- 按门禁 onFailure=fail:本节点失败")
	} else if lastErr != nil && onFailure == "human" {
		issues = append(issues, "- 按门禁 onFailure=human:转人工确认")
	}
	if lastErr != nil && strings.Contains(lastErr.Error(), "without a terminal result") {
		issues = append(issues, "- 沙箱里可能已经写了报告,但节点在登记交付物前就被判失败,所以页面上往往只剩 loop-retro")
	} else if lastErr != nil && strings.Contains(lastErr.Error(), "No such file") {
		issues = append(issues, "- 产物未落地或会话提前结束")
	}
	fmt.Fprintf(&b, "## 信号\n\n- agent.completed:%d\n- 门禁通过 / 失败:%d / %d\n- 工具调用(finish):%d\n- 进入自修正:%d\n\n", signals.completed, signals.gatePass, signals.gateFail, signals.toolFinishes, signals.loopStarts)
	b.WriteString("## 问题\n\n")
	if len(issues) == 0 {
		b.WriteString("- 本节点未发现需要改 Loop 的异常。\n")
	} else {
		b.WriteString(strings.Join(issues, "\n") + "\n")
	}
	b.WriteString("\n## 建议\n\n")
	switch {
	case lastErr != nil && onFailure == "reject":
		b.WriteString("- 按页面配置打回上游,不要再开自修正。\n")
	case lastErr != nil && onFailure == "fail":
		b.WriteString("- 按页面配置结束本节点为失败。\n")
	case lastErr != nil && onFailure == "human":
		b.WriteString("- 按页面配置转人工确认。\n")
	case lastErr != nil && onFailure == "loop":
		b.WriteString("- 自修正轮次已用尽。若应直接打回或失败,到页面改这条门禁的失败策略。\n")
	case lastErr != nil && strings.Contains(lastErr.Error(), "without a terminal result"):
		b.WriteString("- 缺 `type:result` 时应交给门禁核对产物,而不是按节点失败整链打回;工具次数远低于 `--max-turns` 时不要写成撞轮次。\n")
	default:
		b.WriteString("- 失败策略只认门禁 onFailure(loop / reject / fail / human),在 Studio 里改,保存即写库。\n")
	}
	return b.String()
}

func (e *Engine) attachLoopRetro(runID, nodeID, workspace string, iterations int, lastErr error, onFailure string) {
	if lastErr == nil && iterations <= 1 {
		return
	}
	live, ok := e.repo.Run(runID)
	if !ok {
		return
	}
	attempt := 0
	if nr := live.Nodes[nodeID]; nr != nil {
		attempt = nr.Attempt
	}
	body := []byte(buildLoopRetro(live, nodeID, iterations, lastErr, onFailure))
	rel := filepath.ToSlash(filepath.Join(".agentflow", "loop-retro-"+nodeID+".md"))
	if workspace != "" {
		_ = os.MkdirAll(filepath.Join(workspace, ".agentflow"), 0o755)
		_ = os.WriteFile(filepath.Join(workspace, rel), body, 0o644)
	}
	e.updateRun(runID, func(r *domain.Run) {
		appendArtifact(r, nodeID, attempt, "loop-retro", rel, "text/markdown", body)
	})
	e.observe(runID, nodeID, domain.TelemetryEvent{Category: "artifact", Name: "artifact.published", Phase: "finish", Message: "loop-retro", Attributes: map[string]any{"path": rel, "size": len(body)}})
}