ModelRouter/internal/lua/toolcall_preservation_test.go

package lua

import (
	"encoding/json"
	"strings"
	"testing"
)

// TestAdaptersPreserveToolCalls is the fleet-wide guard for the
// "orphaned tool result" class of bug: when an agent client replays a turn
// whose assistant message carries tool_calls, EVERY adapter must forward both
// the call and the attribution of its result. Dropping the call (or the
// tool_call_id / tool_name that ties the result to it) makes the model see a
// result for a call it never made and re-issue the same call forever.
//
// The input deliberately uses content:[] — the shape most agent clients emit
// for a tool-calling assistant turn with no text.
func TestAdaptersPreserveToolCalls(t *testing.T) {
	vm := NewVM(freshAdapterDir(t))
	if err := vm.Start(); err != nil {
		t.Fatal(err)
	}
	defer vm.Stop()

	body := `{"model":"m","messages":[
		{"role":"user","content":"read /tmp/x"},
		{"role":"assistant","content":[],"tool_calls":[{"id":"call_abc","type":"function","function":{"name":"read","arguments":"{\"path\":\"/tmp/x\"}"}}]},
		{"role":"tool","tool_call_id":"call_abc","content":"hello world"},
		{"role":"user","content":"summarize"}
	]}`
	const (
		callID   = "call_abc"
		fnName   = "read"
		toolOut  = "hello world"
		lastUser = "summarize"
	)

	// Adapters that identify a tool result by the call id.
	byID := []string{"openai", "deepseek", "github", "groq", "kimicode", "mistral",
		"sensenova", "trae", "agentrouter", "opencode", "anthropic"}

	for _, a := range byID {
		out, err := vm.Transform(a, "transform_request", body)
		if err != nil {
			t.Errorf("%s: transform_request: %v", a, err)
			continue
		}
		if !strings.Contains(out, callID) {
			t.Errorf("%s dropped the tool call id %q: %s", a, callID, out)
		}
		if !strings.Contains(out, fnName) {
			t.Errorf("%s dropped the function name %q: %s", a, fnName, out)
		}
		if !strings.Contains(out, toolOut) {
			t.Errorf("%s dropped the tool result: %s", a, out)
		}
		if !strings.Contains(out, lastUser) {
			t.Errorf("%s dropped the final user turn: %s", a, out)
		}
	}

	// Ollama identifies the result with tool_name (its API has no tool_call_id
	// on assistant turns) and takes arguments as an object, not a JSON string.
	out, err := vm.Transform("ollama", "transform_request", body)
	if err != nil {
		t.Fatalf("ollama: %v", err)
	}
	for _, want := range []string{`"tool_calls"`, fnName, `"tool_name"`, toolOut} {
		if !strings.Contains(out, want) {
			t.Errorf("ollama missing %s: %s", want, out)
		}
	}

	// Gemini identifies the result by function NAME and has no call id in its
	// wire format; both directions must be present as functionCall /
	// functionResponse parts, and the system role must move to
	// systemInstruction rather than sitting in contents.
	gBody := `{"model":"m","messages":[
		{"role":"system","content":"be brief"},
		{"role":"user","content":"read /tmp/x"},
		{"role":"assistant","content":[],"tool_calls":[{"id":"call_abc","type":"function","function":{"name":"read","arguments":"{\"path\":\"/tmp/x\"}"}}]},
		{"role":"tool","tool_call_id":"call_abc","content":"hello world"}
	]}`
	gout, err := vm.Transform("gemini", "transform_request", gBody)
	if err != nil {
		t.Fatalf("gemini: %v", err)
	}
	for _, want := range []string{`"functionCall"`, `"functionResponse"`, fnName, toolOut, `"systemInstruction"`} {
		if !strings.Contains(gout, want) {
			t.Errorf("gemini missing %s: %s", want, gout)
		}
	}
	// No message may keep the OpenAI-only roles inside contents.
	var greq struct {
		Contents []struct {
			Role string `json:"role"`
		} `json:"contents"`
	}
	if err := json.Unmarshal([]byte(gout), &greq); err != nil {
		t.Fatalf("gemini unmarshal: %v (%s)", err, gout)
	}
	for _, c := range greq.Contents {
		if c.Role != "user" && c.Role != "model" {
			t.Errorf("gemini contents carry an invalid role %q: %s", c.Role, gout)
		}
	}

	// Negative control: a text-only turn must still be forwarded verbatim.
	plain := `{"model":"m","messages":[{"role":"user","content":"just text"}]}`
	for _, a := range append(byID, "ollama", "gemini") {
		pout, err := vm.Transform(a, "transform_request", plain)
		if err != nil {
			t.Errorf("%s plain: %v", a, err)
			continue
		}
		if !strings.Contains(pout, "just text") {
			t.Errorf("%s dropped plain text: %s", a, pout)
		}
	}
}