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.

15.1 KB
Raw Blame
package httpapi

import (
	"context"
	"encoding/json"
	"fmt"
	"path/filepath"
	"strings"
	"testing"

	"agentflow/internal/domain"
	"agentflow/internal/engine"
	"agentflow/internal/repo"
	"agentflow/internal/runtime"
	"agentflow/internal/tracker"
)

const cliBashNotice = `Tool "Bash" does not exist in the current tool set.`

func TestAssistantStreamKeepsSubAgentProseOutOfReply(t *testing.T) {
	sub := `{"type":"assistant","parent_tool_use_id":"agent-call","message":{"content":[{"type":"thinking","thinking":"plan"},{"type":"text","text":"Let me run this python script"},{"type":"tool_use","id":"sub-read","name":"Read","input":{"file_path":"/tmp/x"}}]}}`
	events := assistantStreamEvents(sub)
	// Sub-agent prose is its own kind, shown in its dispatch, never in the reply.
	if len(events) != 3 || events[0].Kind != "thinking" || events[1].Kind != "agentText" || events[2].Kind != "tool" || events[2].ID != "sub-read" || events[2].Parent != "agent-call" {
		t.Fatalf("sub-agent events=%+v", events)
	}
	for _, line := range []string{
		`{"type":"stream_event","parent_tool_use_id":"agent-call","event":{"type":"content_block_delta","delta":{"type":"text_delta","text":"NO_EXEC_TOOL"}}}`,
		`{"type":"stream_event","parent_tool_use_id":"agent-call","event":{"type":"content_block_delta","delta":{"type":"input_json_delta","partial_json":"{\"message\":"}}}`,
		`{"type":"stream_event","parent_tool_use_id":"agent-call","event":{"type":"content_block_start","content_block":{"type":"tool_use","id":"sub-reply","name":"mcp__agentflow_session__submit_assistant_reply","input":{}}}}`,
	} {
		if got := assistantStreamEvents(line); len(got) != 0 {
			t.Fatalf("sub-agent line leaked %+v from %s", got, line)
		}
	}
	if got := assistantStreamEvents(`{"type":"stream_event","parent_tool_use_id":"agent-call","event":{"type":"content_block_delta","delta":{"type":"thinking_delta","thinking":"hm"}}}`); len(got) != 1 || got[0].Kind != "thinking" {
		t.Fatalf("sub-agent thinking=%+v", got)
	}
	// The main agent (no or null parent) is unchanged.
	for _, line := range []string{
		`{"type":"stream_event","event":{"type":"content_block_delta","delta":{"type":"text_delta","text":"main"}}}`,
		`{"type":"stream_event","parent_tool_use_id":null,"event":{"type":"content_block_delta","delta":{"type":"text_delta","text":"main"}}}`,
		`{"type":"assistant","parent_tool_use_id":null,"message":{"content":[{"type":"text","text":"main"}]}}`,
	} {
		if got := assistantStreamEvents(line); len(got) != 1 || got[0].Kind != "answer" || got[0].Text != "main" {
			t.Fatalf("main answer=%+v from %s", got, line)
		}
	}
	if got := assistantStreamEvents(`{"type":"stream_event","event":{"type":"content_block_start","content_block":{"type":"tool_use","id":"reply","name":"mcp__agentflow_session__submit_assistant_reply","input":{}}}}`); len(got) != 1 || got[0].Kind != "draftStart" {
		t.Fatalf("main draft start=%+v", got)
	}
}

func TestAssistantStreamDropsCLIToolNotFoundNotice(t *testing.T) {
	line := fmt.Sprintf(`{"type":"assistant","message":{"content":[{"type":"text","text":%q}]}}`, cliBashNotice)
	if got := assistantStreamEvents(line); len(got) != 0 {
		t.Fatalf("CLI notice became reply text: %+v", got)
	}
	quoted := `{"type":"assistant","message":{"content":[{"type":"text","text":"报错原文是 Tool \"Bash\" does not exist in the current tool set.,原因是未开放。"}]}}`
	if got := assistantStreamEvents(quoted); len(got) != 1 || got[0].Kind != "answer" {
		t.Fatalf("prose quoting the notice must stay: %+v", got)
	}
}

func TestAssistantVisibleReplyStripsCLINotice(t *testing.T) {
	events := []domain.AssistantActivityEvent{
		{Kind: "text", Text: "我先读取角色列表。"},
		{Kind: "tool", Tool: "agentflow__agents_list"},
		{Kind: "text", Text: cliBashNotice},
		{Kind: "text", Text: "核对完成。"},
	}
	got := assistantVisibleReply("核对完成。\n\n"+cliBashNotice, events)
	if strings.Contains(got, "does not exist") || !strings.Contains(got, "我先读取角色列表。") || !strings.Contains(got, "核对完成。") {
		t.Fatalf("visible reply=%q", got)
	}
	// A reply made only of the notice is kept rather than stored empty.
	if got := assistantVisibleReply(cliBashNotice, nil); got != cliBashNotice {
		t.Fatalf("notice-only reply=%q", got)
	}
	if got := stripAssistantCLINotices("a\n" + cliBashNotice + "\nb"); got != "a\nb" {
		t.Fatalf("stripped=%q", got)
	}
}

func testAgentsJSON(n, instructionRunes int) string {
	items := make([]map[string]any, 0, n)
	for i := 0; i < n; i++ {
		items = append(items, map[string]any{
			"id":           fmt.Sprintf("agent-%03d", i),
			"name":         fmt.Sprintf("角色 %d <a&b>", i),
			"model":        "claude-opus-5-5",
			"version":      json.Number("1234567890123456789"),
			"instructions": strings.Repeat("指", instructionRunes),
		})
	}
	raw, _ := json.Marshal(items)
	return string(raw)
}

func decodeFitted(t *testing.T, got string, result any) string {
	t.Helper()
	if len(got) > assistantToolResultBudget {
		t.Fatalf("fitted result %d bytes exceeds budget", len(got))
	}
	wrapped := struct {
		Notice string `json:"notice"`
		Result any    `json:"result"`
	}{Result: result}
	dec := json.NewDecoder(strings.NewReader(got))
	dec.UseNumber()
	if err := dec.Decode(&wrapped); err != nil {
		t.Fatalf("fitted result is not JSON: %v", err)
	}
	return wrapped.Notice
}

func TestFitAssistantToolResultKeepsWholeLeadingListItems(t *testing.T) {
	small := testAgentsJSON(2, 10)
	if got := fitAssistantToolResult("agents_list", small); got != small {
		t.Fatal("result within budget must stay byte-identical")
	}
	big := testAgentsJSON(60, 3000)
	if len(big) <= assistantToolResultBudget {
		t.Fatalf("fixture too small: %d", len(big))
	}
	var items []map[string]any
	notice := decodeFitted(t, fitAssistantToolResult("agents_list", big), &items)
	n := len(items)
	if n == 0 || n >= 60 || !strings.Contains(notice, fmt.Sprintf("前 %d 条(共 60 条)", n)) || !strings.Contains(notice, "不代表不存在") || !strings.Contains(notice, "fields=") {
		t.Fatalf("items=%d notice=%s", n, notice)
	}
	for i, item := range items {
		// Every kept item is complete: no value is shortened.
		if item["id"] != fmt.Sprintf("agent-%03d", i) || item["instructions"] != strings.Repeat("指", 3000) || item["name"] != fmt.Sprintf("角色 %d <a&b>", i) || item["version"] != json.Number("1234567890123456789") {
			t.Fatalf("item %d changed: %.200v", i, item)
		}
	}
}

func TestFitAssistantToolResultTrimsWrappedList(t *testing.T) {
	items := make([]map[string]any, 0, 5000)
	for i := 0; i < 5000; i++ {
		items = append(items, map[string]any{"id": fmt.Sprintf("issue-%05d", i), "status": "open"})
	}
	raw, _ := json.Marshal(map[string]any{"total": 5000, "items": items})
	var result struct {
		Total int              `json:"total"`
		Items []map[string]any `json:"items"`
	}
	notice := decodeFitted(t, fitAssistantToolResult("issues_list", string(raw)), &result)
	n := len(result.Items)
	if result.Total != 5000 || n == 0 || n >= 5000 || result.Items[0]["id"] != "issue-00000" || !strings.Contains(notice, fmt.Sprintf("前 %d 条(共 5000 条)", n)) {
		t.Fatalf("items=%d total=%d notice=%s", n, result.Total, notice)
	}
}

func TestFitAssistantToolResultLeavesDefinitionsAndTextUnchanged(t *testing.T) {
	// A *_get result is copied back into *_save (workflows_save overwrites the
	// whole graph), so it must never lose nodes or text.
	nodes := make([]map[string]any, 0, 40)
	for i := 0; i < 40; i++ {
		nodes = append(nodes, map[string]any{"id": fmt.Sprintf("n%d", i), "prompt": strings.Repeat("词", 2000)})
	}
	raw, _ := json.Marshal(map[string]any{"id": "wf", "nodes": nodes})
	workflow := string(raw)
	if len(workflow) <= assistantToolResultBudget {
		t.Fatalf("fixture too small: %d", len(workflow))
	}
	for _, tool := range []string{"workflows_get", "workflows_revision_get", "runs_artifact_get"} {
		if got := assistantPlatformResultForModel(tool, workflow); got != workflow {
			t.Fatalf("%s result changed", tool)
		}
	}
	text := strings.Repeat("日志行\n", assistantToolResultBudget)
	if got := fitAssistantToolResult("runs_logs_list", text); got != text {
		t.Fatal("multi-line text must stay readable in chunks, unchanged")
	}
	// Indented JSON that fits once compacted keeps every item.
	short := make([]map[string]any, 0, 20)
	for i := 0; i < 20; i++ {
		short = append(short, map[string]any{"id": fmt.Sprintf("wf%d", i), "name": "SOP", "status": "published"})
	}
	indented, _ := json.MarshalIndent(map[string]any{"items": short}, strings.Repeat(" ", 600), "\t")
	if len(indented) <= assistantToolResultBudget {
		t.Fatalf("indented fixture too small: %d", len(indented))
	}
	var compact struct{ Items []any }
	if got := fitAssistantToolResult("workflows_list", string(indented)); strings.Contains(got, "notice") || json.Unmarshal([]byte(got), &compact) != nil || len(compact.Items) != 20 {
		t.Fatalf("compacted list lost items: %.200s", got)
	}
	if got := assistantPlatformResultForModel("agents_list", testAgentsJSON(60, 3000)); len(got) > assistantToolResultBudget {
		t.Fatalf("model-facing list result not fitted: %d", len(got))
	}
}

func TestProjectAssistantResultFields(t *testing.T) {
	fields := assistantResultFields(" id, model ,,id")
	if strings.Join(fields, "|") != "id|model" {
		t.Fatalf("fields=%v", fields)
	}
	for _, tc := range []struct{ in, want string }{
		{`[{"id":"a","model":"m","instructions":"long"},{"id":"b"}]`, `[{"id":"a","model":"m"},{"id":"b"}]`},
		{`{"id":"a","model":"m","instructions":"long"}`, `{"id":"a","model":"m"}`},
		{`{"total":2,"items":[{"id":"a","x":1},{"id":"b","x":2}]}`, `{"items":[{"id":"a"},{"id":"b"}],"total":2}`},
		{`{"id":12345678901234567890,"x":1}`, `{"id":12345678901234567890}`},
		{`not json`, `not json`},
	} {
		if got := projectAssistantResult(tc.in, fields); got != tc.want {
			t.Fatalf("project(%s)=%s want %s", tc.in, got, tc.want)
		}
	}
	if got := projectAssistantResult(`[{"id":"a"}]`, nil); got != `[{"id":"a"}]` {
		t.Fatal("no fields must leave the result unchanged")
	}
}

func TestFilterAssistantResultIDs(t *testing.T) {
	ids := assistantResultFields("b, 12345678901234567890 ,b")
	for _, tc := range []struct{ in, want string }{
		{`[{"id":"a","x":1},{"id":"b","x":"<&>"},"c",{"x":3}]`, `[{"id":"b","x":"<&>"}]`},
		{`{"total":3,"items":[{"id":"a"},{"id":"b","y":2}]}`, `{"items":[{"id":"b","y":2}],"total":3}`},
		{`[{"id":12345678901234567890},{"id":1}]`, `[{"id":12345678901234567890}]`},
		{`{"id":"a","nodes":["x"]}`, `{"id":"a","nodes":["x"]}`},
		{`not json`, `not json`},
	} {
		if got := filterAssistantResultIDs(tc.in, ids); got != tc.want {
			t.Fatalf("filter(%s)=%s want %s", tc.in, got, tc.want)
		}
	}
	if got := filterAssistantResultIDs(`[{"id":"a"}]`, nil); got != `[{"id":"a"}]` {
		t.Fatal("no ids must leave the result unchanged")
	}
	// A trimmed list says how to reach the items it left out, including those
	// of lists without a *_get tool.
	var items []map[string]any
	if notice := decodeFitted(t, fitAssistantToolResult("skills_list", testAgentsJSON(60, 3000)), &items); !strings.Contains(notice, "ids") {
		t.Fatalf("notice=%s", notice)
	}
}

func TestAssistantPlatformFieldsAndModelCatalog(t *testing.T) {
	st, err := repo.OpenTest()
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(st.Close)
	user, ok := st.UserByLoginName("demo-owner")
	if !ok {
		t.Fatal("seed user")
	}
	if err := st.PutProject(domain.Project{ID: "proj-fields", Name: "Fields"}); err != nil {
		t.Fatal(err)
	}
	if err := st.PutAgent(domain.AgentDefinition{ID: "proj-fields-planner", Name: "Planner", ProjectID: "proj-fields", ExecutorID: "claude", Model: "claude-opus-5-5", Prompt: "long instructions"}); err != nil {
		t.Fatal(err)
	}
	api := New(st, engine.New(st, runtime.NewManager(filepath.Join(t.TempDir(), "workspaces"))), tracker.NewService(), "", "")
	h := &assistantHandlers{deps: &deps{repo: st}, api: api}
	got, err := h.callAssistantPlatform(context.Background(), user, "proj-fields", assistantMCPCall{Server: "agentflow", Tool: "agents_list", Arguments: map[string]any{"query": map[string]any{"fields": "id,model"}}})
	if err != nil {
		t.Fatal(err)
	}
	var agents []map[string]any
	if err := json.Unmarshal([]byte(got), &agents); err != nil || len(agents) == 0 {
		t.Fatalf("agents_list fields: %s %v", got, err)
	}
	found := false
	for _, agent := range agents {
		for key := range agent {
			if key != "id" && key != "model" {
				t.Fatalf("unrequested field %q in %v", key, agent)
			}
		}
		found = found || (agent["id"] == "proj-fields-planner" && agent["model"] == "claude-opus-5-5")
	}
	if !found {
		t.Fatalf("agent missing: %s", got)
	}
	// Skills have no *_get: ids reaches one skill in full, and is consumed by
	// the platform instead of reaching the handler.
	for _, id := range []string{"proj-fields-skill-a", "proj-fields-skill-b"} {
		if err := st.PutSkill(domain.SkillDefinition{ID: id, Name: id, ProjectID: "proj-fields", Content: "content of " + id}); err != nil {
			t.Fatal(err)
		}
	}
	got, err = h.callAssistantPlatform(context.Background(), user, "proj-fields", assistantMCPCall{Server: "agentflow", Tool: "skills_list", Arguments: map[string]any{"query": map[string]any{"ids": "proj-fields-skill-b"}}})
	if err != nil {
		t.Fatal(err)
	}
	var skills []map[string]any
	if err := json.Unmarshal([]byte(got), &skills); err != nil || len(skills) != 1 || skills[0]["id"] != "proj-fields-skill-b" || skills[0]["content"] != "content of proj-fields-skill-b" {
		t.Fatalf("skills_list ids: %s %v", got, err)
	}
	models, err := h.callAssistantPlatform(context.Background(), user, "proj-fields", assistantMCPCall{Server: "agentflow", Tool: "executor_models_list"})
	if err != nil || !strings.Contains(models, `"claude-opus-5-5"`) || !strings.Contains(models, `"codebuddy"`) {
		t.Fatalf("executor_models_list: %.300s %v", models, err)
	}
	if !assistantPlatformToolAllowed(assistantExecMode{}, "executor_models_list") {
		t.Fatal("model catalog must be readable in every approval mode")
	}
}

func TestAssistantPromptExplainsLargeResultsWithoutRestrictingSubAgents(t *testing.T) {
	for _, mode := range []string{AssistantApprovalConfirm, AssistantApprovalAssisted, AssistantApprovalAuto} {
		prompt := assistantSystemPromptForMode(mode)
		for _, want := range []string{"CLI 原生命令工具", "fields=id,name,model", "ids(逗号分隔的 id)", "executor_models_list"} {
			if !strings.Contains(prompt, want) {
				t.Fatalf("mode %s prompt lacks %q", mode, want)
			}
		}
		// Sub-agent prose is filtered out of the reply by parent_tool_use_id, so
		// the prompt must not discourage delegating to sub-agents.
		if strings.Contains(prompt, "子代理") {
			t.Fatalf("mode %s prompt must not restrict sub-agents", mode)
		}
	}
}

// A workspace is described by its environment, never by an old goal that
// would read like pending work.
func TestConversationWorkspaceDescribedByEnvironment(t *testing.T) {
	run := domain.Run{ID: "run-ws", Kind: domain.RunKindWorkspace, Input: "对话改代码:只读解析 JSON", WorkflowSnapshot: domain.WorkflowDefinition{SandboxProfileID: "generic-docker"}}
	got := describeConversationWorkspace(run)
	if got != "对话工作区 run-ws(运行环境 generic-docker,在线)" {
		t.Fatalf("workspace description=%s", got)
	}
	run.Repositories = []domain.RepositoryContext{{Name: "web"}}
	if got := describeConversationWorkspace(run); !strings.Contains(got, "预检出仓库 web") {
		t.Fatalf("legacy workspace description=%s", got)
	}
}