/** * Integration tests — end-to-end proxy tests with mock upstream. */ import { describe, it, expect, beforeAll, afterAll } from "bun:test"; import { mkdtempSync, rmSync, writeFileSync } from "node:fs"; import { tmpdir } from "node:os"; import { join } from "node:path"; import { loadConfig } from "./config/loader.js"; import { AuthManager } from "./auth/manager.js"; import { startServer, type ProxyServer } from "./server/server.js"; let proxyServer: ProxyServer; let mockUpstreamServer: ReturnType; let proxyPort: number; let mockPort: number; let capturedUpstreamBodies: string[] = []; function findFreePort(): number { return 18000 + Math.floor(Math.random() * 1000); } // The former config.test.yaml fixture (removed in f6aa147) inlined as a temp // file so the suite stays self-contained. let configDir: string; function writeTestConfig(): string { configDir = mkdtempSync(join(tmpdir(), "zcode-int-")); const yaml = [ "server:", ' port: 19090', ' host: "127.0.0.1"', "auth:", ' proxyApiKey: "test-proxy-key"', "provider: zai", "defaultModel: glm-4.6", "models:", " - glm-4.6", "logging:", " level: info", "", ].join("\n"); const path = join(configDir, "config.test.yaml"); writeFileSync(path, yaml); return path; } beforeAll(async () => { mockPort = findFreePort(); proxyPort = findFreePort(); mockUpstreamServer = Bun.serve({ port: mockPort, hostname: "127.0.0.1", async fetch(req) { const url = new URL(req.url); const rawBody = await req.text(); let parsed: { stream?: boolean; model?: string } = {}; try { parsed = JSON.parse(rawBody); } catch {} if (url.pathname.includes("/v1/messages")) { capturedUpstreamBodies.push(rawBody); let hasToolResult = false; let hasToolsDefined = false; try { const parsedAny = JSON.parse(rawBody) as { messages?: Array<{ content?: unknown }>; tools?: unknown[]; }; hasToolResult = (parsedAny.messages ?? []).some( (m) => Array.isArray(m.content) && m.content.some((b: any) => b?.type === "tool_result"), ); hasToolsDefined = (parsedAny.tools?.length ?? 0) > 0; } catch {} if (hasToolResult) { return new Response(JSON.stringify({ id: "msg_after_tool", type: "message", role: "assistant", content: [{ type: "text", text: "Tool result acknowledged" }], model: "glm-4.6", stop_reason: "end_turn", stop_sequence: null, usage: { input_tokens: 25, output_tokens: 4 }, }), { status: 200, headers: { "content-type": "application/json" } }); } if (hasToolsDefined && !parsed.stream) { return new Response(JSON.stringify({ id: "msg_tool_call", type: "message", role: "assistant", content: [ { type: "text", text: "Calling tool." }, { type: "tool_use", id: "toolu_http_1", name: "get_weather", input: { city: "SF" } }, ], model: "glm-4.6", stop_reason: "tool_use", stop_sequence: null, usage: { input_tokens: 15, output_tokens: 12 }, }), { status: 200, headers: { "content-type": "application/json" } }); } if (parsed.stream) { const sse = [ 'event: message_start\ndata: {"type":"message_start","message":{"id":"msg_int","model":"glm-4.6","usage":{"input_tokens":33,"output_tokens":1}}}\n\n', 'event: content_block_delta\ndata: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"Integration stream"}}\n\n', 'event: message_delta\ndata: {"type":"message_delta","delta":{"stop_reason":"end_turn"},"usage":{"output_tokens":4}}\n\n', 'event: message_stop\ndata: {"type":"message_stop"}\n\n', ].join(""); return new Response(sse, { status: 200, headers: { "content-type": "text/event-stream" } }); } return new Response(JSON.stringify({ id: "msg_int_test", type: "message", role: "assistant", content: [{ type: "text", text: "Integration test response" }], model: "glm-4.6", stop_reason: "end_turn", stop_sequence: null, usage: { input_tokens: 10, output_tokens: 8 }, }), { status: 200, headers: { "content-type": "application/json" } }); } if (url.pathname.includes("/chat/completions")) { capturedUpstreamBodies.push(rawBody); let hasToolResult = false; let hasToolsDefined = false; try { const parsedAny = JSON.parse(rawBody) as { messages?: Array<{ role?: string }>; tools?: unknown[]; }; hasToolResult = (parsedAny.messages ?? []).some((m) => m.role === "tool"); hasToolsDefined = (parsedAny.tools?.length ?? 0) > 0; } catch {} if (hasToolResult) { return new Response(JSON.stringify({ id: "chatcmpl-after-tool", object: "chat.completion", created: Date.now(), model: "glm-4.6", choices: [{ index: 0, message: { role: "assistant", content: "Tool result acknowledged" }, finish_reason: "stop", }], usage: { prompt_tokens: 25, completion_tokens: 4, total_tokens: 29 }, }), { status: 200, headers: { "content-type": "application/json" } }); } if (hasToolsDefined && !parsed.stream) { return new Response(JSON.stringify({ id: "chatcmpl-tool-call", object: "chat.completion", created: Date.now(), model: "glm-4.6", choices: [{ index: 0, message: { role: "assistant", content: "Calling tool.", tool_calls: [{ id: "call_http_1", type: "function", function: { name: "get_weather", arguments: "{\"city\":\"SF\"}" }, }], }, finish_reason: "tool_calls", }], usage: { prompt_tokens: 15, completion_tokens: 12, total_tokens: 27 }, }), { status: 200, headers: { "content-type": "application/json" } }); } if (parsed.stream) { const sse = [ 'data: {"id":"chatcmpl-int-stream","object":"chat.completion.chunk","created":1,"model":"glm-4.6","choices":[{"index":0,"delta":{"role":"assistant"},"finish_reason":null}]}', '', 'data: {"id":"chatcmpl-int-stream","object":"chat.completion.chunk","created":1,"model":"glm-4.6","choices":[{"index":0,"delta":{"content":"Integration stream"},"finish_reason":null}]}', '', 'data: {"id":"chatcmpl-int-stream","object":"chat.completion.chunk","created":1,"model":"glm-4.6","choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}', '', 'data: {"id":"chatcmpl-int-stream","object":"chat.completion.chunk","created":1,"model":"glm-4.6","choices":[],"usage":{"prompt_tokens":33,"completion_tokens":4,"total_tokens":37}}', '', 'data: [DONE]', '', ].join("\n"); return new Response(sse, { status: 200, headers: { "content-type": "text/event-stream" } }); } return new Response(JSON.stringify({ id: "chatcmpl-int-test", object: "chat.completion", created: Date.now(), model: "glm-4.6", choices: [{ index: 0, message: { role: "assistant", content: "OpenAI integration response" }, finish_reason: "stop", }], usage: { prompt_tokens: 12, completion_tokens: 6, total_tokens: 18 }, }), { status: 200, headers: { "content-type": "application/json" } }); } return new Response("not found", { status: 404 }); }, }); const config = loadConfig(writeTestConfig()); config.server.port = proxyPort; config.server.host = "127.0.0.1"; config.auth.proxyApiKey = "integration-test-key"; config.providers.zai.anthropicBase = `http://127.0.0.1:${mockPort}/anthropic`; config.providers.zai.openaiBase = `http://127.0.0.1:${mockPort}/coding`; const auth = new AuthManager(); auth.setOAuthCredential({ apiKey: "integrationTestKey", secret: "integrationTestSecret", provider: "zai" }); proxyServer = await startServer({ config, auth }); }); afterAll(() => { // Use stop(false) (not stop(true)) — stop(true) calls process.exit(0) which // terminates test discovery early and masks failures in other test files. proxyServer?.stop(false); mockUpstreamServer?.stop(false); if (configDir) rmSync(configDir, { recursive: true, force: true }); }); function proxyUrl(path: string): string { return `http://127.0.0.1:${proxyPort}${path}`; } function authHeader(): Record { return { "Authorization": "Bearer integration-test-key", "Content-Type": "application/json" }; } describe("integration: OpenAI clients (translated Anthropic upstream)", () => { it("POST /v1/chat/completions returns 200 with a translated OpenAI response", async () => { const resp = await fetch(proxyUrl("/v1/chat/completions"), { method: "POST", headers: authHeader(), body: JSON.stringify({ model: "glm-4.6", messages: [{ role: "user", content: "Hello" }], }), }); expect(resp.status).toBe(200); const body = await resp.json(); expect(body.object).toBe("chat.completion"); expect(body.choices[0].message.content).toBe("Integration test response"); expect(body.model).toBe("glm-4.6"); }); it("gzips the translated response when the client advertises gzip", async () => { const resp = await fetch(proxyUrl("/v1/chat/completions"), { method: "POST", headers: { ...authHeader(), "accept-encoding": "gzip" }, body: JSON.stringify({ model: "glm-4.6", messages: [{ role: "user", content: "Hi" }] }), }); expect(resp.status).toBe(200); expect(resp.headers.get("content-encoding")).toBe("gzip"); const body = await resp.json(); expect(body.object).toBe("chat.completion"); expect(body.choices[0].message.content).toBe("Integration test response"); }); }); describe("integration: OpenAI streaming passthrough", () => { it("passes OpenAI-compatible SSE chunks through", async () => { const resp = await fetch(proxyUrl("/v1/chat/completions"), { method: "POST", headers: authHeader(), body: JSON.stringify({ model: "glm-4.6", messages: [{ role: "user", content: "Stream test" }], stream: true, }), }); expect(resp.status).toBe(200); expect(resp.headers.get("content-type")).toBe("text/event-stream"); const text = await resp.text(); expect(text).toContain("chat.completion.chunk"); expect(text).toContain("Integration stream"); expect(text).toContain("data: [DONE]"); }); }); describe("integration: Anthropic streaming usage", () => { it("passes upstream usage through verbatim (input_tokens on message_start)", async () => { const resp = await fetch(proxyUrl("/v1/messages"), { method: "POST", headers: authHeader(), body: JSON.stringify({ model: "glm-4.6", max_tokens: 100, stream: true, messages: [{ role: "user", content: "Stream test" }], }), }); expect(resp.status).toBe(200); const text = await resp.text(); // passthrough: the upstream's message_start usage (input_tokens 33) and // message_delta usage (output_tokens 4) must arrive unmodified const startLine = text.split("\n").find((l) => l.startsWith("data: ") && l.includes('"message_start"')); expect(startLine).toBeDefined(); const start = JSON.parse(startLine!.slice(6)); expect(start.message.usage.input_tokens).toBe(33); const deltaLine = text.split("\n").find((l) => l.startsWith("data: ") && l.includes('"message_delta"')); expect(deltaLine).toBeDefined(); const delta = JSON.parse(deltaLine!.slice(6)); expect(delta.usage.output_tokens).toBe(4); expect(text).toContain("event: message_stop"); }); }); describe("integration: OpenAI tool-call roundtrip (HTTP layer)", () => { it("returns OpenAI tool_calls on turn 1, accepts tool results on turn 2, upstream receives Anthropic shape", async () => { const tools = [{ type: "function", function: { name: "get_weather", parameters: { type: "object", properties: { city: { type: "string" } } } } }]; const resp1 = await fetch(proxyUrl("/v1/chat/completions"), { method: "POST", headers: authHeader(), body: JSON.stringify({ model: "glm-4.6", messages: [{ role: "user", content: "weather in SF?" }], tools, tool_choice: "auto", }), }); expect(resp1.status).toBe(200); const body1 = await resp1.json(); expect(body1.choices[0].finish_reason).toBe("tool_calls"); const toolCall = body1.choices[0].message.tool_calls?.[0]; expect(toolCall).toBeDefined(); expect(toolCall.id).toBe("toolu_http_1"); expect(toolCall.function.name).toBe("get_weather"); expect(JSON.parse(toolCall.function.arguments)).toEqual({ city: "SF" }); const resp2 = await fetch(proxyUrl("/v1/chat/completions"), { method: "POST", headers: authHeader(), body: JSON.stringify({ model: "glm-4.6", messages: [ { role: "user", content: "weather in SF?" }, { role: "assistant", content: null, tool_calls: [toolCall] }, { role: "tool", tool_call_id: toolCall.id, content: "62°F" }, ], tools, }), }); expect(resp2.status).toBe(200); const body2 = await resp2.json(); expect(body2.choices[0].finish_reason).toBe("stop"); expect(body2.choices[0].message.content).toBe("Tool result acknowledged"); const toolResultBody = capturedUpstreamBodies .map((b) => JSON.parse(b)) .filter((b) => (b.messages ?? []).some( (m: any) => Array.isArray(m.content) && m.content.some((blk: any) => blk?.type === "tool_result" && blk?.tool_use_id === "toolu_http_1"), )); expect(toolResultBody.length).toBeGreaterThanOrEqual(1); const upstreamReq = toolResultBody.at(-1); expect(upstreamReq.messages).toHaveLength(3); expect(upstreamReq.messages[0].role).toBe("user"); expect(upstreamReq.messages[1].role).toBe("assistant"); expect(upstreamReq.messages[1].content.some((b: any) => b.type === "tool_use" && b.id === "toolu_http_1")).toBeTrue(); expect(upstreamReq.messages[2].content.some((b: any) => b.type === "tool_result" && b.content === "62°F")).toBeTrue(); expect(upstreamReq.tools).toHaveLength(1); expect(upstreamReq.tools[0].name).toBe("get_weather"); }); }); describe("integration: Anthropic clients (native passthrough)", () => { it("POST /v1/messages returns 200 with the upstream Anthropic response verbatim", async () => { const resp = await fetch(proxyUrl("/v1/messages"), { method: "POST", headers: authHeader(), body: JSON.stringify({ model: "glm-4.6", max_tokens: 100, messages: [{ role: "user", content: "Hello" }], }), }); expect(resp.status).toBe(200); const body = await resp.json(); expect(body.content[0].text).toBe("Integration test response"); expect(body.stop_reason).toBe("end_turn"); }); it("round-trips Anthropic tool_use → tool_result with the native shape upstream", async () => { const tools = [{ name: "get_weather", description: "Get weather", input_schema: { type: "object", properties: { city: { type: "string" } } } }]; // Turn 1: Anthropic client asks for a tool call. const resp1 = await fetch(proxyUrl("/v1/messages"), { method: "POST", headers: authHeader(), body: JSON.stringify({ model: "glm-4.6", max_tokens: 100, messages: [{ role: "user", content: "weather in SF?" }], tools, tool_choice: { type: "auto" }, }), }); expect(resp1.status).toBe(200); const body1 = await resp1.json(); expect(body1.stop_reason).toBe("tool_use"); const toolUse = body1.content.find((b: any) => b.type === "tool_use"); expect(toolUse).toBeDefined(); expect(toolUse.name).toBe("get_weather"); expect(toolUse.input).toEqual({ city: "SF" }); // Turn 2: Anthropic client replays tool_result history; the upstream must // see the native Anthropic shape (assistant tool_use + user tool_result). const resp2 = await fetch(proxyUrl("/v1/messages"), { method: "POST", headers: authHeader(), body: JSON.stringify({ model: "glm-4.6", max_tokens: 100, messages: [ { role: "user", content: "weather in SF?" }, { role: "assistant", content: [toolUse] }, { role: "user", content: [{ type: "tool_result", tool_use_id: toolUse.id, content: "62°F" }] }, ], tools, }), }); expect(resp2.status).toBe(200); const body2 = await resp2.json(); expect(body2.stop_reason).toBe("end_turn"); expect(body2.content[0].text).toBe("Tool result acknowledged"); const upstreamReq = capturedUpstreamBodies .map((b) => JSON.parse(b)) .filter((b) => (b.messages ?? []).some( (m: any) => Array.isArray(m.content) && m.content.some((blk: any) => blk?.type === "tool_result" && blk?.tool_use_id === toolUse.id), )) .at(-1); expect(upstreamReq).toBeDefined(); expect(upstreamReq.messages.map((m: any) => m.role)).toEqual(["user", "assistant", "user"]); expect(upstreamReq.messages[1].content.some((b: any) => b.type === "tool_use" && b.name === "get_weather")).toBeTrue(); expect(upstreamReq.messages[2].content.some((b: any) => b.type === "tool_result" && b.content === "62°F")).toBeTrue(); expect(upstreamReq.tools[0].name).toBe("get_weather"); }); }); describe("integration: Models endpoint", () => { it("GET /v1/models returns model list", async () => { const resp = await fetch(proxyUrl("/v1/models"), { headers: { Authorization: "Bearer integration-test-key" }, }); expect(resp.status).toBe(200); const body = await resp.json(); expect(body.object).toBe("list"); expect(body.data.length).toBeGreaterThan(0); }); }); describe("integration: Auth", () => { it("rejects request without proxy key", async () => { const resp = await fetch(proxyUrl("/v1/models")); expect(resp.status).toBe(401); }); it("rejects request with wrong proxy key", async () => { const resp = await fetch(proxyUrl("/v1/models"), { headers: { Authorization: "Bearer wrong-key" }, }); expect(resp.status).toBe(401); }); }); describe("integration: Health", () => { it("GET /health returns ok", async () => { const resp = await fetch(proxyUrl("/health"), { headers: { Authorization: "Bearer integration-test-key" }, }); expect(resp.status).toBe(200); const body = await resp.json(); expect(body.status).toBe("ok"); }); }); describe("integration: Error handling", () => { it("unknown route returns 404", async () => { const resp = await fetch(proxyUrl("/unknown"), { headers: { Authorization: "Bearer integration-test-key" }, }); expect(resp.status).toBe(404); }); it("CORS preflight returns 204", async () => { const resp = await fetch(proxyUrl("/v1/models"), { method: "OPTIONS" }); expect(resp.status).toBe(204); expect(resp.headers.get("access-control-allow-origin")).toBe("*"); }); });