Skip to content

Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.

6.9 KB
Raw Blame
package sessions

import (
	"cmp"
	"math"
	"slices"
	"sort"
	"time"
)

// ExternalModel and ExternalSession are read-only session projections from a
// request ledger such as the gateway. They intentionally carry no file or
// resume capability.
type ExternalModel struct {
	Model string
	Tokens
	Cost   float64
	Priced bool
}
type ExternalSession struct {
	Agent, ID   string
	Title       string // what it was first asked (GatewayTitle); its id when ""
	Start, Last time.Time
	Models      []ExternalModel
	Daily       []ExternalDayUsage
	Tokens
	Cost     float64
	Unpriced int
}

// MergeExternal adds external sessions to a file-backed listing. Native
// sessions win on the exact Agent+ID identity and external entries are kept
// read-only (no file of the agent's to resume or open) with a gateway transcript
// reader; magpie's own record of one is deleted by DeleteGateway.
func MergeExternal(native []Session, external []ExternalSession) []Session {
	names := desktopExternalTitles(external)
	// keyed by the pair, not "agent|id": a string made for each of ~5000
	// sessions on each of a poll's listings, and the set and the list grown
	// an append at a time, were ~200 MB in 80s of polls (#2278)
	type agentID struct{ agent, id string }
	seen := make(map[agentID]struct{}, len(native))
	for _, s := range native {
		// GatewayKeys, as pairs
		seen[agentID{s.Agent, s.ID}] = struct{}{}
		if s.Agent == "raft" {
			seen[agentID{"pi", s.ID}] = struct{}{}
		}
		for _, id := range s.Copies {
			seen[agentID{s.Agent, id}] = struct{}{}
		}
	}
	added := func(e ExternalSession) bool {
		_, dup := seen[agentID{e.Agent, e.ID}]
		return e.Agent != "" && e.ID != "" && !dup
	}
	n := len(native)
	for _, e := range external {
		if added(e) {
			n++
		}
	}
	out := make([]Session, len(native), n)
	copy(out, native)
	for _, e := range external {
		if !added(e) {
			continue
		}
		s := Session{ReadOnly: true, Gateway: true, Transcript: true, Agent: e.Agent, ID: e.ID, Title: cmp.Or(names[e.Agent+"|"+e.ID], e.Title, e.ID), Start: e.Start, Last: e.Last, Models: []Model{}, Unpriced: e.Unpriced}
		for _, m := range e.Models {
			s.Models = append(s.Models, Model{Model: m.Model, Tokens: m.Tokens, Cost: m.Cost, Priced: m.Priced})
			s.Tokens.add(m.Tokens)
		}
		s.Cost = e.Cost
		out = append(out, s)
	}
	sort.SliceStable(out, func(i, j int) bool { return out[i].Last.After(out[j].Last) })
	return out
}

// desktopExternalTitles are the names an app saved for its sessions among
// external, by Agent|ID: Claude Desktop's (DesktopTitles), PI-Desktop's
// (PIDesktopTitles, #1967). They come before the gateway's recorded first
// prompt.
func desktopExternalTitles(external []ExternalSession) map[string]string {
	var ids, pi []string
	for _, e := range external {
		if e.Agent == "claude-desktop" {
			ids = append(ids, e.ID)
		} else if isPIDesktop(e.Agent) {
			pi = append(pi, e.ID)
		}
	}
	out := map[string]string{}
	for id, name := range DesktopTitles(ids) {
		out["claude-desktop|"+id] = name
	}
	if len(pi) > 0 {
		names := PIDesktopTitles(pi)
		for _, e := range external {
			if name := names[e.ID]; name != "" && isPIDesktop(e.Agent) {
				out[e.Agent+"|"+e.ID] = name
			}
		}
	}
	return out
}

// MergeExternalStats appends external daily usage and session summaries to a
// Stats snapshot. It is deliberately data-only so callers can keep their own
// source and pricing policy.
type ExternalDayUsage struct {
	Date, Agent, Cwd, Model string
	Tokens
	Cost   float64
	Priced bool
}

// st itself is not written: its Days and Sessions may be kept for the next
// read (keptStats), so what is changed is copied first.
func MergeExternalStats(st Stats, days []ExternalDayUsage, external []ExternalSession) Stats {
	oldFirst, _ := time.ParseInLocation(time.DateOnly, st.From, time.Local)
	sessionsOwn := false
	for _, d := range days {
		if d.Date <= st.To && (st.From == "" || d.Date < st.From) {
			st.From = d.Date
		}
	}
	first, _ := time.ParseInLocation(time.DateOnly, st.From, time.Local)
	if !oldFirst.IsZero() && !first.Equal(oldFirst) {
		shift := int(math.Round(oldFirst.Sub(first).Hours() / 24))
		st.Sessions, sessionsOwn = slices.Clone(st.Sessions), true
		for i := range st.Sessions {
			s := &st.Sessions[i]
			s.Days = slices.Clone(s.Days)
			for j := range s.Days {
				s.Days[j] += shift
			}
			s.perDay = slices.Clone(s.perDay)
			for j := range s.perDay {
				s.perDay[j].day += shift
			}
		}
	}
	st.Days = slices.Clone(st.Days)
	byDate, own := map[string]int{}, map[int]bool{}
	for i := range st.Days {
		byDate[st.Days[i].Date] = i
	}
	for _, u := range days {
		if u.Date < st.From || u.Date > st.To {
			continue
		}
		i, ok := byDate[u.Date]
		if !ok {
			st.Days = append(st.Days, Day{Date: u.Date, Usage: []Usage{}, Active: []Active{}})
			i = len(st.Days) - 1
			byDate[u.Date], own[i] = i, true
		}
		d := &st.Days[i]
		if !own[i] {
			// a day of st's: its rows are copied before one is added to
			d.Usage, own[i] = slices.Clone(d.Usage), true
		}
		found := false
		for i := range d.Usage {
			if d.Usage[i].Agent == u.Agent && d.Usage[i].Cwd == u.Cwd && d.Usage[i].Model == u.Model {
				d.Usage[i].Tokens.add(u.Tokens)
				d.Usage[i].Cost += u.Cost
				d.Usage[i].Priced = d.Usage[i].Priced && u.Priced
				found = true
				break
			}
		}
		if !found {
			d.Usage = append(d.Usage, Usage{Agent: u.Agent, Cwd: u.Cwd, Model: u.Model, Tokens: u.Tokens, Cost: u.Cost, Priced: u.Priced})
		}
	}
	names := desktopExternalTitles(external)
	// grown once for every external: a Clip and then an append a session
	// copied the whole list again and again, ~110 MB a minute of polls on a
	// full history (#2278)
	n := 0
	for _, e := range external {
		if e.ID != "" && e.Agent != "" {
			n++
		}
	}
	if n > 0 {
		st.Sessions, sessionsOwn = slices.Grow(slices.Clip(st.Sessions), n), true
	}
	for _, e := range external {
		if e.ID == "" || e.Agent == "" {
			continue
		}
		s := Summary{Key: e.Agent + ":" + e.ID, Agent: e.Agent, ID: e.ID, Title: cmp.Or(names[e.Agent+"|"+e.ID], e.Title), Gateway: true, Last: e.Last, Tokens: e.Tokens, Cost: e.Cost, Priced: true, Models: []string{}, Days: []int{}}
		perDay := map[int]*summaryDay{}
		for _, u := range e.Daily {
			day, err := time.ParseInLocation(time.DateOnly, u.Date, time.Local)
			if err != nil {
				continue
			}
			d := int(math.Round(day.Sub(first).Hours() / 24))
			if first.IsZero() || u.Date < st.From || u.Date > st.To {
				continue
			}
			pd := perDay[d]
			if pd == nil {
				pd = &summaryDay{day: d}
				perDay[d] = pd
				s.Days = append(s.Days, d)
			}
			pd.output += u.Output
		}
		sort.Ints(s.Days)
		for _, d := range s.Days {
			s.perDay = append(s.perDay, *perDay[d])
		}
		for _, m := range e.Models {
			s.Models = append(s.Models, m.Model)
			s.Priced = s.Priced && m.Priced
		}
		st.Sessions = append(st.Sessions, s)
	}
	sort.Slice(st.Days, func(i, j int) bool { return st.Days[i].Date < st.Days[j].Date })
	if sessionsOwn {
		// st's own come sorted so
		sort.SliceStable(st.Sessions, func(i, j int) bool { return st.Sessions[i].Last.After(st.Sessions[j].Last) })
	}
	return st
}