@agentgazer/proxy 0.3.4 → 0.3.6

package/dist/__tests__/proxy-server.test.js

@@ -1198,5 +1198,473 @@ function waitForServer(port, maxAttempts = 20) {
         // No authorization header should be injected for non-provider hostname
         (0, vitest_1.expect)(providerServer.receivedRequests[0].headers["authorization"]).toBeUndefined();
     });
+    // -----------------------------------------------------------------------
+    // Cross-Provider Override Tests
+    // -----------------------------------------------------------------------
+    // Helper: Create a test database with proper schema matching the production DB
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    function createTestDb(agentId) {
+        const Database = require("better-sqlite3");
+        const db = new Database(":memory:");
+        db.exec(`
+      CREATE TABLE agents (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL UNIQUE,
+        name TEXT,
+        active INTEGER NOT NULL DEFAULT 1,
+        deactivated_by TEXT,
+        budget_limit REAL,
+        allowed_hours_start INTEGER,
+        allowed_hours_end INTEGER,
+        kill_switch_enabled INTEGER NOT NULL DEFAULT 0,
+        kill_switch_window_size INTEGER NOT NULL DEFAULT 20,
+        kill_switch_threshold REAL NOT NULL DEFAULT 10.0,
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+      CREATE TABLE agent_model_rules (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        provider TEXT NOT NULL,
+        model_override TEXT,
+        target_provider TEXT,
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+        UNIQUE(agent_id, provider)
+      );
+      CREATE TABLE agent_rate_limits (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        provider TEXT NOT NULL,
+        max_requests INTEGER NOT NULL,
+        window_seconds INTEGER NOT NULL
+      );
+      CREATE TABLE provider_settings (
+        provider TEXT PRIMARY KEY,
+        active INTEGER DEFAULT 1,
+        rate_limit_max_requests INTEGER,
+        rate_limit_window_seconds INTEGER
+      );
+    `);
+        db.prepare("INSERT INTO agents (id, agent_id, name) VALUES (?, ?, ?)").run(`id-${agentId}`, agentId, "Test Agent");
+        return db;
+    }
+    (0, vitest_1.describe)("Cross-Provider Override", () => {
+        (0, vitest_1.it)("converts OpenAI request to Anthropic format when override is configured", async () => {
+            // Create mock Anthropic server that expects Anthropic-format requests
+            const anthropicServer = await new Promise((resolve) => {
+                const receivedRequests = [];
+                const server = http.createServer((req, res) => {
+                    const chunks = [];
+                    req.on("data", (chunk) => chunks.push(chunk));
+                    req.on("end", () => {
+                        receivedRequests.push({
+                            headers: req.headers,
+                            body: Buffer.concat(chunks).toString("utf-8"),
+                        });
+                        // Return Anthropic-format response
+                        const response = {
+                            id: "msg_cross_provider",
+                            type: "message",
+                            role: "assistant",
+                            content: [{ type: "text", text: "Hello from Anthropic!" }],
+                            model: "claude-sonnet-4-20250514",
+                            stop_reason: "end_turn",
+                            usage: { input_tokens: 50, output_tokens: 20 },
+                        };
+                        const payload = JSON.stringify(response);
+                        res.writeHead(200, {
+                            "Content-Type": "application/json",
+                            "Content-Length": Buffer.byteLength(payload).toString(),
+                        });
+                        res.end(payload);
+                    });
+                });
+                server.listen(0, "127.0.0.1", () => {
+                    const addr = server.address();
+                    resolve({ server, port: addr.port, receivedRequests });
+                });
+            });
+            ingestServer = await createMockIngestServer();
+            // Mock fetch to redirect Anthropic API calls to our mock server
+            const originalFetch = global.fetch;
+            vitest_1.vi.spyOn(global, "fetch").mockImplementation(async (input, init) => {
+                const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+                if (url.includes("api.anthropic.com")) {
+                    const redirectUrl = url.replace(/https:\/\/api\.anthropic\.com/, `http://127.0.0.1:${anthropicServer.port}`);
+                    return originalFetch(redirectUrl, init);
+                }
+                return originalFetch(input, init);
+            });
+            // Create mock DB with model override rule - use unique agent ID to avoid cache issues
+            const agentId = `test-agent-openai-to-anthropic-${Date.now()}`;
+            const db = createTestDb(agentId);
+            db.prepare("INSERT INTO agent_model_rules (id, agent_id, provider, model_override, target_provider) VALUES (?, ?, ?, ?, ?)").run("rule-1", agentId, "openai", "claude-sonnet-4-20250514", "anthropic");
+            proxy = (0, proxy_server_js_1.startProxy)({
+                port: 0,
+                apiKey: "test-api-key",
+                agentId: agentId,
+                endpoint: ingestServer.url,
+                flushInterval: 60_000,
+                maxBufferSize: 1,
+                providerKeys: {
+                    openai: "sk-openai-key",
+                    anthropic: "sk-ant-key",
+                },
+                db,
+            });
+            const proxyPort = proxy.server.address().port;
+            await waitForServer(proxyPort);
+            // Send OpenAI-format request to OpenAI endpoint
+            const res = await httpRequest({
+                hostname: "127.0.0.1",
+                port: proxyPort,
+                path: `/agents/${agentId}/openai/v1/chat/completions`,
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    model: "gpt-4o",
+                    messages: [
+                        { role: "system", content: "You are helpful." },
+                        { role: "user", content: "Hello" },
+                    ],
+                    max_tokens: 100,
+                }),
+            });
+            // Response should be converted back to OpenAI format
+            (0, vitest_1.expect)(res.status).toBe(200);
+            const responseBody = JSON.parse(res.body);
+            (0, vitest_1.expect)(responseBody.object).toBe("chat.completion");
+            (0, vitest_1.expect)(responseBody.choices[0].message.content).toBe("Hello from Anthropic!");
+            (0, vitest_1.expect)(responseBody.usage.prompt_tokens).toBe(50);
+            (0, vitest_1.expect)(responseBody.usage.completion_tokens).toBe(20);
+            // Verify the request was converted to Anthropic format
+            (0, vitest_1.expect)(anthropicServer.receivedRequests).toHaveLength(1);
+            const sentRequest = JSON.parse(anthropicServer.receivedRequests[0].body);
+            (0, vitest_1.expect)(sentRequest.model).toBe("claude-sonnet-4-20250514");
+            (0, vitest_1.expect)(sentRequest.system).toBe("You are helpful."); // System extracted to top-level
+            (0, vitest_1.expect)(sentRequest.messages).toHaveLength(1);
+            (0, vitest_1.expect)(sentRequest.messages[0].role).toBe("user");
+            (0, vitest_1.expect)(sentRequest.max_tokens).toBe(100);
+            // Verify Anthropic auth header was used
+            (0, vitest_1.expect)(anthropicServer.receivedRequests[0].headers["x-api-key"]).toBe("sk-ant-key");
+            vitest_1.vi.restoreAllMocks();
+            await closeServer(anthropicServer.server);
+            db.close();
+        });
+        (0, vitest_1.it)("converts Anthropic request to OpenAI format when override is configured", async () => {
+            providerServer = await createMockProviderServer();
+            ingestServer = await createMockIngestServer();
+            // Mock fetch to redirect OpenAI API calls to our mock server
+            const originalFetch = global.fetch;
+            vitest_1.vi.spyOn(global, "fetch").mockImplementation(async (input, init) => {
+                const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+                if (url.includes("api.openai.com")) {
+                    const redirectUrl = url.replace(/https:\/\/api\.openai\.com/, providerServer.url);
+                    return originalFetch(redirectUrl, init);
+                }
+                return originalFetch(input, init);
+            });
+            // Create mock DB with unique agent ID
+            const agentId = `test-agent-anthropic-to-openai-${Date.now()}`;
+            const db = createTestDb(agentId);
+            db.prepare("INSERT INTO agent_model_rules (id, agent_id, provider, model_override, target_provider) VALUES (?, ?, ?, ?, ?)").run("rule-1", agentId, "anthropic", "gpt-4o", "openai");
+            proxy = (0, proxy_server_js_1.startProxy)({
+                port: 0,
+                apiKey: "test-api-key",
+                agentId: agentId,
+                endpoint: ingestServer.url,
+                flushInterval: 60_000,
+                maxBufferSize: 1,
+                providerKeys: {
+                    openai: "sk-openai-key",
+                    anthropic: "sk-ant-key",
+                },
+                db,
+            });
+            const proxyPort = proxy.server.address().port;
+            await waitForServer(proxyPort);
+            // Send Anthropic-format request to Anthropic endpoint
+            const res = await httpRequest({
+                hostname: "127.0.0.1",
+                port: proxyPort,
+                path: `/agents/${agentId}/anthropic/v1/messages`,
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    model: "claude-sonnet-4-20250514",
+                    system: "You are helpful.",
+                    messages: [{ role: "user", content: "Hello" }],
+                    max_tokens: 100,
+                }),
+            });
+            // Response should be converted back to Anthropic format
+            (0, vitest_1.expect)(res.status).toBe(200);
+            const responseBody = JSON.parse(res.body);
+            (0, vitest_1.expect)(responseBody.type).toBe("message");
+            (0, vitest_1.expect)(responseBody.content[0].type).toBe("text");
+            // Verify the request was converted to OpenAI format
+            (0, vitest_1.expect)(providerServer.receivedRequests).toHaveLength(1);
+            const sentRequest = JSON.parse(providerServer.receivedRequests[0].body);
+            (0, vitest_1.expect)(sentRequest.model).toBe("gpt-4o");
+            (0, vitest_1.expect)(sentRequest.messages).toHaveLength(2);
+            (0, vitest_1.expect)(sentRequest.messages[0].role).toBe("system");
+            (0, vitest_1.expect)(sentRequest.messages[0].content).toBe("You are helpful.");
+            (0, vitest_1.expect)(sentRequest.messages[1].role).toBe("user");
+            // Verify OpenAI auth header was used
+            (0, vitest_1.expect)(providerServer.receivedRequests[0].headers["authorization"]).toBe("Bearer sk-openai-key");
+            vitest_1.vi.restoreAllMocks();
+            db.close();
+        });
+        (0, vitest_1.it)("triggers cross-provider override even when request body has no model field", async () => {
+            // This tests the fix for Google → Anthropic override where Google requests
+            // don't have model in the body (model is in URL path)
+            // Create mock Anthropic server
+            const anthropicServer = await new Promise((resolve) => {
+                const receivedRequests = [];
+                const server = http.createServer((req, res) => {
+                    const chunks = [];
+                    req.on("data", (chunk) => chunks.push(chunk));
+                    req.on("end", () => {
+                        receivedRequests.push({
+                            body: Buffer.concat(chunks).toString("utf-8"),
+                        });
+                        const response = {
+                            id: "msg_123",
+                            type: "message",
+                            role: "assistant",
+                            content: [{ type: "text", text: "Hello!" }],
+                            model: "claude-sonnet-4-20250514",
+                            stop_reason: "end_turn",
+                            usage: { input_tokens: 10, output_tokens: 5 },
+                        };
+                        const payload = JSON.stringify(response);
+                        res.writeHead(200, {
+                            "Content-Type": "application/json",
+                            "Content-Length": Buffer.byteLength(payload).toString(),
+                        });
+                        res.end(payload);
+                    });
+                });
+                server.listen(0, "127.0.0.1", () => {
+                    const addr = server.address();
+                    resolve({ server, port: addr.port, receivedRequests });
+                });
+            });
+            ingestServer = await createMockIngestServer();
+            // Mock fetch
+            const originalFetch = global.fetch;
+            vitest_1.vi.spyOn(global, "fetch").mockImplementation(async (input, init) => {
+                const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+                if (url.includes("api.anthropic.com")) {
+                    const redirectUrl = url.replace(/https:\/\/api\.anthropic\.com/, `http://127.0.0.1:${anthropicServer.port}`);
+                    return originalFetch(redirectUrl, init);
+                }
+                return originalFetch(input, init);
+            });
+            // Create mock DB with unique agent ID
+            const agentId = `test-agent-google-no-model-${Date.now()}`;
+            const db = createTestDb(agentId);
+            db.prepare("INSERT INTO agent_model_rules (id, agent_id, provider, model_override, target_provider) VALUES (?, ?, ?, ?, ?)").run("rule-1", agentId, "google", "claude-sonnet-4-20250514", "anthropic");
+            proxy = (0, proxy_server_js_1.startProxy)({
+                port: 0,
+                apiKey: "test-api-key",
+                agentId: agentId,
+                endpoint: ingestServer.url,
+                flushInterval: 60_000,
+                maxBufferSize: 1,
+                providerKeys: {
+                    google: "google-api-key",
+                    anthropic: "sk-ant-key",
+                },
+                db,
+            });
+            const proxyPort = proxy.server.address().port;
+            await waitForServer(proxyPort);
+            // Send request to Google endpoint WITHOUT model in body
+            const res = await httpRequest({
+                hostname: "127.0.0.1",
+                port: proxyPort,
+                path: `/agents/${agentId}/google/v1/chat/completions`,
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    // No model field! This is the key test case
+                    messages: [{ role: "user", content: "Hello" }],
+                    max_tokens: 100,
+                }),
+            });
+            // Should have been redirected to Anthropic
+            (0, vitest_1.expect)(res.status).toBe(200);
+            (0, vitest_1.expect)(anthropicServer.receivedRequests).toHaveLength(1);
+            // Verify the override model was applied
+            const sentRequest = JSON.parse(anthropicServer.receivedRequests[0].body);
+            (0, vitest_1.expect)(sentRequest.model).toBe("claude-sonnet-4-20250514");
+            vitest_1.vi.restoreAllMocks();
+            await closeServer(anthropicServer.server);
+            db.close();
+        });
+        (0, vitest_1.it)("does not apply cross-provider override when no rule exists", async () => {
+            providerServer = await createMockProviderServer();
+            ingestServer = await createMockIngestServer();
+            // Mock fetch
+            const originalFetch = global.fetch;
+            vitest_1.vi.spyOn(global, "fetch").mockImplementation(async (input, init) => {
+                const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+                if (url.includes("api.openai.com")) {
+                    const redirectUrl = url.replace(/https:\/\/api\.openai\.com/, providerServer.url);
+                    return originalFetch(redirectUrl, init);
+                }
+                return originalFetch(input, init);
+            });
+            // Create mock DB with unique agent ID but NO model rules
+            const agentId = `test-agent-no-rules-${Date.now()}`;
+            const db = createTestDb(agentId);
+            // No model rules inserted
+            proxy = (0, proxy_server_js_1.startProxy)({
+                port: 0,
+                apiKey: "test-api-key",
+                agentId: agentId,
+                endpoint: ingestServer.url,
+                flushInterval: 60_000,
+                maxBufferSize: 1,
+                providerKeys: {
+                    openai: "sk-openai-key",
+                },
+                db,
+            });
+            const proxyPort = proxy.server.address().port;
+            await waitForServer(proxyPort);
+            // Send request - should go directly to OpenAI without conversion
+            const res = await httpRequest({
+                hostname: "127.0.0.1",
+                port: proxyPort,
+                path: `/agents/${agentId}/openai/v1/chat/completions`,
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    model: "gpt-4o",
+                    messages: [{ role: "user", content: "Hello" }],
+                }),
+            });
+            (0, vitest_1.expect)(res.status).toBe(200);
+            // Request should have been forwarded as-is (OpenAI format)
+            (0, vitest_1.expect)(providerServer.receivedRequests).toHaveLength(1);
+            const sentRequest = JSON.parse(providerServer.receivedRequests[0].body);
+            (0, vitest_1.expect)(sentRequest.model).toBe("gpt-4o");
+            (0, vitest_1.expect)(sentRequest.messages[0].role).toBe("user");
+            vitest_1.vi.restoreAllMocks();
+            db.close();
+        });
+        (0, vitest_1.it)("returns error when cross-provider override target has no API key", async () => {
+            ingestServer = await createMockIngestServer();
+            // Create mock DB with unique agent ID
+            const agentId = `test-agent-no-key-${Date.now()}`;
+            const db = createTestDb(agentId);
+            db.prepare("INSERT INTO agent_model_rules (id, agent_id, provider, model_override, target_provider) VALUES (?, ?, ?, ?, ?)").run("rule-1", agentId, "openai", "claude-sonnet-4-20250514", "anthropic");
+            proxy = (0, proxy_server_js_1.startProxy)({
+                port: 0,
+                apiKey: "test-api-key",
+                agentId: agentId,
+                endpoint: ingestServer.url,
+                flushInterval: 60_000,
+                maxBufferSize: 1,
+                providerKeys: {
+                    openai: "sk-openai-key",
+                    // No anthropic key!
+                },
+                db,
+            });
+            const proxyPort = proxy.server.address().port;
+            await waitForServer(proxyPort);
+            const res = await httpRequest({
+                hostname: "127.0.0.1",
+                port: proxyPort,
+                path: `/agents/${agentId}/openai/v1/chat/completions`,
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    model: "gpt-4o",
+                    messages: [{ role: "user", content: "Hello" }],
+                }),
+            });
+            (0, vitest_1.expect)(res.status).toBe(400);
+            const body = JSON.parse(res.body);
+            (0, vitest_1.expect)(body.error).toContain("no API key for anthropic");
+            db.close();
+        });
+        (0, vitest_1.it)("same-provider override works (model change without cross-provider)", async () => {
+            ingestServer = await createMockIngestServer();
+            // Create mock DB with same-provider override (target_provider is NULL)
+            const agentId = `test-agent-same-provider-${Date.now()}`;
+            const db = createTestDb(agentId);
+            db.prepare("INSERT INTO agent_model_rules (id, agent_id, provider, model_override, target_provider) VALUES (?, ?, ?, ?, ?)").run("rule-1", agentId, "openai", "gpt-4o-mini", null // same provider, different model
+            );
+            // Mock fetch - verify same-provider override by checking the response
+            const originalFetch = global.fetch;
+            vitest_1.vi.spyOn(global, "fetch").mockImplementation(async (input, init) => {
+                const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+                if (url.includes("api.openai.com")) {
+                    // Echo back the model from the request body to verify override
+                    let reqModel = "unknown";
+                    if (init?.body) {
+                        const bodyText = typeof init.body === "string" ? init.body : await new Response(init.body).text();
+                        const parsed = JSON.parse(bodyText);
+                        reqModel = parsed.model;
+                    }
+                    return new Response(JSON.stringify({
+                        id: "chatcmpl-123",
+                        object: "chat.completion",
+                        model: reqModel, // Echo the model we received
+                        choices: [{ index: 0, message: { role: "assistant", content: "Hello!" }, finish_reason: "stop" }],
+                        usage: { prompt_tokens: 10, completion_tokens: 5, total_tokens: 15 },
+                    }), {
+                        status: 200,
+                        headers: { "Content-Type": "application/json" },
+                    });
+                }
+                return originalFetch(input, init);
+            });
+            proxy = (0, proxy_server_js_1.startProxy)({
+                port: 0,
+                apiKey: "test-api-key",
+                agentId: agentId,
+                endpoint: ingestServer.url,
+                flushInterval: 60_000,
+                maxBufferSize: 1,
+                providerKeys: { openai: "sk-openai-key" },
+                db,
+            });
+            const proxyPort = proxy.server.address().port;
+            await waitForServer(proxyPort);
+            const res = await httpRequest({
+                hostname: "127.0.0.1",
+                port: proxyPort,
+                path: `/agents/${agentId}/openai/v1/chat/completions`,
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    model: "gpt-4o", // Original model
+                    messages: [{ role: "user", content: "Hello" }],
+                }),
+            });
+            (0, vitest_1.expect)(res.status).toBe(200);
+            const response = JSON.parse(res.body);
+            // The mock echoes the model it received - should be the overridden model
+            (0, vitest_1.expect)(response.model).toBe("gpt-4o-mini");
+            vitest_1.vi.restoreAllMocks();
+            db.close();
+        });
+    });
 });
 //# sourceMappingURL=proxy-server.test.js.map