X-Git-Url: https://git.giacomolli.uk/onechat/blobdiff_plain/6d96a69d33eb634f61f809001aca19ae57113180..eb05edcf5d575e8a3b1040debfb57423312e8320:/turn.go?ds=inline diff --git a/turn.go b/turn.go index 08a144e..051c74d 100644 --- a/turn.go +++ b/turn.go @@ -2,22 +2,16 @@ package main import ( "context" - "encoding/json" "errors" - "fmt" "path/filepath" - "strings" "sync" "time" ) -// errTurnLogWrite marks an error of a log write, which ends the loop. -var errTurnLogWrite = errors.New("log write failed") - // newTurnLoop returns the loop of agent with its memory. Its calls go through // client, and notify gets each event. The clock gives the date of a turn. -func newTurnLoop(agent *Agent, memory *Memory, client TurnClient, clock func() time.Time, notify func(Event)) (*TurnLoop, error) { - layout, err := loadLayout(filepath.Join(agent.dir, layoutFileName)) +func newTurnLoop(agent *Agent, memory *Memory, client ChainClient, clock func() time.Time, notify func(Event)) (*TurnLoop, error) { + layout, err := loadViewLayout(filepath.Join(agent.dir, viewLayoutFileName)) if err != nil { return nil, err } @@ -32,7 +26,7 @@ func newTurnLoop(agent *Agent, memory *Memory, client TurnClient, clock func() t wake: make(chan struct{}, 1), } - l.tools = &toolbox{ + l.tools = &Toolbox{ log: l, chat: memory, workdir: agent.config.Workdir, @@ -41,11 +35,6 @@ func newTurnLoop(agent *Agent, memory *Memory, client TurnClient, clock func() t return l, nil } -// TurnClient sends model calls. -type TurnClient interface { - Create(ctx context.Context, request ModelRequest) (ModelResponse, error) -} - // Event tells the clients what the agent does as it happens. Kind is the kind // of a logged message (user, reply, tool, echo), or one of ready, busy, idle, // and error. ID is the ID of a logged message. Source names the client that @@ -60,26 +49,19 @@ type Event struct { // TurnLoop runs the turns of one agent. A user message goes to the log when it // comes, and it wakes the loop. A turn waits until every message before it is -// summarized. Then its first request holds the prompt, the tools, and the input -// of turnInput. The loop runs the tool calls of each response and sends their -// results back, until a response has no tool call: the final answer. +// summarized. Then the turn runs a Chain whose first request holds the prompt, +// the tools, and the input of turnInput. // -// The view goes out as the messages of a viewLayout, so the first request of -// a turn reads the view of the turn before from the prompt cache. -// -// Each later request of a turn begins with the whole input of the request -// before it, then its output items, then the tool results. The output items -// hold the reasoning with its encrypted content, because the calls do not -// store it. So each request begins with all of the previous one and reads it -// from the prompt cache. User messages that come during a turn join the next -// request after the tool results. The replies, the tool calls, and the results -// go to the log as they happen. The thoughts never do. +// The view goes out as the messages of a ViewLayout, so the first request of a +// turn reads the view of the turn before from the prompt cache. User messages +// that come during a turn join the next request of its chain after the tool +// results. type TurnLoop struct { agent *Agent memory *Memory - client TurnClient - tools *toolbox - layout *viewLayout + client ChainClient + tools *Toolbox + layout *ViewLayout clock func() time.Time notify func(Event) wake chan struct{} @@ -212,7 +194,7 @@ func (l *TurnLoop) turn(ctx context.Context) error { }) err := l.chain(ctx) - if err != nil && !errors.Is(err, errTurnLogWrite) { + if err != nil && !errors.Is(err, errChainLogWrite) { l.notify(Event{ Kind: "error", Text: turnError(ctx, err), @@ -255,29 +237,21 @@ func (l *TurnLoop) chain(ctx context.Context) error { return err } - input := turnInput(view, l.state(), messages) - for turn := "first"; ; turn = "next" { - response, err := l.client.Create(ctx, ModelRequest{ + chain := &Chain{ + client: l.client, + tools: l.tools, + request: ModelRequest{ Model: l.agent.config.Model, Effort: l.agent.config.Effort, Instructions: instructions, - Tools: agentTools(), - Input: input, - Turn: turn, - }) - if err != nil { - return err - } + Tools: promptTools(), + }, + take: l.take, + } - input, err = l.handle(ctx, input, response) - if err != nil { - return err - } + _, err = chain.Run(ctx, turnInput(view, l.state(), messages)) - if len(input) == 0 { - return nil - } - } + return err } // take returns the user messages that wait for a request, and removes them. @@ -297,83 +271,6 @@ func (l *TurnLoop) state() string { return "\n\nNow: " + l.clock().Format("Monday 2006-01-02 15:04 -07:00") } -// handle logs the replies of response and runs its tool calls. It returns the -// input of the next request: input, the output items, the tool results, and -// the user messages that came in the meantime. After the final answer it -// returns no input. -func (l *TurnLoop) handle(ctx context.Context, input []any, response ModelResponse) ([]any, error) { - var outputs []any - for _, raw := range response.Output { - item, err := turnInputItem(raw) - if err != nil { - return nil, err - } - - input = append(input, item) - - var call TurnFunctionCall - err = json.Unmarshal(raw, &call) - if err != nil { - return nil, fmt.Errorf("decode output item: %w", err) - } - - switch call.Type { - case "message": - text, err := modelOutputText([]json.RawMessage{raw}) - if err != nil { - return nil, err - } - - text = strings.TrimSpace(text) - if text == "" { - continue - } - - _, err = l.Append("reply", text) - if err != nil { - return nil, fmt.Errorf("%w: %w", errTurnLogWrite, err) - } - case "function_call": - output, err := l.tools.Call(ctx, call.Name, call.Arguments) - if err != nil { - return nil, fmt.Errorf("%w: %w", errTurnLogWrite, err) - } - - outputs = append(outputs, TurnFunctionCallOutput{ - Type: "function_call_output", - CallID: call.CallID, - Output: output, - }) - } - } - - if len(outputs) == 0 { - return nil, nil - } - - input = append(input, outputs...) - for _, message := range l.take() { - input = append(input, modelUserMessage(message.Text)) - } - - return input, nil -} - -// TurnFunctionCall holds the fields of a function call output item. -type TurnFunctionCall struct { - Type string `json:"type"` - Name string `json:"name"` - Arguments string `json:"arguments"` - CallID string `json:"call_id"` -} - -// TurnFunctionCallOutput is the input item with the result of a function call. -type TurnFunctionCallOutput struct { - Type string `json:"type"` - CallID string `json:"call_id"` - Output string `json:"output"` -} - // turnError returns the text of the error that ended a turn. func turnError(ctx context.Context, err error) string { if ctx.Err() != nil { @@ -400,18 +297,3 @@ func turnInput(view []string, state string, messages []Message) []any { return input } - -// turnInputItem returns an output item as an input item for the next request. -// The calls do not store their items, so the item goes back whole, without its -// id. -func turnInputItem(raw json.RawMessage) (map[string]any, error) { - var item map[string]any - err := json.Unmarshal(raw, &item) - if err != nil { - return nil, fmt.Errorf("decode output item: %w", err) - } - - delete(item, "id") - - return item, nil -}