mirror of
https://gitcode.com/JianFeeeee/ModelRouter.git
synced 2026-09-19 16:39:15 +00:00
2e3d5b79ad
Four adapters handled tool_calls in transform_stream_chunk but lost them in
transform_response, so any NON-streaming tool-using conversation broke on its
second request: the client received finish_reason:"tool_calls" with no
tool_calls payload, replayed an assistant message whose function
name/arguments were empty, and the upstream rejected the next turn with
400 invalid tool_call function, function/name/arguments cannot be empty
The production audit trail shows 46 such failures on sensenova alone.
- sensenova.lua: forward message.tool_calls, decoding the arguments JSON string
into an object as the unified shape expects.
- gemini.lua: collect functionCall parts from candidates[].content.parts. Also
correct finish_reason, since Gemini reports "STOP" even when it emitted a
function call and clients keyed on it treat that as a finished answer.
- ollama.lua: the field was initialized to an empty table and never filled;
fill it and likewise correct done_reason "stop" -> "tool_calls".
trae is a different failure with the same symptom: trae-local-api's OpenAI
endpoint (/v1/chat/completions, src/server.js:353) never reads the request's
`tools` array — only its Anthropic endpoint does — so the relayed model is never
told the tool schema and instead PRINTS a <tool_call>{...}</tool_call> block into
content, leaving message.tool_calls null and finish_reason "stop". An OpenAI
client sees an ordinary completion and its agent loop ends mid-conversation.
trae.lua now recovers the structured call from that text, strips the block from
user-visible content, and corrects finish_reason. Both tag spellings
(<tool_call>/<toolcall>, the latter is what the same codebase's Anthropic prompt
asks for) and all three argument key names (arguments/params/input) are accepted.
This is a defensive fallback: fixing the upstream shim to honour `tools` remains
the real fix, since the model still guesses parameter names.
Tests: TestNonStreamToolCallsPreserved covers all ten OpenAI-shaped adapters,
TestGeminiNonStreamToolCalls and TestOllamaNonStreamToolCalls cover their native
shapes, TestTraeTextToolCallRecovery covers both tag spellings, prose around the
block, and asserts a plain text answer never gains tool_calls.
Verified end-to-end against mock upstreams reproducing each shape: a full
two-round agent loop (tool call -> tool result -> final answer) now completes for
both the structured and the text-emitted variants.
1602 lines
52 KiB
Go
1602 lines
52 KiB
Go
package lua
|
||
|
||
import (
|
||
"encoding/json"
|
||
"os"
|
||
"path/filepath"
|
||
"strings"
|
||
"sync"
|
||
"testing"
|
||
"time"
|
||
)
|
||
|
||
// freshAdapterDir returns a path under a temp dir that does not exist yet, so
|
||
// VM.Start() treats it as first-run and seeds the bundled adapters.
|
||
func freshAdapterDir(t *testing.T) string {
|
||
t.Helper()
|
||
return filepath.Join(t.TempDir(), "adapters")
|
||
}
|
||
|
||
func TestLoadBundledAdapters(t *testing.T) {
|
||
vm := NewVM(freshAdapterDir(t))
|
||
if err := vm.Start(); err != nil {
|
||
t.Fatalf("start: %v", err)
|
||
}
|
||
defer vm.Stop()
|
||
adapters := vm.ListAdapters()
|
||
if len(adapters) == 0 {
|
||
t.Fatal("no adapters loaded")
|
||
}
|
||
names := map[string]bool{}
|
||
for _, a := range adapters {
|
||
names[a.Name] = true
|
||
}
|
||
for _, want := range []string{"openai", "deepseek", "anthropic", "gemini", "ollama", "kimicode", "opencode"} {
|
||
if !names[want] {
|
||
t.Errorf("missing adapter %s (got %v)", want, names)
|
||
}
|
||
}
|
||
}
|
||
|
||
func TestFirstRunSeedsEveryBundledAdapter(t *testing.T) {
|
||
dir := filepath.Join(t.TempDir(), "adapters")
|
||
vm := NewVM(dir)
|
||
if err := vm.Start(); err != nil {
|
||
t.Fatalf("start: %v", err)
|
||
}
|
||
defer vm.Stop()
|
||
// every embedded .lua must have been copied out (and no extra, non-.lua files)
|
||
embedded, err := bundledAdapters.ReadDir("adapters")
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
seeded := 0
|
||
for _, e := range embedded {
|
||
if e.IsDir() || !strings.HasSuffix(e.Name(), ".lua") {
|
||
continue
|
||
}
|
||
seeded++
|
||
if _, err := os.Stat(filepath.Join(dir, e.Name())); err != nil {
|
||
t.Errorf("embedded adapter %s not seeded", e.Name())
|
||
}
|
||
}
|
||
if seeded == 0 {
|
||
t.Fatal("no embedded adapters found")
|
||
}
|
||
written := 0
|
||
entries, _ := os.ReadDir(dir)
|
||
for _, e := range entries {
|
||
if !e.IsDir() && strings.HasSuffix(e.Name(), ".lua") {
|
||
written++
|
||
}
|
||
}
|
||
if written != seeded {
|
||
t.Fatalf("seeded %d files but %d embedded adapters exist", written, seeded)
|
||
}
|
||
// re-start with the existing dir: authoritative, never rewritten
|
||
vm2 := NewVM(dir)
|
||
if err := vm2.Start(); err != nil {
|
||
t.Fatalf("second start: %v", err)
|
||
}
|
||
defer vm2.Stop()
|
||
}
|
||
|
||
func TestTransformRequest(t *testing.T) {
|
||
vm := NewVM(freshAdapterDir(t))
|
||
if err := vm.Start(); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
defer vm.Stop()
|
||
out, err := vm.Transform("openai", "transform_request", `{"model":"x","disable_thinking":true,"messages":[]}`)
|
||
if err != nil {
|
||
t.Fatalf("transform: %v", err)
|
||
}
|
||
if strings.Contains(out, "disable_thinking") {
|
||
t.Fatalf("disable_thinking not stripped: %s", out)
|
||
}
|
||
}
|
||
|
||
func TestBuildHeadersFallbackStatic(t *testing.T) {
|
||
vm := NewVM(freshAdapterDir(t))
|
||
if err := vm.Start(); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
defer vm.Stop()
|
||
hdrs, err := vm.BuildHeaders("anthropic", nil)
|
||
if err != nil {
|
||
t.Fatalf("build headers: %v", err)
|
||
}
|
||
if hdrs["anthropic-version"] != "2023-06-01" {
|
||
t.Fatalf("static header missing: %v", hdrs)
|
||
}
|
||
}
|
||
|
||
func TestOpenCodeAdapterFingerprint(t *testing.T) {
|
||
vm := NewVM(freshAdapterDir(t))
|
||
if err := vm.Start(); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
defer vm.Stop()
|
||
hdrs, err := vm.BuildHeaders("opencode", map[string]interface{}{
|
||
"api_key": "public",
|
||
"timestamp": 1700000000,
|
||
"body": `{"model":"x"}`,
|
||
"url": "https://opencode.ai/zen/v1/chat/completions",
|
||
"method": "POST",
|
||
})
|
||
if err != nil {
|
||
t.Fatalf("build headers: %v", err)
|
||
}
|
||
// zen 按客户端指纹路由请求池：UA 必须是 opencode 真实格式，
|
||
// 且必须携带 x-opencode-* 身份头，否则带 tools 的请求会被上游
|
||
// 判为匿名客户端并返回 network_error 空流（表现为空回复）。
|
||
if ua := hdrs["User-Agent"]; !strings.HasPrefix(ua, "opencode/") ||
|
||
!strings.Contains(ua, "ai-sdk/provider-utils/") {
|
||
t.Fatalf("opencode adapter must send the real opencode client UA, got %q", ua)
|
||
}
|
||
for _, h := range []string{"x-opencode-client", "x-opencode-project", "x-opencode-session", "x-opencode-request"} {
|
||
if hdrs[h] == "" {
|
||
t.Fatalf("opencode adapter must send %q (zen client fingerprint), got %v", h, hdrs)
|
||
}
|
||
}
|
||
hdrs2, _ := vm.BuildHeaders("opencode", map[string]interface{}{"api_key": "public", "timestamp": 1700000001, "body": `{"model":"y"}`, "method": "POST"})
|
||
if hdrs["x-opencode-request"] == hdrs2["x-opencode-request"] {
|
||
t.Fatalf("x-opencode-request must vary per request, got %q twice", hdrs["x-opencode-request"])
|
||
}
|
||
if hdrs["Authorization"] != "" {
|
||
t.Fatalf("opencode adapter must not hardcode Authorization (config api_key supplies it), got %q", hdrs["Authorization"])
|
||
}
|
||
// passthrough behaves like the openai adapter
|
||
out, err := vm.Transform("opencode", "transform_request", `{"model":"x","disable_thinking":true,"extra_body":{},"messages":[{"role":"user","content":"hi"}]}`)
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if strings.Contains(out, "disable_thinking") || strings.Contains(out, "extra_body") {
|
||
t.Fatalf("opencode transform_request must strip provider fields: %s", out)
|
||
}
|
||
}
|
||
|
||
func TestOpenCodeNormalizesRoles(t *testing.T) {
|
||
vm := NewVM(freshAdapterDir(t))
|
||
if err := vm.Start(); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
defer vm.Stop()
|
||
// zen 上游只接受 system/user/assistant/tool/latest_reminder；
|
||
// OpenAI 系客户端发 `developer`（Claude Code 还会用 `function`）必须归一化成 system。
|
||
body := `{"model":"x","messages":[
|
||
{"role":"developer","content":"you are helpful"},
|
||
{"role":"system","content":"sys"},
|
||
{"role":"user","content":"hi"},
|
||
{"role":"assistant","content":"ok"},
|
||
{"role":"tool","tool_call_id":"t1","content":"{\"ok\":true}"}
|
||
]}`
|
||
out, err := vm.Transform("opencode", "transform_request", body)
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if strings.Contains(out, `"developer"`) {
|
||
t.Fatalf("developer role must be normalized: %s", out)
|
||
}
|
||
if !strings.Contains(out, `"system"`) || !strings.Contains(out, `"user"`) {
|
||
t.Fatalf("allowed roles must survive: %s", out)
|
||
}
|
||
if !strings.Contains(out, `"assistant"`) {
|
||
t.Fatalf("assistant role must survive: %s", out)
|
||
}
|
||
if !strings.Contains(out, `"tool"`) {
|
||
t.Fatalf("tool role must survive: %s", out)
|
||
}
|
||
}
|
||
|
||
func TestOpenCodeStripsMultiModalParts(t *testing.T) {
|
||
vm := NewVM(freshAdapterDir(t))
|
||
if err := vm.Start(); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
defer vm.Stop()
|
||
body := `{"model":"x","messages":[
|
||
{"role":"user","content":[
|
||
{"type":"text","text":"describe"},
|
||
{"type":"image_url","image_url":{"url":"data:image/png;base64,QUJD"}},
|
||
{"type":"input_audio","input_audio":{"data":"QQ","format":"wav"}}
|
||
]},
|
||
{"role":"user","content":[{"type":"image_url","image_url":{"url":"https://ex.com/a.png"}}]},
|
||
{"role":"assistant","content":"plain"}
|
||
]}`
|
||
out, err := vm.Transform("opencode", "transform_request", body)
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if strings.Contains(out, "image_url") || strings.Contains(out, "input_audio") {
|
||
t.Fatalf("opencode must strip multimodal parts: %s", out)
|
||
}
|
||
if !strings.Contains(out, "describe") {
|
||
t.Fatalf("text parts must survive: %s", out)
|
||
}
|
||
// image-only message dropped: only the text message and plain assistant message remain
|
||
if got := strings.Count(out, `"role"`); got != 2 {
|
||
t.Fatalf("image-only message must be dropped, got %d messages: %s", got, out)
|
||
}
|
||
}
|
||
|
||
func TestBuildHeadersCustomHook(t *testing.T) {
|
||
vm := NewVM(freshAdapterDir(t))
|
||
if err := vm.Start(); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
defer vm.Stop()
|
||
hdrs, err := vm.BuildHeaders("kimicode", map[string]interface{}{
|
||
"timestamp": int64(12345),
|
||
"api_key": "k",
|
||
"body": "{}",
|
||
"method": "POST",
|
||
"url": "http://x/chat",
|
||
"source": map[string]interface{}{"meta": map[string]interface{}{
|
||
"app_id": "app-9", "app_secret": "s", "api_key": "k",
|
||
}},
|
||
})
|
||
if err != nil {
|
||
t.Fatalf("build headers: %v", err)
|
||
}
|
||
if hdrs["X-App-Id"] != "app-9" {
|
||
t.Fatalf("x-app-id = %q", hdrs["X-App-Id"])
|
||
}
|
||
if hdrs["X-App-Sign"] == "" {
|
||
t.Fatal("expected signature header")
|
||
}
|
||
if hdrs["X-Timestamp"] != "12345" {
|
||
t.Fatalf("timestamp = %q", hdrs["X-Timestamp"])
|
||
}
|
||
}
|
||
|
||
func TestDisableThinkingPassthrough(t *testing.T) {
|
||
vm := NewVM(freshAdapterDir(t))
|
||
if err := vm.Start(); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
defer vm.Stop()
|
||
body := `{"model":"x","disable_thinking":true,"messages":[{"role":"user","content":"hi"}]}`
|
||
out, err := vm.Transform("deepseek", "transform_request", body)
|
||
if err != nil {
|
||
t.Fatalf("deepseek transform: %v", err)
|
||
}
|
||
var req struct {
|
||
ExtraBody map[string]interface{} `json:"extra_body"`
|
||
}
|
||
if err := json.Unmarshal([]byte(out), &req); err != nil {
|
||
t.Fatalf("unmarshal: %v (%s)", err, out)
|
||
}
|
||
thinking, ok := req.ExtraBody["thinking"].(map[string]interface{})
|
||
if !ok {
|
||
t.Fatalf("deepseek should emit extra_body.thinking on disable_thinking: %s", out)
|
||
}
|
||
if thinking["type"] != "disabled" {
|
||
t.Fatalf("thinking.type = %v", thinking["type"])
|
||
}
|
||
|
||
// anthropic: thinking is opt-in (Issue 3) — never emitted by default, and
|
||
// disable_thinking is not a trigger either.
|
||
out2, err := vm.Transform("anthropic", "transform_request", body)
|
||
if err != nil {
|
||
t.Fatalf("anthropic transform: %v", err)
|
||
}
|
||
if strings.Contains(out2, "thinking") {
|
||
t.Fatalf("anthropic should drop thinking when disable_thinking: %s", out2)
|
||
}
|
||
out3, err := vm.Transform("anthropic", "transform_request", `{"model":"x","messages":[{"role":"user","content":"hi"}]}`)
|
||
if err != nil {
|
||
t.Fatalf("anthropic transform: %v", err)
|
||
}
|
||
if strings.Contains(out3, "thinking") {
|
||
t.Fatalf("anthropic must not enable thinking by default: %s", out3)
|
||
}
|
||
// opt-in path: extra_body.thinking is forwarded verbatim
|
||
out4, err := vm.Transform("anthropic", "transform_request",
|
||
`{"model":"x","messages":[{"role":"user","content":"hi"}],"extra_body":{"thinking":{"type":"enabled","budget_tokens":2048}}}`)
|
||
if err != nil {
|
||
t.Fatalf("anthropic transform: %v", err)
|
||
}
|
||
if !strings.Contains(out4, `"type":"enabled"`) || !strings.Contains(out4, "2048") {
|
||
t.Fatalf("anthropic should forward extra_body.thinking: %s", out4)
|
||
}
|
||
}
|
||
|
||
func TestMultimodalTransform(t *testing.T) {
|
||
vm := NewVM(freshAdapterDir(t))
|
||
if err := vm.Start(); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
defer vm.Stop()
|
||
body := `{"model":"x","messages":[{"role":"user","content":[
|
||
{"type":"text","text":"what is this?"},
|
||
{"type":"image_url","image_url":{"url":"data:image/png;base64,QUJD"}},
|
||
{"type":"image_url","image_url":{"url":"https://ex.com/a.png"}}
|
||
]}]}`
|
||
|
||
// anthropic: image_url -> image block (base64/url), text preserved
|
||
out, err := vm.Transform("anthropic", "transform_request", body)
|
||
if err != nil {
|
||
t.Fatalf("anthropic: %v", err)
|
||
}
|
||
for _, want := range []string{`"media_type":"image/png"`, `"data":"QUJD"`, `"type":"url","url":"https://ex.com/a.png"`, `"what is this?"`} {
|
||
if !strings.Contains(out, want) {
|
||
t.Fatalf("anthropic multimodal missing %s: %s", want, out)
|
||
}
|
||
}
|
||
|
||
// gemini: image_url -> inline_data
|
||
gout, err := vm.Transform("gemini", "transform_request", body)
|
||
if err != nil {
|
||
t.Fatalf("gemini: %v", err)
|
||
}
|
||
var g struct {
|
||
Contents []struct {
|
||
Parts []map[string]interface{} `json:"parts"`
|
||
} `json:"contents"`
|
||
}
|
||
if err := json.Unmarshal([]byte(gout), &g); err != nil {
|
||
t.Fatalf("gemini unmarshal: %v", err)
|
||
}
|
||
if len(g.Contents) == 0 {
|
||
t.Fatalf("gemini no contents")
|
||
}
|
||
var found bool
|
||
for _, p := range g.Contents[0].Parts {
|
||
if v, ok := p["inline_data"].(map[string]interface{}); ok && v["data"] == "QUJD" && v["mime_type"] == "image/png" {
|
||
found = true
|
||
}
|
||
}
|
||
if !found {
|
||
t.Fatalf("gemini missing inline_data image: %s", gout)
|
||
}
|
||
|
||
// ollama: image_url -> images base64 array
|
||
out, err = vm.Transform("ollama", "transform_request", body)
|
||
if err != nil {
|
||
t.Fatalf("ollama: %v", err)
|
||
}
|
||
if !strings.Contains(out, `"images":["QUJD"]`) {
|
||
t.Fatalf("ollama multimodal missing images: %s", out)
|
||
}
|
||
|
||
// openai passthrough keeps the content array intact
|
||
po, _ := vm.Transform("openai", "transform_request", body)
|
||
if !strings.Contains(po, `"image_url"`) || !strings.Contains(po, `,QUJD"`) {
|
||
t.Fatalf("openai passthrough lost multimodal content: %s", po)
|
||
}
|
||
}
|
||
|
||
func TestOpenCodeAdapterNormalizesDeveloperRole(t *testing.T) {
|
||
vm := NewVM(freshAdapterDir(t))
|
||
if err := vm.Start(); err != nil {
|
||
t.Fatalf("start: %v", err)
|
||
}
|
||
defer vm.Stop()
|
||
|
||
raw := `{"model":"zen","messages":[` +
|
||
`{"role":"developer","content":"be concise"},` +
|
||
`{"role":"user","content":"hi"},` +
|
||
`{"role":"assistant","content":"hello"},` +
|
||
`{"role":"function","content":"{\"a\":1}"},` +
|
||
`{"role":"latest_reminder","content":"remind"}]}`
|
||
out, err := vm.Transform("opencode", "transform_request", raw)
|
||
if err != nil {
|
||
t.Fatalf("transform_request: %v", err)
|
||
}
|
||
var req struct {
|
||
Messages []struct {
|
||
Role string `json:"role"`
|
||
} `json:"messages"`
|
||
}
|
||
if err := json.Unmarshal([]byte(out), &req); err != nil {
|
||
t.Fatalf("output not JSON: %v\n%s", err, out)
|
||
}
|
||
want := []string{"system", "user", "assistant", "system", "latest_reminder"}
|
||
if len(req.Messages) != len(want) {
|
||
t.Fatalf("got %d messages, want %d: %s", len(req.Messages), len(want), out)
|
||
}
|
||
for i, w := range want {
|
||
if req.Messages[i].Role != w {
|
||
t.Errorf("message %d role = %q, want %q", i, req.Messages[i].Role, w)
|
||
}
|
||
}
|
||
}
|
||
|
||
func TestOpenCodeAdapterKeepsWhitelistedRolesAndDropsMultimodal(t *testing.T) {
|
||
vm := NewVM(freshAdapterDir(t))
|
||
if err := vm.Start(); err != nil {
|
||
t.Fatalf("start: %v", err)
|
||
}
|
||
defer vm.Stop()
|
||
|
||
raw := `{"messages":[` +
|
||
`{"role":"system","content":"sys"},` +
|
||
`{"role":"user","content":[{"type":"text","text":"keep"},{"type":"image_url","url":"x"}]},` +
|
||
`{"role":"user","content":[{"type":"image_url","url":"x"}]}]}`
|
||
out, err := vm.Transform("opencode", "transform_request", raw)
|
||
if err != nil {
|
||
t.Fatalf("transform_request: %v", err)
|
||
}
|
||
var req struct {
|
||
Messages []struct {
|
||
Role string `json:"role"`
|
||
Content any `json:"content"`
|
||
} `json:"messages"`
|
||
}
|
||
if err := json.Unmarshal([]byte(out), &req); err != nil {
|
||
t.Fatalf("output not JSON: %v\n%s", err, out)
|
||
}
|
||
if len(req.Messages) != 2 {
|
||
t.Fatalf("got %d messages, want 2 (multimodal-only dropped): %s", len(req.Messages), out)
|
||
}
|
||
if req.Messages[0].Role != "system" || req.Messages[1].Role != "user" {
|
||
t.Fatalf("unexpected roles: %s", out)
|
||
}
|
||
}
|
||
|
||
func TestAdaptersPassFinishReason(t *testing.T) {
|
||
vm := NewVM(freshAdapterDir(t))
|
||
if err := vm.Start(); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
defer vm.Stop()
|
||
// OpenAI-style chunk with a real finish reason must surface finish_reason
|
||
// and done=true; an empty-string finish_reason (sensenova sends "" on
|
||
// every chunk) must NOT terminate the stream.
|
||
chunk := `{"choices":[{"index":0,"finish_reason":"tool_calls","delta":{"content":""}}]}`
|
||
empty := `{"choices":[{"index":0,"finish_reason":"","delta":{"content":"x"}}]}`
|
||
for _, name := range []string{"openai", "deepseek", "github", "groq", "kimicode", "mistral", "opencode"} {
|
||
out, err := vm.Transform(name, "transform_stream_chunk", chunk)
|
||
if err != nil {
|
||
t.Fatalf("%s: %v", name, err)
|
||
}
|
||
if !strings.Contains(out, `"finish_reason":"tool_calls"`) {
|
||
t.Fatalf("%s: finish_reason lost: %s", name, out)
|
||
}
|
||
if !strings.Contains(out, `"done":true`) {
|
||
t.Fatalf("%s: done not set on real finish: %s", name, out)
|
||
}
|
||
out, err = vm.Transform(name, "transform_stream_chunk", empty)
|
||
if err != nil {
|
||
t.Fatalf("%s: %v", name, err)
|
||
}
|
||
if strings.Contains(out, `"done":true`) {
|
||
t.Fatalf("%s: empty finish_reason must not end stream: %s", name, out)
|
||
}
|
||
}
|
||
}
|
||
|
||
// TestAnthropicToolRoundTrip verifies the OpenAI->Anthropic request mapping for
|
||
// a full agent tool-call round (Issue 1): assistant tool_calls become
|
||
// tool_use content blocks and role:"tool" results become user tool_result
|
||
// blocks merged into ONE user message. This is the regression that made agent
|
||
// clients (dsh/Claude Code/Cursor) repeatedly re-invoke the same tool.
|
||
func TestAnthropicToolRoundTrip(t *testing.T) {
|
||
vm := NewVM(freshAdapterDir(t))
|
||
if err := vm.Start(); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
defer vm.Stop()
|
||
|
||
round1 := `{"model":"x","tools":[{"type":"function","function":{"name":"calc","description":"multiply","parameters":{"type":"object","properties":{"a":{"type":"integer"},"b":{"type":"integer"}},"required":["a","b"]}}}],"messages":[{"role":"user","content":"what is 17*23?"}]}`
|
||
out1, err := vm.Transform("anthropic", "transform_request", round1)
|
||
if err != nil {
|
||
t.Fatalf("round1 transform: %v", err)
|
||
}
|
||
var r1 struct {
|
||
Tools []struct {
|
||
Name string `json:"name"`
|
||
InputSchema map[string]interface{} `json:"input_schema"`
|
||
} `json:"tools"`
|
||
Messages []map[string]interface{} `json:"messages"`
|
||
}
|
||
if err := json.Unmarshal([]byte(out1), &r1); err != nil {
|
||
t.Fatalf("unmarshal r1: %v (%s)", err, out1)
|
||
}
|
||
if len(r1.Tools) != 1 || r1.Tools[0].Name != "calc" {
|
||
t.Fatalf("tools not mapped: %s", out1)
|
||
}
|
||
|
||
// Round 2: assistant tool_calls + tool result
|
||
round2 := `{"model":"x","messages":[
|
||
{"role":"user","content":"what is 17*23?"},
|
||
{"role":"assistant","content":"","tool_calls":[
|
||
{"id":"call_1","type":"function","function":{"name":"calc","arguments":"{\"a\":17,\"b\":23}"}}
|
||
]},
|
||
{"role":"tool","tool_call_id":"call_1","content":"391"}
|
||
]}`
|
||
out2, err := vm.Transform("anthropic", "transform_request", round2)
|
||
if err != nil {
|
||
t.Fatalf("round2 transform: %v", err)
|
||
}
|
||
var r2 struct {
|
||
Messages []struct {
|
||
Role string `json:"role"`
|
||
Content []struct {
|
||
Type string `json:"type"`
|
||
ID string `json:"id"`
|
||
Name string `json:"name"`
|
||
Input map[string]interface{} `json:"input"`
|
||
ToolUseID string `json:"tool_use_id"`
|
||
ContentText string `json:"content"`
|
||
} `json:"content"`
|
||
} `json:"messages"`
|
||
}
|
||
if err := json.Unmarshal([]byte(out2), &r2); err != nil {
|
||
t.Fatalf("unmarshal r2: %v (%s)", err, out2)
|
||
}
|
||
// Message 2 (index 1) must be assistant with one tool_use block
|
||
am := r2.Messages[1]
|
||
if am.Role != "assistant" {
|
||
t.Fatalf("msg[1].role = %q, want assistant", am.Role)
|
||
}
|
||
var toolUse struct {
|
||
Type string `json:"type"`
|
||
ID string `json:"id"`
|
||
Name string `json:"name"`
|
||
Input map[string]interface{} `json:"input"`
|
||
}
|
||
for _, b := range am.Content {
|
||
if b.Type == "tool_use" {
|
||
toolUse = struct {
|
||
Type string `json:"type"`
|
||
ID string `json:"id"`
|
||
Name string `json:"name"`
|
||
Input map[string]interface{} `json:"input"`
|
||
}{b.Type, b.ID, b.Name, b.Input}
|
||
}
|
||
}
|
||
if toolUse.ID != "call_1" || toolUse.Name != "calc" {
|
||
t.Fatalf("tool_use not mapped: %+v", am.Content)
|
||
}
|
||
if toolUse.Input["a"] != float64(17) || toolUse.Input["b"] != float64(23) {
|
||
t.Fatalf("tool_use input args not decoded from JSON string: %+v", toolUse.Input)
|
||
}
|
||
// Message 3 (index 2) must be user with one tool_result block
|
||
um := r2.Messages[2]
|
||
if um.Role != "user" {
|
||
t.Fatalf("msg[2].role = %q, want user (tool_result)", um.Role)
|
||
}
|
||
if len(um.Content) != 1 || um.Content[0].Type != "tool_result" || um.Content[0].ToolUseID != "call_1" {
|
||
t.Fatalf("tool_result not mapped: %+v", um.Content)
|
||
}
|
||
|
||
// Round 3: consecutive tool results must merge into ONE user message
|
||
round3 := `{"model":"x","messages":[
|
||
{"role":"user","content":"do both"},
|
||
{"role":"assistant","content":"","tool_calls":[
|
||
{"id":"c1","type":"function","function":{"name":"calc","arguments":"{\"a\":1,\"b\":2}"}},
|
||
{"id":"c2","type":"function","function":{"name":"calc","arguments":"{\"a\":3,\"b\":4}"}}
|
||
]},
|
||
{"role":"tool","tool_call_id":"c1","content":"2"},
|
||
{"role":"tool","tool_call_id":"c2","content":"12"}
|
||
]}`
|
||
out3, err := vm.Transform("anthropic", "transform_request", round3)
|
||
if err != nil {
|
||
t.Fatalf("round3 transform: %v", err)
|
||
}
|
||
var r3 struct {
|
||
Messages []map[string]interface{} `json:"messages"`
|
||
}
|
||
if err := json.Unmarshal([]byte(out3), &r3); err != nil {
|
||
t.Fatalf("unmarshal r3: %v (%s)", err, out3)
|
||
}
|
||
// messages: user, assistant(tool_use x2), user(tool_result x2 merged)
|
||
if len(r3.Messages) != 3 {
|
||
t.Fatalf("round3 len(messages) = %d, want 3 (merged tool results): %s", len(r3.Messages), out3)
|
||
}
|
||
last := r3.Messages[3-1]
|
||
blocks := last["content"].([]interface{})
|
||
if len(blocks) != 2 {
|
||
t.Fatalf("last user message content blocks = %d, want 2 merged tool_results: %s", len(blocks), out3)
|
||
}
|
||
}
|
||
|
||
// TestOpenAITransformErrorEnvelopes covers Issue 6: the openai adapter must
|
||
// condense every shape of upstream error body that real OpenAI-compatible
|
||
// gateways emit, not just the {error:{message}} envelope. Unhandled shapes
|
||
// used to fall through to Go's generic "unknown error" and dump raw HTML /
|
||
// JSON into the server log.
|
||
func TestOpenAITransformErrorEnvelopes(t *testing.T) {
|
||
vm := NewVM(freshAdapterDir(t))
|
||
if err := vm.Start(); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
defer vm.Stop()
|
||
|
||
cases := []struct {
|
||
name string
|
||
status int
|
||
body string
|
||
want string
|
||
}{
|
||
{"standard openai envelope", 429,
|
||
`{"error":{"message":"Rate limit reached","type":"rate_limit"}}`,
|
||
"Rate limit reached"},
|
||
{"error as bare string", 400,
|
||
`{"error":"bad request"}`,
|
||
"bad request"},
|
||
{"flat numeric code (qijiar/siliconflow style)", 400,
|
||
`{"code":20012,"message":"Model does not exist. Please check it carefully.","data":null}`,
|
||
"20012: Model does not exist. Please check it carefully."},
|
||
{"flat string code (remotezen style)", 401,
|
||
`{"code":"INVALID_API_KEY","message":"Invalid API key"}`,
|
||
"INVALID_API_KEY: Invalid API key"},
|
||
{"fastapi detail", 422,
|
||
`{"detail":"validation failed"}`,
|
||
"validation failed"},
|
||
{"nginx html error page", 413,
|
||
`<html> <head><title>413 Request Entity Too Large</title></head> <body> <center><h1>413 Request Entity Too Large</h1></center> <hr><center>nginx/1.18.0 (Ubuntu)</center> </body> </html>`,
|
||
"413 Request Entity Too Large"},
|
||
{"plain text body", 502,
|
||
"upstream connect error",
|
||
"upstream connect error"},
|
||
}
|
||
for _, tc := range cases {
|
||
t.Run(tc.name, func(t *testing.T) {
|
||
got, ok, err := vm.TransformError("openai", tc.status, tc.body)
|
||
if err != nil {
|
||
t.Fatalf("TransformError: %v", err)
|
||
}
|
||
if !ok {
|
||
t.Fatalf("hook returned no reason for %s body: %s", tc.name, tc.body)
|
||
}
|
||
if got != tc.want {
|
||
t.Fatalf("reason = %q, want %q", got, tc.want)
|
||
}
|
||
})
|
||
}
|
||
|
||
// A body carrying no usable message must fall through (ok=false) so the
|
||
// Go-side generic condenser stays in charge instead of inventing text.
|
||
t.Run("no usable message falls through", func(t *testing.T) {
|
||
if _, ok, _ := vm.TransformError("openai", 500, `{"foo":"bar"}`); ok {
|
||
t.Fatal("expected fallthrough for a body with no message field")
|
||
}
|
||
})
|
||
}
|
||
|
||
// TestAdaptersReportZeroCacheHit covers the "distinguish missed from not
|
||
// reported" contract on BOTH adapter paths: whenever an upstream reports a
|
||
// cache field, the adapter must emit prompt_tokens_details even when the hit
|
||
// count is 0, so the gateway can record cache_reported=true and the UI shows
|
||
// 0% instead of "—". Adapters that dropped the 0 case made a reported miss
|
||
// indistinguishable from an upstream that never reported cache info.
|
||
func TestAdaptersReportZeroCacheHit(t *testing.T) {
|
||
vm := NewVM(freshAdapterDir(t))
|
||
if err := vm.Start(); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
defer vm.Stop()
|
||
|
||
// OpenAI-shaped upstreams: usage.prompt_tokens_details.cached_tokens = 0
|
||
openaiLike := []string{"openai", "deepseek", "sensenova", "opencode",
|
||
"agentrouter", "github", "groq", "kimicode", "mistral"}
|
||
respBody := `{"choices":[{"message":{"content":"hi"},"finish_reason":"stop"}],
|
||
"usage":{"prompt_tokens":10,"completion_tokens":2,"total_tokens":12,
|
||
"prompt_tokens_details":{"cached_tokens":0}}}`
|
||
streamBody := `{"choices":[],"usage":{"prompt_tokens":10,"completion_tokens":2,
|
||
"total_tokens":12,"prompt_tokens_details":{"cached_tokens":0}}}`
|
||
for _, name := range openaiLike {
|
||
out, err := vm.Transform(name, "transform_response", respBody)
|
||
if err != nil {
|
||
t.Fatalf("%s transform_response: %v", name, err)
|
||
}
|
||
if !strings.Contains(out, "prompt_tokens_details") {
|
||
t.Fatalf("%s: zero cached_tokens dropped in transform_response: %s", name, out)
|
||
}
|
||
out, err = vm.Transform(name, "transform_stream_chunk", streamBody)
|
||
if err != nil {
|
||
t.Fatalf("%s transform_stream_chunk: %v", name, err)
|
||
}
|
||
if !strings.Contains(out, "prompt_tokens_details") {
|
||
t.Fatalf("%s: zero cached_tokens dropped in transform_stream_chunk: %s", name, out)
|
||
}
|
||
}
|
||
|
||
// gemini: usageMetadata.cachedContentTokenCount = 0
|
||
gResp := `{"candidates":[{"content":{"parts":[{"text":"hi"}]},"finishReason":"STOP"}],
|
||
"usageMetadata":{"promptTokenCount":10,"candidatesTokenCount":2,
|
||
"totalTokenCount":12,"cachedContentTokenCount":0}}`
|
||
out, err := vm.Transform("gemini", "transform_response", gResp)
|
||
if err != nil {
|
||
t.Fatalf("gemini transform_response: %v", err)
|
||
}
|
||
if !strings.Contains(out, "prompt_tokens_details") {
|
||
t.Fatalf("gemini: cachedContentTokenCount not normalized in transform_response: %s", out)
|
||
}
|
||
gStream := `{"usageMetadata":{"promptTokenCount":10,"candidatesTokenCount":2,
|
||
"totalTokenCount":12,"cachedContentTokenCount":0}}`
|
||
out, err = vm.Transform("gemini", "transform_stream_chunk", gStream)
|
||
if err != nil {
|
||
t.Fatalf("gemini transform_stream_chunk: %v", err)
|
||
}
|
||
if !strings.Contains(out, "prompt_tokens_details") {
|
||
t.Fatalf("gemini: zero cachedContentTokenCount dropped in stream: %s", out)
|
||
}
|
||
|
||
// anthropic: usage.cache_read_input_tokens = 0
|
||
aResp := `{"content":[{"type":"text","text":"hi"}],"stop_reason":"end_turn",
|
||
"usage":{"input_tokens":10,"output_tokens":2,"cache_read_input_tokens":0}}`
|
||
out, err = vm.Transform("anthropic", "transform_response", aResp)
|
||
if err != nil {
|
||
t.Fatalf("anthropic transform_response: %v", err)
|
||
}
|
||
if !strings.Contains(out, "prompt_tokens_details") {
|
||
t.Fatalf("anthropic: zero cache_read_input_tokens dropped in response: %s", out)
|
||
}
|
||
aStream := `{"type":"message_start","message":{"usage":{"input_tokens":10,
|
||
"output_tokens":2,"cache_read_input_tokens":0}}}`
|
||
out, err = vm.Transform("anthropic", "transform_stream_chunk", aStream)
|
||
if err != nil {
|
||
t.Fatalf("anthropic transform_stream_chunk: %v", err)
|
||
}
|
||
if !strings.Contains(out, "prompt_tokens_details") {
|
||
t.Fatalf("anthropic: zero cache_read_input_tokens dropped in stream: %s", out)
|
||
}
|
||
|
||
// Negative control: an upstream that reports NO cache field at all must
|
||
// not fabricate details (that would flip "not reported" into a fake 0%).
|
||
noCache := `{"choices":[{"message":{"content":"hi"},"finish_reason":"stop"}],
|
||
"usage":{"prompt_tokens":10,"completion_tokens":2,"total_tokens":12}}`
|
||
out, err = vm.Transform("openai", "transform_response", noCache)
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if strings.Contains(out, "prompt_tokens_details") {
|
||
t.Fatalf("openai fabricated cache details when upstream reported none: %s", out)
|
||
}
|
||
}
|
||
|
||
// ---- elastic pool sizing (plan 阶段 2) ----
|
||
|
||
// poolOf reaches into the VM for one adapter's pool. Tests assert on internal
|
||
// counters because the whole point of the change is that they no longer grow
|
||
// monotonically.
|
||
func poolOf(t *testing.T, v *VM, name string) *adapterPool {
|
||
t.Helper()
|
||
p := v.pool(name)
|
||
if p == nil {
|
||
t.Fatalf("adapter %q not loaded", name)
|
||
}
|
||
return p
|
||
}
|
||
|
||
func poolCounts(p *adapterPool) (created, idle, inUse int) {
|
||
p.mu.Lock()
|
||
defer p.mu.Unlock()
|
||
return p.created, len(p.idle), p.inUse
|
||
}
|
||
|
||
// TestPoolStartsEmpty is the startup-memory claim: loading adapters must not
|
||
// boot a single Lua state, no matter how large the configured ceiling is.
|
||
func TestPoolStartsEmpty(t *testing.T) {
|
||
vm := NewVM(freshAdapterDir(t))
|
||
if err := vm.Start(); err != nil {
|
||
t.Fatalf("start: %v", err)
|
||
}
|
||
defer vm.Stop()
|
||
vm.ConfigureConcurrency(map[string]int{"openai": 64, "deepseek": 32})
|
||
for _, st := range vm.PoolStats() {
|
||
if st.Created != 0 || st.Idle != 0 || st.InUse != 0 {
|
||
t.Fatalf("adapter %q booted eagerly: created=%d idle=%d in_use=%d",
|
||
st.Name, st.Created, st.Idle, st.InUse)
|
||
}
|
||
}
|
||
}
|
||
|
||
// TestGrowStepFollowsMaxConcurrent pins requirement 3: the growth step is
|
||
// derived from the adapter's maximum concurrency.
|
||
func TestGrowStepFollowsMaxConcurrent(t *testing.T) {
|
||
p := newAdapterPool("t", "return {name='t'}", staticInfo{name: "t"})
|
||
for _, tc := range []struct{ max, want int }{
|
||
{1, 1}, {4, 1}, {8, 1}, {9, 2}, {16, 2}, {32, 4}, {64, 8}, {200, 8},
|
||
} {
|
||
p.setMax(tc.max)
|
||
p.mu.Lock()
|
||
got := p.growStepLocked()
|
||
p.mu.Unlock()
|
||
if got != tc.want {
|
||
t.Fatalf("max=%d: grow step = %d, want %d", tc.max, got, tc.want)
|
||
}
|
||
}
|
||
}
|
||
|
||
// TestShrinkStepFollowsConnections pins requirement 4: the shrink step is
|
||
// driven by the live connection count — no connections means collapse, busy
|
||
// means give up one state at a time.
|
||
func TestShrinkStepFollowsConnections(t *testing.T) {
|
||
p := newAdapterPool("t", "return {name='t'}", staticInfo{name: "t"})
|
||
p.setMax(32)
|
||
p.used = true
|
||
|
||
cases := []struct {
|
||
created, idle, inUse, want int
|
||
why string
|
||
}{
|
||
{created: 9, idle: 9, inUse: 0, want: 8, why: "no connections: collapse to the resident floor in one round"},
|
||
{created: 9, idle: 8, inUse: 1, want: 4, why: "1 connection: halve the slack"},
|
||
{created: 9, idle: 6, inUse: 3, want: 2, why: "3 connections: quarter the slack"},
|
||
{created: 9, idle: 2, inUse: 7, want: 1, why: "busy: release one state at a time"},
|
||
{created: 4, idle: 0, inUse: 4, want: 0, why: "everything checked out: nothing to reclaim"},
|
||
{created: 1, idle: 1, inUse: 0, want: 0, why: "at the resident floor: keep the warm state"},
|
||
}
|
||
for _, tc := range cases {
|
||
p.mu.Lock()
|
||
p.created, p.inUse = tc.created, tc.inUse
|
||
p.idle = make([]*worker, tc.idle)
|
||
got := p.shrinkStepLocked()
|
||
p.mu.Unlock()
|
||
if got != tc.want {
|
||
t.Fatalf("%s: created=%d idle=%d inUse=%d -> step %d, want %d",
|
||
tc.why, tc.created, tc.idle, tc.inUse, got, tc.want)
|
||
}
|
||
}
|
||
}
|
||
|
||
// TestPoolGrowsOnDemandAndReclaims is the end-to-end elasticity loop: boot on
|
||
// demand, stay under the ceiling, then collapse back to the resident floor.
|
||
func TestPoolGrowsOnDemandAndReclaims(t *testing.T) {
|
||
vm := NewVM(freshAdapterDir(t))
|
||
if err := vm.Start(); err != nil {
|
||
t.Fatalf("start: %v", err)
|
||
}
|
||
defer vm.Stop()
|
||
vm.ConfigureConcurrency(map[string]int{"openai": 16})
|
||
p := poolOf(t, vm, "openai")
|
||
|
||
if created, _, _ := poolCounts(p); created != 0 {
|
||
t.Fatalf("pool must start empty, created=%d", created)
|
||
}
|
||
|
||
// concurrent load: hold several workers at once so the pool must grow
|
||
const hold = 6
|
||
var wg sync.WaitGroup
|
||
release := make(chan struct{})
|
||
for i := 0; i < hold; i++ {
|
||
wg.Add(1)
|
||
go func() {
|
||
defer wg.Done()
|
||
w, err := p.acquire()
|
||
if err != nil {
|
||
t.Errorf("acquire: %v", err)
|
||
return
|
||
}
|
||
<-release
|
||
p.release(w)
|
||
}()
|
||
}
|
||
// wait until all six are checked out
|
||
deadline := time.Now().Add(5 * time.Second)
|
||
for {
|
||
_, _, inUse := poolCounts(p)
|
||
if inUse >= hold {
|
||
break
|
||
}
|
||
if time.Now().After(deadline) {
|
||
t.Fatalf("workers never checked out, in_use=%d", inUse)
|
||
}
|
||
time.Sleep(5 * time.Millisecond)
|
||
}
|
||
created, _, inUse := poolCounts(p)
|
||
if inUse != hold {
|
||
t.Fatalf("in_use = %d, want %d", inUse, hold)
|
||
}
|
||
if created < hold {
|
||
t.Fatalf("created = %d, must cover %d concurrent checkouts", created, hold)
|
||
}
|
||
if created > 16 {
|
||
t.Fatalf("created = %d exceeds the ceiling 16", created)
|
||
}
|
||
close(release)
|
||
wg.Wait()
|
||
|
||
// all connections closed: the janitor collapses the pool to the floor.
|
||
// shrinkGraceRounds rounds are required, and one extra round proves the
|
||
// floor is stable rather than shrinking to zero.
|
||
for i := 0; i < shrinkGraceRounds+2; i++ {
|
||
vm.ReclaimIdleNow()
|
||
}
|
||
created, idle, inUse := poolCounts(p)
|
||
if inUse != 0 {
|
||
t.Fatalf("in_use = %d after release, want 0", inUse)
|
||
}
|
||
if created != residentWorkers || idle != residentWorkers {
|
||
t.Fatalf("after reclaim: created=%d idle=%d, want %d/%d (resident floor)",
|
||
created, idle, residentWorkers, residentWorkers)
|
||
}
|
||
}
|
||
|
||
// TestReclaimNeedsGraceRounds: a single quiet round must not tear the pool
|
||
// down — a gap between requests is not the end of a load period.
|
||
func TestReclaimNeedsGraceRounds(t *testing.T) {
|
||
vm := NewVM(freshAdapterDir(t))
|
||
if err := vm.Start(); err != nil {
|
||
t.Fatalf("start: %v", err)
|
||
}
|
||
defer vm.Stop()
|
||
vm.ConfigureConcurrency(map[string]int{"openai": 8})
|
||
p := poolOf(t, vm, "openai")
|
||
|
||
// build slack: 4 states created, all returned
|
||
var ws []*worker
|
||
for i := 0; i < 4; i++ {
|
||
w, err := p.acquire()
|
||
if err != nil {
|
||
t.Fatalf("acquire: %v", err)
|
||
}
|
||
ws = append(ws, w)
|
||
}
|
||
for _, w := range ws {
|
||
p.release(w)
|
||
}
|
||
created, _, _ := poolCounts(p)
|
||
if created != 4 {
|
||
t.Fatalf("created = %d, want 4", created)
|
||
}
|
||
|
||
if n := vm.ReclaimIdleNow(); n != 0 {
|
||
t.Fatalf("first quiet round must not reclaim (grace), closed %d", n)
|
||
}
|
||
if c, _, _ := poolCounts(p); c != 4 {
|
||
t.Fatalf("created = %d after the grace round, want 4", c)
|
||
}
|
||
if n := vm.ReclaimIdleNow(); n == 0 {
|
||
t.Fatal("second quiet round must reclaim")
|
||
}
|
||
}
|
||
|
||
// TestGrowthResetsGrace: growth (real contention) must cancel a pending shrink
|
||
// decision, but ordinary sequential traffic must NOT — otherwise a busy gateway
|
||
// that always has a request in flight would pin every state a past burst
|
||
// created, which is exactly the leak this change removes.
|
||
func TestGrowthResetsGrace(t *testing.T) {
|
||
vm := NewVM(freshAdapterDir(t))
|
||
if err := vm.Start(); err != nil {
|
||
t.Fatalf("start: %v", err)
|
||
}
|
||
defer vm.Stop()
|
||
vm.ConfigureConcurrency(map[string]int{"openai": 8})
|
||
p := poolOf(t, vm, "openai")
|
||
|
||
var ws []*worker
|
||
for i := 0; i < 4; i++ {
|
||
w, _ := p.acquire()
|
||
ws = append(ws, w)
|
||
}
|
||
for _, w := range ws {
|
||
p.release(w)
|
||
}
|
||
if n := vm.ReclaimIdleNow(); n != 0 {
|
||
t.Fatalf("grace round reclaimed %d", n)
|
||
}
|
||
|
||
// a lone sequential request reuses a warm state: no growth, so the pending
|
||
// shrink decision stands and the second round reclaims
|
||
w, _ := p.acquire()
|
||
p.release(w)
|
||
if n := vm.ReclaimIdleNow(); n == 0 {
|
||
t.Fatal("sequential traffic must not keep resetting the grace counter")
|
||
}
|
||
|
||
// now rebuild slack and prove that GROWTH does reset it
|
||
ws = ws[:0]
|
||
for i := 0; i < 4; i++ {
|
||
w, _ := p.acquire() // concurrent holds force created to grow
|
||
ws = append(ws, w)
|
||
}
|
||
for _, w := range ws {
|
||
p.release(w)
|
||
}
|
||
if n := vm.ReclaimIdleNow(); n != 0 {
|
||
t.Fatalf("growth must reset the grace counter, reclaimed %d", n)
|
||
}
|
||
}
|
||
|
||
// TestPoolCeilingIsRespectedUnderContention: acquires beyond the ceiling block
|
||
// instead of booting unbounded states.
|
||
func TestPoolCeilingIsRespectedUnderContention(t *testing.T) {
|
||
vm := NewVM(freshAdapterDir(t))
|
||
if err := vm.Start(); err != nil {
|
||
t.Fatalf("start: %v", err)
|
||
}
|
||
defer vm.Stop()
|
||
vm.ConfigureConcurrency(map[string]int{"openai": 2})
|
||
p := poolOf(t, vm, "openai")
|
||
|
||
w1, err := p.acquire()
|
||
if err != nil {
|
||
t.Fatalf("acquire 1: %v", err)
|
||
}
|
||
w2, err := p.acquire()
|
||
if err != nil {
|
||
t.Fatalf("acquire 2: %v", err)
|
||
}
|
||
got := make(chan struct{})
|
||
go func() {
|
||
w3, err := p.acquire()
|
||
if err == nil {
|
||
p.release(w3)
|
||
}
|
||
close(got)
|
||
}()
|
||
select {
|
||
case <-got:
|
||
t.Fatal("a third acquire must block at the ceiling of 2")
|
||
case <-time.After(100 * time.Millisecond):
|
||
}
|
||
if created, _, _ := poolCounts(p); created != 2 {
|
||
t.Fatalf("created = %d, must not exceed the ceiling 2", created)
|
||
}
|
||
p.release(w1)
|
||
select {
|
||
case <-got:
|
||
case <-time.After(2 * time.Second):
|
||
t.Fatal("releasing a state must unblock the waiter")
|
||
}
|
||
p.release(w2)
|
||
}
|
||
|
||
// TestLoweredCeilingReleasesStates: shrinking max_concurrent in the config must
|
||
// actually give memory back rather than leaving orphaned states parked.
|
||
func TestLoweredCeilingReleasesStates(t *testing.T) {
|
||
vm := NewVM(freshAdapterDir(t))
|
||
if err := vm.Start(); err != nil {
|
||
t.Fatalf("start: %v", err)
|
||
}
|
||
defer vm.Stop()
|
||
vm.ConfigureConcurrency(map[string]int{"openai": 8})
|
||
p := poolOf(t, vm, "openai")
|
||
|
||
var ws []*worker
|
||
for i := 0; i < 6; i++ {
|
||
w, err := p.acquire()
|
||
if err != nil {
|
||
t.Fatalf("acquire: %v", err)
|
||
}
|
||
ws = append(ws, w)
|
||
}
|
||
if created, _, _ := poolCounts(p); created != 6 {
|
||
t.Fatalf("created = %d, want 6", created)
|
||
}
|
||
// operator lowers the ceiling while the states are still checked out
|
||
vm.ConfigureConcurrency(map[string]int{"openai": 2})
|
||
for _, w := range ws {
|
||
p.release(w)
|
||
}
|
||
created, idle, _ := poolCounts(p)
|
||
if created > 2 || idle > 2 {
|
||
t.Fatalf("lowering the ceiling must drop the excess: created=%d idle=%d", created, idle)
|
||
}
|
||
}
|
||
|
||
// TestPoolStatsSurfacesAlgorithm checks the observability payload the status API
|
||
// exposes.
|
||
func TestPoolStatsSurfacesAlgorithm(t *testing.T) {
|
||
vm := NewVM(freshAdapterDir(t))
|
||
if err := vm.Start(); err != nil {
|
||
t.Fatalf("start: %v", err)
|
||
}
|
||
defer vm.Stop()
|
||
vm.ConfigureConcurrency(map[string]int{"openai": 32})
|
||
p := poolOf(t, vm, "openai")
|
||
w, err := p.acquire()
|
||
if err != nil {
|
||
t.Fatalf("acquire: %v", err)
|
||
}
|
||
|
||
var st PoolStats
|
||
for _, s := range vm.PoolStats() {
|
||
if s.Name == "openai" {
|
||
st = s
|
||
}
|
||
}
|
||
if st.Max != 32 {
|
||
t.Fatalf("Max = %d, want 32", st.Max)
|
||
}
|
||
if st.InUse != 1 || st.Created != 1 {
|
||
t.Fatalf("InUse=%d Created=%d, want 1/1", st.InUse, st.Created)
|
||
}
|
||
if st.GrowStep != 4 {
|
||
t.Fatalf("GrowStep = %d, want ceil(32/8)=4", st.GrowStep)
|
||
}
|
||
if st.PeakInUse != 1 {
|
||
t.Fatalf("PeakInUse = %d, want 1", st.PeakInUse)
|
||
}
|
||
p.release(w)
|
||
|
||
// stats must be sorted by name for a stable UI
|
||
names := []string{}
|
||
for _, s := range vm.PoolStats() {
|
||
names = append(names, s.Name)
|
||
}
|
||
for i := 1; i < len(names); i++ {
|
||
if names[i-1] > names[i] {
|
||
t.Fatalf("PoolStats not sorted: %v", names)
|
||
}
|
||
}
|
||
}
|
||
|
||
// TestHotReloadKeepsCeiling: replacing an adapter's code must not reset its
|
||
// elastic ceiling back to 1.
|
||
func TestHotReloadKeepsCeiling(t *testing.T) {
|
||
vm := NewVM(freshAdapterDir(t))
|
||
if err := vm.Start(); err != nil {
|
||
t.Fatalf("start: %v", err)
|
||
}
|
||
defer vm.Stop()
|
||
vm.ConfigureConcurrency(map[string]int{"openai": 24})
|
||
if err := vm.LoadAdapterSource("openai", "return {name='openai', version='9'}"); err != nil {
|
||
t.Fatalf("reload: %v", err)
|
||
}
|
||
p := poolOf(t, vm, "openai")
|
||
p.mu.Lock()
|
||
maxW := p.maxW
|
||
p.mu.Unlock()
|
||
if maxW != 24 {
|
||
t.Fatalf("ceiling after hot reload = %d, want 24", maxW)
|
||
}
|
||
}
|
||
|
||
// TestConcurrentTransformStress exercises the grow/shrink paths together under
|
||
// real hook calls, and asserts the accounting stays consistent (no leaked
|
||
// states, no negative counters).
|
||
func TestConcurrentTransformStress(t *testing.T) {
|
||
vm := NewVM(freshAdapterDir(t))
|
||
if err := vm.Start(); err != nil {
|
||
t.Fatalf("start: %v", err)
|
||
}
|
||
defer vm.Stop()
|
||
vm.ConfigureConcurrency(map[string]int{"openai": 16})
|
||
|
||
var wg sync.WaitGroup
|
||
for i := 0; i < 40; i++ {
|
||
wg.Add(1)
|
||
go func() {
|
||
defer wg.Done()
|
||
raw := `{"model":"m","messages":[{"role":"user","content":"hi"}]}`
|
||
if _, err := vm.Transform("openai", "transform_request", raw); err != nil {
|
||
t.Errorf("transform: %v", err)
|
||
}
|
||
}()
|
||
}
|
||
wg.Wait()
|
||
|
||
p := poolOf(t, vm, "openai")
|
||
created, idle, inUse := poolCounts(p)
|
||
if inUse != 0 {
|
||
t.Fatalf("in_use = %d after the stress run, want 0 (leaked checkout)", inUse)
|
||
}
|
||
if created != idle {
|
||
t.Fatalf("created=%d idle=%d must match when nothing is checked out", created, idle)
|
||
}
|
||
if created > 16 {
|
||
t.Fatalf("created = %d exceeds the ceiling", created)
|
||
}
|
||
for i := 0; i < shrinkGraceRounds+2; i++ {
|
||
vm.ReclaimIdleNow()
|
||
}
|
||
created, idle, _ = poolCounts(p)
|
||
if created != residentWorkers || idle != residentWorkers {
|
||
t.Fatalf("post-stress reclaim: created=%d idle=%d, want %d/%d",
|
||
created, idle, residentWorkers, residentWorkers)
|
||
}
|
||
}
|
||
|
||
// TestStopIsIdempotent guards the janitor's stop channel against a double close.
|
||
func TestStopIsIdempotent(t *testing.T) {
|
||
vm := NewVM(freshAdapterDir(t))
|
||
if err := vm.Start(); err != nil {
|
||
t.Fatalf("start: %v", err)
|
||
}
|
||
vm.Stop()
|
||
vm.Stop() // must not panic
|
||
}
|
||
|
||
// TestSequentialTrafficDoesNotBatch: a single caller looping must keep reusing
|
||
// one warm state — batch prewarm is for genuine concurrency only.
|
||
func TestSequentialTrafficDoesNotBatch(t *testing.T) {
|
||
vm := NewVM(freshAdapterDir(t))
|
||
if err := vm.Start(); err != nil {
|
||
t.Fatalf("start: %v", err)
|
||
}
|
||
defer vm.Stop()
|
||
vm.ConfigureConcurrency(map[string]int{"openai": 64}) // grow step would be 8
|
||
p := poolOf(t, vm, "openai")
|
||
for i := 0; i < 20; i++ {
|
||
w, err := p.acquire()
|
||
if err != nil {
|
||
t.Fatalf("acquire %d: %v", i, err)
|
||
}
|
||
p.release(w)
|
||
}
|
||
created, _, _ := poolCounts(p)
|
||
if created != 1 {
|
||
t.Fatalf("sequential traffic must reuse one state, created=%d", created)
|
||
}
|
||
}
|
||
|
||
// TestContentionBatchPrewarms: when callers are actually QUEUED behind a full
|
||
// pool, the pool warms extra states for them instead of booting one per request.
|
||
// The batch is bounded by the queue depth, not by the ceiling, so it can never
|
||
// warm states nobody is waiting for.
|
||
func TestContentionBatchPrewarms(t *testing.T) {
|
||
vm := NewVM(freshAdapterDir(t))
|
||
if err := vm.Start(); err != nil {
|
||
t.Fatalf("start: %v", err)
|
||
}
|
||
defer vm.Stop()
|
||
// ceiling 32 -> step cap 4; queue depth will be the real bound
|
||
vm.ConfigureConcurrency(map[string]int{"openai": 32})
|
||
p := poolOf(t, vm, "openai")
|
||
|
||
// Fill the pool to its ceiling-independent state: hold 1, then queue 3 more
|
||
// so waiting == 3 when the next miss happens.
|
||
p.mu.Lock()
|
||
p.maxW = 1 // force the next acquires to queue
|
||
p.mu.Unlock()
|
||
w1, err := p.acquire()
|
||
if err != nil {
|
||
t.Fatalf("acquire 1: %v", err)
|
||
}
|
||
done := make(chan *worker, 3)
|
||
for i := 0; i < 3; i++ {
|
||
go func() {
|
||
w, err := p.acquire()
|
||
if err != nil {
|
||
done <- nil
|
||
return
|
||
}
|
||
done <- w
|
||
}()
|
||
}
|
||
// wait until all three are queued
|
||
deadline := time.Now().Add(5 * time.Second)
|
||
for {
|
||
p.mu.Lock()
|
||
w := p.waiting
|
||
p.mu.Unlock()
|
||
if w >= 3 {
|
||
break
|
||
}
|
||
if time.Now().After(deadline) {
|
||
t.Fatalf("waiters never queued, waiting=%d", w)
|
||
}
|
||
time.Sleep(5 * time.Millisecond)
|
||
}
|
||
|
||
// raise the ceiling: the next miss sees waiting=3 and prewarms a batch
|
||
p.setMax(32)
|
||
got := make([]*worker, 0, 3)
|
||
for i := 0; i < 3; i++ {
|
||
select {
|
||
case w := <-done:
|
||
if w == nil {
|
||
t.Fatal("a queued acquire failed")
|
||
}
|
||
got = append(got, w)
|
||
case <-time.After(5 * time.Second):
|
||
t.Fatal("queued acquires never completed after the ceiling was raised")
|
||
}
|
||
}
|
||
created, _, _ := poolCounts(p)
|
||
if created < 4 {
|
||
t.Fatalf("queued demand must be satisfied, created=%d want >=4", created)
|
||
}
|
||
if created > 32 {
|
||
t.Fatalf("prewarm exceeded the ceiling, created=%d", created)
|
||
}
|
||
p.release(w1)
|
||
for _, w := range got {
|
||
p.release(w)
|
||
}
|
||
}
|
||
|
||
// TestNoPrewarmWithoutWaiters is the production regression this bound fixes: two
|
||
// concurrent requests against a wide adapter (ceiling 76, step 8) must NOT warm
|
||
// eight states. Warming for nobody meant the janitor discarded the surplus a
|
||
// minute later, so RSS oscillated between ~46 MB and ~56 MB forever.
|
||
func TestNoPrewarmWithoutWaiters(t *testing.T) {
|
||
vm := NewVM(freshAdapterDir(t))
|
||
if err := vm.Start(); err != nil {
|
||
t.Fatalf("start: %v", err)
|
||
}
|
||
defer vm.Stop()
|
||
vm.ConfigureConcurrency(map[string]int{"openai": 76})
|
||
p := poolOf(t, vm, "openai")
|
||
|
||
// two overlapping requests: the second misses while the first holds its
|
||
// state, but nobody is blocked, so no batch may be warmed
|
||
w1, err := p.acquire()
|
||
if err != nil {
|
||
t.Fatalf("acquire 1: %v", err)
|
||
}
|
||
w2, err := p.acquire()
|
||
if err != nil {
|
||
t.Fatalf("acquire 2: %v", err)
|
||
}
|
||
time.Sleep(100 * time.Millisecond) // give any background prewarm a chance
|
||
created, _, _ := poolCounts(p)
|
||
if created != 2 {
|
||
t.Fatalf("two overlapping requests must create exactly 2 states, got %d", created)
|
||
}
|
||
p.release(w1)
|
||
p.release(w2)
|
||
}
|
||
|
||
// TestBurstLeftoverIsReclaimedUnderSteadyTraffic reproduces what production
|
||
// showed right after the first deploy: a burst grew the openai pool to 9 states,
|
||
// then steady low-concurrency traffic kept arriving and the pool never shrank,
|
||
// because any checkout reset the shrink grace counter. Slack must be reclaimed
|
||
// even while the gateway keeps serving requests one at a time.
|
||
func TestBurstLeftoverIsReclaimedUnderSteadyTraffic(t *testing.T) {
|
||
vm := NewVM(freshAdapterDir(t))
|
||
if err := vm.Start(); err != nil {
|
||
t.Fatalf("start: %v", err)
|
||
}
|
||
defer vm.Stop()
|
||
vm.ConfigureConcurrency(map[string]int{"openai": 32})
|
||
p := poolOf(t, vm, "openai")
|
||
|
||
// burst: 9 concurrent holds
|
||
var ws []*worker
|
||
for i := 0; i < 9; i++ {
|
||
w, err := p.acquire()
|
||
if err != nil {
|
||
t.Fatalf("acquire: %v", err)
|
||
}
|
||
ws = append(ws, w)
|
||
}
|
||
for _, w := range ws {
|
||
p.release(w)
|
||
}
|
||
if created, _, _ := poolCounts(p); created < 9 {
|
||
t.Fatalf("burst should have grown the pool, created=%d", created)
|
||
}
|
||
|
||
// steady state: one request between every janitor round, forever
|
||
for round := 0; round < 8; round++ {
|
||
w, err := p.acquire()
|
||
if err != nil {
|
||
t.Fatalf("round %d acquire: %v", round, err)
|
||
}
|
||
p.release(w)
|
||
vm.ReclaimIdleNow()
|
||
}
|
||
created, idle, inUse := poolCounts(p)
|
||
if inUse != 0 {
|
||
t.Fatalf("in_use = %d, want 0", inUse)
|
||
}
|
||
if created > residentWorkers+idleHeadroom {
|
||
t.Fatalf("burst leftovers were never reclaimed under steady traffic: created=%d idle=%d",
|
||
created, idle)
|
||
}
|
||
}
|
||
|
||
// TestNonStreamToolCallsPreserved is the regression for the bug that killed
|
||
// tool-using conversations on their SECOND request: several adapters handled
|
||
// tool_calls in transform_stream_chunk but dropped them in
|
||
// transform_response. A client then received finish_reason:"tool_calls" with no
|
||
// tool_calls payload, replayed an assistant message whose function
|
||
// name/arguments were empty, and the upstream rejected the next turn with
|
||
//
|
||
// 400 invalid tool_call function, function/name/arguments cannot be empty
|
||
//
|
||
// Every OpenAI-shaped adapter must forward non-streaming tool calls.
|
||
func TestNonStreamToolCallsPreserved(t *testing.T) {
|
||
vm := NewVM(freshAdapterDir(t))
|
||
if err := vm.Start(); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
defer vm.Stop()
|
||
|
||
// upstream shape: arguments is a JSON *string*, as OpenAI sends it
|
||
body := `{"choices":[{"index":0,"message":{"role":"assistant","content":"",` +
|
||
`"tool_calls":[{"index":0,"id":"call_abc","type":"function",` +
|
||
`"function":{"name":"get_weather","arguments":"{\"city\":\"Beijing\"}"}}]},` +
|
||
`"finish_reason":"tool_calls"}],` +
|
||
`"usage":{"prompt_tokens":10,"completion_tokens":5,"total_tokens":15}}`
|
||
|
||
for _, name := range []string{
|
||
"openai", "sensenova", "trae", "deepseek", "github",
|
||
"groq", "kimicode", "mistral", "opencode", "agentrouter",
|
||
} {
|
||
out, err := vm.Transform(name, "transform_response", body)
|
||
if err != nil {
|
||
t.Fatalf("%s transform_response: %v", name, err)
|
||
}
|
||
var got struct {
|
||
FinishReason string `json:"finish_reason"`
|
||
ToolCalls []struct {
|
||
ID string `json:"id"`
|
||
Type string `json:"type"`
|
||
Name string `json:"name"`
|
||
Arguments map[string]interface{} `json:"arguments"`
|
||
} `json:"tool_calls"`
|
||
}
|
||
if err := json.Unmarshal([]byte(out), &got); err != nil {
|
||
t.Fatalf("%s: unmarshal %v (%s)", name, err, out)
|
||
}
|
||
if len(got.ToolCalls) != 1 {
|
||
t.Fatalf("%s: dropped non-streaming tool_calls (client would replay an empty function): %s", name, out)
|
||
}
|
||
tc := got.ToolCalls[0]
|
||
if tc.Name != "get_weather" {
|
||
t.Errorf("%s: tool name lost: %s", name, out)
|
||
}
|
||
if tc.ID != "call_abc" {
|
||
t.Errorf("%s: tool id lost: %s", name, out)
|
||
}
|
||
// arguments must be decoded into an object, not left as a string
|
||
if tc.Arguments == nil || tc.Arguments["city"] != "Beijing" {
|
||
t.Errorf("%s: arguments not decoded: %s", name, out)
|
||
}
|
||
if got.FinishReason != "tool_calls" {
|
||
t.Errorf("%s: finish_reason lost: %s", name, out)
|
||
}
|
||
}
|
||
}
|
||
|
||
// TestGeminiNonStreamToolCalls covers Gemini's native shape (functionCall parts
|
||
// under candidates[].content.parts). The streaming path handled these; the
|
||
// non-streaming path silently returned text only.
|
||
func TestGeminiNonStreamToolCalls(t *testing.T) {
|
||
vm := NewVM(freshAdapterDir(t))
|
||
if err := vm.Start(); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
defer vm.Stop()
|
||
|
||
body := `{"candidates":[{"content":{"parts":[` +
|
||
`{"text":"checking"},` +
|
||
`{"functionCall":{"name":"get_weather","args":{"city":"Beijing"}}}` +
|
||
`]},"finishReason":"STOP"}],` +
|
||
`"usageMetadata":{"promptTokenCount":8,"candidatesTokenCount":4,"totalTokenCount":12}}`
|
||
|
||
out, err := vm.Transform("gemini", "transform_response", body)
|
||
if err != nil {
|
||
t.Fatalf("gemini transform_response: %v", err)
|
||
}
|
||
var got struct {
|
||
Content string `json:"content"`
|
||
FinishReason string `json:"finish_reason"`
|
||
ToolCalls []struct {
|
||
Name string `json:"name"`
|
||
Arguments map[string]interface{} `json:"arguments"`
|
||
} `json:"tool_calls"`
|
||
}
|
||
if err := json.Unmarshal([]byte(out), &got); err != nil {
|
||
t.Fatalf("unmarshal: %v (%s)", err, out)
|
||
}
|
||
if len(got.ToolCalls) != 1 || got.ToolCalls[0].Name != "get_weather" {
|
||
t.Fatalf("gemini dropped non-streaming functionCall: %s", out)
|
||
}
|
||
if got.ToolCalls[0].Arguments["city"] != "Beijing" {
|
||
t.Errorf("gemini args lost: %s", out)
|
||
}
|
||
// a tool call must not be reported as a plain stop
|
||
if got.FinishReason != "tool_calls" {
|
||
t.Errorf("gemini finish_reason should become tool_calls: %s", out)
|
||
}
|
||
}
|
||
|
||
// TestOllamaNonStreamToolCalls covers Ollama's non-streaming shape
|
||
// (message.tool_calls with an already-decoded arguments object). The adapter
|
||
// initialized tool_calls to an empty table and never filled it.
|
||
func TestOllamaNonStreamToolCalls(t *testing.T) {
|
||
vm := NewVM(freshAdapterDir(t))
|
||
if err := vm.Start(); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
defer vm.Stop()
|
||
|
||
body := `{"message":{"role":"assistant","content":"",` +
|
||
`"tool_calls":[{"function":{"name":"get_weather","arguments":{"city":"Beijing"}}}]},` +
|
||
`"done_reason":"stop","prompt_eval_count":7,"eval_count":3}`
|
||
|
||
out, err := vm.Transform("ollama", "transform_response", body)
|
||
if err != nil {
|
||
t.Fatalf("ollama transform_response: %v", err)
|
||
}
|
||
var got struct {
|
||
FinishReason string `json:"finish_reason"`
|
||
ToolCalls []struct {
|
||
Name string `json:"name"`
|
||
Arguments map[string]interface{} `json:"arguments"`
|
||
} `json:"tool_calls"`
|
||
}
|
||
if err := json.Unmarshal([]byte(out), &got); err != nil {
|
||
t.Fatalf("unmarshal: %v (%s)", err, out)
|
||
}
|
||
if len(got.ToolCalls) != 1 || got.ToolCalls[0].Name != "get_weather" {
|
||
t.Fatalf("ollama dropped non-streaming tool_calls: %s", out)
|
||
}
|
||
if got.ToolCalls[0].Arguments["city"] != "Beijing" {
|
||
t.Errorf("ollama args lost: %s", out)
|
||
}
|
||
if got.FinishReason != "tool_calls" {
|
||
t.Errorf("ollama finish_reason should become tool_calls: %s", out)
|
||
}
|
||
}
|
||
|
||
// TestTraeTextToolCallRecovery covers the trae-specific failure: its upstream
|
||
// (trae-local-api's OpenAI endpoint) never reads the request's `tools` array, so
|
||
// the relayed model prints a <tool_call> block as TEXT, leaves
|
||
// message.tool_calls null and reports finish_reason:"stop". An OpenAI client
|
||
// then sees an ordinary completion and its agent loop ends mid-conversation.
|
||
// The adapter must recover the structured call, strip the block from content,
|
||
// and correct finish_reason.
|
||
func TestTraeTextToolCallRecovery(t *testing.T) {
|
||
vm := NewVM(freshAdapterDir(t))
|
||
if err := vm.Start(); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
defer vm.Stop()
|
||
|
||
cases := []struct {
|
||
name string
|
||
body string
|
||
}{
|
||
{
|
||
"tool_call tag with arguments",
|
||
`{"choices":[{"message":{"role":"assistant","content":"<tool_call>\n{\"name\": \"get_weather\", \"arguments\": {\"city\": \"Beijing\"}}\n</tool_call>"},"finish_reason":"stop"}]}`,
|
||
},
|
||
{
|
||
// the same codebase's Anthropic endpoint prompts for <toolcall> and "params"
|
||
"toolcall tag with params",
|
||
`{"choices":[{"message":{"role":"assistant","content":"<toolcall>{\"name\": \"get_weather\", \"params\": {\"city\": \"Beijing\"}}</toolcall>"},"finish_reason":"stop"}]}`,
|
||
},
|
||
{
|
||
"prose around the block is preserved",
|
||
`{"choices":[{"message":{"role":"assistant","content":"Let me check.\n<tool_call>{\"name\":\"get_weather\",\"arguments\":{\"city\":\"Beijing\"}}</tool_call>"},"finish_reason":"stop"}]}`,
|
||
},
|
||
}
|
||
|
||
for _, c := range cases {
|
||
out, err := vm.Transform("trae", "transform_response", c.body)
|
||
if err != nil {
|
||
t.Fatalf("%s: transform: %v", c.name, err)
|
||
}
|
||
var got struct {
|
||
Content string `json:"content"`
|
||
FinishReason string `json:"finish_reason"`
|
||
ToolCalls []struct {
|
||
Name string `json:"name"`
|
||
Arguments map[string]interface{} `json:"arguments"`
|
||
} `json:"tool_calls"`
|
||
}
|
||
if err := json.Unmarshal([]byte(out), &got); err != nil {
|
||
t.Fatalf("%s: unmarshal %v (%s)", c.name, err, out)
|
||
}
|
||
if len(got.ToolCalls) != 1 {
|
||
t.Fatalf("%s: text tool call not recovered: %s", c.name, out)
|
||
}
|
||
if got.ToolCalls[0].Name != "get_weather" {
|
||
t.Errorf("%s: name wrong: %s", c.name, out)
|
||
}
|
||
if got.ToolCalls[0].Arguments["city"] != "Beijing" {
|
||
t.Errorf("%s: args wrong: %s", c.name, out)
|
||
}
|
||
if got.FinishReason != "tool_calls" {
|
||
t.Errorf("%s: finish_reason must be corrected to tool_calls: %s", c.name, out)
|
||
}
|
||
if strings.Contains(got.Content, "<tool_call") || strings.Contains(got.Content, "<toolcall") {
|
||
t.Errorf("%s: raw block left in user-visible content: %s", c.name, out)
|
||
}
|
||
}
|
||
|
||
// a plain text answer must be untouched
|
||
plain := `{"choices":[{"message":{"role":"assistant","content":"just text"},"finish_reason":"stop"}]}`
|
||
out, err := vm.Transform("trae", "transform_response", plain)
|
||
if err != nil {
|
||
t.Fatalf("plain: %v", err)
|
||
}
|
||
if strings.Contains(out, "tool_calls") {
|
||
t.Errorf("plain answer must not gain tool_calls: %s", out)
|
||
}
|
||
if !strings.Contains(out, `"finish_reason":"stop"`) {
|
||
t.Errorf("plain answer finish_reason changed: %s", out)
|
||
}
|
||
}
|