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.
90 lines
3.3 KiB
Go
90 lines
3.3 KiB
Go
package codex
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"sync"
|
|
"testing"
|
|
|
|
"git.a-wan.net/alan/pipelines/internal/protocol"
|
|
)
|
|
|
|
const effortCatalog = `{"data":[
|
|
{"id":"a","model":"thinker","displayName":"Thinker","hidden":false,"supportedReasoningEfforts":[{"reasoningEffort":"low","description":"Quick"},{"reasoningEffort":"high","description":"Deep"},{"reasoningEffort":"xhigh","description":"Deeper"}],"defaultReasoningEffort":"high"},
|
|
{"id":"b","model":"plain","displayName":"Plain","hidden":false,"supportedReasoningEfforts":[],"defaultReasoningEffort":"medium"}
|
|
],"nextCursor":null}`
|
|
|
|
func TestCodexEffortsComeFromModelListAndReachTurnStart(t *testing.T) {
|
|
var mu sync.Mutex
|
|
lists, turns := 0, []map[string]any{}
|
|
chat := modelTestChat(t, func(method string, raw json.RawMessage) any {
|
|
mu.Lock()
|
|
defer mu.Unlock()
|
|
switch method {
|
|
case "thread/read":
|
|
return json.RawMessage(`{"thread":{"id":"` + fixtureThread + `","model":"thinker","modelProvider":"openai","reasoningEffort":"low","turns":[]}}`)
|
|
case "model/list":
|
|
lists++
|
|
return json.RawMessage(effortCatalog)
|
|
case "turn/start":
|
|
var params map[string]any
|
|
_ = json.Unmarshal(raw, ¶ms)
|
|
turns = append(turns, params)
|
|
return json.RawMessage(`{"turn":{"id":"turn-1","status":"inProgress","items":[]}}`)
|
|
}
|
|
t.Errorf("unexpected method %s", method)
|
|
return map[string]any{}
|
|
})
|
|
ctx := context.Background()
|
|
session, _, err := chat.Session(ctx, fixtureThread)
|
|
if err != nil || session.Effort != "low" {
|
|
t.Fatalf("thread's own level = %q, %v", session.Effort, err)
|
|
}
|
|
efforts, fallback, err := chat.Efforts(ctx, session)
|
|
if err != nil || fallback != "high" || len(efforts) != 3 || efforts[0] != (protocol.ChatEffort{ID: "low", Name: "Low", Description: "Quick"}) || efforts[2].Name != "Extra high" {
|
|
t.Fatalf("efforts = %+v default %q, %v", efforts, fallback, err)
|
|
}
|
|
for _, model := range []string{"plain", "unlisted", ""} {
|
|
if none, _, err := chat.Efforts(ctx, protocol.ChatSession{ID: fixtureThread, Model: model}); err != nil || len(none) != 0 {
|
|
t.Fatalf("model %q offers %+v, %v", model, none, err)
|
|
}
|
|
}
|
|
models, err := chat.Models(ctx, fixtureThread)
|
|
if err != nil || len(models) != 2 || len(models[0].Efforts) != 3 || models[0].DefaultEffort != "high" || len(models[1].Efforts) != 0 || models[1].DefaultEffort != "" {
|
|
t.Fatalf("catalog = %+v, %v", models, err)
|
|
}
|
|
if lists != 1 {
|
|
t.Fatalf("model/list read %d times; rows must share one cached catalog", lists)
|
|
}
|
|
|
|
if err := chat.Prompt(ctx, fixtureThread, "no level"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := chat.SetEffort(ctx, fixtureThread, "xhigh"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := chat.PromptWithMessageIDModel(ctx, fixtureThread, "deep", "msg", "thinker"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := chat.SetEffort(ctx, fixtureThread, ""); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := chat.Prompt(ctx, fixtureThread, "default again"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
mu.Lock()
|
|
defer mu.Unlock()
|
|
if len(turns) != 3 {
|
|
t.Fatalf("turns = %d", len(turns))
|
|
}
|
|
if _, sent := turns[0]["effort"]; sent {
|
|
t.Fatalf("turn without a level sent one: %v", turns[0])
|
|
}
|
|
if turns[1]["effort"] != "xhigh" || turns[1]["model"] != "thinker" {
|
|
t.Fatalf("turn/start params = %v", turns[1])
|
|
}
|
|
if _, sent := turns[2]["effort"]; sent {
|
|
t.Fatalf("cleared level still sent: %v", turns[2])
|
|
}
|
|
}
|