111 lines
3.5 KiB
Go
111 lines
3.5 KiB
Go
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
|
|
}
|