Files
alan 06001697c8 Add per-chat thinking levels for Codex, Claude Code and OpenCode
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.
2026-11-09 20:07:41 +00:00

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, &params)
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])
}
}