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 runtime
import (
"crypto/rand"
"encoding/hex"
"os"
"path/filepath"
"slices"
"strings"
"agentflow/internal/domain"
)
// agentCLIProvider runs one of the agent CLIs (AgentCLIKinds) in its native
// headless mode. The role's MCP servers go into the CLI's own configuration
// inside a per-Agent private HOME; ApplyAgentCLICredential adds the model configuration
// and the user's key there at launch.
type agentCLIProvider struct{ baseProvider }
func newAgentCLIProvider(kind string) agentCLIProvider {
return agentCLIProvider{baseProvider{kind: kind, parser: protocolTranslated, adapter: "agent-cli-stream-v1"}}
}
func (p agentCLIProvider) Materialize(ctx *providerMaterializeContext) error {
entries, err := mcpConfigEntries(ctx.MCPServers)
if err != nil {
return err
}
name := AgentCLIPrivateHomeKey(p.kind, ctx.AgentID)
if _, err := EnsureControlDirectory(ctx.Workspace, "private-home", name); err != nil {
return err
}
if err := WriteAgentCLIMCPConfig(p.kind, WorkspaceAgentCLIHome(ctx.Workspace, name), entries, AgentCLIMCPOptions{}); err != nil {
return err
}
ctx.Compiled.SystemPrompt = string(ctx.Content)
return nil
}
// agentCLINativeSystemPrompt marks CLIs that load the system prompt file
// themselves; the others receive it ahead of the task.
func agentCLINativeSystemPrompt(kind string) bool {
return kind == AgentCLIOpenCode || kind == AgentCLIPi
}
// AgentCLITaskPrompt prefixes the system prompt for CLIs without a system
// prompt option. An oversized prompt is referenced by path instead.
func AgentCLITaskPrompt(system, systemFile, task string) string {
system = strings.TrimSpace(system)
if system == "" {
return task
}
if len(system)+len(task) > maxArgvPromptBytes && systemFile != "" {
return "先完整阅读并严格遵守 `" + systemFile + "` 中的系统指令,然后完成下面的任务。\n\n" + task
}
return "<system_instructions>\n" + system + "\n</system_instructions>\n\n" + task
}
func newAgentCLISessionID() string {
var b [16]byte
_, _ = rand.Read(b[:])
b[6] = b[6]&0x0f | 0x40
b[8] = b[8]&0x3f | 0x80
h := hex.EncodeToString(b[:])
return h[0:8] + "-" + h[8:12] + "-" + h[12:16] + "-" + h[16:20] + "-" + h[20:32]
}
func (p agentCLIProvider) Prepare(in providerInvocation) (CommandSpec, error) {
systemFile := ""
if in.Compiled.AgentRoot != "" {
systemFile = filepath.ToSlash(filepath.Join(in.Compiled.AgentRoot, "agent-system.md"))
}
command := AgentCLICommand(p.kind, AgentCLICommandOptions{
Binary: in.Executor.Binary, Model: in.Executor.Model, Effort: in.Executor.Effort,
Resume: in.Options.ResumeSessionID, Prompt: positionalPrompt(in),
SystemPrompt: in.Compiled.SystemPrompt, SystemPromptFile: systemFile, Extra: in.Executor.Args,
RunnerLogin: in.Options.RunnerLogin,
})
command.CredentialBindings = []CredentialBinding{BindAgentCLI, BindGit, BindMCP}
command.PrivateHome = true
command.PrivateHomeKey = AgentCLIPrivateHomeKey(p.kind, in.Compiled.AgentID)
return command, nil
}
// AgentCLICommandOptions describes one headless agent CLI turn.
type AgentCLICommandOptions struct {
Binary, Model, Effort string
// Resume is the CLI's own session ID to continue; empty starts one.
Resume string
Prompt string
// SystemPrompt is the system prompt body; SystemPromptFile is the same
// text as a path the process can read.
SystemPrompt, SystemPromptFile string
Extra []string
// Chat runs the CLI for AI 对话 on the control plane: MCP tools stay
// available, shell, file writes and web access do not. The MCP
// configuration (WriteAgentCLIMCPConfig ReadOnly) completes the policy.
Chat bool
Workspace bool
RunnerLogin bool
// AgentFile is Kimi Code's chat agent definition (WriteKimiChatAgent).
AgentFile string
}
// AgentCLICommand builds the argv of an agent CLI turn; the caller adds
// credential bindings and the HOME policy.
func AgentCLICommand(kind string, o AgentCLICommandOptions) CommandSpec {
binary := strings.TrimSpace(o.Binary)
if binary == "" {
binary = AgentCLIBinary(kind)
}
model := strings.TrimSpace(o.Model)
effort := strings.TrimSpace(o.Effort)
resume := strings.TrimSpace(o.Resume)
prompt := o.Prompt
// A chat session keeps the prompt of its first turn; SOP invocations
// are independent processes that each receive it.
inline := !agentCLINativeSystemPrompt(kind) && !(o.Chat && kind == AgentCLIKimi)
if inline && !(o.Chat && resume != "") {
prompt = AgentCLITaskPrompt(o.SystemPrompt, o.SystemPromptFile, prompt)
}
extra := append([]string{}, o.Extra...)
var argv []string
readOnly := o.Chat && !o.Workspace
options := AgentCLIOptions{Model: model, Effort: effort, ReadOnly: readOnly}
switch kind {
case AgentCLIOpenCode:
argv = []string{binary, "run", "--format", "json", "--thinking"}
if model != "" {
argv = append(argv, "-m", "agentflow/"+model)
}
if resume != "" {
argv = append(argv, "-s", resume)
}
if effort != "" {
argv = append(argv, "--variant", effort)
}
options.SystemPromptFile = o.SystemPromptFile
argv = append(append(argv, extra...), prompt)
case AgentCLICursor:
// Chat relies on the deny rules of .cursor/cli-config.json; --force
// still approves the MCP tools.
argv = []string{binary, "-p", "--output-format", "stream-json", "--stream-partial-output", "--trust", "--force", "--approve-mcps"}
if model != "" {
// ApplyAgentCLICredential re-resolves this against the owner's
// saved catalog, which only the credential carries.
argv = append(argv, "--model", CursorModelID(model, effort, nil))
}
if resume != "" {
argv = append(argv, "--resume", resume)
}
argv = append(append(argv, extra...), prompt)
case AgentCLIAntigravity:
// Chat deny rules travel as --settings (ApplyAgentCLICredential);
// they hold even with --dangerously-skip-permissions.
argv = []string{binary, "--output-format", "stream-json", "--dangerously-skip-permissions", "--disable-slash-commands"}
if family := agyClaudeFamily(model); o.RunnerLogin && family != "" && slices.Contains(AgyAccountModelEfforts(family), effort) {
model, effort = family+"-"+effort, ""
}
if model != "" && AgyModelEfforts(model) == nil {
effort = ""
}
if model != "" {
argv = append(argv, "--model", agyModelForEffort(model, effort))
}
if effort != "" {
argv = append(argv, "--effort", effort)
}
if resume != "" {
argv = append(argv, "--conversation", resume)
}
argv = append(append(argv, extra...), "-p", prompt)
case AgentCLIKimi:
argv = []string{binary, "--output-format", "stream-json"}
if resume != "" {
argv = append(argv, "-S", resume)
}
if o.AgentFile != "" && resume == "" {
// The session keeps the agent, so resumed turns cannot pass it again.
argv = append(argv, "--agent-file", o.AgentFile)
}
argv = append(append(argv, extra...), "-p", prompt)
case AgentCLIPi:
session := resume
if session == "" {
session = newAgentCLISessionID()
}
argv = []string{binary, "--mode", "json", "--session-id", session}
if model != "" {
argv = append(argv, "--model", "agentflow/"+model)
}
if effort != "" {
argv = append(argv, "--thinking", effort)
}
if o.SystemPromptFile != "" {
argv = append(argv, "--append-system-prompt", o.SystemPromptFile)
}
if o.Chat {
// Pi restores its last declared tool loadout from the journal when
// --tools is omitted. Explicitly reset it on every mode handoff.
tools := "read,codemode"
if o.Workspace {
tools = "read,bash,edit,write,codemode"
}
argv = append(argv, "--tools", tools)
}
if readOnly {
argv = append(argv, "--exclude-tools", "bash,edit,write")
}
argv = append(append(argv, extra...), prompt)
case AgentCLIDeepSeek:
mode := "danger-full-access"
if readOnly {
mode = "read-only"
}
argv = []string{binary, "--profile", "headless", "--json", "--permission-mode", mode, "--approval-policy", "never"}
if resume != "" {
argv = append(argv, "--session-id", resume)
}
argv = append(append(argv, extra...), prompt)
case AgentCLIZCode:
disallowed := zcodeSOPDisallowedTools
if readOnly {
disallowed = zcodeChatDisallowedTools
}
argv = []string{binary, "--prompt", prompt, "--output-format", "stream-json", "--mode", "yolo", "--no-color", "--disallowed-tools", disallowed}
if resume != "" {
argv = append(argv, "--resume", resume)
}
argv = append(argv, extra...)
}
return CommandSpec{Argv: argv, Provider: kind, AgentCLI: options}
}
// AgyModelEfforts returns the separate effort choices for Gemini API models.
func AgyModelEfforts(model string) []string {
model, _ = SplitAgyModelEffort(strings.TrimSpace(model))
switch model {
case "gemini-4-neon", "gemini-4-hydrogen":
return []string{"low", "medium", "high", "xhigh"}
case "gemini-4-carbon", "gemini-4-argon", "gemini-3.8-flash", "gemini-3.7-flash", "gemini-3.6-flash":
return []string{"low", "medium", "high"}
case "gemini-3.1-pro", "gemini-3.1-pro-preview":
return []string{"low", "high"}
}
if strings.HasPrefix(model, "gemini-") && !strings.HasPrefix(model, "gemini-pro-orchestrator") {
return domain.ExecutorEffortLevels[AgentCLIAntigravity]
}
return nil
}
// agyModelForEffort replaces the effort suffix of an Antigravity model ID
// (gemini-3.8-flash-medium) with the requested effort: agy rejects a model
// whose suffix differs from --effort.
func agyModelForEffort(model, effort string) string {
if effort == "" {
return model
}
if base, existing := SplitAgyModelEffort(model); existing != "" {
return base + "-" + effort
}
return model
}
// kimiChatDisallowedTools are Kimi Code's tools that act outside the chat's
// MCP gateway or spawn further agents.
var kimiChatDisallowedTools = []string{"Bash", "Edit", "Write", "FetchURL", "WebSearch", "Agent", "AgentSwarm", "CronCreate", "CronDelete", "CronList", "TaskOutput", "TaskStop", "WaitFor"}
// WriteKimiChatAgent writes the Kimi Code agent definition for AI 对话: the
// system prompt as its body and the chat's tool restrictions.
func WriteKimiChatAgent(path, systemPrompt string) error {
return WriteKimiConversationAgent(path, systemPrompt, true)
}
func WriteKimiConversationAgent(path, systemPrompt string, readOnly bool) error {
body := strings.TrimSpace(systemPrompt)
if body == "" {
body = "You are the AgentFlow assistant."
}
denied := ""
if readOnly {
denied = strings.Join(kimiChatDisallowedTools, ", ")
}
content := "---\nname: agentflow-chat\ndescription: LoopForge AI 对话\ndisallowedTools: [" + denied + "]\n---\n" + body + "\n"
if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
return err
}
return os.WriteFile(path, []byte(content), 0o600)
}
func (agentCLIProvider) SandboxRequirements() SandboxRequirements {
return SandboxRequirements{PrivateHome: true}
}