Show recorded OpenCode models in the chat list

This commit is contained in:
2026-11-05 13:42:01 +00:00
parent f5bf8ada8a
commit af178b83a1
7 changed files with 433 additions and 5 deletions
+10 -5
View File
@@ -42,11 +42,13 @@ type Chat struct {
// operation and status on the shared connection, so two calls must not
// overlap; the permission poller runs alongside the read loop's
// prompt/interrupt/reply calls.
mu sync.Mutex
usageMu sync.Mutex
usageModels map[string]usageModelCache
modeMu sync.Mutex
agents map[string]string
mu sync.Mutex
usageMu sync.Mutex
usageModels map[string]usageModelCache
modeMu sync.Mutex
agents map[string]string
modelMu sync.Mutex
sessionModels map[string]sessionModelCache
}
// NewChat brokers chat for one owned OpenCode endpoint. The connection must be
@@ -234,6 +236,9 @@ func (c *Chat) SwitchModel(ctx context.Context, id, provider, model string) erro
}
return err
}
c.modelMu.Lock()
delete(c.sessionModels, id)
c.modelMu.Unlock()
return nil
}
+110
View File
@@ -0,0 +1,110 @@
package opencode
import (
"context"
"encoding/json"
"fmt"
"strings"
"time"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
type sessionModelCache struct {
updated int64
at time.Time
provider, model string
}
// ResolveSessionModel fills a missing list model from authoritative detail or
// recent reply metadata. The caller filters operator sessions first: never
// expand every pipeline/stage session into individual history requests.
func (c *Chat) ResolveSessionModel(ctx context.Context, session protocol.ChatSession) (protocol.ChatSession, error) {
if session.Model != "" {
return session, nil
}
if !ValidSessionID(session.ID) {
return session, fmt.Errorf("invalid OpenCode session id")
}
c.modelMu.Lock()
defer c.modelMu.Unlock()
if cached, ok := c.sessionModels[session.ID]; ok && cached.updated == session.UpdatedAt && time.Since(cached.at) < 30*time.Second {
session.Model, session.ModelProvider = cached.model, cached.provider
return session, nil
}
// Detail may carry a selected model omitted by a compact list projection.
prefix := "/api/session/"
if c.conn.Backend == "v1" {
prefix = "/session/"
}
data, err := c.usageRead(ctx, prefix+session.ID, session.Directory, 1<<20)
if err != nil {
return session, err
}
record, err := chatSessionRecord(data)
if err != nil || record.ID != session.ID {
return session, fmt.Errorf("invalid OpenCode model session")
}
model, provider := record.Model.ID, record.Model.ProviderID
if model == "" {
model, provider, err = c.latestSessionModel(ctx, prefix, session)
if err != nil {
return session, err
}
}
if c.sessionModels == nil || len(c.sessionModels) >= 128 {
c.sessionModels = make(map[string]sessionModelCache)
}
c.sessionModels[session.ID] = sessionModelCache{session.UpdatedAt, time.Now(), provider, model}
session.Model, session.ModelProvider = model, provider
return session, nil
}
// Both request and response are bounded. Never download a full transcript or
// CLI export just to label a row, including when an old endpoint ignores limit.
func (c *Chat) latestSessionModel(ctx context.Context, prefix string, session protocol.ChatSession) (string, string, error) {
limit, query := 1, "?type=assistant&order=desc&limit=1"
if c.conn.Backend == "v1" {
limit, query = 8, "?limit=8"
}
data, err := c.usageRead(ctx, prefix+session.ID+"/message"+query, session.Directory, 1<<20)
if err != nil {
return "", "", err
}
var rows []struct {
Type string `json:"type"`
Model nativeChatModel `json:"model"`
Time struct {
Created int64 `json:"created"`
} `json:"time"`
Info struct {
Role string `json:"role"`
Model string `json:"modelID"`
Provider string `json:"providerID"`
Time struct {
Created int64 `json:"created"`
} `json:"time"`
} `json:"info"`
}
var envelope struct {
Data json.RawMessage `json:"data"`
}
if json.Unmarshal(data, &envelope) == nil && envelope.Data != nil {
data = envelope.Data
}
if err := json.Unmarshal(data, &rows); err != nil || len(rows) > limit {
return "", "", fmt.Errorf("invalid bounded OpenCode model history")
}
var model, provider string
var newest int64 = -1
for _, row := range rows {
role, id, source, created := row.Type, row.Model.ID, row.Model.ProviderID, row.Time.Created
if row.Info.Role != "" {
role, id, source, created = row.Info.Role, row.Info.Model, row.Info.Provider, row.Info.Time.Created
}
if role == "assistant" && strings.TrimSpace(id) != "" && created >= newest {
model, provider, newest = id, source, created
}
}
return model, provider, nil
}
@@ -0,0 +1,172 @@
package opencode
import (
"context"
"fmt"
"net/http"
"net/http/httptest"
"strings"
"sync/atomic"
"testing"
"time"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
func TestResolveSessionModel(t *testing.T) {
for _, backend := range []string{"v1", "v2"} {
t.Run(backend, func(t *testing.T) {
var reads atomic.Int32
prefix := "/api/session/ses_operator"
if backend == "v1" {
prefix = "/session/ses_operator"
}
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
reads.Add(1)
if r.URL.Query().Get("directory") != "/operator" {
t.Errorf("wrong directory: %s", r.URL)
}
switch r.URL.Path {
case prefix:
fmt.Fprint(w, `{"data":{"id":"ses_operator"}}`)
case prefix + "/message":
if backend == "v1" {
if r.URL.Query().Get("limit") != "8" {
t.Errorf("unbounded request: %s", r.URL)
}
fmt.Fprint(w, `[{"info":{"role":"assistant","modelID":"old","time":{"created":1}}},{"info":{"role":"assistant","modelID":"deepseek-v4.1-flash","providerID":"opencode-go","time":{"created":2}}},{"info":{"role":"user","modelID":"ignored","time":{"created":3}}}]`)
} else {
if r.URL.Query().Get("limit") != "1" || r.URL.Query().Get("order") != "desc" || r.URL.Query().Get("type") != "assistant" {
t.Errorf("unbounded request: %s", r.URL)
}
fmt.Fprint(w, `{"data":[{"type":"assistant","model":{"id":"deepseek-v4.1-flash","providerID":"opencode-go"},"time":{"created":2}}]}`)
}
default:
t.Errorf("unexpected read: %s", r.URL)
http.NotFound(w, r)
}
}))
defer srv.Close()
chat := NewChat(&Connection{Backend: backend, URL: srv.URL, Directory: "/wrong"})
row := protocol.ChatSession{ID: "ses_operator", Directory: "/operator", UpdatedAt: 10}
for range 2 {
got, err := chat.ResolveSessionModel(context.Background(), row)
if err != nil || got.Model != "deepseek-v4.1-flash" || got.ModelProvider != "opencode-go" {
t.Fatalf("resolved: %+v %v", got, err)
}
}
if reads.Load() != 2 {
t.Fatalf("cache missed: %d reads", reads.Load())
}
row.UpdatedAt++
if _, err := chat.ResolveSessionModel(context.Background(), row); err != nil {
t.Fatal(err)
}
if reads.Load() != 4 {
t.Fatalf("changed session was cached: %d reads", reads.Load())
}
cached := chat.sessionModels[row.ID]
cached.at = time.Now().Add(-time.Minute)
chat.sessionModels[row.ID] = cached
if _, err := chat.ResolveSessionModel(context.Background(), row); err != nil {
t.Fatal(err)
}
if reads.Load() != 6 {
t.Fatalf("expired model was cached: %d reads", reads.Load())
}
})
}
}
func TestResolveSessionModelPrefersSelectedModel(t *testing.T) {
var reads atomic.Int32
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
reads.Add(1)
if r.URL.Path != "/api/session/ses_operator" {
t.Errorf("unnecessary history read: %s", r.URL)
}
fmt.Fprint(w, `{"data":{"id":"ses_operator","model":{"id":"selected","providerID":"provider"}}}`)
}))
defer srv.Close()
chat := NewChat(&Connection{Backend: "v2", URL: srv.URL})
row := protocol.ChatSession{ID: "ses_operator"}
got, err := chat.ResolveSessionModel(context.Background(), row)
if err != nil || got.Model != "selected" || got.ModelProvider != "provider" {
t.Fatalf("selected: %+v %v", got, err)
}
row.Model = "already-listed"
got, err = chat.ResolveSessionModel(context.Background(), row)
if err != nil || got.Model != "already-listed" || reads.Load() != 1 {
t.Fatalf("listed: %+v %v reads=%d", got, err, reads.Load())
}
}
func TestResolveSessionModelRejectsUnboundedOrInvalidMetadata(t *testing.T) {
for _, body := range []string{`{"data":[{},{}]}`, strings.Repeat(" ", 1<<20) + `[]`, `garbage`} {
t.Run(fmt.Sprint(len(body)), func(t *testing.T) {
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
if strings.HasSuffix(r.URL.Path, "/message") {
fmt.Fprint(w, body)
} else {
fmt.Fprint(w, `{"data":{"id":"ses_operator"}}`)
}
}))
defer srv.Close()
chat := NewChat(&Connection{Backend: "v2", URL: srv.URL})
got, err := chat.ResolveSessionModel(context.Background(), protocol.ChatSession{ID: "ses_operator"})
if err == nil || got.Model != "" {
t.Fatalf("unverified model: %+v %v", got, err)
}
})
}
}
func TestResolveSessionModelDoesNotInventModelForEmptyChat(t *testing.T) {
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
if strings.HasSuffix(r.URL.Path, "/message") {
fmt.Fprint(w, `{"data":[]}`)
} else {
fmt.Fprint(w, `{"data":{"id":"ses_empty"}}`)
}
}))
defer srv.Close()
chat := NewChat(&Connection{Backend: "v2", URL: srv.URL})
got, err := chat.ResolveSessionModel(context.Background(), protocol.ChatSession{ID: "ses_empty"})
if err != nil || got.Model != "" || got.ModelProvider != "" {
t.Fatalf("empty session: %+v %v", got, err)
}
}
func TestSwitchModelInvalidatesListModelCache(t *testing.T) {
var switched atomic.Bool
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
if r.Method == http.MethodPost && r.URL.Path == "/api/session/ses_operator/model" {
switched.Store(true)
fmt.Fprint(w, `{}`)
return
}
model := "original"
if switched.Load() {
model = "selected"
}
fmt.Fprintf(w, `{"data":{"id":"ses_operator","model":{"id":%q,"providerID":"provider"}}}`, model)
}))
defer srv.Close()
chat := NewChat(&Connection{Backend: "v2", URL: srv.URL})
row := protocol.ChatSession{ID: "ses_operator"}
if _, err := chat.ResolveSessionModel(context.Background(), row); err != nil {
t.Fatal(err)
}
if err := chat.SwitchModel(context.Background(), row.ID, "provider", "selected"); err != nil {
t.Fatal(err)
}
got, err := chat.ResolveSessionModel(context.Background(), row)
if err != nil || got.Model != "selected" {
t.Fatalf("model switch kept stale row: %+v %v", got, err)
}
}