Let the agent keep user instructions

[onechat] / memory.go

diff --git a/memory.go b/memory.go
index 9846c9817458f77cc0c92febb0a037aa4ff86dfa..5ea12b75a330292d37e26a361026f6e03510aa2e 100644 (file)
--- a/memory.go
+++ b/memory.go
@@ -5,6 +5,7 @@ import (
        "encoding/json"
        "errors"
        "fmt"
        "encoding/json"
        "errors"
        "fmt"

+       "log"

        "os"
        "path/filepath"
        "strings"
        "os"
        "path/filepath"
        "strings"


@@ -12,13 +13,19 @@ import (
        "time"
 )
 
        "time"
 )
 

-// errMemoryNoView tells that a chat has messages but no saved view.
-var errMemoryNoView = errors.New("the chat has messages but no saved view")
+var (
+       // errMemoryNoView tells that a chat has messages but no saved view.
+       errMemoryNoView = errors.New("the chat has messages but no saved view")
+
+       // errMemoryUnsettled tells that a line of the view stays pending,
+       // because its build failed.
+       errMemoryUnsettled = errors.New("a summary of the view failed, and it is tried again at the next message")
+)

 
 // openMemory opens the chat in root and starts the builds that are ready. The
 
 // openMemory opens the chat in root and starts the builds that are ready. The

-// clock gives the dates of new messages and the days of new nodes. The builds
-// stop when ctx ends or at Close.
-func openMemory(ctx context.Context, root string, clock func() time.Time, summarizer Summarizer) (*Memory, error) {
+// clock gives the dates of new messages and the days of new nodes. logger gets
+// one line for each failed build. The builds stop when ctx ends or at Close.
+func openMemory(ctx context.Context, root string, clock func() time.Time, summarizer Summarizer, logger *log.Logger) (*Memory, error) {

        log, err := openLog(ctx, root, clock)
        if err != nil {
                return nil, err
        log, err := openLog(ctx, root, clock)
        if err != nil {
                return nil, err


@@ -29,6 +36,7 @@ func openMemory(ctx context.Context, root string, clock func() time.Time, summar
                log:        log,
                queue:      newBuildQueue(),
                summarizer: summarizer,
                log:        log,
                queue:      newBuildQueue(),
                summarizer: summarizer,

+               logger:     logger,

                changed:    make(chan struct{}),
        }
 
                changed:    make(chan struct{}),
        }
 


@@ -100,6 +108,7 @@ type Memory struct {
        cview      *View
        queue      *BuildQueue
        summarizer Summarizer
        cview      *View
        queue      *BuildQueue
        summarizer Summarizer

+       logger     *log.Logger

        ctx        context.Context
        cancel     context.CancelFunc
        workers    sync.WaitGroup
        ctx        context.Context
        cancel     context.CancelFunc
        workers    sync.WaitGroup


@@ -195,6 +204,34 @@ func (m *Memory) Wait(ctx context.Context) error {
        }
 }
 
        }
 }
 

+// Settle returns when the chat view has no pending line, so that every message
+// so far is summarized. A pending line with no build that runs belongs to a
+// failed build, which waits for the next message, so Settle returns
+// errMemoryUnsettled in place of a wait that never ends.
+func (m *Memory) Settle(ctx context.Context) error {
+       for {
+               m.mutex.Lock()
+               pending := m.chat.Pending()
+               running := m.queue.Running()
+               changed := m.changed
+               m.mutex.Unlock()
+
+               if !pending {
+                       return nil
+               }
+
+               if running == 0 {
+                       return errMemoryUnsettled
+               }
+
+               select {
+               case <-changed:
+               case <-ctx.Done():
+                       return ctx.Err()
+               }
+       }
+}
+

 // Flush returns when every write before the call is durable.
 func (m *Memory) Flush(ctx context.Context) error {
        return m.syncer.Flush(ctx)
 // Flush returns when every write before the call is durable.
 func (m *Memory) Flush(ctx context.Context) error {
        return m.syncer.Flush(ctx)


@@ -360,7 +397,9 @@ func (m *Memory) dispatch() {
 
                task, err := m.task(key)
                if err != nil {
 
                task, err := m.task(key)
                if err != nil {

+                       m.failed(key, fmt.Errorf("read its input: %w", err))

                        m.queue.Fail(key)
                        m.queue.Fail(key)

+

                        continue
                }
 
                        continue
                }
 


@@ -527,6 +566,10 @@ func (m *Memory) run(key NodeKey, task Task) {
                m.syncer.Written()
        }
 
                m.syncer.Written()
        }
 

+       if err != nil && m.ctx.Err() == nil {
+               m.failed(key, err)
+       }
+

        if err != nil {
                m.queue.Fail(key)
        } else {
        if err != nil {
                m.queue.Fail(key)
        } else {


@@ -538,6 +581,11 @@ func (m *Memory) run(key NodeKey, task Task) {
        m.dispatch()
 }
 
        m.dispatch()
 }
 

+// failed logs the failed build of the node key with its cause err.
+func (m *Memory) failed(key NodeKey, err error) {
+       m.logger.Printf("summary failed, retry at next message: node (%d, %d): %v", key.level, key.index, err)
+}
+

 // ready tells if both children of the node key are built and the node is not.
 func (m *Memory) ready(key NodeKey) (bool, error) {
        for _, index := range []int{2 * key.index, 2*key.index + 1} {
 // ready tells if both children of the node key are built and the node is not.
 func (m *Memory) ready(key NodeKey) (bool, error) {
        for _, index := range []int{2 * key.index, 2*key.index + 1} {