git.giacomolli.uk - onechat/blob - agent.go

   1 package main
   2
   3 import (
   4         "bytes"
   5         "crypto/rand"
   6         "encoding/hex"
   7         "encoding/json"
   8         "errors"
   9         "fmt"
  10         "io"
  11         "os"
  12         "path/filepath"
  13         "strings"
  14 )
  15
  16 const (
  17         // agentInstructionsFileName is the file of the user's instructions in
  18         // the directory of an agent.
  19         agentInstructionsFileName = "instructions.md"
  20
  21         // agentIDBytes is the number of random bytes of an agent ID.
  22         agentIDBytes = 16
  23 )
  24
  25 // openAgent reads the config.json of the agent in dir. When the file does not
  26 // exist, it makes the directory and writes the file with the defaults and a new
  27 // ID. A missing field of an existing file takes the default, but the ID must be
  28 // there. An unknown field is an error, so a typo does not become a silent
  29 // default.
  30 func openAgent(dir string) (*Agent, error) {
  31         err := os.MkdirAll(dir, 0o700)
  32         if err != nil {
  33                 return nil, fmt.Errorf("create agent directory: %w", err)
  34         }
  35
  36         path := filepath.Join(dir, "config.json")
  37         data, err := os.ReadFile(path)
  38         if errors.Is(err, os.ErrNotExist) {
  39                 return createAgent(dir)
  40         }
  41
  42         if err != nil {
  43                 return nil, fmt.Errorf("read agent config: %w", err)
  44         }
  45
  46         config, err := defaultAgentConfig()
  47         if err != nil {
  48                 return nil, err
  49         }
  50
  51         decoder := json.NewDecoder(bytes.NewReader(data))
  52         decoder.DisallowUnknownFields()
  53
  54         err = decoder.Decode(&config)
  55         if err == nil && !errors.Is(decoder.Decode(&struct{}{}), io.EOF) {
  56                 err = errors.New("data after the JSON object")
  57         }
  58
  59         if err == nil {
  60                 err = config.validate()
  61         }
  62
  63         if err != nil {
  64                 return nil, fmt.Errorf("%s: %w", path, err)
  65         }
  66
  67         return &Agent{
  68                 dir:    dir,
  69                 config: config,
  70         }, nil
  71 }
  72
  73 // Agent is one agent and its directory. The directory holds config.json, the
  74 // user's instructions in instructions.md, the chat, and the usage file.
  75 type Agent struct {
  76         dir    string
  77         config AgentConfig
  78 }
  79
  80 // CacheKey returns the prompt cache key of every model call of the agent.
  81 func (a *Agent) CacheKey() string {
  82         return "onechat-" + a.config.ID
  83 }
  84
  85 // Prompt returns the system prompt of the agent with the user's instructions
  86 // from instructions.md. It reads the file on each call, so a change applies at
  87 // the next call. A missing file means no instructions.
  88 func (a *Agent) Prompt() (string, error) {
  89         instructions, err := a.instructions()
  90         if err != nil {
  91                 return "", fmt.Errorf("read prompt instructions: %w", err)
  92         }
  93
  94         path, err := filepath.Abs(filepath.Join(a.dir, agentInstructionsFileName))
  95         if err != nil {
  96                 return "", fmt.Errorf("find instructions path: %w", err)
  97         }
  98
  99         return prompt(a.config.Name, path, instructions), nil
 100 }
 101
 102 // SubagentPrompt returns the system prompt of a subagent of the agent, with the
 103 // user's instructions as Prompt reads them.
 104 func (a *Agent) SubagentPrompt() (string, error) {
 105         instructions, err := a.instructions()
 106         if err != nil {
 107                 return "", err
 108         }
 109
 110         return promptSubagent(a.config.Name, instructions), nil
 111 }
 112
 113 // instructions reads the user's instructions from instructions.md. A missing
 114 // file means no instructions.
 115 func (a *Agent) instructions() (string, error) {
 116         data, err := os.ReadFile(filepath.Join(a.dir, agentInstructionsFileName))
 117         if err != nil && !errors.Is(err, os.ErrNotExist) {
 118                 return "", fmt.Errorf("read instructions: %w", err)
 119         }
 120
 121         return string(data), nil
 122 }
 123
 124 // AgentConfig holds the settings of the config.json of an agent. ID is random,
 125 // made once when the file is made, and never changes. The cache key comes from
 126 // the ID, so a rename keeps the prompt cache and two agents with one name do
 127 // not share a key. Workdir is the directory where the commands of the agent
 128 // run.
 129 type AgentConfig struct {
 130         Name    string `json:"name"`
 131         ID      string `json:"id"`
 132         Model   string `json:"model"`
 133         Effort  string `json:"effort"`
 134         Workdir string `json:"workdir"`
 135 }
 136
 137 // validate makes sure that each setting has a valid value.
 138 func (c AgentConfig) validate() error {
 139         if c.Name == "" || strings.ContainsAny(c.Name, "\r\n") {
 140                 return errors.New("name must be one line of text")
 141         }
 142
 143         id, err := hex.DecodeString(c.ID)
 144         if err != nil || len(id) != agentIDBytes {
 145                 return fmt.Errorf("id must be %d hexadecimal digits", 2*agentIDBytes)
 146         }
 147
 148         if c.Model == "" || c.Effort == "" {
 149                 return errors.New("agent needs a model and an effort")
 150         }
 151
 152         if !filepath.IsAbs(c.Workdir) {
 153                 return fmt.Errorf("workdir %q is not an absolute path", c.Workdir)
 154         }
 155
 156         return nil
 157 }
 158
 159 // createAgent writes the config.json of a new agent in dir with the defaults
 160 // and a new ID.
 161 func createAgent(dir string) (*Agent, error) {
 162         config, err := defaultAgentConfig()
 163         if err != nil {
 164                 return nil, err
 165         }
 166
 167         id := make([]byte, agentIDBytes)
 168         _, err = rand.Read(id)
 169         if err != nil {
 170                 return nil, fmt.Errorf("make agent ID: %w", err)
 171         }
 172
 173         config.ID = hex.EncodeToString(id)
 174         data, err := json.MarshalIndent(config, "", "  ")
 175         if err != nil {
 176                 return nil, fmt.Errorf("encode agent config: %w", err)
 177         }
 178
 179         err = writeFileAtomic(filepath.Join(dir, "config.json"), append(data, '\n'))
 180         if err != nil {
 181                 return nil, fmt.Errorf("write agent config: %w", err)
 182         }
 183
 184         return &Agent{
 185                 dir:    dir,
 186                 config: config,
 187         }, nil
 188 }
 189
 190 // defaultAgentConfig returns the settings of a new agent, without an ID. The
 191 // commands run in the home directory of the user.
 192 func defaultAgentConfig() (AgentConfig, error) {
 193         home, err := os.UserHomeDir()
 194         if err != nil {
 195                 return AgentConfig{}, fmt.Errorf("find working directory: %w", err)
 196         }
 197
 198         return AgentConfig{
 199                 Name:    "OneChat",
 200                 Model:   "gpt-6.1-sol",
 201                 Effort:  "medium",
 202                 Workdir: home,
 203         }, nil
 204 }