vikingowl
b0b393517e
internal/context/: - Tracker: monitors token usage with OK/Warning/Critical states (thresholds from CC: 20K warning buffer, 13K autocompact buffer) - TruncateStrategy: drops oldest messages, preserves system prompt + recent N turns, adds compaction boundary marker - Window: manages message history with auto-compaction trigger, circuit breaker after 3 consecutive failures Engine integration: - Context window tracks usage per turn - Auto-compacts when critical threshold reached - History syncs with context window after compaction TUI status bar: - Token count with percentage (tokens: 1234 (5%)) - Color-coded: green=ok, yellow=warning, red=critical Session Status extended: TokensMax, TokenPercent, TokenState. 7 context tests.
137 lines
2.4 KiB
Go
137 lines
2.4 KiB
Go
package session
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"sync"
|
|
|
|
"somegit.dev/Owlibou/gnoma/internal/engine"
|
|
"somegit.dev/Owlibou/gnoma/internal/stream"
|
|
)
|
|
|
|
// Local implements Session using goroutines and channels within the same process.
|
|
type Local struct {
|
|
mu sync.Mutex
|
|
|
|
eng *engine.Engine
|
|
state SessionState
|
|
events chan stream.Event
|
|
|
|
// Current turn context
|
|
cancel context.CancelFunc
|
|
turn *engine.Turn
|
|
err error
|
|
|
|
// Stats
|
|
provider string
|
|
model string
|
|
turnCount int
|
|
}
|
|
|
|
// NewLocal creates a channel-based in-process session.
|
|
func NewLocal(eng *engine.Engine, providerName, model string) *Local {
|
|
return &Local{
|
|
eng: eng,
|
|
state: StateIdle,
|
|
provider: providerName,
|
|
model: model,
|
|
}
|
|
}
|
|
|
|
func (s *Local) Send(input string) error {
|
|
s.mu.Lock()
|
|
if s.state != StateIdle {
|
|
s.mu.Unlock()
|
|
return fmt.Errorf("session not idle (state: %s)", s.state)
|
|
}
|
|
|
|
s.state = StateStreaming
|
|
s.events = make(chan stream.Event, 64)
|
|
s.turn = nil
|
|
s.err = nil
|
|
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
s.cancel = cancel
|
|
s.turnCount++
|
|
s.mu.Unlock()
|
|
|
|
// Run engine in background goroutine
|
|
go func() {
|
|
cb := func(evt stream.Event) {
|
|
select {
|
|
case s.events <- evt:
|
|
case <-ctx.Done():
|
|
}
|
|
}
|
|
|
|
turn, err := s.eng.Submit(ctx, input, cb)
|
|
|
|
s.mu.Lock()
|
|
s.turn = turn
|
|
s.err = err
|
|
if err != nil && ctx.Err() != nil {
|
|
s.state = StateCancelled
|
|
} else if err != nil {
|
|
s.state = StateError
|
|
} else {
|
|
s.state = StateIdle
|
|
}
|
|
s.mu.Unlock()
|
|
|
|
close(s.events)
|
|
}()
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *Local) Events() <-chan stream.Event {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
return s.events
|
|
}
|
|
|
|
func (s *Local) TurnResult() (*engine.Turn, error) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
return s.turn, s.err
|
|
}
|
|
|
|
func (s *Local) Cancel() {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
if s.cancel != nil {
|
|
s.cancel()
|
|
}
|
|
}
|
|
|
|
func (s *Local) Close() error {
|
|
s.Cancel()
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
s.state = StateClosed
|
|
return nil
|
|
}
|
|
|
|
func (s *Local) Status() Status {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
st := Status{
|
|
State: s.state,
|
|
Provider: s.provider,
|
|
Model: s.model,
|
|
TokensUsed: s.eng.Usage().TotalTokens(),
|
|
TurnCount: s.turnCount,
|
|
TokenState: "ok",
|
|
}
|
|
|
|
if w := s.eng.ContextWindow(); w != nil {
|
|
tr := w.Tracker()
|
|
st.TokensMax = tr.MaxTokens()
|
|
st.TokenPercent = tr.PercentUsed()
|
|
st.TokenState = tr.State().String()
|
|
}
|
|
|
|
return st
|
|
}
|