@agentgazer/proxy 0.3.5 → 0.3.7

package/dist/proxy-server.js

@@ -35,27 +35,32 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.startProxy = startProxy;
 const http = __importStar(require("node:http"));
+const node_string_decoder_1 = require("node:string_decoder");
 const shared_1 = require("@agentgazer/shared");
 const server_1 = require("@agentgazer/server");
 const modelOverrideCache = {};
 const MODEL_OVERRIDE_CACHE_TTL_MS = 30_000; // 30 seconds
 function getModelOverride(db, agentId, provider) {
+    const noOverride = { model: null, targetProvider: null };
     if (!db)
-        return null;
+        return noOverride;
     const cacheKey = `${agentId}:${provider}`;
     const cached = modelOverrideCache[cacheKey];
     if (cached && cached.expiresAt > Date.now()) {
-        return cached.model_override;
+        return cached.result;
     }
     // Fetch from DB
     const rule = (0, server_1.getModelRule)(db, agentId, provider);
-    const modelOverride = rule?.model_override ?? null;
+    const result = {
+        model: rule?.model_override ?? null,
+        targetProvider: rule?.target_provider ?? null,
+    };
     // Cache the result
     modelOverrideCache[cacheKey] = {
-        model_override: modelOverride,
+        result,
         expiresAt: Date.now() + MODEL_OVERRIDE_CACHE_TTL_MS,
     };
-    return modelOverride;
+    return result;
 }
 const log = (0, shared_1.createLogger)("proxy");
 const event_buffer_js_1 = require("./event-buffer.js");
@@ -110,7 +115,11 @@ function normalizeRequestBody(provider, body, log) {
     let modified = false;
     const changes = [];
     // Fields that only OpenAI supports (top-level)
-    const openaiOnlyFields = ["store", "metadata", "parallel_tool_calls", "stream_options"];
+    const openaiOnlyFields = ["store", "metadata", "parallel_tool_calls"];
+    // Providers that support stream_options for usage tracking
+    const streamOptionsProviders = new Set(["openai", "deepseek", "moonshot", "zhipu", "minimax", "yi", "baichuan"]);
+    // Providers that don't support stream_options at all
+    const noStreamOptionsProviders = new Set(["anthropic", "google", "mistral", "cohere"]);
     // max_completion_tokens -> max_tokens conversion for non-OpenAI providers
     if (provider !== "openai" && "max_completion_tokens" in result) {
         if (!("max_tokens" in result)) {
@@ -164,6 +173,29 @@ function normalizeRequestBody(provider, body, log) {
             }
         }
     }
+    // Handle stream_options for usage tracking
+    if (result.stream === true) {
+        if (streamOptionsProviders.has(provider)) {
+            // Add stream_options.include_usage for providers that support it
+            const existingStreamOptions = result.stream_options;
+            if (!existingStreamOptions?.include_usage) {
+                result.stream_options = {
+                    ...existingStreamOptions,
+                    include_usage: true,
+                };
+                changes.push("+stream_options.include_usage");
+                modified = true;
+            }
+        }
+        else if (noStreamOptionsProviders.has(provider)) {
+            // Remove stream_options for providers that don't support it
+            if ("stream_options" in result) {
+                delete result.stream_options;
+                changes.push("-stream_options");
+                modified = true;
+            }
+        }
+    }
     // Provider-specific handling
     switch (provider) {
         case "mistral":
@@ -180,7 +212,7 @@ function normalizeRequestBody(provider, body, log) {
         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"];
+            const cohereUnsupported = ["top_logprobs", "n", "user"];
             for (const field of cohereUnsupported) {
                 if (field in result) {
                     delete result[field];
@@ -238,12 +270,20 @@ function parseAnthropicSSE(dataLines, statusCode) {
     let model = null;
     let tokensIn = null;
     let tokensOut = null;
+    let cacheCreationTokens = null;
+    let cacheReadTokens = null;
     for (const line of dataLines) {
         try {
             const data = JSON.parse(line);
             if (data.type === "message_start" && data.message) {
                 model = data.message.model ?? null;
-                tokensIn = data.message.usage?.input_tokens ?? null;
+                const usage = data.message.usage;
+                if (usage) {
+                    tokensIn = usage.input_tokens ?? null;
+                    // Anthropic prompt caching: include cache tokens in input count
+                    cacheCreationTokens = usage.cache_creation_input_tokens ?? null;
+                    cacheReadTokens = usage.cache_read_input_tokens ?? null;
+                }
             }
             if (data.type === "message_delta" && data.usage) {
                 tokensOut = data.usage.output_tokens ?? null;
@@ -253,10 +293,22 @@ function parseAnthropicSSE(dataLines, statusCode) {
             continue;
         }
     }
-    const tokensTotal = tokensIn != null && tokensOut != null ? tokensIn + tokensOut : null;
+    // Total input includes regular + cache tokens
+    // Note: cache_creation is charged at 1.25x, cache_read at 0.1x
+    // For now we count all as regular input tokens for simplicity
+    let totalInputTokens = tokensIn;
+    if (totalInputTokens != null) {
+        if (cacheCreationTokens != null) {
+            totalInputTokens += cacheCreationTokens;
+        }
+        if (cacheReadTokens != null) {
+            totalInputTokens += cacheReadTokens;
+        }
+    }
+    const tokensTotal = totalInputTokens != null && tokensOut != null ? totalInputTokens + tokensOut : null;
     return {
         model,
-        tokensIn,
+        tokensIn: totalInputTokens,
         tokensOut,
         tokensTotal,
         statusCode,
@@ -292,6 +344,77 @@ function parseGoogleSSE(dataLines, statusCode) {
         errorMessage: null,
     };
 }
+/**
+ * Parse Google's streaming response format (JSON array chunks, not standard SSE).
+ * Google Gemini API returns streaming data as: [{"candidates":...}, {"candidates":...}]
+ * Each chunk may or may not have usageMetadata - typically only the last chunk has it.
+ */
+function parseGoogleStreamingResponse(rawText, statusCode) {
+    let model = null;
+    let tokensIn = null;
+    let tokensOut = null;
+    let tokensTotal = null;
+    // Try to extract JSON objects from the response
+    // Google streaming format: [{"candidates":...},\n{"candidates":...}]
+    // We need to handle the array brackets and commas between objects
+    // First, try parsing as a complete JSON array
+    try {
+        const cleanedText = rawText.trim();
+        if (cleanedText.startsWith("[")) {
+            const data = JSON.parse(cleanedText);
+            if (Array.isArray(data)) {
+                for (const chunk of data) {
+                    if (chunk.modelVersion)
+                        model = chunk.modelVersion;
+                    if (chunk.usageMetadata) {
+                        tokensIn = chunk.usageMetadata.promptTokenCount ?? null;
+                        tokensOut = chunk.usageMetadata.candidatesTokenCount ?? null;
+                        tokensTotal = chunk.usageMetadata.totalTokenCount ?? null;
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        // Not a valid JSON array, try line-by-line parsing
+    }
+    // If we didn't find data, try extracting individual JSON objects
+    if (tokensIn === null && tokensOut === null) {
+        // Remove array brackets and split by object boundaries
+        const cleanedText = rawText
+            .replace(/^\s*\[\s*/, "") // Remove leading [
+            .replace(/\s*\]\s*$/, "") // Remove trailing ]
+            .replace(/^\s*,\s*/gm, "") // Remove leading commas on each line
+            .trim();
+        // Try to find and parse JSON objects
+        const objectMatches = cleanedText.match(/\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}/g);
+        if (objectMatches) {
+            for (const objStr of objectMatches) {
+                try {
+                    const data = JSON.parse(objStr);
+                    if (data.modelVersion)
+                        model = data.modelVersion;
+                    if (data.usageMetadata) {
+                        tokensIn = data.usageMetadata.promptTokenCount ?? null;
+                        tokensOut = data.usageMetadata.candidatesTokenCount ?? null;
+                        tokensTotal = data.usageMetadata.totalTokenCount ?? null;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+    }
+    return {
+        model,
+        tokensIn,
+        tokensOut,
+        tokensTotal,
+        statusCode,
+        errorMessage: null,
+    };
+}
 function parseCohereSSE(dataLines, statusCode) {
     let tokensIn = null;
     let tokensOut = null;
@@ -330,6 +453,18 @@ function parseSSEResponse(provider, sseText, statusCode) {
             dataLines.push(line.slice(6));
         }
     }
+    // Google Gemini API uses a different streaming format (JSON array, not SSE)
+    // Handle it specially even if no "data: " lines found
+    if (provider === "google") {
+        if (dataLines.length > 0) {
+            // Google with SSE format (when ?alt=sse is used)
+            return parseGoogleSSE(dataLines, statusCode);
+        }
+        else {
+            // Google's default JSON array streaming format
+            return parseGoogleStreamingResponse(sseText, statusCode);
+        }
+    }
     if (dataLines.length === 0)
         return null;
     switch (provider) {
@@ -343,8 +478,6 @@ function parseSSEResponse(provider, sseText, statusCode) {
             return parseOpenAISSE(dataLines, statusCode);
         case "anthropic":
             return parseAnthropicSSE(dataLines, statusCode);
-        case "google":
-            return parseGoogleSSE(dataLines, statusCode);
         case "cohere":
             return parseCohereSSE(dataLines, statusCode);
         default:
@@ -802,9 +935,15 @@ function startProxy(options) {
             log.warn(`No parseable SSE data for provider: ${provider} — skipping event`);
             return;
         }
+        // Use requestedModel as fallback when provider doesn't return model in response
+        // (Google Gemini API typically doesn't include model in streaming response)
+        const effectiveModel = parsed.model ?? requestedModel;
         let costUsd = null;
-        if (parsed.model && parsed.tokensIn != null && parsed.tokensOut != null) {
-            costUsd = (0, shared_1.calculateCost)(parsed.model, parsed.tokensIn, parsed.tokensOut);
+        if (effectiveModel && parsed.tokensIn != null && parsed.tokensOut != null) {
+            costUsd = (0, shared_1.calculateCost)(effectiveModel, parsed.tokensIn, parsed.tokensOut, {
+                cacheCreation: parsed.cacheCreationTokens ?? undefined,
+                cacheRead: parsed.cacheReadTokens ?? undefined,
+            }, provider);
         }
         // Record response for loop detection
         loop_detector_js_1.loopDetector.recordResponse(effectiveAgentId, sseText);
@@ -812,7 +951,7 @@ function startProxy(options) {
             agent_id: effectiveAgentId,
             event_type: "llm_call",
             provider,
-            model: parsed.model,
+            model: effectiveModel,
             requested_model: requestedModel,
             tokens_in: parsed.tokensIn,
             tokens_out: parsed.tokensOut,
@@ -845,10 +984,16 @@ function startProxy(options) {
             log.warn(`No parser result for provider: ${provider}`);
             return;
         }
+        // Use requestedModel as fallback when provider doesn't return model in response
+        // (Google Gemini API typically doesn't include model in response)
+        const effectiveModel = parsed.model ?? requestedModel;
         // 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);
+        if (effectiveModel && parsed.tokensIn != null && parsed.tokensOut != null) {
+            costUsd = (0, shared_1.calculateCost)(effectiveModel, parsed.tokensIn, parsed.tokensOut, {
+                cacheCreation: parsed.cacheCreationTokens ?? undefined,
+                cacheRead: parsed.cacheReadTokens ?? undefined,
+            }, provider);
         }
         // Record response for loop detection
         loop_detector_js_1.loopDetector.recordResponse(effectiveAgentId, responseBody.toString("utf-8"));
@@ -856,7 +1001,7 @@ function startProxy(options) {
             agent_id: effectiveAgentId,
             event_type: "llm_call",
             provider,
-            model: parsed.model,
+            model: effectiveModel,
             requested_model: requestedModel,
             tokens_in: parsed.tokensIn,
             tokens_out: parsed.tokensOut,
@@ -985,21 +1130,75 @@ function startProxy(options) {
         // Model override and request normalization
         let requestedModel = null;
         let modifiedRequestBody = requestBody;
+        let crossProviderOverride = null;
+        let effectiveProvider = provider; // May change if cross-provider override
+        let isStreaming = false;
         try {
             let bodyJson = JSON.parse(requestBody.toString("utf-8"));
             let bodyModified = false;
-            // Extract and optionally override model
+            isStreaming = bodyJson.stream === true;
+            // Extract model from request body if present
             if (bodyJson.model) {
                 requestedModel = bodyJson.model;
-                const modelOverride = getModelOverride(db, effectiveAgentId, provider);
-                if (modelOverride) {
-                    log.info(`[PROXY] Model override: ${requestedModel} → ${modelOverride}`);
-                    bodyJson.model = modelOverride;
+            }
+            // Always check for model override rules (even if request has no model)
+            // This handles providers like Google where model is in URL, not body
+            const override = getModelOverride(db, effectiveAgentId, provider);
+            // Apply model override if configured
+            if (override.model) {
+                if (requestedModel) {
+                    log.info(`[PROXY] Model override: ${requestedModel} → ${override.model}`);
+                }
+                else {
+                    log.info(`[PROXY] Model override (no model in request): → ${override.model}`);
+                }
+                bodyJson.model = override.model;
+                bodyModified = true;
+            }
+            // Handle cross-provider override
+            if (override.targetProvider && override.targetProvider !== provider && shared_1.KNOWN_PROVIDER_NAMES.includes(override.targetProvider)) {
+                const targetProv = override.targetProvider;
+                log.info(`[PROXY] Cross-provider override: ${provider} → ${targetProv}`);
+                // Check if we have an API key for the target provider
+                if (!providerKeys[targetProv]) {
+                    log.error(`[PROXY] No API key configured for target provider: ${targetProv}`);
+                    sendJson(res, 400, { error: `Cross-provider override failed: no API key for ${targetProv}` });
+                    return;
+                }
+                crossProviderOverride = { targetProvider: targetProv, originalProvider: provider };
+                effectiveProvider = targetProv;
+                // Transform request format if needed
+                if (provider !== "anthropic" && targetProv === "anthropic") {
+                    // OpenAI-compatible or Google → Anthropic
+                    // For Google, we need to ensure the request has required fields
+                    if (provider === "google") {
+                        // Google native format → need to convert to OpenAI first, then to Anthropic
+                        // For now, assume the request is already in a compatible format or
+                        // the client is using OpenAI-compatible format through the Google endpoint
+                        log.info(`[PROXY] Converting Google request → Anthropic`);
+                    }
+                    const anthropicRequest = (0, shared_1.openaiToAnthropic)(bodyJson);
+                    bodyJson = anthropicRequest;
+                    bodyModified = true;
+                    log.info(`[PROXY] Transformed request: ${provider} → Anthropic`);
+                }
+                else if (provider === "anthropic" && targetProv !== "anthropic") {
+                    // Anthropic → OpenAI-compatible
+                    const openaiRequest = (0, shared_1.anthropicToOpenaiRequest)(bodyJson);
+                    bodyJson = openaiRequest;
                     bodyModified = true;
+                    log.info(`[PROXY] Transformed request: Anthropic → OpenAI`);
+                }
+                // Other cases (OpenAI-compatible → OpenAI-compatible) don't need transformation
+                // Update target URL for cross-provider
+                const newEndpoint = (0, shared_1.getProviderChatEndpoint)(targetProv);
+                if (newEndpoint) {
+                    targetUrl = newEndpoint;
+                    log.info(`[PROXY] Redirecting to: ${targetUrl}`);
                 }
             }
             // Normalize request body for provider compatibility
-            const normalized = normalizeRequestBody(provider, bodyJson, log);
+            const normalized = normalizeRequestBody(effectiveProvider, bodyJson, log);
             if (normalized.modified) {
                 bodyJson = normalized.body;
                 bodyModified = true;
@@ -1050,23 +1249,43 @@ function startProxy(options) {
                 forwardHeaders[key] = Array.isArray(value) ? value.join(", ") : value;
             }
         }
-        // Inject API key
-        const providerKey = providerKeys[provider];
+        // For cross-provider override, remove ALL auth-related headers from the original request
+        // This prevents the original provider's API key from being forwarded to the target provider
+        if (crossProviderOverride) {
+            const authHeaders = ["authorization", "x-api-key", "api-key", "x-goog-api-key"];
+            for (const key of Object.keys(forwardHeaders)) {
+                if (authHeaders.includes(key.toLowerCase())) {
+                    delete forwardHeaders[key];
+                    log.info(`[PROXY] Removed ${key} header for cross-provider override`);
+                }
+            }
+        }
+        // Inject API key (use effective provider for cross-provider override)
+        const providerKey = providerKeys[effectiveProvider];
+        if (crossProviderOverride) {
+            // Debug: show available provider keys for troubleshooting
+            const availableProviders = Object.keys(providerKeys);
+            log.info(`[PROXY] Cross-provider: looking for "${effectiveProvider}" key, available: [${availableProviders.join(", ")}]`);
+            // Show key lengths for debugging
+            const keyLengths = availableProviders.map(p => `${p}:${providerKeys[p]?.length ?? 0}`).join(", ");
+            log.info(`[PROXY] Key lengths: ${keyLengths}`);
+        }
         if (providerKey) {
-            const authHeader = (0, shared_1.getProviderAuthHeader)(provider, providerKey, useNativeApi);
+            const authHeader = (0, shared_1.getProviderAuthHeader)(effectiveProvider, providerKey, useNativeApi && !crossProviderOverride);
             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)" : ""}`);
+                const maskedKey = providerKey.length > 12 ? `${providerKey.slice(0, 8)}...${providerKey.slice(-4)}` : "****";
+                log.info(`[PROXY] Injected ${authHeader.name}=${maskedKey} (len=${providerKey.length}) for ${effectiveProvider}${crossProviderOverride ? " (cross-provider)" : ""}${useNativeApi ? " (native API)" : ""}`);
             }
         }
         else {
-            log.warn(`[PROXY] No API key configured for provider: ${provider}`);
+            log.warn(`[PROXY] No API key configured for provider: ${effectiveProvider}`);
         }
         // Add provider-specific required headers
-        if (provider === "anthropic") {
+        if (effectiveProvider === "anthropic") {
             // Anthropic requires anthropic-version header
             if (!forwardHeaders["anthropic-version"]) {
                 forwardHeaders["anthropic-version"] = "2023-06-01";
@@ -1113,30 +1332,191 @@ function startProxy(options) {
         const contentType = providerResponse.headers.get("content-type") ?? "";
         const isSSE = contentType.includes("text/event-stream");
         if (isSSE && providerResponse.body) {
-            // Streaming response
+            // Determine stream conversion direction BEFORE setting headers
+            // Case 1: OpenAI-compatible client → Anthropic target (convert Anthropic SSE → OpenAI SSE)
+            const needsAnthropicToOpenai = crossProviderOverride && effectiveProvider === "anthropic" && crossProviderOverride.originalProvider !== "anthropic";
+            // Case 2: Anthropic client → OpenAI-compatible target (convert OpenAI SSE → Anthropic SSE)
+            const needsOpenaiToAnthropic = crossProviderOverride && crossProviderOverride.originalProvider === "anthropic" && effectiveProvider !== "anthropic";
+            // Streaming response - build headers carefully
             const responseHeaders = {};
+            // Headers to skip when forwarding SSE response
+            const skipHeaders = new Set([
+                "content-encoding", // fetch() auto-decompresses, so this would be wrong
+                "content-length", // SSE is streamed, no fixed length
+                "transfer-encoding", // Let Node.js handle this
+                "connection", // Let Node.js handle this
+            ]);
+            // Headers to skip when doing cross-provider override (provider-specific headers)
+            const providerSpecificHeaders = new Set([
+                "x-request-id",
+                "openai-processing-ms",
+                "openai-organization",
+                "openai-version",
+                "x-ratelimit-limit-requests",
+                "x-ratelimit-limit-tokens",
+                "x-ratelimit-remaining-requests",
+                "x-ratelimit-remaining-tokens",
+                "x-ratelimit-reset-requests",
+                "x-ratelimit-reset-tokens",
+            ]);
             providerResponse.headers.forEach((value, key) => {
+                const lowerKey = key.toLowerCase();
+                if (skipHeaders.has(lowerKey))
+                    return;
+                if (crossProviderOverride && providerSpecificHeaders.has(lowerKey))
+                    return;
                 responseHeaders[key] = value;
             });
+            // Ensure correct headers for SSE
+            responseHeaders["Content-Type"] = "text/event-stream; charset=utf-8";
+            responseHeaders["Cache-Control"] = "no-cache";
+            responseHeaders["Connection"] = "keep-alive";
+            responseHeaders["X-Accel-Buffering"] = "no"; // Disable nginx buffering if behind nginx
             res.writeHead(providerResponse.status, responseHeaders);
+            res.flushHeaders(); // Ensure headers are sent immediately
             const chunks = [];
             let accumulatedSize = 0;
             const reader = providerResponse.body.getReader();
+            let streamState = null;
+            let reverseStreamState = null;
+            let lineBuffer = "";
+            // Use StringDecoder to handle multi-byte UTF-8 characters split across chunks
+            const utf8Decoder = new node_string_decoder_1.StringDecoder("utf8");
+            if (needsAnthropicToOpenai) {
+                streamState = (0, shared_1.createStreamingConverterState)();
+                log.info(`[PROXY] Converting Anthropic SSE stream → OpenAI format`);
+            }
+            else if (needsOpenaiToAnthropic) {
+                reverseStreamState = (0, shared_1.createOpenAIToAnthropicStreamState)();
+                log.info(`[PROXY] Converting OpenAI SSE stream → Anthropic format`);
+            }
             try {
                 for (;;) {
                     const { done, value } = await reader.read();
                     if (done)
                         break;
                     const buf = Buffer.from(value);
-                    res.write(buf);
-                    accumulatedSize += buf.length;
-                    if (accumulatedSize <= MAX_SSE_BUFFER_SIZE) {
-                        chunks.push(buf);
+                    if (needsAnthropicToOpenai && streamState) {
+                        // Transform Anthropic SSE to OpenAI SSE
+                        // Use StringDecoder to properly handle multi-byte UTF-8 characters
+                        lineBuffer += utf8Decoder.write(buf);
+                        const lines = lineBuffer.split("\n");
+                        lineBuffer = lines.pop() ?? ""; // Keep incomplete line for next chunk
+                        for (const line of lines) {
+                            if (line.startsWith("data: ")) {
+                                const data = line.slice(6).trim();
+                                if (data && data !== "[DONE]") {
+                                    try {
+                                        const event = JSON.parse(data);
+                                        const openaiChunks = (0, shared_1.anthropicSseToOpenaiChunks)(event, streamState, requestedModel ?? undefined);
+                                        for (const chunk of openaiChunks) {
+                                            const sseData = (0, shared_1.formatOpenAISSELine)(chunk);
+                                            res.write(sseData);
+                                            accumulatedSize += sseData.length;
+                                        }
+                                    }
+                                    catch (e) {
+                                        log.debug(`[PROXY] Failed to parse Anthropic SSE event: ${data}`);
+                                    }
+                                }
+                            }
+                        }
+                        // Store original for metrics
+                        if (accumulatedSize <= MAX_SSE_BUFFER_SIZE) {
+                            chunks.push(buf);
+                        }
+                    }
+                    else if (needsOpenaiToAnthropic && reverseStreamState) {
+                        // Transform OpenAI SSE to Anthropic SSE
+                        // Use StringDecoder to properly handle multi-byte UTF-8 characters
+                        lineBuffer += utf8Decoder.write(buf);
+                        const lines = lineBuffer.split("\n");
+                        lineBuffer = lines.pop() ?? ""; // Keep incomplete line for next chunk
+                        for (const line of lines) {
+                            if (line.startsWith("data: ")) {
+                                const data = line.slice(6).trim();
+                                if (data && data !== "[DONE]") {
+                                    try {
+                                        const chunk = JSON.parse(data);
+                                        const anthropicLines = (0, shared_1.openaiChunkToAnthropicSse)(chunk, reverseStreamState, requestedModel ?? undefined);
+                                        for (const sseLine of anthropicLines) {
+                                            log.info(`[PROXY] Anthropic SSE: ${sseLine.slice(0, 150).replace(/\n/g, "\\n")}`);
+                                            res.write(sseLine);
+                                            accumulatedSize += sseLine.length;
+                                        }
+                                    }
+                                    catch (e) {
+                                        log.debug(`[PROXY] Failed to parse OpenAI SSE chunk: ${data}`);
+                                    }
+                                }
+                            }
+                        }
+                        // Store original for metrics
+                        if (accumulatedSize <= MAX_SSE_BUFFER_SIZE) {
+                            chunks.push(buf);
+                        }
+                    }
+                    else {
+                        // No conversion needed, pass through
+                        res.write(buf);
+                        accumulatedSize += buf.length;
+                        if (accumulatedSize <= MAX_SSE_BUFFER_SIZE) {
+                            chunks.push(buf);
+                        }
+                    }
+                }
+                // Handle any remaining data in lineBuffer for OpenAI → Anthropic conversion
+                if (needsOpenaiToAnthropic && reverseStreamState && lineBuffer.trim()) {
+                    if (lineBuffer.startsWith("data: ")) {
+                        const data = lineBuffer.slice(6).trim();
+                        if (data && data !== "[DONE]") {
+                            try {
+                                const chunk = JSON.parse(data);
+                                const anthropicLines = (0, shared_1.openaiChunkToAnthropicSse)(chunk, reverseStreamState, requestedModel ?? undefined);
+                                for (const sseLine of anthropicLines) {
+                                    log.info(`[PROXY] Anthropic SSE (final): ${sseLine.slice(0, 150).replace(/\n/g, "\\n")}`);
+                                    res.write(sseLine);
+                                }
+                            }
+                            catch (e) {
+                                log.debug(`[PROXY] Failed to parse final OpenAI SSE chunk: ${data}`);
+                            }
+                        }
+                    }
+                }
+                // Send done markers for converted streams
+                if (needsAnthropicToOpenai) {
+                    res.write((0, shared_1.formatOpenAISSEDone)());
+                }
+                // For OpenAI → Anthropic conversion, ensure proper stream finalization
+                // This handles cases where the OpenAI stream ended without a finish_reason chunk
+                if (needsOpenaiToAnthropic && reverseStreamState) {
+                    if (!(0, shared_1.isOpenAIToAnthropicStreamFinalized)(reverseStreamState)) {
+                        log.info(`[PROXY] OpenAI stream ended without proper finalization, sending closing events`);
+                        const finalLines = (0, shared_1.finalizeOpenAIToAnthropicStream)(reverseStreamState);
+                        for (const sseLine of finalLines) {
+                            log.info(`[PROXY] Anthropic SSE (finalize): ${sseLine.slice(0, 150).replace(/\n/g, "\\n")}`);
+                            res.write(sseLine);
+                        }
                     }
                 }
             }
             catch (error) {
                 log.error("Stream read error", { err: error instanceof Error ? error.message : String(error) });
+                // Even on error, try to finalize the Anthropic stream
+                if (needsOpenaiToAnthropic && reverseStreamState && reverseStreamState.sentMessageStart) {
+                    try {
+                        if (!(0, shared_1.isOpenAIToAnthropicStreamFinalized)(reverseStreamState)) {
+                            const finalLines = (0, shared_1.finalizeOpenAIToAnthropicStream)(reverseStreamState);
+                            for (const sseLine of finalLines) {
+                                res.write(sseLine);
+                            }
+                        }
+                    }
+                    catch {
+                        // Ignore errors during error recovery
+                    }
+                }
             }
             finally {
                 res.end();
@@ -1144,7 +1524,8 @@ function startProxy(options) {
             const latencyMs = Date.now() - requestStart;
             const fullBody = Buffer.concat(chunks);
             try {
-                extractStreamingMetrics(provider, providerResponse.status, fullBody, latencyMs, effectiveAgentId, requestedModel);
+                // Use effective provider for metrics extraction
+                extractStreamingMetrics(effectiveProvider, providerResponse.status, fullBody, latencyMs, effectiveAgentId, requestedModel);
             }
             catch (error) {
                 log.error("Streaming metric extraction error", { err: error instanceof Error ? error.message : String(error) });
@@ -1162,26 +1543,70 @@ function startProxy(options) {
                 return;
             }
             const latencyMs = Date.now() - requestStart;
+            // Transform response if cross-provider override
+            let finalResponseBody = responseBodyBuffer;
+            let responseConverted = false;
+            if (crossProviderOverride && providerResponse.status < 400) {
+                // Case 1: OpenAI-compatible client → Anthropic target
+                // Need to convert Anthropic response → OpenAI format
+                if (effectiveProvider === "anthropic" && crossProviderOverride.originalProvider !== "anthropic") {
+                    try {
+                        const anthropicResponse = JSON.parse(responseBodyBuffer.toString("utf-8"));
+                        const openaiResponse = (0, shared_1.anthropicToOpenai)(anthropicResponse, requestedModel ?? undefined);
+                        finalResponseBody = Buffer.from(JSON.stringify(openaiResponse), "utf-8");
+                        responseConverted = true;
+                        log.info(`[PROXY] Converted Anthropic response → OpenAI format`);
+                    }
+                    catch (e) {
+                        log.error(`[PROXY] Failed to convert Anthropic response: ${e instanceof Error ? e.message : String(e)}`);
+                    }
+                }
+                // Case 2: Anthropic client → OpenAI-compatible target
+                // Need to convert OpenAI response → Anthropic format
+                else if (crossProviderOverride.originalProvider === "anthropic" && effectiveProvider !== "anthropic") {
+                    try {
+                        const openaiResponse = JSON.parse(responseBodyBuffer.toString("utf-8"));
+                        const anthropicResponse = (0, shared_1.openaiToAnthropicResponse)(openaiResponse, requestedModel ?? undefined);
+                        finalResponseBody = Buffer.from(JSON.stringify(anthropicResponse), "utf-8");
+                        responseConverted = true;
+                        log.info(`[PROXY] Converted OpenAI response → Anthropic format`);
+                    }
+                    catch (e) {
+                        log.error(`[PROXY] Failed to convert OpenAI response: ${e instanceof Error ? e.message : String(e)}`);
+                    }
+                }
+            }
             const responseHeaders = {};
             providerResponse.headers.forEach((value, key) => {
                 if (key.toLowerCase() === "transfer-encoding")
                     return;
+                // Update content-length if we transformed the body
+                if (key.toLowerCase() === "content-length" && responseConverted) {
+                    responseHeaders[key] = String(finalResponseBody.length);
+                    return;
+                }
                 responseHeaders[key] = value;
             });
-            // Debug log error responses
+            // Log error responses (INFO level for cross-provider, DEBUG for others)
             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)" : ""}`);
+                    if (crossProviderOverride) {
+                        log.info(`[PROXY] Cross-provider error (${providerResponse.status}): ${errorBody}${responseBodyBuffer.length > 2000 ? "... (truncated)" : ""}`);
+                    }
+                    else {
+                        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);
+            res.end(finalResponseBody);
             try {
-                extractAndQueueMetrics(provider, providerResponse.status, responseBodyBuffer, latencyMs, effectiveAgentId, requestedModel);
+                // Use effective provider for metrics, but pass original response for parsing
+                extractAndQueueMetrics(effectiveProvider, providerResponse.status, responseBodyBuffer, latencyMs, effectiveAgentId, requestedModel);
             }
             catch (error) {
                 log.error("Metric extraction error", { err: error instanceof Error ? error.message : String(error) });