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.
JavaScript agent-orchestrationagentic-workflowai-agentsai-codingclaude-codecode-reviewcodebuddycodexcoding-agentscursordeveloper-toolshuman-on-the-loopllmmcpmulti-agentsdlcself-hostedsopworkflow-automationworkflow-engine
package httpapi
import (
"agentflow/internal/engine"
"agentflow/internal/runtime"
"agentflow/internal/tracker"
"bytes"
"context"
"encoding/json"
"fmt"
"os"
"path/filepath"
"strings"
"testing"
"agentflow/internal/domain"
"agentflow/internal/repo"
)
func TestPersonalConversationRunsInItsOwnRootWithProjectSkills(t *testing.T) {
h, u := workbenchFixture(t)
if err := h.repo.PutProject(domain.Project{ID: "other", Name: "Other", OwnerID: u.ID}); err != nil {
t.Fatal(err)
}
for _, skill := range []domain.SkillDefinition{
{ID: "notes", Name: "notes", ProjectID: "workbench", Content: "记录要点"},
{ID: "shared-notes", Name: "shared-notes", ProjectID: "other", Shared: true, Content: "共享要点"},
} {
if err := h.repo.PutSkill(skill); err != nil {
t.Fatal(err)
}
}
root := t.TempDir()
bin := filepath.Join(root, "codebuddy")
homeFile := filepath.Join(root, "home")
script := `#!/bin/sh
printf '%s' "$HOME" > '` + homeFile + `'
printf '%s\n' '{"type":"result","result":"好"}'
`
if err := os.WriteFile(bin, []byte(script), 0700); err != nil {
t.Fatal(err)
}
t.Setenv("AGENTFLOW_CODEBUDDY_BIN", bin)
send := func(project, session string) string {
body, _ := json.Marshal(assistantRequest{ProjectID: project, SessionID: session, Messages: []assistantMessage{{Role: "user", Content: "你好"}}})
c, w := workbenchContext(u, "POST", "/api/assistant/chat", bytes.NewBuffer(body))
h.chat(c)
if w.Code != 200 {
t.Fatal(w.Code, w.Body.String())
}
home, _ := os.ReadFile(homeFile)
return string(home)
}
home := send("workbench", "personal-a")
if home != filepath.Join(assistantConversationRoot(u.ID, "personal-a"), "home") {
t.Fatalf("home=%s", home)
}
if _, err := os.Stat(filepath.Join(home, ".codebuddy", "skills", "notes", "SKILL.md")); err != nil {
t.Fatal("project skill not written to the conversation home", err)
}
other := send("", "personal-b")
if other == home || strings.HasPrefix(other, assistantCLIHome(u.ID)) {
t.Fatalf("conversations share a CLI home: %s", other)
}
if _, err := os.Stat(filepath.Join(other, ".codebuddy", "skills", "notes", "SKILL.md")); !os.IsNotExist(err) {
t.Fatal("a conversation without a project received a project skill", err)
}
if _, err := os.Stat(filepath.Join(other, ".codebuddy", "skills", "shared-notes", "SKILL.md")); err != nil {
t.Fatal("a conversation without a project did not receive the shared skill", err)
}
if assistantConversationRoot(u.ID, "same") == assistantConversationRoot(u.ID+1, "same") {
t.Fatal("a reused session ID reaches another user's root")
}
}
func TestConversationRootsFollowConversationDir(t *testing.T) {
sessions, conversations := t.TempDir(), t.TempDir()
t.Setenv("AGENTFLOW_ASSISTANT_SESSION_DIR", sessions)
under := func(root, base, kind string) bool {
return filepath.Base(filepath.Dir(root)) == kind && filepath.Dir(filepath.Dir(root)) == base
}
for _, unset := range []string{"", " "} {
t.Setenv("AGENTFLOW_CONVERSATION_DIR", unset)
if root := assistantConversationRoot(7, "s"); !under(root, sessions, "conversations") {
t.Fatalf("personal root with AGENTFLOW_CONVERSATION_DIR=%q = %s", unset, root)
}
if root := assistantSharedSessionRoot("s"); !under(root, sessions, "shared") {
t.Fatalf("shared root with AGENTFLOW_CONVERSATION_DIR=%q = %s", unset, root)
}
}
t.Setenv("AGENTFLOW_CONVERSATION_DIR", conversations)
if root := assistantConversationRoot(7, "s"); !under(root, conversations, "conversations") {
t.Fatalf("personal root = %s, want under %s", root, conversations)
}
if root := assistantSharedSessionRoot("s"); !under(root, conversations, "shared") {
t.Fatalf("shared root = %s, want under %s", root, conversations)
}
for _, path := range []string{assistantSessionRoot(7), assistantCLIHome(7), workbenchAttachmentDir(7)} {
if !strings.HasPrefix(path, sessions+string(filepath.Separator)) {
t.Fatalf("per-user state %s left AGENTFLOW_ASSISTANT_SESSION_DIR", path)
}
}
native := filepath.Join(assistantConversationRoot(7, "s"), "home", "state")
attachment := filepath.Join(workbenchAttachmentDir(7), "kept.bin")
for _, file := range []string{native, attachment} {
if err := os.MkdirAll(filepath.Dir(file), 0700); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(file, []byte("x"), 0600); err != nil {
t.Fatal(err)
}
}
deleteAssistantCLISession(7, "s")
if _, err := os.Stat(assistantConversationRoot(7, "s")); !os.IsNotExist(err) {
t.Fatalf("deleting the conversation left its root: %v", err)
}
if _, err := os.Stat(attachment); err != nil {
t.Fatalf("deleting the conversation removed per-user state: %v", err)
}
}
func TestProjectConversationIsolatesReferencesAndOffersProjectRoles(t *testing.T) {
h, u := workbenchFixture(t)
h.repo.PutProject(domain.Project{ID: "other", Name: "Other", OwnerID: u.ID})
for _, role := range []domain.AgentDefinition{
{ID: "dev", Name: "开发", ProjectID: "workbench", Prompt: "实现"},
{ID: "ops", Name: "运维", ProjectID: "other", Prompt: "部署"},
{ID: "reviewer", Name: "评审", ProjectID: "other", Shared: true, Prompt: "评审"},
} {
h.repo.PutAgent(role)
}
h.repo.PutIssue(domain.Issue{ID: "other-issue", Title: "别的需求", ProjectID: "other"})
c, _ := workbenchContext(u, "POST", "/", bytes.NewBuffer(nil))
prepare := func(project string, refs ...domain.AssistantReference) (assistantRequest, error) {
req := assistantRequest{ProjectID: project, Messages: []assistantMessage{{Role: "user", Content: "看看", References: refs}}}
return req, h.prepareWorkbenchContext(c, &req, u)
}
req, err := prepare("workbench")
if err != nil || len(req.roles) != 1 || req.roles[0].Role.ID != "dev" || !strings.Contains(req.contextText, "subagent_type=role-<角色ID>") {
t.Fatalf("project roles not offered unmentioned: %+v %v", req.roles, err)
}
for _, ref := range []domain.AssistantReference{{Type: "agent", ID: "ops"}, {Type: "issue", ID: "other-issue"}} {
if _, err := prepare("workbench", ref); err != errForeignReference {
t.Fatalf("%s from another project accepted: %v", ref.ID, err)
}
}
req, err = prepare("workbench", domain.AssistantReference{Type: "agent", ID: "reviewer"})
if err != nil || len(req.roles) != 2 {
t.Fatalf("shared role rejected or not offered: %+v %v", req.roles, err)
}
if _, err := prepare("", domain.AssistantReference{Type: "issue", ID: "other-issue"}); err != nil {
t.Fatal("a personal conversation lost cross-project references", err)
}
}
func TestSkillMentionsAreScopedHintedAndWrittenToHome(t *testing.T) {
h, u := workbenchFixture(t)
h.repo.PutProject(domain.Project{ID: "other", Name: "Other", OwnerID: u.ID})
for _, skill := range []domain.SkillDefinition{
{ID: "lint", Name: "代码检查", ProjectID: "workbench", Content: "检查"},
{ID: "Shared_Doc", Name: "写文档", ProjectID: "other", Shared: true, Content: "文档"},
{ID: "deploy", Name: "部署", ProjectID: "other", Content: "部署"},
} {
if err := h.repo.PutSkill(skill); err != nil {
t.Fatal(err)
}
}
c, rec := workbenchContext(u, "GET", "/api/assistant/references?projectId=workbench&type=skill", bytes.NewBuffer(nil))
h.workbenchReferences(c)
var found []domain.AssistantReference
json.Unmarshal(rec.Body.Bytes(), &found)
ids := map[string]bool{}
for _, item := range found {
ids[item.ID] = true
}
if !ids["lint"] || !ids["Shared_Doc"] || ids["deploy"] {
t.Fatalf("project skill search=%s", rec.Body.String())
}
c, _ = workbenchContext(u, "POST", "/", bytes.NewBuffer(nil))
req := assistantRequest{ProjectID: "workbench", Messages: []assistantMessage{{Role: "user", Content: "写一下", References: []domain.AssistantReference{{Type: "skill", ID: "Shared_Doc"}}}}}
if err := h.prepareWorkbenchContext(c, &req, u); err != nil {
t.Fatal(err)
}
if !strings.Contains(req.contextText, "skill=shareddoc") || req.Messages[0].References[0].Name != "写文档" {
t.Fatalf("skill hint missing: %s", req.contextText)
}
root := t.TempDir()
// Sharing installs the skill on a project turn that never mentions it.
plain := assistantRequest{ProjectID: "workbench", Messages: []assistantMessage{{Role: "user", Content: "写一下"}}}
if err := h.writeConversationAssets(root, plain); err != nil {
t.Fatal(err)
}
for _, name := range []string{"lint", "shareddoc"} {
if _, err := os.Stat(filepath.Join(root, "home", ".codebuddy", "skills", name, "SKILL.md")); err != nil {
t.Fatalf("skill %s not written: %v", name, err)
}
}
if _, err := os.Stat(filepath.Join(root, "home", ".codebuddy", "skills", "deploy", "SKILL.md")); !os.IsNotExist(err) {
t.Fatalf("another project's private skill was installed: %v", err)
}
req.Messages[0].References = []domain.AssistantReference{{Type: "skill", ID: "deploy"}}
if err := h.prepareWorkbenchContext(c, &req, u); err != errForeignReference {
t.Fatalf("another project's skill accepted: %v", err)
}
run := domain.Run{WorkflowSnapshot: domain.WorkflowDefinition{Nodes: []domain.WorkflowNode{{ID: "n", AgentID: "dev"}}}}
h.repo.PutAgent(domain.AgentDefinition{ID: "dev", Name: "开发", ProjectID: "workbench", Skills: []string{"lint"}})
if !h.taskReferenceAllowed(run, "skill", "lint") || h.taskReferenceAllowed(run, "skill", "Shared_Doc") {
t.Fatal("task skill references must follow the task's roles")
}
}
// Every shared skill on the platform reaches the CLI home, whichever project
// owns it, while private skills of other projects stay out; a conversation
// without a project gets the same shared set. A shared skill nobody mentioned
// brings only its SKILL.md; mentioning it installs its other files too.
func TestEverySharedSkillIsInstalledWithItsSkillMD(t *testing.T) {
h, u := workbenchFixture(t)
for _, project := range []string{"docs", "ops"} {
if err := h.repo.PutProject(domain.Project{ID: project, Name: project, OwnerID: u.ID}); err != nil {
t.Fatal(err)
}
}
runbook := domain.SkillDefinition{ID: "ops-runbook", Name: "ops-runbook", ProjectID: "ops", Shared: true, Content: "runbook", Files: map[string]string{"scripts/check.sh": "echo ok"}}
for _, skill := range []domain.SkillDefinition{
{ID: "own", Name: "own", ProjectID: "workbench", Content: "own"},
{ID: "docs-writer", Name: "docs-writer", ProjectID: "docs", Shared: true, Content: "write"},
{ID: "docs-draft", Name: "docs-draft", ProjectID: "docs", Content: "draft"},
runbook,
{ID: "ops-secret", Name: "ops-secret", ProjectID: "ops", Content: "secret"},
} {
if err := h.repo.PutSkill(skill); err != nil {
t.Fatal(err)
}
}
asset := []byte{0, 1, 2, 255}
skillMD := []byte("---\nname: ops-runbook\ndescription: run the ops checks\n---\nRun scripts/check.sh.\n")
if err := h.repo.PutSkillFiles("ops-runbook", []repo.SkillFileInput{
{Path: "SKILL.md", Content: skillMD, Mode: 0o644},
{Path: "assets/check.bin", Content: asset, Mode: 0o644},
}); err != nil {
t.Fatal(err)
}
stored, ok := h.repo.Skill("ops-runbook")
if !ok {
t.Fatal("ops-runbook not stored")
}
// The test store also seeds the platform's shared skills; they must be
// installed too, so only the skills created here are pinned.
for project, want := range map[string]map[string]bool{
"workbench": {"own": true, "docs-writer": true, "ops-runbook": true, "repository-navigation": true, "docs-draft": false, "ops-secret": false},
"": {"own": false, "docs-writer": true, "ops-runbook": true, "repository-navigation": true, "docs-draft": false, "ops-secret": false},
} {
for _, mentioned := range []bool{false, true} {
req := assistantRequest{ProjectID: project}
if mentioned {
req.skills = []domain.SkillDefinition{stored}
}
root := t.TempDir()
if err := h.writeConversationAssets(root, req); err != nil {
t.Fatal(err)
}
dir := filepath.Join(root, "home", ".codebuddy", "skills")
entries, err := os.ReadDir(dir)
if err != nil {
t.Fatal(err)
}
got := map[string]bool{}
for _, entry := range entries {
got[entry.Name()] = true
}
for name, installed := range want {
if got[name] != installed {
t.Fatalf("project %q skill %s installed=%v, want %v (all: %v)", project, name, got[name], installed, got)
}
}
if data, err := os.ReadFile(filepath.Join(dir, "ops-runbook", "SKILL.md")); err != nil || !bytes.Contains(data, []byte("Run scripts/check.sh.")) {
t.Fatalf("project %q mentioned=%v shared SKILL.md = %q %v", project, mentioned, data, err)
}
for path, content := range map[string][]byte{"assets/check.bin": asset, "scripts/check.sh": []byte("echo ok")} {
data, err := os.ReadFile(filepath.Join(dir, "ops-runbook", filepath.FromSlash(path)))
if mentioned && (err != nil || !bytes.Equal(data, content)) {
t.Fatalf("project %q mentioned shared skill file %s = %v %v", project, path, data, err)
}
if !mentioned && !os.IsNotExist(err) {
t.Fatalf("project %q unmentioned shared skill file %s was installed: %v", project, path, err)
}
}
}
}
}
func TestEverySharedSkillIsInstalledHoweverManyAreShared(t *testing.T) {
h, u := workbenchFixture(t)
if err := h.repo.PutProject(domain.Project{ID: "docs", Name: "docs", OwnerID: u.ID}); err != nil {
t.Fatal(err)
}
if err := h.repo.PutSkill(domain.SkillDefinition{ID: "own", Name: "own", ProjectID: "workbench", Content: "own"}); err != nil {
t.Fatal(err)
}
if err := h.repo.PutSkill(domain.SkillDefinition{ID: "docs-private", Name: "docs-private", ProjectID: "docs", Content: "private"}); err != nil {
t.Fatal(err)
}
// More shared skills than the 50 an earlier revision installed, so a
// skill late in id order (the one a scheduled task needs) is still there.
for i := 0; i < 120; i++ {
id := fmt.Sprintf("zz-shared-%03d", i)
if err := h.repo.PutSkill(domain.SkillDefinition{ID: id, Name: id, ProjectID: "docs", Shared: true, Content: id}); err != nil {
t.Fatal(err)
}
}
var shared []string
for _, skill := range h.repo.Skills() {
if skill.Shared && skill.ProjectID != "workbench" {
shared = append(shared, skill.ID)
}
}
if len(shared) < 120 {
t.Fatalf("fixture has %d shared skills, want at least 120", len(shared))
}
for _, project := range []string{"workbench", ""} {
root := t.TempDir()
if err := h.writeConversationAssets(root, assistantRequest{ProjectID: project}); err != nil {
t.Fatal(err)
}
entries, err := os.ReadDir(filepath.Join(root, "home", ".codebuddy", "skills"))
if err != nil {
t.Fatal(err)
}
got := map[string]bool{}
for _, entry := range entries {
got[entry.Name()] = true
}
if got["own"] != (project == "workbench") {
t.Fatalf("project %q own skill installed=%v", project, got["own"])
}
if got["docs-private"] {
t.Fatalf("project %q installed another project's private skill", project)
}
for _, id := range shared {
if !got[id] {
t.Fatalf("project %q shared skill %s not installed (installed %d of %d)", project, id, len(got), len(shared))
}
}
}
}
func TestSubagentStreamEventsCarryTheirDispatch(t *testing.T) {
dispatch := assistantStreamEvents(`{"type":"assistant","message":{"content":[{"type":"tool_use","id":"call-1","name":"Agent","input":{"subagent_type":"role-qa","description":"补单测","prompt":"x"}}]}}`)
if len(dispatch) != 1 || dispatch[0].Subagent != "role-qa" || dispatch[0].Parent != "" || dispatch[0].Input != "x" || dispatch[0].Model != "" {
t.Fatalf("dispatch=%+v", dispatch)
}
// A dispatch that names a model keeps it; one that only inherits does not.
for input, want := range map[string]string{
`"model":"claude-sonnet-4-5"`: "claude-sonnet-4-5",
`"model":" lite "`: "lite",
`"model":"default"`: "",
`"model":"inherit"`: "",
`"model":"<synthetic>"`: "",
} {
got := assistantStreamEvents(`{"type":"assistant","message":{"content":[{"type":"tool_use","id":"call-m","name":"Agent","input":{"subagent_type":"Explore","prompt":"x",` + input + `}}]}}`)
if len(got) != 1 || got[0].Model != want {
t.Fatalf("%s: dispatch=%+v, want model %q", input, got, want)
}
}
// A subagent's line reports the model it actually runs on, under its
// dispatch; Main Bot's own lines do not.
ran := assistantStreamEvents(`{"type":"assistant","parent_tool_use_id":"call-1","message":{"model":"deepseek-v4.1-flash-ioa","content":[{"type":"text","text":"ok"}]}}`)
if len(ran) != 2 || ran[0].Kind != "agentModel" || ran[0].Model != "deepseek-v4.1-flash-ioa" || ran[0].Parent != "call-1" {
t.Fatalf("subagent line=%+v", ran)
}
// A synthesized line names no real model.
if synthetic := assistantStreamEvents(`{"type":"assistant","parent_tool_use_id":"call-1","message":{"model":"<synthetic>","content":[{"type":"text","text":"ok"}]}}`); len(synthetic) != 1 || synthetic[0].Kind != "agentText" {
t.Fatalf("synthetic line=%+v", synthetic)
}
if main := assistantStreamEvents(`{"type":"assistant","message":{"model":"deepseek-v4.1-flash-ioa","content":[{"type":"text","text":"ok"}]}}`); len(main) != 1 || main[0].Kind != "answer" {
t.Fatalf("main line=%+v", main)
}
if got := labelRoleSubagent(dispatch[0], []roleSubagent{{Role: domain.AgentDefinition{ID: "qa", Name: "测试工程师"}}}); got.Role != "测试工程师" {
t.Fatalf("role label=%q", got.Role)
}
inner := assistantStreamEvents(`{"type":"assistant","parent_tool_use_id":"call-1","message":{"content":[{"type":"thinking","thinking":"先看"},{"type":"text","text":"已补 3 个用例"}]}}`)
if len(inner) != 2 || inner[0].Parent != "call-1" || inner[1].Kind != "agentText" || inner[1].Parent != "call-1" {
t.Fatalf("subagent events=%+v", inner)
}
done := assistantStreamEvents(`{"type":"user","message":{"content":[{"type":"tool_result","tool_use_id":"call-1","content":[{"type":"text","text":"已补 3 个用例\n[Agent ID: agent-b8c88507-5a8e]"}]}]}}`)
// The report is kept without the CLI's agent ID bookkeeping.
if len(done) != 1 || done[0].Kind != "toolDone" || done[0].AgentID != "agent-b8c88507-5a8e" || done[0].Output != "已补 3 个用例" {
t.Fatalf("done=%+v", done)
}
if plain := assistantStreamEvents(`{"type":"user","message":{"content":[{"type":"tool_result","tool_use_id":"r","content":"Agent ID: agent-x1"}]}}`); plain[0].AgentID != "agent-x1" {
t.Fatalf("string result=%+v", plain)
}
// Other tool results stay out of the record.
if other := assistantStreamEvents(`{"type":"user","message":{"content":[{"type":"tool_result","tool_use_id":"r","content":"secret file body"}]}}`); other[0].Output != "" {
t.Fatalf("plain tool result kept: %+v", other)
}
}
func TestActivityLogKeepsSubagentThoughtsApart(t *testing.T) {
var log assistantActivityLog
log.add(assistantStreamEvent{Kind: "thinking", Text: "主"})
log.add(assistantStreamEvent{Kind: "thinking", Text: "子", Parent: "call-1"})
log.add(assistantStreamEvent{Kind: "agentText", Text: "汇报", Parent: "call-1", Full: true})
log.add(assistantStreamEvent{Kind: "agentText", Text: "汇报", Parent: "call-1", Full: true})
if len(log.events) != 3 || log.events[0].Text != "主" || log.events[1].Parent != "call-1" || log.events[2].Kind != "agentText" {
t.Fatalf("events=%+v", log.events)
}
}
func TestRoleAgentIDsHintReuse(t *testing.T) {
h, u := workbenchFixture(t)
h.repo.PutAgent(domain.AgentDefinition{ID: "qa", Name: "测试工程师", ProjectID: "workbench", Prompt: "测试"})
activity := func(id, agent string, failed bool) []domain.AssistantActivityEvent {
return []domain.AssistantActivityEvent{{Kind: "tool", ID: id}, {Kind: "tool", ID: id, Subagent: "role-qa"}, {Kind: "toolDone", ID: id, AgentID: agent, Failed: failed}}
}
session := domain.AssistantSession{ID: "reuse", ProjectID: "workbench", Messages: []domain.AssistantMessage{
{Role: "user", Content: "补单测"},
{Role: "assistant", Content: "好", Activity: activity("c1", "agent-old", false)},
{Role: "user", Content: "再补"},
{Role: "assistant", Content: "好", Activity: append(activity("c2", "agent-new", false), activity("c3", "agent-broken", true)...)},
}}
if err := h.repo.PutAssistantSession(u.ID, session); err != nil {
t.Fatal(err)
}
if ids := roleAgentIDs(session.Messages); ids["role-qa"] != "agent-new" {
t.Fatalf("ids=%v", ids)
}
c, _ := workbenchContext(u, "POST", "/", bytes.NewBuffer(nil))
req := assistantRequest{ProjectID: "workbench", SessionID: "reuse", Messages: append(session.Messages, domain.AssistantMessage{Role: "user", Content: "继续"})}
if err := h.prepareWorkbenchContext(c, &req, u); err != nil {
t.Fatal(err)
}
if !strings.Contains(req.contextText, "agent ID agent-new") || !strings.Contains(req.contextText, "resume=<agent ID>") {
t.Fatalf("reuse hint missing: %s", req.contextText)
}
}
// The CLI announces an Agent call with empty input before the full one; the
// stream filter must let the full copy through, or the dispatch loses its
// subagent type, task and the agent ID reuse depends on.
func TestStreamFilterKeepsCompletedAgentCall(t *testing.T) {
var filter assistantStreamFilter
var kept []assistantStreamEvent
for _, line := range []string{
`{"type":"stream_event","event":{"type":"content_block_start","content_block":{"type":"tool_use","id":"call-1","name":"Agent","input":{}}}}`,
`{"type":"assistant","message":{"content":[{"type":"tool_use","id":"call-1","name":"Agent","input":{"subagent_type":"role-fe","description":"梳理入口","prompt":"读 chatbot/src"}}]}}`,
`{"type":"assistant","message":{"content":[{"type":"tool_use","id":"call-1","name":"Agent","input":{"subagent_type":"role-fe","description":"梳理入口","prompt":"读 chatbot/src"}}]}}`,
} {
for _, ev := range assistantStreamEvents(line) {
if filter.accept(ev) {
kept = append(kept, ev)
}
}
}
if len(kept) != 2 {
t.Fatalf("kept=%+v", kept)
}
full := kept[1]
if full.Subagent != "role-fe" || full.Input != "读 chatbot/src" || full.Detail != "梳理入口" {
t.Fatalf("full dispatch=%+v", full)
}
var log assistantActivityLog
for _, ev := range kept {
log.add(ev)
}
log.add(assistantStreamEvent{Kind: "toolDone", ID: "call-1", AgentID: "agent-1"})
if ids := roleAgentIDs([]domain.AssistantMessage{{Role: "assistant", Activity: log.snapshot()}}); ids["role-fe"] != "agent-1" {
t.Fatalf("reuse ids=%v", ids)
}
}
// A subagent never sees Main Bot's system prompt, so its own file says where
// the code is and that the task outranks the role's SOP-node conventions.
func TestRoleAgentFileExplainsChatWork(t *testing.T) {
file := roleAgentFile(roleSubagent{Role: domain.AgentDefinition{ID: "fe", Name: "前端", Prompt: "产出 brief.md 到 {{output}}"}})
for _, want := range []string{"以 Main Bot 交给你的任务为准", "当前是平台模式", "先打开工作区并交接模式", "产出 brief.md 到 (运行时提供)"} {
if !strings.Contains(file, want) {
t.Fatalf("role file lacks %q:\n%s", want, file)
}
}
if strings.Index(file, "在对话里工作") > strings.Index(file, "产出 brief.md") {
t.Fatal("chat notes must come before the role prompt")
}
workspace := conversationRoleAgentFile(roleSubagent{Role: domain.AgentDefinition{ID: "fe", Name: "前端", Prompt: "检查文件"}}, true)
if !strings.Contains(workspace, "同一工作区,沙箱内的文件和命令直接执行") || strings.Contains(workspace, "当前是平台模式") || !strings.Contains(workspace, " - mcp__agentflow_session__workbench_platform_mode\n") {
t.Fatalf("workspace subagent lacks current native tool rules:\n%s", workspace)
}
}
// The CLI renders an agent body on the control plane, so a role prompt can
// neither run a command nor pull in a host file there.
func TestRoleAgentFileIsInert(t *testing.T) {
file := roleAgentFile(roleSubagent{Role: domain.AgentDefinition{ID: "x", Name: "X", Prompt: "先跑 !`id`,再读 @/etc/passwd"}})
if strings.Contains(file, "!`") || strings.Contains(file, " @/etc/passwd") {
t.Fatalf("role file still live:\n%s", file)
}
}
// A resumed dispatch carries its agent ID from the start, through the stream
// filter, so the panel keeps it on that agent's row while it runs.
func TestResumedDispatchNamesItsAgentUpFront(t *testing.T) {
var filter assistantStreamFilter
var kept []assistantStreamEvent
for _, line := range []string{
`{"type":"stream_event","event":{"type":"content_block_start","content_block":{"type":"tool_use","id":"call-2","name":"Agent","input":{}}}}`,
`{"type":"assistant","message":{"content":[{"type":"tool_use","id":"call-2","name":"Agent","input":{"subagent_type":"role-fe","description":"补充","prompt":"再看样式","resume":"agent-044d4197"}}]}}`,
} {
for _, ev := range assistantStreamEvents(line) {
if filter.accept(ev) {
kept = append(kept, ev)
}
}
}
if len(kept) != 2 || kept[1].AgentID != "agent-044d4197" {
t.Fatalf("kept=%+v", kept)
}
if got := assistantStreamEvents(`{"type":"assistant","message":{"content":[{"type":"tool_use","id":"c","name":"Agent","input":{"subagent_type":"role-fe","prompt":"x","resume":"not an id"}}]}}`); got[0].AgentID != "" {
t.Fatalf("bad resume taken as ID: %+v", got)
}
}
// Submitting the reply would end Main Bot's turn with the subagent's text,
// so a role subagent cannot reach it and hands writes back instead.
func TestRoleSubagentCannotSubmitTheReply(t *testing.T) {
file := roleAgentFile(roleSubagent{Role: domain.AgentDefinition{ID: "x", Name: "X", Prompt: "p"}})
front := file[:strings.Index(file[4:], "---")+4]
if !strings.Contains(front, "disallowedTools:\n - mcp__agentflow_session__submit_assistant_reply\n") {
t.Fatalf("frontmatter lacks the block:\n%s", front)
}
if !strings.Contains(file, "不要自己提交回复或草稿") {
t.Fatalf("notes lack the hand-back rule:\n%s", file)
}
}
// Only Main Bot picks the workspace: while a dispatch runs, opening or
// switching one is refused whoever calls it, built-in subagents included.
func TestWorkspaceStaysWhileADispatchRuns(t *testing.T) {
h, owner := workbenchFixture(t)
gateway := &agentToolGateway{deps: h.deps}
s := &AgentToolSession{Mode: AgentToolAssistant, ProjectID: "workbench", UserID: owner.ID, User: owner, ChatSessionID: "chat-1", ChatOwnerID: owner.ID}
open := func() error {
_, err := gateway.callMainBotWorkspace(context.Background(), s, "workbench_workspace_open", map[string]any{"sandboxProfileId": "generic-docker"})
return err
}
for _, line := range []string{
`{"type":"stream_event","event":{"type":"content_block_start","content_block":{"type":"tool_use","id":"call-1","name":"Agent","input":{}}}}`,
`{"type":"assistant","message":{"content":[{"type":"tool_use","id":"call-1","name":"Agent","input":{"subagent_type":"general-purpose","prompt":"x"}}]}}`,
} {
for _, ev := range assistantStreamEvents(line) {
s.trackDispatch(ev)
}
}
// The subagent's own calls carry a parent and never count as dispatches.
s.trackDispatch(assistantStreamEvent{Kind: "toolDone", ID: "inner", Parent: "call-1"})
if err := open(); err == nil || !strings.Contains(err.Error(), "子 Agent 运行期间") {
t.Fatalf("open during a dispatch must be refused: %v", err)
}
for _, ev := range assistantStreamEvents(`{"type":"user","message":{"content":[{"type":"tool_result","tool_use_id":"call-1","content":"done\nAgent ID: agent-1"}]}}`) {
s.trackDispatch(ev)
}
if err := open(); err != nil && strings.Contains(err.Error(), "子 Agent 运行期间") {
t.Fatalf("open after the dispatch must go through: %v", err)
}
if file := roleAgentFile(roleSubagent{Role: domain.AgentDefinition{ID: "x", Name: "X", Prompt: "p"}}); !strings.Contains(file, " - mcp__agentflow_session__workbench_workspace_open\n") {
t.Fatalf("role file must block workspace_open:\n%s", file)
}
}
// A finished role dispatch is collected like an SOP node: the files its
// artifactOutputs name are attached to the reply, past the per-turn cap, and
// a required one that is missing becomes a failed step under the dispatch.
func TestRoleDeliverablesAreCollectedWhenTheDispatchEnds(t *testing.T) {
hostConversationWorkspace(t)
h, owner := workbenchFixture(t)
configureConversationSandbox(t, h)
if err := h.repo.PutRepository(domain.Repository{ID: "repo-web", ProjectID: "workbench", Name: "web", LocalPath: gitRepo(t), DefaultBranch: "main"}); err != nil {
t.Fatal(err)
}
if err := h.repo.PutAssistantSession(owner.ID, domain.AssistantSession{ID: "chat-d", ProjectID: "workbench", Messages: []domain.AssistantMessage{{Role: "user", Content: "归档"}}}); err != nil {
t.Fatal(err)
}
en := engine.New(h.repo, runtime.NewManager(t.TempDir()))
h.deps.engine = en
gateway := &agentToolGateway{deps: h.deps}
gateway.api = New(h.repo, en, tracker.NewService(), "", "")
s := &AgentToolSession{Mode: AgentToolAssistant, ProjectID: "workbench", UserID: owner.ID, User: owner, ChatSessionID: "chat-d", ChatOwnerID: owner.ID}
if _, err := gateway.callMainBotWorkspace(context.Background(), s, "workbench_workspace_open", map[string]any{}); err != nil {
t.Fatal(err)
}
if err := workspaceTestEdit(context.Background(), gateway, s, "archive.md", "# 归档\n"); err != nil {
t.Fatal(err)
}
for i := 0; i < agentReplyFileLimit; i++ {
if err := s.attachReplyFile(fmt.Sprintf("main-%d.md", i), "text/markdown", []byte("x")); err != nil {
t.Fatal(err)
}
}
roles := []roleSubagent{{Role: domain.AgentDefinition{ID: "archiver", Name: "归档", ArtifactOutputs: []domain.ArtifactContract{
{Name: "archive", Path: "archive.md", Required: true},
{Name: "plan", Path: "plan.md"},
{Name: "review", Path: "review.md", Required: true},
{Name: "escape", Path: "../secret.md", Required: true},
}}}}
// Only a dispatch the stream saw finish is collected.
s.trackDispatch(assistantStreamEvent{Kind: "tool", Tool: "Agent", ID: "call-a", Subagent: "role-archiver"})
finished := s.trackDispatch(assistantStreamEvent{Kind: "toolDone", ID: "call-a"})
events := h.collectRoleDeliverables(context.Background(), s, "call-a", finished, roles)
var steps []string
for _, ev := range events {
if ev.Parent != "call-a" {
t.Fatalf("deliverable step outside its dispatch: %+v", ev)
}
if ev.Kind == "tool" {
steps = append(steps, ev.Text)
}
}
if strings.Join(steps, "|") != "已收集交付物 · archive.md|缺少必需交付物 · review.md" {
t.Fatalf("steps=%v", steps)
}
if events[len(events)-1].Kind != "toolDone" || !events[len(events)-1].Failed {
t.Fatalf("missing required file must fail: %+v", events[len(events)-1])
}
var archived bool
for _, f := range s.takeReplyFiles() {
archived = archived || (f.Name == "archive.md" && string(f.Data) == "# 归档\n")
}
if !archived {
t.Fatal("archive.md was not attached past the per-turn cap")
}
if got := h.collectRoleDeliverables(context.Background(), s, "call-b", "general-purpose", roles); got != nil {
t.Fatalf("non-role dispatch collected: %+v", got)
}
}