mrcharles
c9e86eefa8
OpenWebUI becomes the interactive surface by talking to MOPAC like any
OpenAI provider: GET /v1/models lists the servable catalog (one model per
[models.classes] class, named mopac-<class>, routed through the same
tier table `once` uses; unknown model = 400 naming the valid ones) and
POST /v1/chat/completions runs ONE bounded stateless conductor turn over
the sent conversation history — no session storage, tools hard-off,
non-streaming (stream:true gets an explicit 400; OWUI tolerates
non-streaming providers). Bearer vkey auth compares SHA-256 digests in
constant time; missing/wrong keys get one byte-identical 401 body, and
the vkey never reaches logs or responses. temperature/max_tokens are
forwarded upstream; usage is summed across rounds and returned in the
reply. Upstream failures surface as a terse 502. Own port (:8090
default) so it coexists with the events receiver; dev.sh gets a serve
runner publishing 8090 on the LAN. Tests drive a scripted fake OpenAI
upstream through the real HTTP server: auth matrix, catalog + subset,
history assembly (client system message preserved, harness identity
prepended only when missing), multi-round usage accounting, refused
tool-call feedback, knob forwarding, 400/502 paths.
💘 Generated with Crush
Assisted-by: Crush:glm-5.2
475 lines
16 KiB
Go
475 lines
16 KiB
Go
package serve
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"sync"
|
|
"testing"
|
|
|
|
"ukrrs.com/mopac/harness/internal/config"
|
|
"ukrrs.com/mopac/harness/internal/llm"
|
|
"ukrrs.com/mopac/harness/internal/loop"
|
|
)
|
|
|
|
const testVKey = "owui-test-vkey"
|
|
|
|
// fakeUpstream is a scripted OpenAI-compatible upstream that records every
|
|
// request (the "fake OpenAI client against the real server" pattern).
|
|
type fakeUpstream struct {
|
|
mu sync.Mutex
|
|
requests []llm.ChatRequest
|
|
srv *httptest.Server
|
|
}
|
|
|
|
func (f *fakeUpstream) handler(t *testing.T, bodies ...string) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
var req llm.ChatRequest
|
|
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
|
t.Errorf("decode upstream request: %v", err)
|
|
}
|
|
f.mu.Lock()
|
|
f.requests = append(f.requests, req)
|
|
n := len(f.requests)
|
|
f.mu.Unlock()
|
|
body := bodies[len(bodies)-1]
|
|
if n <= len(bodies) {
|
|
body = bodies[n-1]
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
fmt.Fprint(w, body)
|
|
})
|
|
}
|
|
|
|
func textBody(content string, prompt, completion int) string {
|
|
return fmt.Sprintf(`{"choices":[{"message":{"role":"assistant","content":%q},"finish_reason":"stop"}],"usage":{"prompt_tokens":%d,"completion_tokens":%d,"total_tokens":%d}}`,
|
|
content, prompt, completion, prompt+completion)
|
|
}
|
|
|
|
func (f *fakeUpstream) request(i int) llm.ChatRequest {
|
|
f.mu.Lock()
|
|
defer f.mu.Unlock()
|
|
return f.requests[i]
|
|
}
|
|
|
|
func (f *fakeUpstream) count() int {
|
|
f.mu.Lock()
|
|
defer f.mu.Unlock()
|
|
return len(f.requests)
|
|
}
|
|
|
|
// newStack wires fake upstream + conductor + serve server, the same way
|
|
// `harness serve` does in main.
|
|
func newStack(t *testing.T, bodies ...string) (*Server, *fakeUpstream, *httptest.Server) {
|
|
t.Helper()
|
|
up := &fakeUpstream{}
|
|
up.srv = httptest.NewServer(up.handler(t, bodies...))
|
|
t.Cleanup(up.srv.Close)
|
|
|
|
dir := t.TempDir()
|
|
cfg := config.Default()
|
|
cfg.Vertical = "teststack"
|
|
cfg.WorkRoot = dir
|
|
cfg.ReportDir = filepath.Join(dir, "reports")
|
|
cfg.LiteLLM.BaseURL = up.srv.URL
|
|
cfg.LiteLLM.KeyRef = "literal:upstream-key"
|
|
cfg.LiteLLM.MaxRetries = 0
|
|
cfg.Models.Tiers = map[string]string{
|
|
"mopac-study": "glm-4.7-flash",
|
|
"mopac-code": "glm-5.2",
|
|
"mopac-review": "glm-5-turbo",
|
|
"mopac-primary": "glm-5.3",
|
|
}
|
|
cfg.Models.Classes = map[string]string{
|
|
"study": "mopac-study",
|
|
"read": "mopac-study",
|
|
"code": "mopac-code",
|
|
"primary": "mopac-primary",
|
|
}
|
|
cfg.Serve.VKeyRef = "literal:" + testVKey
|
|
|
|
cond, err := loop.New(cfg, io.Discard)
|
|
if err != nil {
|
|
t.Fatalf("loop.New: %v", err)
|
|
}
|
|
srv, err := NewServer(cfg.Serve, cond.Router(), cond, io.Discard)
|
|
if err != nil {
|
|
t.Fatalf("NewServer: %v", err)
|
|
}
|
|
ts := httptest.NewServer(srv.Handler())
|
|
t.Cleanup(ts.Close)
|
|
return srv, up, ts
|
|
}
|
|
|
|
func do(t *testing.T, method, url, auth string, body string) (int, string) {
|
|
t.Helper()
|
|
var rd io.Reader
|
|
if body != "" {
|
|
rd = strings.NewReader(body)
|
|
}
|
|
req, err := http.NewRequest(method, url, rd)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if auth != "" {
|
|
req.Header.Set("Authorization", auth)
|
|
}
|
|
req.Header.Set("Content-Type", "application/json")
|
|
resp, err := http.DefaultClient.Do(req)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer resp.Body.Close()
|
|
b, _ := io.ReadAll(resp.Body)
|
|
return resp.StatusCode, string(b)
|
|
}
|
|
|
|
func bearer(key string) string { return "Bearer " + key }
|
|
|
|
func TestAuth(t *testing.T) {
|
|
_, _, ts := newStack(t, textBody("hi", 5, 5))
|
|
chatURL := ts.URL + "/v1/chat/completions"
|
|
body := `{"model":"mopac-code","messages":[{"role":"user","content":"hi"}]}`
|
|
modelsURL := ts.URL + "/v1/models"
|
|
|
|
cases := []struct {
|
|
name string
|
|
url string
|
|
method string
|
|
auth string
|
|
body string
|
|
wantCode int
|
|
}{
|
|
{"chat no auth header", chatURL, http.MethodPost, "", body, 401},
|
|
{"chat malformed scheme", chatURL, http.MethodPost, "Basic " + testVKey, body, 401},
|
|
{"chat wrong key", chatURL, http.MethodPost, bearer("wrong-key"), body, 401},
|
|
{"chat right key", chatURL, http.MethodPost, bearer(testVKey), body, 200},
|
|
{"models no auth", modelsURL, http.MethodGet, "", "", 401},
|
|
{"models wrong key", modelsURL, http.MethodGet, bearer("nope"), "", 401},
|
|
{"models right key", modelsURL, http.MethodGet, bearer(testVKey), "", 200},
|
|
}
|
|
for _, tc := range cases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
code, respBody := do(t, tc.method, tc.url, tc.auth, tc.body)
|
|
if code != tc.wantCode {
|
|
t.Errorf("code = %d, want %d (body %s)", code, tc.wantCode, respBody)
|
|
}
|
|
if code == 401 {
|
|
if !strings.Contains(respBody, "invalid api key") {
|
|
t.Errorf("401 body = %q, want the generic message", respBody)
|
|
}
|
|
if strings.Contains(respBody, testVKey) {
|
|
t.Errorf("401 body leaks the vkey: %s", respBody)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestModelsCatalog(t *testing.T) {
|
|
srv, _, ts := newStack(t)
|
|
code, body := do(t, http.MethodGet, ts.URL+"/v1/models", bearer(testVKey), "")
|
|
if code != 200 {
|
|
t.Fatalf("code = %d body %s", code, body)
|
|
}
|
|
var list modelList
|
|
if err := json.Unmarshal([]byte(body), &list); err != nil {
|
|
t.Fatalf("decode: %v", err)
|
|
}
|
|
var ids []string
|
|
for _, m := range list.Data {
|
|
ids = append(ids, m.ID)
|
|
if m.Object != "model" || m.OwnedBy != "mopac" || m.Created == 0 {
|
|
t.Errorf("entry shape wrong: %+v", m)
|
|
}
|
|
}
|
|
want := "mopac-code mopac-primary mopac-read mopac-study"
|
|
if strings.Join(ids, " ") != want {
|
|
t.Errorf("catalog = %v, want %v", ids, want)
|
|
}
|
|
if srv.ModelNames()[0] != "mopac-code" {
|
|
t.Errorf("ModelNames() = %v", srv.ModelNames())
|
|
}
|
|
}
|
|
|
|
func TestModelsCatalogEnabledSubset(t *testing.T) {
|
|
// Rebuild the stack with enabled_models narrowed to two classes.
|
|
up := &fakeUpstream{}
|
|
up.srv = httptest.NewServer(up.handler(t, textBody("x", 1, 1)))
|
|
defer up.srv.Close()
|
|
cfg := config.Default()
|
|
cfg.Vertical = "teststack"
|
|
cfg.LiteLLM.BaseURL = up.srv.URL
|
|
cfg.LiteLLM.KeyRef = "literal:k"
|
|
cfg.Models.Tiers = map[string]string{"mopac-study": "glm-4.7-flash", "mopac-code": "glm-5.2", "mopac-primary": "glm-5.3"}
|
|
cfg.Models.Classes = map[string]string{"study": "mopac-study", "code": "mopac-code", "primary": "mopac-primary"}
|
|
cfg.Serve.VKeyRef = "literal:" + testVKey
|
|
cfg.Serve.EnabledModels = []string{"mopac-code"}
|
|
cond, err := loop.New(cfg, io.Discard)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
srv, err := NewServer(cfg.Serve, cond.Router(), cond, io.Discard)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
ts := httptest.NewServer(srv.Handler())
|
|
defer ts.Close()
|
|
|
|
code, body := do(t, http.MethodGet, ts.URL+"/v1/models", bearer(testVKey), "")
|
|
if code != 200 {
|
|
t.Fatalf("code = %d body %s", code, body)
|
|
}
|
|
var list modelList
|
|
if err := json.Unmarshal([]byte(body), &list); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(list.Data) != 1 || list.Data[0].ID != "mopac-code" {
|
|
t.Errorf("catalog = %+v, want only mopac-code", list.Data)
|
|
}
|
|
// A disabled model must now be unknown.
|
|
code, body = do(t, http.MethodPost, ts.URL+"/v1/chat/completions", bearer(testVKey),
|
|
`{"model":"mopac-study","messages":[{"role":"user","content":"x"}]}`)
|
|
if code != 400 || !strings.Contains(body, "unknown model") {
|
|
t.Errorf("disabled model: code=%d body=%s, want 400 unknown model", code, body)
|
|
}
|
|
}
|
|
|
|
func TestChatEndToEnd(t *testing.T) {
|
|
_, up, ts := newStack(t, textBody("the serve reply", 20, 40))
|
|
code, body := do(t, http.MethodPost, ts.URL+"/v1/chat/completions", bearer(testVKey),
|
|
`{"model":"mopac-code","messages":[{"role":"user","content":"write a function"}]}`)
|
|
if code != 200 {
|
|
t.Fatalf("code = %d body %s", code, body)
|
|
}
|
|
var out chatCompletion
|
|
if err := json.Unmarshal([]byte(body), &out); err != nil {
|
|
t.Fatalf("decode: %v (%s)", err, body)
|
|
}
|
|
if !strings.HasPrefix(out.ID, "chatcmpl-") || out.Object != "chat.completion" {
|
|
t.Errorf("id/object wrong: %q %q", out.ID, out.Object)
|
|
}
|
|
if out.Model != "mopac-code" {
|
|
t.Errorf("response model = %q, want the requested name echoed", out.Model)
|
|
}
|
|
if len(out.Choices) != 1 || out.Choices[0].Message.Role != "assistant" ||
|
|
out.Choices[0].Message.Content != "the serve reply" || out.Choices[0].FinishReason != "stop" {
|
|
t.Errorf("choices wrong: %+v", out.Choices)
|
|
}
|
|
if out.Usage.PromptTokens != 20 || out.Usage.CompletionTokens != 40 || out.Usage.TotalTokens != 60 {
|
|
t.Errorf("usage wrong: %+v", out.Usage)
|
|
}
|
|
// Routing: the request the upstream saw must carry the CONCRETE model
|
|
// resolved through the tier map, and no tools.
|
|
req := up.request(0)
|
|
if req.Model != "glm-5.2" {
|
|
t.Errorf("upstream model = %q, want glm-5.2 (mopac-code tier)", req.Model)
|
|
}
|
|
if len(req.Tools) != 0 {
|
|
t.Errorf("upstream tools = %+v, want none (v0 serve turns are pure chat)", req.Tools)
|
|
}
|
|
}
|
|
|
|
func TestChatHistoryAssembly(t *testing.T) {
|
|
// OWUI sends the whole conversation each call. The system message is
|
|
// the client's own (no harness prepend) and the history order is
|
|
// preserved verbatim; only when no system message leads does the
|
|
// conductor inject the vertical identity prompt.
|
|
_, up, ts := newStack(t, textBody("reply", 1, 1))
|
|
payload := `{"model":"mopac-primary","messages":[
|
|
{"role":"system","content":"You are the test persona."},
|
|
{"role":"user","content":"first question"},
|
|
{"role":"assistant","content":"first answer"},
|
|
{"role":"user","content":"second question"}
|
|
]}`
|
|
if code, body := do(t, http.MethodPost, ts.URL+"/v1/chat/completions", bearer(testVKey), payload); code != 200 {
|
|
t.Fatalf("code = %d body %s", code, body)
|
|
}
|
|
got := up.request(0).Messages
|
|
if len(got) != 4 {
|
|
t.Fatalf("upstream history length = %d, want 4 (client system wins)", len(got))
|
|
}
|
|
wantRoles := "system user assistant user"
|
|
var roles []string
|
|
for _, m := range got {
|
|
roles = append(roles, m.Role)
|
|
}
|
|
if strings.Join(roles, " ") != wantRoles {
|
|
t.Errorf("roles = %v, want %v", roles, wantRoles)
|
|
}
|
|
if got[0].Content != "You are the test persona." || got[3].Content != "second question" {
|
|
t.Errorf("history contents wrong: %+v", got)
|
|
}
|
|
}
|
|
|
|
func TestChatPrependsSystemWhenMissing(t *testing.T) {
|
|
_, up, ts := newStack(t, textBody("r", 1, 1))
|
|
if code, body := do(t, http.MethodPost, ts.URL+"/v1/chat/completions", bearer(testVKey),
|
|
`{"model":"mopac-study","messages":[{"role":"user","content":"hi"}]}`); code != 200 {
|
|
t.Fatalf("code = %d body %s", code, body)
|
|
}
|
|
got := up.request(0).Messages
|
|
if len(got) != 2 || got[0].Role != "system" || got[1].Role != "user" {
|
|
t.Fatalf("messages = %+v, want [system, user]", got)
|
|
}
|
|
if !strings.Contains(got[0].Content, "teststack") {
|
|
t.Errorf("prepended system prompt lacks vertical identity: %q", got[0].Content)
|
|
}
|
|
// flash tier routes through the same class map
|
|
if up.request(0).Model != "glm-4.7-flash" {
|
|
t.Errorf("upstream model = %q, want glm-4.7-flash (mopac-study tier)", up.request(0).Model)
|
|
}
|
|
}
|
|
|
|
func TestChatUsageAccountingAcrossRounds(t *testing.T) {
|
|
// A model that hallucinates a tool call first (tools are off) then
|
|
// answers: usage must be the SUM over both rounds.
|
|
toolCall := `{"choices":[{"message":{"role":"assistant","content":"","tool_calls":[{"id":"c1","type":"function","function":{"name":"bash","arguments":"{\"command\":\"pwd\"}"}}]},"finish_reason":"tool_calls"}],"usage":{"prompt_tokens":10,"completion_tokens":5,"total_tokens":15}}`
|
|
_, up, ts := newStack(t, toolCall, textBody("final text", 30, 25))
|
|
code, body := do(t, http.MethodPost, ts.URL+"/v1/chat/completions", bearer(testVKey),
|
|
`{"model":"mopac-primary","messages":[{"role":"user","content":"go"}]}`)
|
|
if code != 200 {
|
|
t.Fatalf("code = %d body %s", code, body)
|
|
}
|
|
if up.count() != 2 {
|
|
t.Fatalf("upstream calls = %d, want 2", up.count())
|
|
}
|
|
// The refused tool call must come back as a tool result, never executed.
|
|
second := up.request(1).Messages
|
|
last := second[len(second)-1]
|
|
if last.Role != "tool" || !strings.Contains(last.Content, "tools are disabled") {
|
|
t.Errorf("tool result = %+v, want the disabled refusal", last)
|
|
}
|
|
var out chatCompletion
|
|
if err := json.Unmarshal([]byte(body), &out); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if out.Usage.PromptTokens != 40 || out.Usage.CompletionTokens != 30 || out.Usage.TotalTokens != 70 {
|
|
t.Errorf("usage = %+v, want sums over both rounds (40/30/70)", out.Usage)
|
|
}
|
|
if out.Choices[0].Message.Content != "final text" {
|
|
t.Errorf("content = %q", out.Choices[0].Message.Content)
|
|
}
|
|
}
|
|
|
|
func TestChatForwardsKnobs(t *testing.T) {
|
|
_, up, ts := newStack(t, textBody("r", 1, 1))
|
|
if code, body := do(t, http.MethodPost, ts.URL+"/v1/chat/completions", bearer(testVKey),
|
|
`{"model":"mopac-code","messages":[{"role":"user","content":"hi"}],"temperature":0.3,"max_tokens":256}`); code != 200 {
|
|
t.Fatalf("code = %d body %s", code, body)
|
|
}
|
|
req := up.request(0)
|
|
if req.Temperature == nil || *req.Temperature != 0.3 {
|
|
t.Errorf("temperature = %v, want 0.3 forwarded", req.Temperature)
|
|
}
|
|
if req.MaxTokens != 256 {
|
|
t.Errorf("max_tokens = %d, want 256 forwarded", req.MaxTokens)
|
|
}
|
|
}
|
|
|
|
func TestChatBadRequestTable(t *testing.T) {
|
|
_, _, ts := newStack(t, textBody("unused", 1, 1))
|
|
url := ts.URL + "/v1/chat/completions"
|
|
cases := []struct {
|
|
name string
|
|
body string
|
|
wantCode int
|
|
wantBody string
|
|
}{
|
|
{
|
|
"unknown model names valid ones",
|
|
`{"model":"gpt-4","messages":[{"role":"user","content":"x"}]}`,
|
|
400, `valid models: mopac-code, mopac-primary, mopac-read, mopac-study`,
|
|
},
|
|
{"stream requested", `{"model":"mopac-code","stream":true,"messages":[{"role":"user","content":"x"}]}`, 400, "streaming is not supported"},
|
|
{"empty messages", `{"model":"mopac-code","messages":[]}`, 400, "messages must not be empty"},
|
|
{"bad role", `{"model":"mopac-code","messages":[{"role":"tool","content":"x"}]}`, 400, "unsupported role"},
|
|
{"malformed json", `{not json`, 400, "malformed request body"},
|
|
}
|
|
for _, tc := range cases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
code, body := do(t, http.MethodPost, url, bearer(testVKey), tc.body)
|
|
if code != tc.wantCode {
|
|
t.Errorf("code = %d, want %d (body %s)", code, tc.wantCode, body)
|
|
}
|
|
if !strings.Contains(body, tc.wantBody) {
|
|
t.Errorf("body %q does not contain %q", body, tc.wantBody)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestChatUpstreamErrorIs502(t *testing.T) {
|
|
up := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
http.Error(w, "upstream exploded", http.StatusInternalServerError)
|
|
}))
|
|
defer up.Close()
|
|
cfg := config.Default()
|
|
cfg.Vertical = "teststack"
|
|
cfg.LiteLLM.BaseURL = up.URL
|
|
cfg.LiteLLM.KeyRef = "literal:k"
|
|
cfg.LiteLLM.MaxRetries = 0
|
|
cfg.Models.Tiers = map[string]string{"mopac-primary": "glm-5.3"}
|
|
cfg.Models.Classes = map[string]string{"primary": "mopac-primary"}
|
|
cfg.Serve.VKeyRef = "literal:" + testVKey
|
|
cond, err := loop.New(cfg, io.Discard)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
srv, err := NewServer(cfg.Serve, cond.Router(), cond, io.Discard)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
ts := httptest.NewServer(srv.Handler())
|
|
defer ts.Close()
|
|
|
|
code, body := do(t, http.MethodPost, ts.URL+"/v1/chat/completions", bearer(testVKey),
|
|
`{"model":"mopac-primary","messages":[{"role":"user","content":"x"}]}`)
|
|
if code != http.StatusBadGateway {
|
|
t.Fatalf("code = %d, want 502 (body %s)", code, body)
|
|
}
|
|
if strings.Contains(body, "exploded") {
|
|
t.Errorf("502 body must not echo upstream details: %s", body)
|
|
}
|
|
}
|
|
|
|
func TestNewServerFailFast(t *testing.T) {
|
|
cfg := config.Default()
|
|
cfg.Vertical = "teststack"
|
|
cfg.LiteLLM.BaseURL = "http://unused"
|
|
cfg.LiteLLM.KeyRef = "literal:k"
|
|
cfg.Models.Tiers = map[string]string{"mopac-primary": "glm-5.3"}
|
|
cfg.Models.Classes = map[string]string{"primary": "mopac-primary"}
|
|
cond, err := loop.New(cfg, os.Stdout)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if _, err := NewServer(cfg.Serve, cond.Router(), cond, io.Discard); err == nil || !strings.Contains(err.Error(), "vkey_ref is required") {
|
|
t.Errorf("missing vkey_ref: err = %v", err)
|
|
}
|
|
|
|
cfg.Serve.VKeyRef = "literal:" + testVKey
|
|
cfg.Serve.EnabledModels = []string{"mopac-nope"}
|
|
if _, err := NewServer(cfg.Serve, cond.Router(), cond, io.Discard); err == nil || !strings.Contains(err.Error(), "not servable") {
|
|
t.Errorf("bad enabled_models: err = %v", err)
|
|
}
|
|
}
|
|
|
|
func TestHealthz(t *testing.T) {
|
|
_, _, ts := newStack(t)
|
|
// No auth on healthz (liveness probe, same as the events receiver).
|
|
code, body := do(t, http.MethodGet, ts.URL+"/healthz", "", "")
|
|
if code != 200 || !strings.Contains(body, `"status":"ok"`) {
|
|
t.Errorf("healthz: code=%d body=%s", code, body)
|
|
}
|
|
}
|
|
|
|
// Compile-time check that the conductor satisfies the Turner contract.
|
|
var _ Turner = (*loop.Conductor)(nil)
|