Skip to content

Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.

8.6 KB
Raw Blame
package gateway

import (
	"encoding/json"
	"io"
	"net/http"
	"net/http/httptest"
	"os"
	"path/filepath"
	"strings"
	"testing"
	"time"

	"github.com/yetone/magpie/internal/provider"
	"github.com/yetone/magpie/internal/sessions"
	"github.com/yetone/magpie/internal/settings"
	"github.com/yetone/magpie/internal/usage"
)

func TestGatewayConversationCapture(t *testing.T) {
	fresh(t)
	serveOn(t, "fake", "k", []string{"m1"}, archiveVendor{})
	s := New()
	post := func(id string) {
		r := httptest.NewRequest("POST", "/v1/chat/completions", strings.NewReader(`{"model":"fake/m1","messages":[{"role":"user","content":"hello"}]}`))
		r.Header.Set("User-Agent", "claude-cli/2.1.0")
		r.Header.Set("X-Magpie-Session", id)
		w := httptest.NewRecorder()
		s.Handler().ServeHTTP(w, r)
		if w.Code != 200 || !strings.Contains(w.Body.String(), "done") {
			t.Fatalf("relay changed: %d %s", w.Code, w.Body)
		}
	}
	post("s")
	agent := usage.AgentOf("claude-cli/2.1.0")
	tr, err := sessions.GatewayTranscript(agent, "s")
	if err != nil || tr.Captured != 0 {
		t.Fatalf("default must be off: %+v %v", tr, err)
	}
	if err := sessions.SetGatewayRecording(true, false); err != nil {
		t.Fatal(err)
	}
	post("s")
	post("")
	tr, err = sessions.GatewayTranscript(agent, "s")
	if err != nil || tr.Captured != 1 || len(tr.Parts) != 2 || tr.Parts[0].Text != "hello" || tr.Parts[1].Text != "done" {
		t.Fatalf("captured: %+v %v", tr, err)
	}
}

func TestGatewayConversationCodexDirectRelay(t *testing.T) {
	fresh(t)
	chatgpt(t, func(w http.ResponseWriter, r *http.Request) {
		if r.Header.Get(SessionHeader) != "" {
			t.Error("gateway identity leaked to vendor")
		}
		w.Header().Set("Content-Type", "text/event-stream")
		io.WriteString(w, sse(`data: {"type":"response.completed","response":{"id":"r1","status":"completed","output":[{"type":"message","role":"assistant","content":[{"type":"output_text","text":"direct answer"}]}],"usage":{"input_tokens":9,"output_tokens":2}}}`))
	})
	if err := sessions.SetGatewayRecording(true, false); err != nil {
		t.Fatal(err)
	}
	r := httptest.NewRequest("POST", CodexPath+"/responses", strings.NewReader(`{"model":"gpt-5.5","stream":true,"input":"direct question"}`))
	r.Header.Set("Authorization", "Bearer chatgpt-token")
	r.Header.Set("User-Agent", "codex/1")
	r.Header.Set("session_id", "codex-thread")
	w := httptest.NewRecorder()
	New().Handler().ServeHTTP(w, r)
	id := w.Header().Get(SessionHeader)
	tr, err := sessions.GatewayTranscript("codex", id)
	if w.Code != 200 || err != nil || tr.Captured != 1 || len(tr.Parts) != 2 || tr.Parts[1].Text != "direct answer" {
		t.Fatalf("direct relay missing from Sessions: status=%d id=%q transcript=%+v error=%v", w.Code, id, tr, err)
	}
	if id != "codex-thread" {
		t.Fatalf("recorded direct relay should expose Codex's session, got %q", id)
	}
}

// Text is recorded only under a session the client named, so every recorded
// conversation is one the Sessions page lists and can open. A request with no
// session is not recorded at all, and magpie makes up no id for it (#1355).
func TestGatewayConversationNeedsTheClientsSession(t *testing.T) {
	fresh(t)
	serveOn(t, "fake", "k", []string{"m1"}, archiveVendor{})
	_, secrets := newCaller(t, "NAS client")
	server := lanGuard(New().Handler())
	post := func(header, id string) *httptest.ResponseRecorder {
		r := httptest.NewRequest("POST", "/v1/chat/completions", strings.NewReader(`{"model":"fake/m1","messages":[{"role":"user","content":"hello"}]}`))
		r.RemoteAddr = "192.168.1.19:12345"
		r.Header.Set("Authorization", "Bearer "+secrets[0])
		r.Header.Set("User-Agent", "review-client/1")
		if header != "" {
			r.Header.Set(header, id)
		}
		w := httptest.NewRecorder()
		server.ServeHTTP(w, r)
		if w.Code != http.StatusOK || !strings.Contains(w.Body.String(), "done") {
			t.Fatalf("relay changed: %d %s", w.Code, w.Body)
		}
		return w
	}
	if err := sessions.SetGatewayRecording(true, false); err != nil {
		t.Fatal(err)
	}
	if got := post("", "").Header().Get(SessionHeader); got != "" {
		t.Fatalf("a request with no session was given %q", got)
	}
	if entries, err := os.ReadDir(filepath.Join(settings.Dir(), "gateway-conversations")); len(entries) != 0 {
		t.Fatalf("a request with no session was recorded where no Sessions row can open it: %v %v", entries, err)
	}
	if got := post("session_id", "native-session").Header().Get(SessionHeader); got != "native-session" {
		t.Fatalf("native identity replaced: %q", got)
	}
	for range 2 {
		if got := post(SessionHeader, "s1").Header().Get(SessionHeader); got != "s1" {
			t.Fatalf("session continuity lost: %q", got)
		}
	}
	tr, err := sessions.GatewayTranscript("review-client", "s1")
	if err != nil || tr.Captured != 2 || len(tr.Parts) != 4 {
		t.Fatalf("named session content missing: %+v %v", tr, err)
	}
	if _, ok := usage.GatewaySessionByID("review-client", "s1", nil); !ok {
		t.Fatal("a recorded session has no Sessions row to open it from")
	}
}

// A session id is the client's own, whatever it starts with: one named
// "request-…" is listed, counted and readable like any other (#1355).
func TestGatewayConversationClientRequestPrefixedSession(t *testing.T) {
	fresh(t)
	serveOn(t, "fake", "k", []string{"m1"}, archiveVendor{})
	if err := sessions.SetGatewayRecording(true, false); err != nil {
		t.Fatal(err)
	}
	const id = "request-7f3a"
	s := New()
	for range 2 {
		r := httptest.NewRequest("POST", "/v1/chat/completions", strings.NewReader(`{"model":"fake/m1","messages":[{"role":"user","content":"hello"}]}`))
		r.Header.Set("User-Agent", "review-client/1")
		r.Header.Set(SessionHeader, id)
		w := httptest.NewRecorder()
		s.Handler().ServeHTTP(w, r)
		if w.Code != http.StatusOK {
			t.Fatalf("relay changed: %d %s", w.Code, w.Body)
		}
	}
	calls := 0
	usage.Visit(time.Time{}, func(r usage.Record) {
		if r.Session == id {
			calls++
		}
	})
	if calls != 2 {
		t.Fatalf("the ledger kept %d of 2 calls under the client's session %q", calls, id)
	}
	g, ok := usage.GatewaySessionByID("review-client", id, nil)
	if !ok || g.ID != id {
		t.Fatalf("the client's session %q is missing from Sessions: %+v", id, g)
	}
	if tr, err := sessions.GatewayTranscript("review-client", id); err != nil || tr.Captured != 2 {
		t.Fatalf("the client's session text is missing: %+v %v", tr, err)
	}
}

func TestGatewayConversationProtocols(t *testing.T) {
	for _, tc := range []struct {
		name                string
		proto               provider.Protocol
		input, output, want string
	}{
		{"chat", provider.Chat, `{"messages":[{"role":"system","content":"rules"},{"role":"user","content":"hello"}]}`, `{"choices":[{"message":{"role":"assistant","content":"answer"}}]}`, "answer"},
		{"anthropic", provider.Anthropic, `{"messages":[{"role":"user","content":"hello"}]}`, `{"content":[{"type":"text","text":"answer"}]}`, "answer"},
		{"responses", provider.Responses, `{"input":"hello"}`, `{"output":[{"type":"message","role":"assistant","content":[{"type":"output_text","text":"answer"}]}]}`, "answer"},
		{"chat-stream", provider.Chat, `{"messages":[]}`, "data: {\"choices\":[{\"delta\":{\"content\":\"ans\"}}]}\n\ndata: {\"choices\":[{\"delta\":{\"content\":\"wer\"},\"finish_reason\":\"stop\"}]}\n\ndata: [DONE]\n\n", "answer"},
		{"anthropic-tool", provider.Anthropic, `{"messages":[]}`, "data: {\"type\":\"content_block_start\",\"index\":0,\"content_block\":{\"type\":\"tool_use\",\"id\":\"t\",\"name\":\"bash\",\"input\":{}}}\n\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"input_json_delta\",\"partial_json\":\"{\\\"command\\\":\\\"pwd\\\"}\"}}\n\ndata: {\"type\":\"message_delta\",\"delta\":{\"stop_reason\":\"tool_use\"}}\n\n", "pwd"},
		{"responses-custom", provider.Responses, `{"input":[]}`, "data: {\"type\":\"response.output_item.done\",\"item\":{\"type\":\"custom_tool_call\",\"call_id\":\"t\",\"name\":\"apply_patch\",\"input\":\"patch body\"}}\n\ndata: {\"type\":\"response.completed\",\"response\":{\"status\":\"completed\",\"output\":[]}}\n\n", "patch body"},
	} {
		t.Run(tc.name, func(t *testing.T) {
			turn := conversationTurn(tc.proto, []byte(tc.input), []byte(tc.output))
			b, _ := json.Marshal(turn.Output)
			if turn.Cut || !strings.Contains(string(b), tc.want) {
				t.Fatalf("parsed: %+v", turn)
			}
		})
	}
}

func TestGatewayConversationScrubsAndMarksIncomplete(t *testing.T) {
	turn := conversationTurn(provider.Chat, []byte(`{"messages":[{"role":"assistant","tool_calls":[{"id":"t","type":"function","function":{"name":"login","arguments":"{\"password\":\"private-value\"}"}}]}]}`), []byte("data: {\"choices\":[{\"delta\":{\"content\":\"partial\"}}]}\n\n"))
	b, _ := json.Marshal(turn)
	if !turn.Cut || strings.Contains(string(b), "private-value") || !strings.Contains(string(b), "partial") {
		t.Fatalf("scrub or incomplete failed: %s", b)
	}
}