"io"
"os"
"path/filepath"
+ "slices"
"strings"
+
+ "golang.org/x/sys/unix"
)
const (
decoder := json.NewDecoder(bytes.NewReader(data))
decoder.DisallowUnknownFields()
+
err = decoder.Decode(&config)
if err == nil && !errors.Is(decoder.Decode(&struct{}{}), io.EOF) {
err = errors.New("data after the JSON object")
func (a *Agent) Prompt() (string, error) {
instructions, err := a.instructions()
if err != nil {
- return "", err
+ return "", fmt.Errorf("read prompt instructions: %w", err)
}
path, err := filepath.Abs(filepath.Join(a.dir, agentInstructionsFileName))
return "", fmt.Errorf("find instructions path: %w", err)
}
+ if a.config.Parent != "" {
+ return promptChild(a.config.Name, a.config.Parent, a.config.Responsibility, path, instructions), nil
+ }
+
return prompt(a.config.Name, path, instructions), nil
}
+// Tools returns the tools shared by the turns and compactions of this agent. A
+// child has no WhatsApp, child creation, or route tools.
+func (a *Agent) Tools() []ModelTool {
+ tools := promptTools()
+ if a.config.Parent != "" {
+ tools = slices.DeleteFunc(tools, func(tool ModelTool) bool {
+ return strings.HasPrefix(tool.Name, "whatsapp_") || tool.Name == "agent_create" || tool.Name == "route" || tool.Name == "unroute" || tool.Name == "routes"
+ })
+ }
+
+ return tools
+}
+
+// Children reads the direct children in directory order. Each child needs an
+// existing config with its directory name and this agent as parent. Children
+// cannot have children. A missing children directory means no children.
+func (a *Agent) Children() ([]*Agent, error) {
+ dir := filepath.Join(a.dir, "children")
+ entries, err := os.ReadDir(dir)
+ if errors.Is(err, os.ErrNotExist) {
+ return nil, nil
+ }
+
+ if err != nil {
+ return nil, fmt.Errorf("read children: %w", err)
+ }
+
+ if a.config.Parent != "" && len(entries) != 0 {
+ return nil, errors.New("children cannot have children")
+ }
+
+ var children []*Agent
+
+ keys := map[string]bool{a.CacheKey(): true}
+
+ for _, entry := range entries {
+ name := entry.Name()
+ if !entry.IsDir() {
+ return nil, fmt.Errorf("child %q must be a directory", name)
+ }
+
+ path := filepath.Join(dir, name)
+ _, err = os.Stat(filepath.Join(path, "config.json"))
+ if err != nil {
+ return nil, fmt.Errorf("child %q config: %w", name, err)
+ }
+
+ child, err := openAgent(path)
+ if err != nil {
+ return nil, fmt.Errorf("open child %q: %w", name, err)
+ }
+
+ if child.config.Name != name || child.config.Parent != a.config.Name {
+ return nil, fmt.Errorf("child %q needs name %q and parent %q", name, name, a.config.Name)
+ }
+
+ if child.config.Name == a.config.Name || keys[child.CacheKey()] {
+ return nil, fmt.Errorf("child %q must have its own name and ID", name)
+ }
+
+ keys[child.CacheKey()] = true
+ _, err = child.Children()
+ if err != nil {
+ return nil, fmt.Errorf("read child %q: %w", name, err)
+ }
+
+ children = append(children, child)
+ }
+
+ return children, nil
+}
+
+// CreateChild writes a new direct child with its own ID and the model, effort,
+// and working directory of the root. Child and subagent names share a
+// namespace. The config is complete before an atomic rename publishes the
+// child. Preparation stays outside children, so an interrupted write cannot
+// stop startup.
+func (a *Agent) CreateChild(name, responsibility string, subagents *Subagents) (_ *Agent, err error) {
+ if a.config.Parent != "" {
+ return nil, errors.New("only the root can create children")
+ }
+
+ if !agentChildNameValid(name) {
+ return nil, errors.New("name must have 2 to 32 ASCII letters and start with a capital letter")
+ }
+
+ if name == a.config.Name {
+ return nil, errors.New("the name is already used by the root")
+ }
+
+ responsibility = strings.TrimSpace(responsibility)
+ if responsibility == "" {
+ return nil, errors.New("responsibility must not be empty")
+ }
+
+ err = subagents.Reserve(name)
+ if err != nil {
+ return nil, fmt.Errorf("reserve child name: %w", err)
+ }
+
+ published := false
+ defer func() {
+ if !published {
+ subagents.Release(name)
+ }
+ }()
+
+ staged, err := os.MkdirTemp(a.dir, ".child-*")
+ if err != nil {
+ return nil, fmt.Errorf("prepare child directory: %w", err)
+ }
+
+ defer func() {
+ cleanupErr := os.RemoveAll(staged)
+ if cleanupErr != nil {
+ err = errors.Join(err, fmt.Errorf("remove prepared child: %w", cleanupErr))
+ }
+ }()
+
+ config := a.config
+ config.Name = name
+ config.ID = ""
+ config.Parent = a.config.Name
+ config.Responsibility = responsibility
+ child, err := writeAgent(staged, config)
+ if err != nil {
+ return nil, fmt.Errorf("write child: %w", err)
+ }
+
+ dir := filepath.Join(a.dir, "children")
+ err = os.MkdirAll(dir, 0o700)
+ if err != nil {
+ return nil, fmt.Errorf("create children directory: %w", err)
+ }
+
+ dir = filepath.Join(dir, name)
+ err = unix.Renameat2(unix.AT_FDCWD, staged, unix.AT_FDCWD, dir, unix.RENAME_NOREPLACE)
+ if err != nil {
+ return nil, fmt.Errorf("publish child directory: %w", err)
+ }
+
+ published = true
+ child.dir = dir
+
+ return child, nil
+}
+
// SubagentPrompt returns the system prompt of a subagent of the agent, with the
// user's instructions as Prompt reads them.
func (a *Agent) SubagentPrompt() (string, error) {
// made once when the file is made, and never changes. The cache key comes from
// the ID, so a rename keeps the prompt cache and two agents with one name do
// not share a key. Workdir is the directory where the commands of the agent
-// run.
+// run. Responsibility and Parent are set together for a child agent.
type AgentConfig struct {
- Name string `json:"name"`
- ID string `json:"id"`
- Model string `json:"model"`
- Effort string `json:"effort"`
- Workdir string `json:"workdir"`
+ Name string `json:"name"`
+ ID string `json:"id"`
+ Model string `json:"model"`
+ Effort string `json:"effort"`
+ Workdir string `json:"workdir"`
+ Responsibility string `json:"responsibility,omitempty"`
+ Parent string `json:"parent,omitempty"`
}
// validate makes sure that each setting has a valid value.
return errors.New("agent needs a model and an effort")
}
+ if (strings.TrimSpace(c.Responsibility) == "") != (c.Parent == "") {
+ return errors.New("a child needs both responsibility and parent")
+ }
+
+ if strings.ContainsAny(c.Parent, "\r\n") {
+ return errors.New("parent must be one line of text")
+ }
+
if !filepath.IsAbs(c.Workdir) {
return fmt.Errorf("workdir %q is not an absolute path", c.Workdir)
}
return nil
}
+// agentChildNameValid accepts one word of 2 to 32 ASCII letters with an initial
+// capital letter. Child names describe their area.
+func agentChildNameValid(name string) bool {
+ if len(name) < 2 || len(name) > 32 || name[0] < 'A' || name[0] > 'Z' {
+ return false
+ }
+
+ for i := 1; i < len(name); i++ {
+ letter := name[i]
+ if (letter < 'A' || letter > 'Z') && (letter < 'a' || letter > 'z') {
+ return false
+ }
+ }
+
+ return true
+}
+
// createAgent writes the config.json of a new agent in dir with the defaults
// and a new ID.
func createAgent(dir string) (*Agent, error) {
return nil, err
}
+ return writeAgent(dir, config)
+}
+
+// writeAgent gives config a new ID and writes it in dir.
+func writeAgent(dir string, config AgentConfig) (*Agent, error) {
id := make([]byte, agentIDBytes)
- _, err = rand.Read(id)
+ _, err := rand.Read(id)
if err != nil {
return nil, fmt.Errorf("make agent ID: %w", err)
}
projects / onechat / blobdiff