@agentgazer/proxy 0.2.0 → 0.3.0

package/dist/proxy-server.js

@@ -60,6 +60,7 @@ function getModelOverride(db, agentId, provider) {
 const log = (0, shared_1.createLogger)("proxy");
 const event_buffer_js_1 = require("./event-buffer.js");
 const rate_limiter_js_1 = require("./rate-limiter.js");
+const loop_detector_js_1 = require("./loop-detector.js");
 const DEFAULT_PORT = 4000;
 const DEFAULT_ENDPOINT = "https://ingest.agentgazer.com/v1/events";
 const DEFAULT_FLUSH_INTERVAL = 5000;
@@ -68,6 +69,8 @@ const MAX_REQUEST_BODY_SIZE = 10 * 1024 * 1024; // 10 MB
 const MAX_SSE_BUFFER_SIZE = 50 * 1024 * 1024; // 50 MB
 const UPSTREAM_TIMEOUT_MS = 120_000; // 2 minutes
 const RATE_LIMIT_REFRESH_INTERVAL_MS = 30_000; // 30 seconds
+const PROVIDER_KEYS_REFRESH_INTERVAL_MS = 10_000; // 10 seconds
+const PROVIDER_SERVICE = "com.agentgazer.provider";
 function readRequestBody(req) {
     return new Promise((resolve, reject) => {
         const chunks = [];
@@ -95,6 +98,111 @@ function sendJson(res, statusCode, body) {
     res.end(payload);
 }
 // ---------------------------------------------------------------------------
+// Request body normalization — remove/transform unsupported fields per provider
+// ---------------------------------------------------------------------------
+/**
+ * Normalize request body for provider compatibility.
+ * Some providers don't support all OpenAI fields.
+ * Returns the modified body and a list of changes made.
+ */
+function normalizeRequestBody(provider, body, log) {
+    const result = { ...body };
+    let modified = false;
+    const changes = [];
+    // Fields that only OpenAI supports (top-level)
+    const openaiOnlyFields = ["store", "metadata", "parallel_tool_calls", "stream_options"];
+    // max_completion_tokens -> max_tokens conversion for non-OpenAI providers
+    if (provider !== "openai" && "max_completion_tokens" in result) {
+        if (!("max_tokens" in result)) {
+            result.max_tokens = result.max_completion_tokens;
+            changes.push(`max_completion_tokens→max_tokens`);
+        }
+        delete result.max_completion_tokens;
+        modified = true;
+    }
+    // OpenAI o1/o3 models require max_completion_tokens instead of max_tokens
+    if (provider === "openai" && "max_tokens" in result) {
+        const model = result.model ?? "";
+        if (model.startsWith("o1") || model.startsWith("o3")) {
+            if (!("max_completion_tokens" in result)) {
+                result.max_completion_tokens = result.max_tokens;
+                changes.push(`max_tokens→max_completion_tokens (${model})`);
+            }
+            delete result.max_tokens;
+            modified = true;
+        }
+    }
+    // Remove OpenAI-only fields for other providers
+    if (provider !== "openai") {
+        for (const field of openaiOnlyFields) {
+            if (field in result) {
+                delete result[field];
+                changes.push(`-${field}`);
+                modified = true;
+            }
+        }
+        // Remove 'strict' from within tools array (OpenAI-specific nested field)
+        if (Array.isArray(result.tools)) {
+            let toolsModified = false;
+            for (const tool of result.tools) {
+                if (tool.function && typeof tool.function === "object") {
+                    const fn = tool.function;
+                    if ("strict" in fn) {
+                        delete fn.strict;
+                        toolsModified = true;
+                    }
+                }
+                // Also check top-level strict on tool
+                if ("strict" in tool) {
+                    delete tool.strict;
+                    toolsModified = true;
+                }
+            }
+            if (toolsModified) {
+                changes.push("-tools[].strict");
+                modified = true;
+            }
+        }
+    }
+    // Provider-specific handling
+    switch (provider) {
+        case "mistral":
+            // Mistral doesn't support these additional fields
+            const mistralUnsupported = ["logprobs", "top_logprobs", "n", "user", "service_tier"];
+            for (const field of mistralUnsupported) {
+                if (field in result) {
+                    delete result[field];
+                    changes.push(`-${field}`);
+                    modified = true;
+                }
+            }
+            break;
+        case "cohere":
+            // Cohere uses different field names and doesn't support some OpenAI fields
+            // See: https://docs.cohere.com/reference/chat
+            const cohereUnsupported = ["top_logprobs", "n", "user", "stream_options"];
+            for (const field of cohereUnsupported) {
+                if (field in result) {
+                    delete result[field];
+                    changes.push(`-${field}`);
+                    modified = true;
+                }
+            }
+            // top_p → p for Cohere
+            if ("top_p" in result && !("p" in result)) {
+                result.p = result.top_p;
+                delete result.top_p;
+                changes.push("top_p→p");
+                modified = true;
+            }
+            break;
+    }
+    if (modified) {
+        log.debug(`[PROXY] Normalized request body: ${changes.join(", ")}`);
+    }
+    return { body: result, modified };
+}
+// ---------------------------------------------------------------------------
 // SSE streaming parsers — extract usage/model from provider-specific formats
 // ---------------------------------------------------------------------------
 function parseOpenAISSE(dataLines, statusCode) {
@@ -231,7 +339,6 @@ function parseSSEResponse(provider, sseText, statusCode) {
         case "moonshot":
         case "zhipu":
         case "minimax":
-        case "baichuan":
         case "yi":
             return parseOpenAISSE(dataLines, statusCode);
         case "anthropic":
@@ -298,6 +405,86 @@ function checkAgentPolicy(db, agentId) {
     }
     return { allowed: true };
 }
+const providerPolicyCache = {};
+const PROVIDER_POLICY_CACHE_TTL_MS = 5_000; // 5 seconds (shorter for faster policy updates)
+// Provider-level rate limiter (separate from agent rate limiter)
+const providerRateLimiter = new rate_limiter_js_1.RateLimiter();
+function checkProviderPolicy(db, provider) {
+    if (!db || provider === "unknown") {
+        return { allowed: true };
+    }
+    // Check cache first
+    const cached = providerPolicyCache[provider];
+    let settings;
+    if (cached && cached.expiresAt > Date.now()) {
+        settings = cached.settings;
+    }
+    else {
+        settings = (0, server_1.getProviderSettings)(db, provider);
+        providerPolicyCache[provider] = {
+            settings: settings ?? null,
+            expiresAt: Date.now() + PROVIDER_POLICY_CACHE_TTL_MS,
+        };
+    }
+    if (!settings) {
+        // No settings means default (active, no rate limit)
+        return { allowed: true };
+    }
+    // Check if provider is active
+    if (settings.active === 0) {
+        return {
+            allowed: false,
+            reason: "provider_deactivated",
+            message: `Provider "${provider}" is currently deactivated`,
+        };
+    }
+    // Check provider rate limit
+    if (settings.rate_limit_max_requests && settings.rate_limit_window_seconds) {
+        const isAllowed = providerRateLimiter.checkAndRecord(provider, // Use provider as the key
+        provider, settings.rate_limit_max_requests, settings.rate_limit_window_seconds);
+        if (!isAllowed) {
+            const retryAfter = providerRateLimiter.getRetryAfter(provider, provider);
+            log.info(`[PROXY] Provider ${provider} rate limited, retry after ${retryAfter}s`);
+            return {
+                allowed: false,
+                reason: "provider_rate_limited",
+                message: `Provider "${provider}" rate limit exceeded. Retry after ${retryAfter} seconds.`,
+            };
+        }
+    }
+    return { allowed: true };
+}
+const killSwitchConfigCache = {};
+const KILL_SWITCH_CACHE_TTL_MS = 30_000; // 30 seconds
+function getKillSwitchConfig(db, agentId) {
+    const defaultConfig = {
+        enabled: false,
+        windowSize: 20,
+        threshold: 10.0,
+    };
+    if (!db)
+        return defaultConfig;
+    // Check cache first
+    const cached = killSwitchConfigCache[agentId];
+    if (cached && cached.expiresAt > Date.now()) {
+        return cached.config;
+    }
+    // Fetch from DB
+    const policy = (0, server_1.getAgentPolicy)(db, agentId);
+    const config = {
+        enabled: policy?.kill_switch_enabled === 1,
+        windowSize: policy?.kill_switch_window_size ?? 20,
+        threshold: policy?.kill_switch_threshold ?? 10.0,
+    };
+    // Update loop detector config
+    loop_detector_js_1.loopDetector.setConfig(agentId, config);
+    // Cache the result
+    killSwitchConfigCache[agentId] = {
+        config,
+        expiresAt: Date.now() + KILL_SWITCH_CACHE_TTL_MS,
+    };
+    return config;
+}
 /**
  * Generate a blocked response in OpenAI format.
  */
@@ -356,6 +543,32 @@ function generateBlockedResponse(provider, reason, message) {
     // Default to OpenAI format (used by most providers)
     return generateOpenAIBlockedResponse(reason, message);
 }
+/**
+ * Generate a rate limit response based on provider format.
+ */
+function generateRateLimitResponse(provider, agentId, retryAfterSeconds) {
+    const message = `Rate limit exceeded for provider "${provider}". Please retry after ${retryAfterSeconds} seconds.`;
+    if (provider === "anthropic") {
+        return {
+            type: "error",
+            error: {
+                type: "rate_limit_error",
+                message,
+            },
+            retry_after_seconds: retryAfterSeconds,
+        };
+    }
+    // OpenAI-style error format (used by most providers)
+    return {
+        error: {
+            message,
+            type: "rate_limit_error",
+            param: null,
+            code: "rate_limit_exceeded",
+        },
+        retry_after_seconds: retryAfterSeconds,
+    };
+}
 /**
  * Record a blocked event to the database.
  */
@@ -419,8 +632,9 @@ function startProxy(options) {
     const endpoint = options.endpoint ?? DEFAULT_ENDPOINT;
     const flushInterval = options.flushInterval ?? DEFAULT_FLUSH_INTERVAL;
     const maxBufferSize = options.maxBufferSize ?? DEFAULT_MAX_BUFFER_SIZE;
-    const providerKeys = options.providerKeys ?? {};
+    let providerKeys = options.providerKeys ?? {};
     const db = options.db;
+    const secretStore = options.secretStore;
     // Initialize rate limiter - prefer database, fall back to options for backward compatibility/testing
     let initialRateLimits = {};
     if (db) {
@@ -442,6 +656,27 @@ function startProxy(options) {
         }, RATE_LIMIT_REFRESH_INTERVAL_MS);
         rateLimitRefreshTimer.unref();
     }
+    // Set up periodic refresh of provider keys from secret store
+    let providerKeysRefreshTimer = null;
+    if (secretStore) {
+        providerKeysRefreshTimer = setInterval(async () => {
+            try {
+                const accounts = await secretStore.list(PROVIDER_SERVICE);
+                const newKeys = {};
+                for (const account of accounts) {
+                    const value = await secretStore.get(PROVIDER_SERVICE, account);
+                    if (value) {
+                        newKeys[account] = value;
+                    }
+                }
+                providerKeys = newKeys;
+            }
+            catch (err) {
+                log.error("Failed to refresh provider keys", { err: String(err) });
+            }
+        }, PROVIDER_KEYS_REFRESH_INTERVAL_MS);
+        providerKeysRefreshTimer.unref();
+    }
     const startTime = Date.now();
     const eventBuffer = new event_buffer_js_1.EventBuffer({
         apiKey: options.apiKey,
@@ -465,95 +700,208 @@ function startProxy(options) {
             });
             return;
         }
-        // Agent identification priority: header > path (/agents/{id}/...) > default
-        let effectiveAgentId = req.headers["x-agent-id"];
-        let workingPath = path;
-        // Check for /agents/{id}/... path pattern if no header
-        if (!effectiveAgentId) {
-            const agentPathResult = (0, shared_1.parseAgentPath)(path);
-            if (agentPathResult) {
-                effectiveAgentId = agentPathResult.agentId;
-                workingPath = agentPathResult.remainingPath;
-                log.info(`[PROXY] Agent ID from path: ${effectiveAgentId}`);
-            }
-        }
-        // Fall back to default agent ID
-        if (!effectiveAgentId) {
-            effectiveAgentId = agentId;
-        }
-        // Proxy logic: use x-target-url header if provided, otherwise auto-detect
-        // provider from the Host header or request path.
-        let targetBase = req.headers["x-target-url"];
-        // Validate x-target-url to prevent SSRF
-        if (targetBase) {
-            try {
-                const parsed = new URL(targetBase);
-                if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-                    sendJson(res, 400, { error: "x-target-url must use http or https protocol" });
+        // Internal endpoint: Clear loop detector window for an agent
+        // POST /internal/agents/:id/clear-window
+        const clearWindowMatch = path.match(/^\/internal\/agents\/([^/]+)\/clear-window$/);
+        if (method === "POST" && clearWindowMatch) {
+            const targetAgentId = decodeURIComponent(clearWindowMatch[1]);
+            // Security: Only allow from localhost
+            const remoteAddr = req.socket.remoteAddress;
+            const isLocalhost = remoteAddr === "127.0.0.1" || remoteAddr === "::1" || remoteAddr === "::ffff:127.0.0.1";
+            if (!isLocalhost) {
+                sendJson(res, 403, { error: "This endpoint is only accessible from localhost" });
+                return;
+            }
+            loop_detector_js_1.loopDetector.clearAgent(targetAgentId);
+            log.info(`[PROXY] Cleared loop detector window for agent "${targetAgentId}"`);
+            sendJson(res, 200, { success: true, agent_id: targetAgentId });
+            return;
+        }
+        // Simplified routing: POST /agents/:agent/:provider[/...]
+        // For most providers, trailing path is ignored and we use the fixed chat endpoint.
+        // For providers with path-based routing (e.g., Google), we preserve the trailing path.
+        const simplifiedRouteMatch = path.match(/^\/agents\/([^/]+)\/([^/]+)(\/.*)?$/);
+        if (method === "POST" && simplifiedRouteMatch) {
+            const routeAgentId = decodeURIComponent(simplifiedRouteMatch[1]);
+            const routeProvider = simplifiedRouteMatch[2].toLowerCase();
+            const trailingPath = simplifiedRouteMatch[3] || "";
+            // Validate provider
+            if (!shared_1.KNOWN_PROVIDER_NAMES.includes(routeProvider)) {
+                sendJson(res, 400, { error: `Unknown provider: ${routeProvider}` });
+                return;
+            }
+            let targetUrl;
+            if ((0, shared_1.providerUsesPathRouting)(routeProvider) && trailingPath) {
+                // Path-based routing: append trailing path to root URL
+                const rootUrl = (0, shared_1.getProviderRootUrl)(routeProvider);
+                if (!rootUrl) {
+                    sendJson(res, 400, { error: `No root URL configured for provider: ${routeProvider}` });
                     return;
                 }
+                targetUrl = rootUrl + trailingPath;
+                // For Google native API, add key as query parameter
+                if (routeProvider === "google" && providerKeys["google"]) {
+                    const separator = targetUrl.includes("?") ? "&" : "?";
+                    targetUrl = `${targetUrl}${separator}key=${providerKeys["google"]}`;
+                }
             }
-            catch {
-                sendJson(res, 400, { error: "x-target-url must be a valid URL" });
-                return;
+            else {
+                // Fixed endpoint routing
+                const chatEndpoint = (0, shared_1.getProviderChatEndpoint)(routeProvider);
+                if (!chatEndpoint) {
+                    sendJson(res, 400, { error: `No chat endpoint configured for provider: ${routeProvider}` });
+                    return;
+                }
+                targetUrl = chatEndpoint;
             }
+            log.info(`[PROXY] Simplified route: agent=${routeAgentId}, provider=${routeProvider}`);
+            log.info(`[PROXY] Forwarding to: ${targetUrl}`);
+            // For path-based routing (e.g., Google native API), we use different auth
+            const useNativeApi = (0, shared_1.providerUsesPathRouting)(routeProvider) && !!trailingPath;
+            // Handle the simplified route request
+            await handleSimplifiedRoute(req, res, routeAgentId, routeProvider, targetUrl, useNativeApi);
+            return;
         }
-        // Path prefix routing: /{provider}/... -> provider base URL + remaining path
-        let pathPrefixProvider = null;
-        let effectivePath = workingPath;
-        log.info(`[PROXY] ${method} ${path} (working path: ${workingPath}, agent: ${effectiveAgentId})`);
-        log.info(`[PROXY] Headers: ${JSON.stringify(Object.fromEntries(Object.entries(req.headers).filter(([k]) => !k.toLowerCase().includes('key') && !k.toLowerCase().includes('auth'))))}`);
-        if (!targetBase) {
-            const prefixResult = (0, shared_1.parsePathPrefix)(workingPath);
-            if (prefixResult) {
-                const baseUrl = (0, shared_1.getProviderBaseUrl)(prefixResult.provider);
-                if (baseUrl) {
-                    targetBase = baseUrl;
-                    effectivePath = prefixResult.remainingPath;
-                    pathPrefixProvider = prefixResult.provider;
-                    log.info(`[PROXY] Detected provider: ${prefixResult.provider}, forwarding to: ${baseUrl}${effectivePath}`);
+        // Legacy routing: /:provider/... -> treat as /agents/default/:provider
+        // This maintains backward compatibility with old SDK configurations
+        const legacyProviderMatch = path.match(/^\/([^/]+)/);
+        if (method === "POST" && legacyProviderMatch) {
+            const legacyProvider = legacyProviderMatch[1].toLowerCase();
+            if (shared_1.KNOWN_PROVIDER_NAMES.includes(legacyProvider)) {
+                const chatEndpoint = (0, shared_1.getProviderChatEndpoint)(legacyProvider);
+                if (chatEndpoint) {
+                    log.info(`[PROXY] Legacy route /${legacyProvider}/... -> agents/default/${legacyProvider}`);
+                    log.info(`[PROXY] Forwarding to: ${chatEndpoint}`);
+                    await handleSimplifiedRoute(req, res, "default", legacyProvider, chatEndpoint, false);
+                    return;
                 }
             }
         }
-        if (!targetBase) {
-            // Try to detect provider from the Host header (e.g. api.openai.com)
-            const host = req.headers["host"] ?? "";
-            const hostUrl = `https://${host}${effectivePath}`;
-            const detectedProvider = (0, shared_1.detectProvider)(hostUrl);
-            if (detectedProvider !== "unknown") {
-                targetBase = (0, shared_1.getProviderBaseUrl)(detectedProvider) ?? undefined;
-            }
-            // Fallback: try to detect from path patterns alone
-            if (!targetBase) {
-                const pathProvider = (0, shared_1.detectProvider)(`https://placeholder${effectivePath}`);
-                if (pathProvider !== "unknown") {
-                    targetBase = (0, shared_1.getProviderBaseUrl)(pathProvider) ?? undefined;
-                }
+        // All other requests: return error with usage instructions
+        sendJson(res, 400, {
+            error: "Invalid route. Use POST /agents/:agent/:provider for LLM requests.",
+            usage: {
+                endpoint: "POST /agents/{agent_name}/{provider}",
+                example: "POST /agents/my-agent/openai",
+                providers: shared_1.KNOWN_PROVIDER_NAMES,
+                sdk_config: {
+                    openai: "new OpenAI({ baseURL: 'http://localhost:4000/agents/my-agent/openai' })",
+                    anthropic: "new Anthropic({ baseURL: 'http://localhost:4000/agents/my-agent/anthropic' })",
+                },
+            },
+        });
+    }
+    function extractStreamingMetrics(provider, statusCode, sseBody, latencyMs, effectiveAgentId, requestedModel) {
+        if (provider === "unknown") {
+            log.warn("Unrecognized provider - skipping streaming metric extraction");
+            return;
+        }
+        const sseText = sseBody.toString("utf-8");
+        const parsed = parseSSEResponse(provider, sseText, statusCode);
+        if (!parsed) {
+            log.warn(`No parseable SSE data for provider: ${provider} — skipping event`);
+            return;
+        }
+        let costUsd = null;
+        if (parsed.model && parsed.tokensIn != null && parsed.tokensOut != null) {
+            costUsd = (0, shared_1.calculateCost)(parsed.model, parsed.tokensIn, parsed.tokensOut);
+        }
+        // Record response for loop detection
+        loop_detector_js_1.loopDetector.recordResponse(effectiveAgentId, sseText);
+        const event = {
+            agent_id: effectiveAgentId,
+            event_type: "llm_call",
+            provider,
+            model: parsed.model,
+            requested_model: requestedModel,
+            tokens_in: parsed.tokensIn,
+            tokens_out: parsed.tokensOut,
+            tokens_total: parsed.tokensTotal,
+            cost_usd: costUsd,
+            latency_ms: latencyMs,
+            status_code: statusCode,
+            source: "proxy",
+            timestamp: new Date().toISOString(),
+            tags: { streaming: "true" },
+        };
+        eventBuffer.add(event);
+    }
+    function extractAndQueueMetrics(provider, statusCode, responseBody, latencyMs, effectiveAgentId, requestedModel) {
+        if (provider === "unknown") {
+            log.warn("Unrecognized provider - skipping metric extraction");
+            return;
+        }
+        // Parse the response body as JSON
+        let parsedBody;
+        try {
+            parsedBody = JSON.parse(responseBody.toString("utf-8"));
+        }
+        catch {
+            log.warn(`Could not parse response body as JSON for ${provider} - skipping metric extraction`);
+            return;
+        }
+        const parsed = (0, shared_1.parseProviderResponse)(provider, parsedBody, statusCode);
+        if (!parsed) {
+            log.warn(`No parser result for provider: ${provider}`);
+            return;
+        }
+        // Calculate cost if we have the necessary token data
+        let costUsd = null;
+        if (parsed.model && parsed.tokensIn != null && parsed.tokensOut != null) {
+            costUsd = (0, shared_1.calculateCost)(parsed.model, parsed.tokensIn, parsed.tokensOut);
+        }
+        // Record response for loop detection
+        loop_detector_js_1.loopDetector.recordResponse(effectiveAgentId, responseBody.toString("utf-8"));
+        const event = {
+            agent_id: effectiveAgentId,
+            event_type: "llm_call",
+            provider,
+            model: parsed.model,
+            requested_model: requestedModel,
+            tokens_in: parsed.tokensIn,
+            tokens_out: parsed.tokensOut,
+            tokens_total: parsed.tokensTotal,
+            cost_usd: costUsd,
+            latency_ms: latencyMs,
+            status_code: statusCode,
+            source: "proxy",
+            timestamp: new Date().toISOString(),
+            tags: {},
+        };
+        eventBuffer.add(event);
+    }
+    /**
+     * Handle simplified route: POST /agents/:agent/:provider
+     * All path construction is done internally - user just provides agent and provider.
+     */
+    async function handleSimplifiedRoute(req, res, effectiveAgentId, provider, targetUrl, useNativeApi = false) {
+        // Provider policy check
+        const providerPolicyResult = checkProviderPolicy(db, provider);
+        if (!providerPolicyResult.allowed && providerPolicyResult.reason && providerPolicyResult.message) {
+            log.info(`[PROXY] Request blocked for provider "${provider}": ${providerPolicyResult.reason}`);
+            recordBlockedEvent(db, effectiveAgentId, provider, providerPolicyResult.reason, providerPolicyResult.message);
+            if (providerPolicyResult.reason === "provider_rate_limited") {
+                const retryAfter = providerRateLimiter.getRetryAfter(provider, provider);
+                const rateLimitResponse = generateRateLimitResponse(provider, effectiveAgentId, retryAfter);
+                res.setHeader("Retry-After", String(retryAfter));
+                sendJson(res, 429, rateLimitResponse);
             }
-            if (!targetBase) {
-                sendJson(res, 400, {
-                    error: "Could not determine upstream provider. Use path prefix routing (e.g. /openai/v1/...), set the Host header to a known provider (e.g. api.openai.com), or provide x-target-url header.",
-                });
-                return;
+            else {
+                const blockedResponse = generateBlockedResponse(provider, providerPolicyResult.reason, providerPolicyResult.message);
+                sendJson(res, 200, blockedResponse);
             }
+            return;
         }
-        // Build target URL: combine base with the effective path (prefix stripped if used)
-        const targetUrl = targetBase.replace(/\/+$/, "") + effectivePath;
-        // Detect provider early for policy enforcement response format
-        const earlyProvider = pathPrefixProvider ?? (0, shared_1.detectProvider)(targetUrl);
-        // Policy check: verify agent is allowed to make requests
+        // Agent policy check
         const policyResult = checkAgentPolicy(db, effectiveAgentId);
         if (!policyResult.allowed && policyResult.reason && policyResult.message) {
             log.info(`[PROXY] Request blocked for agent "${effectiveAgentId}": ${policyResult.reason}`);
-            // Record blocked event
-            recordBlockedEvent(db, effectiveAgentId, earlyProvider, policyResult.reason, policyResult.message);
-            // Return a fake LLM response that indicates the block
-            const blockedResponse = generateBlockedResponse(earlyProvider, policyResult.reason, policyResult.message);
+            recordBlockedEvent(db, effectiveAgentId, provider, policyResult.reason, policyResult.message);
+            const blockedResponse = generateBlockedResponse(provider, policyResult.reason, policyResult.message);
             sendJson(res, 200, blockedResponse);
             return;
         }
-        log.info(`[PROXY] Target URL: ${targetUrl}`);
-        // Read the full request body
+        // Read request body
         let requestBody;
         try {
             requestBody = await readRequestBody(req);
@@ -567,153 +915,191 @@ function startProxy(options) {
             }
             return;
         }
-        // Strict detection (hostname-only): used for key injection and rate limiting.
-        // Path prefix is definitively trusted (we resolved the provider ourselves).
-        const detectedProviderStrict = pathPrefixProvider
-            ?? (0, shared_1.detectProviderByHostname)(targetUrl);
-        // Model override: check if we should rewrite the model in request body
-        let requestedModel = null;
-        let actualModel = null;
-        let modifiedRequestBody = requestBody;
-        if (detectedProviderStrict !== "unknown") {
+        // Kill Switch check
+        const killSwitchConfig = getKillSwitchConfig(db, effectiveAgentId);
+        if (killSwitchConfig.enabled) {
             try {
                 const bodyJson = JSON.parse(requestBody.toString("utf-8"));
-                if (bodyJson.model) {
-                    requestedModel = bodyJson.model;
-                    const modelOverride = getModelOverride(db, effectiveAgentId, detectedProviderStrict);
-                    if (modelOverride) {
-                        log.info(`[PROXY] Model override: ${requestedModel} → ${modelOverride}`);
-                        bodyJson.model = modelOverride;
-                        actualModel = modelOverride;
-                        modifiedRequestBody = Buffer.from(JSON.stringify(bodyJson), "utf-8");
+                const { promptHash, toolCalls } = loop_detector_js_1.loopDetector.recordRequest(effectiveAgentId, bodyJson);
+                const loopCheck = loop_detector_js_1.loopDetector.checkLoop(effectiveAgentId, promptHash, toolCalls);
+                if (loopCheck.isLoop) {
+                    log.warn(`[PROXY] Kill Switch triggered for agent "${effectiveAgentId}": score=${loopCheck.score.toFixed(2)}`);
+                    const message = `Agent loop detected (score: ${loopCheck.score.toFixed(1)}). Agent deactivated to prevent runaway costs.`;
+                    if (db) {
+                        try {
+                            (0, server_1.updateAgentPolicy)(db, effectiveAgentId, { active: false, deactivated_by: "kill_switch" });
+                            log.info(`[PROXY] Agent "${effectiveAgentId}" deactivated by Kill Switch`);
+                        }
+                        catch (err) {
+                            log.error("Failed to deactivate agent", { err: String(err) });
+                        }
                     }
-                    else {
-                        actualModel = requestedModel;
+                    recordBlockedEvent(db, effectiveAgentId, provider, "loop_detected", message);
+                    if (db) {
+                        try {
+                            const killSwitchEvent = {
+                                agent_id: effectiveAgentId,
+                                event_type: "kill_switch",
+                                provider,
+                                model: null,
+                                tokens_in: null,
+                                tokens_out: null,
+                                tokens_total: null,
+                                cost_usd: null,
+                                latency_ms: null,
+                                status_code: 200,
+                                source: "proxy",
+                                timestamp: new Date().toISOString(),
+                                tags: {
+                                    loop_score: loopCheck.score,
+                                    similar_prompts: loopCheck.details.similarPrompts,
+                                    similar_responses: loopCheck.details.similarResponses,
+                                    repeated_tool_calls: loopCheck.details.repeatedToolCalls,
+                                    action: "deactivated",
+                                },
+                            };
+                            (0, server_1.insertEvents)(db, [killSwitchEvent]);
+                            // Fire kill_switch alert for Telegram/webhook/email notifications
+                            const killSwitchData = {
+                                agent_id: effectiveAgentId,
+                                score: loopCheck.score,
+                                window_size: killSwitchConfig.windowSize,
+                                threshold: killSwitchConfig.threshold,
+                                details: loopCheck.details,
+                            };
+                            void (0, server_1.fireKillSwitchAlert)(db, killSwitchData);
+                        }
+                        catch (err) {
+                            log.error("Failed to record kill_switch event", { err: String(err) });
+                        }
                     }
+                    const blockedResponse = generateBlockedResponse(provider, "inactive", message);
+                    sendJson(res, 200, blockedResponse);
+                    return;
                 }
             }
             catch {
-                // Not JSON or no model field - continue without modification
-            }
-        }
-        // Lenient detection (hostname + path fallback): used for metric extraction.
-        let detectedProviderForMetrics = pathPrefixProvider
-            ?? (0, shared_1.detectProvider)(targetUrl);
-        if (detectedProviderForMetrics === "unknown") {
-            detectedProviderForMetrics = (0, shared_1.detectProvider)(`https://placeholder${effectivePath}`);
-        }
-        // Warn when path matches a provider but hostname doesn't — key will NOT be injected.
-        // Skip when path prefix was used (provider is already trusted).
-        if (!pathPrefixProvider && detectedProviderStrict === "unknown" && detectedProviderForMetrics !== "unknown") {
-            const providerKey = providerKeys[detectedProviderForMetrics];
-            if (providerKey) {
-                const expectedBase = (0, shared_1.getProviderBaseUrl)(detectedProviderForMetrics) ?? detectedProviderForMetrics;
-                log.warn(`Path matches "${detectedProviderForMetrics}" but hostname does not — ` +
-                    `API key NOT injected. Use x-target-url=${expectedBase} for key injection.`);
-            }
-        }
-        // Rate limiting: check before forwarding (strict match only)
-        if (detectedProviderStrict !== "unknown") {
-            const rateLimitResult = rateLimiter.check(effectiveAgentId, detectedProviderStrict);
-            if (!rateLimitResult.allowed) {
-                const retryAfter = rateLimitResult.retryAfterSeconds ?? 60;
-                const message = `Rate limit exceeded for agent "${effectiveAgentId}" on ${detectedProviderStrict}. Please retry after ${retryAfter} seconds.`;
-                res.writeHead(429, {
-                    "Content-Type": "application/json",
-                    "Retry-After": String(retryAfter),
-                });
-                // Return provider-specific error format
-                let errorBody;
-                if (detectedProviderStrict === "anthropic") {
-                    // Anthropic error format
-                    errorBody = {
-                        type: "error",
-                        error: {
-                            type: "rate_limit_error",
-                            message,
-                        },
-                        retry_after_seconds: retryAfter,
-                    };
-                }
-                else {
-                    // OpenAI-style error format (used by most providers)
-                    errorBody = {
-                        error: {
-                            message,
-                            type: "rate_limit_error",
-                            param: null,
-                            code: "rate_limit_exceeded",
-                        },
-                        retry_after_seconds: retryAfter,
-                    };
+                // Not JSON body - skip loop detection
+            }
+        }
+        // Model override and request normalization
+        let requestedModel = null;
+        let modifiedRequestBody = requestBody;
+        try {
+            let bodyJson = JSON.parse(requestBody.toString("utf-8"));
+            let bodyModified = false;
+            // Extract and optionally override model
+            if (bodyJson.model) {
+                requestedModel = bodyJson.model;
+                const modelOverride = getModelOverride(db, effectiveAgentId, provider);
+                if (modelOverride) {
+                    log.info(`[PROXY] Model override: ${requestedModel} → ${modelOverride}`);
+                    bodyJson.model = modelOverride;
+                    bodyModified = true;
                 }
-                res.end(JSON.stringify(errorBody));
-                // Record rate limit event
-                const event = {
-                    agent_id: effectiveAgentId,
-                    event_type: "error",
-                    provider: detectedProviderStrict,
-                    model: null,
-                    tokens_in: null,
-                    tokens_out: null,
-                    tokens_total: null,
-                    cost_usd: null,
-                    latency_ms: null,
-                    status_code: 429,
-                    source: "proxy",
-                    timestamp: new Date().toISOString(),
-                    tags: { rate_limited: "true" },
-                };
-                eventBuffer.add(event);
-                return;
+            }
+            // Normalize request body for provider compatibility
+            const normalized = normalizeRequestBody(provider, bodyJson, log);
+            if (normalized.modified) {
+                bodyJson = normalized.body;
+                bodyModified = true;
+            }
+            if (bodyModified) {
+                modifiedRequestBody = Buffer.from(JSON.stringify(bodyJson), "utf-8");
             }
         }
-        // Build forwarded headers, removing proxy-specific ones
+        catch {
+            // Not JSON or parse error - forward as-is
+        }
+        // Rate limiting check
+        const rateLimitResult = rateLimiter.check(effectiveAgentId, provider);
+        if (!rateLimitResult.allowed) {
+            const retryAfter = rateLimitResult.retryAfterSeconds ?? 60;
+            const message = `Rate limit exceeded for agent "${effectiveAgentId}" on ${provider}. Please retry after ${retryAfter} seconds.`;
+            res.writeHead(429, { "Content-Type": "application/json", "Retry-After": String(retryAfter) });
+            const errorBody = provider === "anthropic"
+                ? { type: "error", error: { type: "rate_limit_error", message }, retry_after_seconds: retryAfter }
+                : { error: { message, type: "rate_limit_error", param: null, code: "rate_limit_exceeded" }, retry_after_seconds: retryAfter };
+            res.end(JSON.stringify(errorBody));
+            const event = {
+                agent_id: effectiveAgentId,
+                event_type: "error",
+                provider,
+                model: null,
+                tokens_in: null,
+                tokens_out: null,
+                tokens_total: null,
+                cost_usd: null,
+                latency_ms: null,
+                status_code: 429,
+                source: "proxy",
+                timestamp: new Date().toISOString(),
+                tags: { rate_limited: "true" },
+            };
+            eventBuffer.add(event);
+            return;
+        }
+        // Build headers
         const forwardHeaders = {};
         for (const [key, value] of Object.entries(req.headers)) {
             const lowerKey = key.toLowerCase();
-            if (lowerKey === "x-target-url" ||
-                lowerKey === "host" ||
-                lowerKey === "connection" ||
-                lowerKey === "content-length" // Let fetch recalculate after body modification
-            ) {
+            if (lowerKey === "x-target-url" || lowerKey === "host" || lowerKey === "connection" || lowerKey === "content-length") {
                 continue;
             }
             if (value !== undefined) {
                 forwardHeaders[key] = Array.isArray(value) ? value.join(", ") : value;
             }
         }
-        // Inject provider API key only for hostname-matched providers (strict).
-        // Path-only matches are NOT trusted for key injection to prevent leakage.
-        log.info(`[PROXY] Provider detection: strict=${detectedProviderStrict}, metrics=${detectedProviderForMetrics}`);
-        if (detectedProviderStrict !== "unknown") {
-            const providerKey = providerKeys[detectedProviderStrict];
-            if (providerKey) {
-                const authHeader = (0, shared_1.getProviderAuthHeader)(detectedProviderStrict, providerKey);
-                if (authHeader) {
-                    // Remove any existing auth header and inject the configured one
-                    const existingAuthKey = Object.keys(forwardHeaders).find((k) => k.toLowerCase() === authHeader.name.toLowerCase());
-                    if (existingAuthKey) {
-                        log.info(`[PROXY] Replacing existing ${existingAuthKey} header with configured key`);
-                        delete forwardHeaders[existingAuthKey];
-                    }
-                    forwardHeaders[authHeader.name] = authHeader.value;
-                    log.info(`[PROXY] Injected ${authHeader.name} header for ${detectedProviderStrict}`);
-                }
+        // Inject API key
+        const providerKey = providerKeys[provider];
+        if (providerKey) {
+            const authHeader = (0, shared_1.getProviderAuthHeader)(provider, providerKey, useNativeApi);
+            if (authHeader) {
+                const existingAuthKey = Object.keys(forwardHeaders).find(k => k.toLowerCase() === authHeader.name.toLowerCase());
+                if (existingAuthKey)
+                    delete forwardHeaders[existingAuthKey];
+                forwardHeaders[authHeader.name] = authHeader.value;
+                log.info(`[PROXY] Injected ${authHeader.name} header for ${provider}${useNativeApi ? " (native API)" : ""}`);
+            }
+        }
+        else {
+            log.warn(`[PROXY] No API key configured for provider: ${provider}`);
+        }
+        // Add provider-specific required headers
+        if (provider === "anthropic") {
+            // Anthropic requires anthropic-version header
+            if (!forwardHeaders["anthropic-version"]) {
+                forwardHeaders["anthropic-version"] = "2023-06-01";
+                log.info(`[PROXY] Added anthropic-version header`);
+            }
+        }
+        // Debug logging for request details (mask sensitive headers)
+        const maskedHeaders = {};
+        const sensitiveHeaders = ["authorization", "x-api-key", "x-goog-api-key", "api-key"];
+        for (const [key, value] of Object.entries(forwardHeaders)) {
+            if (sensitiveHeaders.includes(key.toLowerCase())) {
+                // Show first 8 chars + masked rest
+                maskedHeaders[key] = value.length > 12 ? `${value.slice(0, 8)}...****` : "****";
             }
             else {
-                log.warn(`[PROXY] No API key configured for provider: ${detectedProviderStrict}`);
+                maskedHeaders[key] = value;
             }
         }
+        log.debug(`[PROXY] Request headers: ${JSON.stringify(maskedHeaders)}`);
+        try {
+            const bodyPreview = modifiedRequestBody.toString("utf-8").slice(0, 2000);
+            log.debug(`[PROXY] Request body: ${bodyPreview}${modifiedRequestBody.length > 2000 ? "... (truncated)" : ""}`);
+        }
+        catch {
+            log.debug(`[PROXY] Request body: (binary, ${modifiedRequestBody.length} bytes)`);
+        }
         const requestStart = Date.now();
         let providerResponse;
         try {
             providerResponse = await fetch(targetUrl, {
-                method,
+                method: "POST",
                 headers: forwardHeaders,
-                body: method !== "GET" && method !== "HEAD"
-                    ? new Uint8Array(modifiedRequestBody)
-                    : undefined,
+                body: new Uint8Array(modifiedRequestBody),
                 signal: AbortSignal.timeout(UPSTREAM_TIMEOUT_MS),
             });
         }
@@ -724,14 +1110,10 @@ function startProxy(options) {
             return;
         }
         log.info(`[PROXY] Response: ${providerResponse.status} ${providerResponse.statusText}`);
-        // Check if the response is an SSE stream
         const contentType = providerResponse.headers.get("content-type") ?? "";
         const isSSE = contentType.includes("text/event-stream");
         if (isSSE && providerResponse.body) {
-            // ---------------------------------------------------------------
-            // STREAMING PATH: pipe chunks through to client in real-time,
-            // accumulate them for metric extraction after the stream ends.
-            // ---------------------------------------------------------------
+            // Streaming response
             const responseHeaders = {};
             providerResponse.headers.forEach((value, key) => {
                 responseHeaders[key] = value;
@@ -762,127 +1144,61 @@ function startProxy(options) {
             const latencyMs = Date.now() - requestStart;
             const fullBody = Buffer.concat(chunks);
             try {
-                extractStreamingMetrics(detectedProviderForMetrics, providerResponse.status, fullBody, latencyMs, effectiveAgentId, requestedModel);
+                extractStreamingMetrics(provider, providerResponse.status, fullBody, latencyMs, effectiveAgentId, requestedModel);
             }
             catch (error) {
                 log.error("Streaming metric extraction error", { err: error instanceof Error ? error.message : String(error) });
             }
         }
         else {
-            // ---------------------------------------------------------------
-            // NON-STREAMING PATH: buffer full response, forward, extract.
-            // ---------------------------------------------------------------
+            // Non-streaming response
             let responseBodyBuffer;
             try {
                 const arrayBuffer = await providerResponse.arrayBuffer();
                 responseBodyBuffer = Buffer.from(arrayBuffer);
             }
             catch {
-                sendJson(res, 502, {
-                    error: "Failed to read upstream response body",
-                });
+                sendJson(res, 502, { error: "Failed to read upstream response body" });
                 return;
             }
             const latencyMs = Date.now() - requestStart;
-            // Forward status code and headers back to the client
             const responseHeaders = {};
             providerResponse.headers.forEach((value, key) => {
-                // Skip transfer-encoding since we are sending the full body
                 if (key.toLowerCase() === "transfer-encoding")
                     return;
                 responseHeaders[key] = value;
             });
+            // Debug log error responses
+            if (providerResponse.status >= 400) {
+                try {
+                    const errorBody = responseBodyBuffer.toString("utf-8").slice(0, 2000);
+                    log.debug(`[PROXY] Error response body: ${errorBody}${responseBodyBuffer.length > 2000 ? "... (truncated)" : ""}`);
+                }
+                catch {
+                    log.debug(`[PROXY] Error response body: (binary, ${responseBodyBuffer.length} bytes)`);
+                }
+            }
             res.writeHead(providerResponse.status, responseHeaders);
             res.end(responseBodyBuffer);
-            // After response is sent, extract metrics asynchronously
             try {
-                extractAndQueueMetrics(detectedProviderForMetrics, providerResponse.status, responseBodyBuffer, latencyMs, effectiveAgentId, requestedModel);
+                extractAndQueueMetrics(provider, providerResponse.status, responseBodyBuffer, latencyMs, effectiveAgentId, requestedModel);
             }
             catch (error) {
                 log.error("Metric extraction error", { err: error instanceof Error ? error.message : String(error) });
             }
         }
     }
-    function extractStreamingMetrics(provider, statusCode, sseBody, latencyMs, effectiveAgentId, requestedModel) {
-        if (provider === "unknown") {
-            log.warn("Unrecognized provider - skipping streaming metric extraction");
-            return;
-        }
-        const sseText = sseBody.toString("utf-8");
-        const parsed = parseSSEResponse(provider, sseText, statusCode);
-        if (!parsed) {
-            log.warn(`No parseable SSE data for provider: ${provider} — skipping event`);
-            return;
-        }
-        let costUsd = null;
-        if (parsed.model && parsed.tokensIn != null && parsed.tokensOut != null) {
-            costUsd = (0, shared_1.calculateCost)(parsed.model, parsed.tokensIn, parsed.tokensOut);
-        }
-        const event = {
-            agent_id: effectiveAgentId,
-            event_type: "llm_call",
-            provider,
-            model: parsed.model,
-            requested_model: requestedModel,
-            tokens_in: parsed.tokensIn,
-            tokens_out: parsed.tokensOut,
-            tokens_total: parsed.tokensTotal,
-            cost_usd: costUsd,
-            latency_ms: latencyMs,
-            status_code: statusCode,
-            source: "proxy",
-            timestamp: new Date().toISOString(),
-            tags: { streaming: "true" },
-        };
-        eventBuffer.add(event);
-    }
-    function extractAndQueueMetrics(provider, statusCode, responseBody, latencyMs, effectiveAgentId, requestedModel) {
-        if (provider === "unknown") {
-            log.warn("Unrecognized provider - skipping metric extraction");
-            return;
-        }
-        // Parse the response body as JSON
-        let parsedBody;
-        try {
-            parsedBody = JSON.parse(responseBody.toString("utf-8"));
-        }
-        catch {
-            log.warn(`Could not parse response body as JSON for ${provider} - skipping metric extraction`);
-            return;
-        }
-        const parsed = (0, shared_1.parseProviderResponse)(provider, parsedBody, statusCode);
-        if (!parsed) {
-            log.warn(`No parser result for provider: ${provider}`);
-            return;
-        }
-        // Calculate cost if we have the necessary token data
-        let costUsd = null;
-        if (parsed.model && parsed.tokensIn != null && parsed.tokensOut != null) {
-            costUsd = (0, shared_1.calculateCost)(parsed.model, parsed.tokensIn, parsed.tokensOut);
-        }
-        const event = {
-            agent_id: effectiveAgentId,
-            event_type: "llm_call",
-            provider,
-            model: parsed.model,
-            requested_model: requestedModel,
-            tokens_in: parsed.tokensIn,
-            tokens_out: parsed.tokensOut,
-            tokens_total: parsed.tokensTotal,
-            cost_usd: costUsd,
-            latency_ms: latencyMs,
-            status_code: statusCode,
-            source: "proxy",
-            timestamp: new Date().toISOString(),
-            tags: {},
-        };
-        eventBuffer.add(event);
-    }
     server.listen(port);
+    // Start loop detector cleanup timer (cleans inactive agents every hour)
+    loop_detector_js_1.loopDetector.startCleanup();
     async function shutdown() {
         if (rateLimitRefreshTimer) {
             clearInterval(rateLimitRefreshTimer);
         }
+        if (providerKeysRefreshTimer) {
+            clearInterval(providerKeysRefreshTimer);
+        }
+        loop_detector_js_1.loopDetector.stopCleanup();
         await eventBuffer.shutdown();
         return new Promise((resolve, reject) => {
             server.close((err) => {