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 (
"context"
"crypto/sha256"
"encoding/hex"
"os"
"os/exec"
"regexp"
"strings"
"sync"
"time"
"agentflow/internal/domain"
"agentflow/internal/runtime"
"github.com/gin-gonic/gin"
)
const assistantDefaultModel = "default"
// assistantChatDefaultModel is the model the legacy sponsor account lends.
// New chat conversations preselect the shared key's default model when one is
// configured; otherwise chat uses the operator's default, like clarification,
// scheduled prompts, reports and executors.
const assistantChatDefaultModel = assistantSponsoredModel
type assistantModel struct {
ID string `json:"id"`
Name string `json:"name"`
Family string `json:"family"`
Credits string `json:"credits"`
Efforts []string `json:"efforts"`
// Engine is set for models that run on a CLI other than CodeBuddy.
Engine string `json:"engine,omitempty"`
}
type assistantModelCatalog struct {
Default string `json:"default"`
DefaultEfforts []string `json:"defaultEfforts,omitempty"`
Models []assistantModel `json:"models"`
// SponsoredModels is set when users without their own CodeBuddy API Key
// may still chat on the platform's shared key, limited to these models;
// SponsoredModel is the first (the default).
SponsoredModel string `json:"sponsoredModel,omitempty"`
SponsoredModels []string `json:"sponsoredModels,omitempty"`
// Engines lists the CLIs a signed-in user can switch between.
Engines []assistantEngineOption `json:"engines,omitempty"`
CursorModelsPending bool `json:"cursorModelsPending,omitempty"`
}
func prefetchAssistantModels() {}
// CodeBuddy publishes the models available in each network environment in its
// --help output; the list differs between international, internal and iOA.
var (
cliModelPattern = regexp.MustCompile(`Currently supported: \(([^)]*)\)`)
cliModelMu sync.Mutex
cliModelCache = map[string]cliModelEntry{}
discoverCLIModels = discoverCodeBuddyModels
)
const cliModelTTL = time.Hour
type cliModelEntry struct {
environment string
models []string
at time.Time
}
// cliModelCacheKey separates accounts within one environment: without a key
// the CLI only prints the environment's fallback list, while an authenticated
// account may unlock extra models (e.g. claude-opus-5.5).
func cliModelCacheKey(environment, apiKey string) string {
apiKey = strings.TrimSpace(apiKey)
if apiKey == "" {
return environment
}
sum := sha256.Sum256([]byte(apiKey))
return environment + "|" + hex.EncodeToString(sum[:8])
}
func discoverCodeBuddyModels(ctx context.Context, environment, apiKey string) []string {
bin, err := resolveCodeBuddyBin()
if err != nil {
return nil
}
dir, err := os.MkdirTemp("", "loopforge-models-")
if err != nil {
return nil
}
defer os.RemoveAll(dir)
ctx, cancel := context.WithTimeout(ctx, 20*time.Second)
defer cancel()
cmd := exec.CommandContext(ctx, bin, "--help")
cmd.Dir = dir
cmd.Env = []string{"PATH=" + os.Getenv("PATH"), "HOME=" + dir, "CODEBUDDY_CONFIG_DIR=" + dir, "CODEBUDDY_INTERNET_ENVIRONMENT=" + environment}
if key := strings.TrimSpace(apiKey); key != "" {
cmd.Env = append(cmd.Env, "CODEBUDDY_API_KEY="+key)
}
out, err := cmd.Output()
if err != nil {
return nil
}
return parseCodeBuddyModels(string(out))
}
func parseCodeBuddyModels(help string) []string {
m := cliModelPattern.FindStringSubmatch(help)
if m == nil {
return nil
}
var models []string
for _, id := range strings.Split(m[1], ",") {
id = strings.TrimSpace(id)
if id == "" || id == "echo" || strings.Contains(id, ":") {
continue
}
models = append(models, id)
}
return models
}
// refreshCLIModels runs discovery when the cached list is missing or stale.
func refreshCLIModels(ctx context.Context, environment, apiKey string) {
environment = strings.TrimSpace(environment)
cacheKey := cliModelCacheKey(environment, apiKey)
cliModelMu.Lock()
entry, ok := cliModelCache[cacheKey]
cliModelMu.Unlock()
if ok && time.Since(entry.at) < cliModelTTL {
return
}
models := discoverCLIModels(ctx, environment, apiKey)
cliModelMu.Lock()
if models != nil || !ok {
cliModelCache[cacheKey] = cliModelEntry{environment: environment, models: models, at: time.Now()}
}
cliModelMu.Unlock()
}
// assistantKnownCatalog validates settings that are not tied to one user's
// environment, such as SOP roles and notification bots.
func assistantKnownCatalog() assistantModelCatalog {
catalog := assistantFixedCatalog()
seen := map[string]bool{}
for _, model := range catalog.Models {
seen[model.ID] = true
}
cliModelMu.Lock()
defer cliModelMu.Unlock()
for _, entry := range cliModelCache {
for _, id := range entry.models {
if !seen[id] {
catalog.Models = append(catalog.Models, assistantListedModel(id, id, ""))
seen[id] = true
}
}
}
return catalog
}
func cachedCLIModels(environment string) []string {
cliModelMu.Lock()
defer cliModelMu.Unlock()
environment = strings.TrimSpace(environment)
var models []string
seen := map[string]bool{}
for _, entry := range cliModelCache {
if entry.environment != environment {
continue
}
for _, id := range entry.models {
if !seen[id] {
models = append(models, id)
seen[id] = true
}
}
}
return models
}
// models returns the chat model catalog for the caller's CodeBuddy
// environment. Guests get the configured models only; actually chatting still
// requires login plus a configured or sponsored CodeBuddy key.
func (h *assistantHandlers) models(c *gin.Context) {
if raw := strings.TrimSpace(c.Query("executor")); raw != "" && assistantExecutor(raw) != "codebuddy" {
engine := assistantExecutor(raw)
id := engine
if engine == assistantEngineClaude {
id = "claude"
} else if id == "claude" {
engine = assistantEngineClaude
}
var user domain.User
if h.repo != nil && (engine == runtime.AgentCLIKimi || engine == runtime.AgentCLIAntigravity) {
if current, signedIn := h.requestUser(c.Request, true); signedIn {
user, _ = h.repo.User(current.ID)
}
}
_, kimiBaseURL := assistantEngineCredential(user, runtime.AgentCLIKimi)
catalog, ok := executorModelCatalogs(kimiBaseURL)[id]
if !ok {
c.JSON(400, gin.H{"error": "不支持的执行器"})
return
}
result := assistantModelCatalog{Models: make([]assistantModel, 0, len(catalog.Models))}
if engine == runtime.AgentCLIAntigravity && antigravityUsesCustomEndpoint(user) {
c.Header("Cache-Control", "private, no-store")
c.JSON(200, result)
return
}
for _, item := range catalog.Models {
levels := make([]string, 0, len(item.Efforts))
for _, option := range item.Efforts {
levels = append(levels, option.Value)
}
result.Models = append(result.Models, assistantModel{ID: item.ID, Name: item.Name, Family: item.Family, Engine: engine, Efforts: levels})
}
if len(result.Models) > 0 {
result.Default = result.Models[0].ID
}
c.JSON(200, result)
return
}
var catalog assistantModelCatalog
key, shared := h.assistantSharedKey()
user, signedIn := domain.User{}, false
if current, ok := h.requestUser(c.Request, true); ok {
user, signedIn = h.repo.User(current.ID)
}
usingSharedKey := signedIn && shared && strings.TrimSpace(user.CodeBuddyAPIKey) == ""
switch {
case usingSharedKey:
// Chat runs on the shared key, so list what that key's environment offers.
refreshCLIModels(c.Request.Context(), key.InternetEnvironment, key.APIKey)
catalog = restrictAssistantCatalog(assistantChatCatalog(c.Request.Context(), key.InternetEnvironment, key.Models), key.Models)
case signedIn:
// A user's own key keeps their environment's models and default: the
// shared key's default may not exist in that environment.
refreshCLIModels(c.Request.Context(), user.CodeBuddyInternetEnvironment, user.CodeBuddyAPIKey)
catalog = assistantChatCatalog(c.Request.Context(), user.CodeBuddyInternetEnvironment, nil)
if saved := codeBuddyPersonalModels(user); len(saved) > 0 {
catalog.Default = saved[0].ID
if listed := selectableCodeBuddyModels(saved); len(listed) > 0 {
catalog.Models = listed
}
}
default:
catalog = assistantChatCatalog(c.Request.Context(), "", nil)
}
if catalog.Default == assistantDefaultModel {
models := user.CodeBuddyModels
if usingSharedKey {
models = nil
}
catalog.DefaultEfforts = assistantModelEffortsIn(catalog.Default, models)
}
catalog.Models = selectableCodeBuddyModels(catalog.Models)
if shared {
catalog.SponsoredModel, catalog.SponsoredModels = key.Models[0], key.Models
}
if signedIn {
c.Header("Cache-Control", "private, no-store")
catalog.Engines = assistantEngineOptions(user, usingSharedKey)
var runnerLogin map[string]bool
if c.Query("schedule") == "1" {
runnerLogin = make(map[string]bool)
for i := range catalog.Engines {
engine := catalog.Engines[i].ID
if scheduleLoginRunner(h.repo, user.ID, engine).ID != "" {
runnerLogin[engine] = true
catalog.Engines[i].Configured = true
}
}
}
models, pending := assistantEngineModels(c.Request.Context(), user, runnerLogin)
catalog.Models = append(catalog.Models, models...)
catalog.CursorModelsPending = pending
h.saveCursorCatalog(user)
}
c.JSON(200, catalog)
}
// Keep the CLI default as an execution fallback and for older saved records.
// The model pickers offer the concrete models available to the caller.
func selectableCodeBuddyModels(models []assistantModel) []assistantModel {
listed := make([]assistantModel, 0, len(models))
for _, model := range models {
if !codeBuddyIsDefaultModel(model.ID) {
listed = append(listed, model)
}
}
return listed
}
func codeBuddyIsDefaultModel(id string) bool {
return id == assistantDefaultModel || id == "default-model"
}
// withCodeBuddyPersonalModels accepts the user's saved CodeBuddy models and
// defaults requests without a model to the first of them. The environment's
// models stay accepted.
func withCodeBuddyPersonalModels(catalog assistantModelCatalog, user domain.User) assistantModelCatalog {
saved := codeBuddyPersonalModels(user)
if len(saved) == 0 {
return catalog
}
catalog.Models = append(catalog.Models, saved...)
catalog.Default = saved[0].ID
return catalog
}
func codeBuddyPersonalModels(user domain.User) []assistantModel {
if strings.TrimSpace(user.CodeBuddyAPIKey) == "" {
return nil
}
var models []assistantModel
for _, item := range assistantSavedModels(user, assistantEngineCodeBuddy) {
name := item.Name
if name == "" {
name = item.ID
}
model := assistantListedModel(item.ID, name, "")
model.Efforts = assistantModelEffortsIn(item.ID, user.CodeBuddyModels)
models = append(models, model)
}
return models
}
// assistantChatCatalog is the catalog used by chat conversations: the same
// models, with the shared key's models listed and its default preselected.
// Pass shared only for turns that run on the shared key (see chatCatalog).
func assistantChatCatalog(ctx context.Context, env string, shared []string) assistantModelCatalog {
catalog := loadAssistantModels(ctx, env)
if len(shared) == 0 {
return catalog
}
listed := map[string]bool{}
for _, model := range catalog.Models {
listed[model.ID] = true
}
for _, id := range shared {
if !listed[id] {
name := id
if id == assistantChatDefaultModel {
name = "Deepseek-V4.1-Flash"
}
catalog.Models = append(catalog.Models, assistantListedModel(id, name, ""))
listed[id] = true
}
}
catalog.Default = shared[0]
return catalog
}
// loadAssistantModels never blocks on discovery; validation accepts models the
// caller's environment has advertised.
func loadAssistantModels(_ context.Context, environment string) assistantModelCatalog {
catalog := assistantFixedCatalog()
seen := map[string]bool{}
for _, model := range catalog.Models {
seen[model.ID] = true
}
for _, id := range cachedCLIModels(environment) {
if !seen[id] {
catalog.Models = append(catalog.Models, assistantListedModel(id, id, ""))
seen[id] = true
}
}
return catalog
}
// assistantFixedCatalog mirrors `codebuddy --help` (CodeBuddy Code 2.180.0)
// --model list, names/credits from the CLI's remote product catalog. Two ids
// are kept although the CLI no longer advertises them: deepseek-v4-flash-ioa
// is pinned by live roles (and was the old built-in executor default), and
// hy4-preview-ioa stays alongside hy4std for existing users.
func assistantFixedCatalog() assistantModelCatalog {
defaultID := strings.TrimSpace(os.Getenv("AGENTFLOW_ASSISTANT_MODEL"))
if defaultID == "" {
defaultID = assistantDefaultModel
}
defaultName := defaultID
if defaultID == assistantDefaultModel {
defaultName = "CLI 默认模型"
}
models := []assistantModel{assistantListedModel(defaultID, defaultName, "")}
seen := map[string]bool{defaultID: true}
for _, id := range strings.Split(os.Getenv("AGENTFLOW_ASSISTANT_MODELS"), ",") {
id = strings.TrimSpace(id)
if id != "" && !seen[id] {
models = append(models, assistantListedModel(id, id, ""))
seen[id] = true
}
}
return assistantModelCatalog{Default: defaultID, Models: models}
}
func assistantListedModel(id, name, credits string) assistantModel {
return assistantModel{ID: id, Name: name, Family: assistantModelFamily(id, assistantEngineCodeBuddy), Credits: credits, Efforts: assistantModelEffortsIn(id, nil)}
}
func assistantModelFamily(id, engine string) string {
id = strings.ToLower(strings.TrimSpace(id))
if engine == assistantEngineCodeBuddy {
switch id {
case "fast-model", "balanced-model", "primary-model", "deep-model":
return "codebuddy"
}
}
id = id[strings.LastIndexByte(id, '/')+1:]
switch {
case strings.HasPrefix(id, "claude"):
return "claude"
case strings.HasPrefix(id, "gpt") || strings.Contains(id, "codex"):
return "gpt"
case strings.HasPrefix(id, "glm"):
return "glm"
case strings.HasPrefix(id, "gemini"):
return "gemini"
case id == "grok" || strings.HasPrefix(id, "grok-") || strings.HasPrefix(id, "cursor-grok-"):
return "grok"
case id == "muse" || strings.HasPrefix(id, "muse-"):
return "muse"
case id == "composer" || strings.HasPrefix(id, "composer-") || (engine == runtime.AgentCLICursor && (id == "auto" || id == "auto-smart")):
return "cursor"
case strings.HasPrefix(id, "kimi") || id == "k3" || strings.HasPrefix(id, "k3-") || strings.HasPrefix(id, "k3."):
return "kimi"
case strings.HasPrefix(id, "moonshot"):
return "moonshot"
case strings.HasPrefix(id, "qwen") || strings.HasPrefix(id, "qvq"):
return "qwen"
case strings.HasPrefix(id, "doubao") || strings.HasPrefix(id, "seed-") || strings.HasPrefix(id, "seedream"):
return "doubao"
case strings.HasPrefix(id, "ernie") || strings.HasPrefix(id, "wenxin") || strings.HasPrefix(id, "qianfan"):
return "qianfan"
case strings.HasPrefix(id, "deepseek"):
return "deepseek"
case strings.HasPrefix(id, "minimax"):
return "minimax"
case strings.HasPrefix(id, "hy") || strings.Contains(id, "hunyuan"):
return "hunyuan"
case strings.HasPrefix(id, "mimo"):
return "mimo"
default:
return "other"
}
}
func assistantAllowedModel(id string, catalog assistantModelCatalog) string {
id = strings.TrimSpace(id)
if id == "" {
return catalog.Default
}
for _, model := range catalog.Models {
if model.ID == id {
return id
}
}
return catalog.Default
}