06001697c8
Codex: model/list supportedReasoningEfforts per model, turn/start effort, thread reasoningEffort as the current level. Claude Code: initialize supportedEffortLevels, apply_flag_settings effortLevel at the next turn start. OpenCode v2: model variants via the session model endpoint. chat_effort sets a level; rows and chat_models carry the levels; Codex and Claude levels persist in operator_sessions.chat_effort and are re-applied before every turn.
97 lines
3.7 KiB
Go
97 lines
3.7 KiB
Go
package opencode
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"sync"
|
|
"testing"
|
|
|
|
"git.a-wan.net/alan/pipelines/internal/protocol"
|
|
)
|
|
|
|
const effortSessionList = `{"data":[{"id":"ses_1","title":"Chat","model":{"id":"thinker","providerID":"prov","variant":"high"},"location":{"directory":"/fixture"},"time":{"created":1,"updated":2}}]}`
|
|
|
|
const effortModelList = `{"data":[
|
|
{"modelID":"thinker","providerID":"prov","name":"Thinker","enabled":true,"status":"active","variants":[{"id":"low","settings":{"reasoningEffort":"low"}},{"id":"high","settings":{"reasoningEffort":"high"}},{"id":"xhigh"}]},
|
|
{"modelID":"plain","providerID":"prov","name":"Plain","enabled":true,"status":"active","variants":[]}
|
|
]}`
|
|
|
|
func TestOpenCodeEffortsAreModelVariants(t *testing.T) {
|
|
var mu sync.Mutex
|
|
modelReads := 0
|
|
var posted []map[string]string
|
|
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
mu.Lock()
|
|
defer mu.Unlock()
|
|
w.Header().Set("Content-Type", "application/json")
|
|
switch {
|
|
case r.Method == http.MethodGet && r.URL.Path == "/api/session":
|
|
_, _ = w.Write([]byte(effortSessionList))
|
|
case r.Method == http.MethodGet && r.URL.Path == "/api/model":
|
|
modelReads++
|
|
_, _ = w.Write([]byte(effortModelList))
|
|
case r.Method == http.MethodPost && r.URL.Path == "/api/session/ses_1/model":
|
|
var body struct {
|
|
Model map[string]string `json:"model"`
|
|
}
|
|
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
|
|
t.Error(err)
|
|
}
|
|
posted = append(posted, body.Model)
|
|
w.WriteHeader(http.StatusNoContent)
|
|
default:
|
|
t.Errorf("unexpected request %s %s", r.Method, r.URL.Path)
|
|
}
|
|
}))
|
|
defer srv.Close()
|
|
chat := NewChat(&Connection{Backend: "v2", URL: srv.URL})
|
|
ctx := context.Background()
|
|
session, found, err := chat.Session(ctx, "ses_1")
|
|
if err != nil || !found || session.Effort != "high" || session.Model != "thinker" {
|
|
t.Fatalf("session = %+v, %v", session, err)
|
|
}
|
|
efforts, fallback, err := chat.Efforts(ctx, session)
|
|
if err != nil || fallback != "" || len(efforts) != 3 || efforts[2] != (protocol.ChatEffort{ID: "xhigh", Name: "Extra high"}) {
|
|
t.Fatalf("efforts = %+v %q, %v", efforts, fallback, err)
|
|
}
|
|
for _, row := range []protocol.ChatSession{{ID: "ses_1", Model: "plain", ModelProvider: "prov"}, {ID: "ses_1", Model: "thinker", ModelProvider: "other"}, {ID: "ses_1"}} {
|
|
if none, _, err := chat.Efforts(ctx, row); err != nil || len(none) != 0 {
|
|
t.Fatalf("row %+v offers %+v, %v", row, none, err)
|
|
}
|
|
}
|
|
models, err := chat.Models(ctx, "ses_1")
|
|
if err != nil || len(models) != 2 || len(models[1].Efforts) != 3 || len(models[0].Efforts) != 0 {
|
|
t.Fatalf("models = %+v, %v", models, err)
|
|
}
|
|
if err := chat.SetEffort(ctx, "ses_1", "low"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := chat.SetEffort(ctx, "ses_1", ""); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
mu.Lock()
|
|
defer mu.Unlock()
|
|
// Rows share one cached catalog read; Models itself still reads live.
|
|
if modelReads != 2 {
|
|
t.Fatalf("model reads = %d", modelReads)
|
|
}
|
|
if len(posted) != 2 || posted[0]["variant"] != "low" || posted[0]["id"] != "thinker" || posted[0]["providerID"] != "prov" {
|
|
t.Fatalf("posted = %+v", posted)
|
|
}
|
|
if _, has := posted[1]["variant"]; has || posted[1]["id"] != "thinker" {
|
|
t.Fatalf("cleared level posted %+v", posted[1])
|
|
}
|
|
}
|
|
|
|
func TestOpenCodeV1HasNoEfforts(t *testing.T) {
|
|
chat := NewChat(&Connection{Backend: "v1"})
|
|
if efforts, _, err := chat.Efforts(context.Background(), protocol.ChatSession{ID: "ses_1", Model: "m", ModelProvider: "p"}); err != nil || len(efforts) != 0 {
|
|
t.Fatalf("v1 efforts = %+v, %v", efforts, err)
|
|
}
|
|
if err := chat.SetEffort(context.Background(), "ses_1", "high"); err == nil {
|
|
t.Fatal("v1 accepted a thinking level")
|
|
}
|
|
}
|