vforclaude2 0.3.87

package/open-sse/utils/error.js

@@ -0,0 +1,185 @@
+import { ERROR_TYPES, DEFAULT_ERROR_MESSAGES } from "../config/runtimeConfig.js";
+
+/**
+ * Build OpenAI-compatible error response body
+ * @param {number} statusCode - HTTP status code
+ * @param {string} message - Error message
+ * @returns {object} Error response object
+ */
+export function buildErrorBody(statusCode, message) {
+  const errorInfo = ERROR_TYPES[statusCode] || 
+    (statusCode >= 500 
+      ? { type: "server_error", code: "internal_server_error" }
+      : { type: "invalid_request_error", code: "" });
+
+  return {
+    error: {
+      message: message || DEFAULT_ERROR_MESSAGES[statusCode] || "An error occurred",
+      type: errorInfo.type,
+      code: errorInfo.code
+    }
+  };
+}
+
+/**
+ * Create error Response object (for non-streaming)
+ * @param {number} statusCode - HTTP status code
+ * @param {string} message - Error message
+ * @returns {Response} HTTP Response object
+ */
+export function errorResponse(statusCode, message) {
+  return new Response(JSON.stringify(buildErrorBody(statusCode, message)), {
+    status: statusCode,
+    headers: {
+      "Content-Type": "application/json",
+      "Access-Control-Allow-Origin": "*"
+    }
+  });
+}
+
+/**
+ * Write error to SSE stream (for streaming)
+ * @param {WritableStreamDefaultWriter} writer - Stream writer
+ * @param {number} statusCode - HTTP status code
+ * @param {string} message - Error message
+ */
+export async function writeStreamError(writer, statusCode, message) {
+  const errorBody = buildErrorBody(statusCode, message);
+  const encoder = new TextEncoder();
+  await writer.write(encoder.encode(`data: ${JSON.stringify(errorBody)}\n\n`));
+}
+
+/**
+ * Parse Antigravity error message to extract retry time
+ * Example: "You have exhausted your capacity on this model. Your quota will reset after 2h7m23s."
+ * @param {string} message - Error message
+ * @returns {number|null} Retry time in milliseconds, or null if not found
+ */
+export function parseAntigravityRetryTime(message) {
+  if (typeof message !== "string") return null;
+  
+  // Match patterns like: 2h7m23s, 5m30s, 45s, 1h20m, etc.
+  const match = message.match(/reset after (\d+h)?(\d+m)?(\d+s)?/i);
+  if (!match) return null;
+  
+  let totalMs = 0;
+  
+  // Extract hours
+  if (match[1]) {
+    const hours = parseInt(match[1]);
+    totalMs += hours * 60 * 60 * 1000;
+  }
+  
+  // Extract minutes
+  if (match[2]) {
+    const minutes = parseInt(match[2]);
+    totalMs += minutes * 60 * 1000;
+  }
+  
+  // Extract seconds
+  if (match[3]) {
+    const seconds = parseInt(match[3]);
+    totalMs += seconds * 1000;
+  }
+  
+  return totalMs > 0 ? totalMs : null;
+}
+
+/**
+ * Parse upstream provider error response
+ * @param {Response} response - Fetch response from provider
+ * @param {string} provider - Provider name (for Antigravity-specific parsing)
+ * @returns {Promise<{statusCode: number, message: string, retryAfterMs: number|null}>}
+ */
+export async function parseUpstreamError(response, provider = null) {
+  let message = "";
+  let retryAfterMs = null;
+  
+  try {
+    const text = await response.text();
+    
+    // Try parse as JSON
+    try {
+      const json = JSON.parse(text);
+      message = json.error?.message || json.message || json.error || text;
+    } catch {
+      message = text;
+    }
+  } catch {
+    message = `Upstream error: ${response.status}`;
+  }
+
+  const messageStr = typeof message === "string" ? message : JSON.stringify(message);
+  const finalMessage = messageStr || DEFAULT_ERROR_MESSAGES[response.status] || `Upstream error: ${response.status}`;
+
+  // Parse Antigravity-specific retry time from error message
+  if (provider === "antigravity" && response.status === 429) {
+    retryAfterMs = parseAntigravityRetryTime(finalMessage);
+  }
+
+  return {
+    statusCode: response.status,
+    message: finalMessage,
+    retryAfterMs
+  };
+}
+
+/**
+ * Create error result for chatCore handler
+ * @param {number} statusCode - HTTP status code
+ * @param {string} message - Error message
+ * @param {number|null} retryAfterMs - Optional retry-after time in milliseconds
+ * @returns {{ success: false, status: number, error: string, response: Response, retryAfterMs?: number }}
+ */
+export function createErrorResult(statusCode, message, retryAfterMs = null) {
+  const result = {
+    success: false,
+    status: statusCode,
+    error: message,
+    response: errorResponse(statusCode, message)
+  };
+  
+  // Add retryAfterMs if available (for Antigravity quota errors)
+  if (retryAfterMs) {
+    result.retryAfterMs = retryAfterMs;
+  }
+  
+  return result;
+}
+
+/**
+ * Create unavailable response when all accounts are rate limited
+ * @param {number} statusCode - Original error status code
+ * @param {string} message - Error message (without retry info)
+ * @param {string} retryAfter - ISO timestamp when earliest account becomes available
+ * @param {string} retryAfterHuman - Human-readable retry info e.g. "reset after 30s"
+ * @returns {Response}
+ */
+export function unavailableResponse(statusCode, message, retryAfter, retryAfterHuman) {
+  const retryAfterSec = Math.max(Math.ceil((new Date(retryAfter).getTime() - Date.now()) / 1000), 1);
+  const msg = `${message} (${retryAfterHuman})`;
+  return new Response(
+    JSON.stringify({ error: { message: msg } }),
+    {
+      status: statusCode,
+      headers: {
+        "Content-Type": "application/json",
+        "Retry-After": String(retryAfterSec)
+      }
+    }
+  );
+}
+
+/**
+ * Format provider error with context
+ * @param {Error} error - Original error
+ * @param {string} provider - Provider name
+ * @param {string} model - Model name
+ * @param {number|string} statusCode - HTTP status code or error code
+ * @returns {string} Formatted error message
+ */
+export function formatProviderError(error, provider, model, statusCode) {
+  const code = statusCode || error.code || 'FETCH_FAILED';
+  const message = error.message || "Unknown error";
+  return `[${code}]: ${message}`;
+}

package/open-sse/utils/ollamaTransform.js

@@ -0,0 +1,85 @@
+// Transform OpenAI SSE stream to Ollama JSON lines format
+export function transformToOllama(response, model) {
+  let buffer = "";
+  let pendingToolCalls = {};
+  
+  const transform = new TransformStream({
+    transform(chunk, controller) {
+      const text = new TextDecoder().decode(chunk);
+      buffer += text;
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+
+      for (const line of lines) {
+        if (!line.startsWith("data:")) continue;
+        const data = line.slice(5).trim();
+        
+        if (data === "[DONE]") {
+          const ollamaEnd = JSON.stringify({ model, message: { role: "assistant", content: "" }, done: true }) + "\n";
+          controller.enqueue(new TextEncoder().encode(ollamaEnd));
+          return;
+        }
+
+        try {
+          const parsed = JSON.parse(data);
+          const delta = parsed.choices?.[0]?.delta || {};
+          const content = delta.content || "";
+          const toolCalls = delta.tool_calls;
+
+          if (toolCalls) {
+            for (const tc of toolCalls) {
+              const idx = tc.index;
+              if (!pendingToolCalls[idx]) {
+                pendingToolCalls[idx] = { id: tc.id, function: { name: "", arguments: "" } };
+              }
+              if (tc.function?.name) pendingToolCalls[idx].function.name += tc.function.name;
+              if (tc.function?.arguments) pendingToolCalls[idx].function.arguments += tc.function.arguments;
+            }
+          }
+
+          if (content) {
+            const ollama = JSON.stringify({ model, message: { role: "assistant", content }, done: false }) + "\n";
+            controller.enqueue(new TextEncoder().encode(ollama));
+          }
+
+          const finishReason = parsed.choices?.[0]?.finish_reason;
+          if (finishReason === "tool_calls" || finishReason === "stop") {
+            const toolCallsArr = Object.values(pendingToolCalls);
+            if (toolCallsArr.length > 0) {
+              const formattedCalls = toolCallsArr.map(tc => ({
+                function: {
+                  name: tc.function.name,
+                  arguments: (() => { try { return JSON.parse(tc.function.arguments || "{}"); } catch { return {}; } })()
+                }
+              }));
+              const ollama = JSON.stringify({ 
+                model, 
+                message: { role: "assistant", content: "", tool_calls: formattedCalls }, 
+                done: true
+              }) + "\n";
+              controller.enqueue(new TextEncoder().encode(ollama));
+              pendingToolCalls = {};
+            } else if (finishReason === "stop") {
+              const ollamaEnd = JSON.stringify({ model, message: { role: "assistant", content: "" }, done: true }) + "\n";
+              controller.enqueue(new TextEncoder().encode(ollamaEnd));
+            }
+          }
+        } catch (e) {
+          // Silently ignore parse errors
+        }
+      }
+    },
+    flush(controller) {
+      const ollamaEnd = JSON.stringify({ model, message: { role: "assistant", content: "" }, done: true }) + "\n";
+      controller.enqueue(new TextEncoder().encode(ollamaEnd));
+    }
+  });
+
+  if (!response.body) {
+    return new Response("", { status: response.status, headers: { "Content-Type": "application/x-ndjson" } });
+  }
+  return new Response(response.body.pipeThrough(transform), {
+    headers: { "Content-Type": "application/x-ndjson", "Access-Control-Allow-Origin": "*" }
+  });
+}
+

package/open-sse/utils/proxyFetch.js

@@ -0,0 +1,258 @@
+import { Readable } from "stream";
+import { MEMORY_CONFIG } from "../config/runtimeConfig.js";
+
+const isCloud = typeof caches !== "undefined" && typeof caches === "object";
+
+const originalFetch = globalThis.fetch;
+const proxyDispatchers = new Map();
+
+// DNS cache — use Map to avoid prototype pollution via malformed hostnames
+const DNS_CACHE = new Map();
+const MITM_BYPASS_HOSTS = [
+  "cloudcode-pa.googleapis.com",
+  "daily-cloudcode-pa.googleapis.com",
+  "api.individual.githubcopilot.com",
+  "q.us-east-1.amazonaws.com",
+  "codewhisperer.us-east-1.amazonaws.com",
+  "api2.cursor.sh",
+];
+const GOOGLE_DNS_SERVERS = ["8.8.8.8", "8.8.4.4"];
+const HTTPS_PORT = 443;
+const HTTP_SUCCESS_MIN = 200;
+const HTTP_SUCCESS_MAX = 300;
+
+function normalizeString(value) {
+  if (value === undefined || value === null) return "";
+  return String(value).trim();
+}
+
+/**
+ * Resolve real IP using Google DNS (bypass system DNS)
+ */
+async function resolveRealIP(hostname) {
+  const cached = DNS_CACHE.get(hostname);
+  if (cached && Date.now() < cached.expiry) return cached.ip;
+
+  try {
+    const dns = await import("dns");
+    const { promisify } = await import("util");
+    const resolver = new dns.Resolver();
+    resolver.setServers(GOOGLE_DNS_SERVERS);
+    const resolve4 = promisify(resolver.resolve4.bind(resolver));
+    const addresses = await resolve4(hostname);
+    DNS_CACHE.set(hostname, { ip: addresses[0], expiry: Date.now() + MEMORY_CONFIG.dnsCacheTtlMs });
+    return addresses[0];
+  } catch (error) {
+    console.warn(`[ProxyFetch] DNS resolve failed for ${hostname}:`, error.message);
+    return null;
+  }
+}
+
+/**
+ * Check if request should bypass MITM DNS redirect
+ */
+function shouldBypassMitmDns(url) {
+  try {
+    const hostname = new URL(url).hostname;
+    return MITM_BYPASS_HOSTS.some(host => hostname.includes(host));
+  } catch { return false; }
+}
+
+function shouldBypassByNoProxy(targetUrl, noProxyValue) {
+  const noProxy = normalizeString(noProxyValue);
+  if (!noProxy) return false;
+
+  let hostname;
+  try { hostname = new URL(targetUrl).hostname.toLowerCase(); } catch { return false; }
+  const patterns = noProxy.split(",").map((p) => p.trim().toLowerCase()).filter(Boolean);
+
+  return patterns.some((pattern) => {
+    if (pattern === "*") return true;
+    if (pattern.startsWith(".")) return hostname.endsWith(pattern) || hostname === pattern.slice(1);
+    return hostname === pattern || hostname.endsWith(`.${pattern}`);
+  });
+}
+
+/**
+ * Get proxy URL from environment
+ */
+function getEnvProxyUrl(targetUrl) {
+  const noProxy = process.env.NO_PROXY || process.env.no_proxy;
+  if (shouldBypassByNoProxy(targetUrl, noProxy)) return null;
+
+  let protocol;
+  try { protocol = new URL(targetUrl).protocol; } catch { return null; }
+
+  if (protocol === "https:") {
+    return process.env.HTTPS_PROXY || process.env.https_proxy ||
+           process.env.ALL_PROXY || process.env.all_proxy;
+  }
+
+  return process.env.HTTP_PROXY || process.env.http_proxy ||
+         process.env.ALL_PROXY || process.env.all_proxy;
+}
+
+/**
+ * Normalize proxy URL (allow host:port)
+ */
+function normalizeProxyUrl(proxyUrl) {
+  const normalizedInput = normalizeString(proxyUrl);
+  if (!normalizedInput) return null;
+
+  try {
+    // eslint-disable-next-line no-new
+    new URL(normalizedInput);
+    return normalizedInput;
+  } catch {
+    // Allow "127.0.0.1:7890" style values
+    return `http://${normalizedInput}`;
+  }
+}
+
+function resolveConnectionProxyUrl(targetUrl, proxyOptions) {
+  const enabled = proxyOptions?.enabled === true || proxyOptions?.connectionProxyEnabled === true;
+  if (!enabled) return null;
+
+  const proxyUrlRaw = normalizeString(proxyOptions?.url ?? proxyOptions?.connectionProxyUrl);
+  if (!proxyUrlRaw) return null;
+
+  const noProxy = normalizeString(proxyOptions?.noProxy ?? proxyOptions?.connectionNoProxy);
+  if (noProxy && shouldBypassByNoProxy(targetUrl, noProxy)) return null;
+
+  return normalizeProxyUrl(proxyUrlRaw);
+}
+
+/**
+ * Create proxy dispatcher lazily (undici-compatible)
+ */
+async function getDispatcher(proxyUrl) {
+  const normalized = normalizeProxyUrl(proxyUrl);
+  if (!normalized) return null;
+
+  if (!proxyDispatchers.has(normalized)) {
+    // Evict oldest entry if max size reached
+    if (proxyDispatchers.size >= MEMORY_CONFIG.proxyDispatchersMaxSize) {
+      proxyDispatchers.delete(proxyDispatchers.keys().next().value);
+    }
+    const { ProxyAgent } = await import("undici");
+    proxyDispatchers.set(normalized, new ProxyAgent({ uri: normalized }));
+  }
+
+  return proxyDispatchers.get(normalized);
+}
+
+/**
+ * Create HTTPS request with manual socket connection (bypass DNS)
+ */
+async function createBypassRequest(parsedUrl, realIP, options) {
+  const httpsModule = await import("https");
+  const netModule = await import("net");
+  // CJS modules expose exports via .default in ESM dynamic import context
+  const https = httpsModule.default ?? httpsModule;
+  const net = netModule.default ?? netModule;
+
+  return new Promise((resolve, reject) => {
+    const socket = new net.Socket();
+
+    socket.connect(HTTPS_PORT, realIP, () => {
+      const reqOptions = {
+        socket,
+        servername: parsedUrl.hostname,
+        rejectUnauthorized: false,
+        path: parsedUrl.pathname + parsedUrl.search,
+        method: options.method || "POST",
+        headers: {
+          ...options.headers,
+          Host: parsedUrl.hostname,
+        },
+      };
+
+      const req = https.request(reqOptions, (res) => {
+        const response = {
+          ok: res.statusCode >= HTTP_SUCCESS_MIN && res.statusCode < HTTP_SUCCESS_MAX,
+          status: res.statusCode,
+          statusText: res.statusMessage,
+          headers: new Map(Object.entries(res.headers)),
+          body: Readable.toWeb(res),
+          text: async () => {
+            const chunks = [];
+            for await (const chunk of res) chunks.push(chunk);
+            return Buffer.concat(chunks).toString();
+          },
+          json: async () => JSON.parse(await response.text()),
+        };
+        resolve(response);
+      });
+
+      req.on("error", reject);
+      if (options.body) {
+        req.write(typeof options.body === "string" ? options.body : JSON.stringify(options.body));
+      }
+      req.end();
+    });
+
+    socket.on("error", reject);
+  });
+}
+
+export async function proxyAwareFetch(url, options = {}, proxyOptions = null) {
+  const targetUrl = typeof url === "string" ? url : url.toString();
+
+  const connectionProxyUrl = resolveConnectionProxyUrl(targetUrl, proxyOptions);
+  const envProxyUrl = connectionProxyUrl ? null : normalizeProxyUrl(getEnvProxyUrl(targetUrl));
+  const proxyUrl = connectionProxyUrl || envProxyUrl;
+
+  // MITM DNS bypass: for known MITM-intercepted hosts, resolve real IP to avoid DNS spoof
+  if (shouldBypassMitmDns(targetUrl)) {
+    if (proxyUrl) {
+      // Proxy resolves DNS externally (not affected by /etc/hosts) — use proxy directly
+      try {
+        const dispatcher = await getDispatcher(proxyUrl);
+        return await originalFetch(url, { ...options, dispatcher });
+      } catch (proxyError) {
+        if (proxyOptions?.strictProxy === true) {
+          throw new Error(`[ProxyFetch] Proxy required but failed (strictProxy=true): ${proxyError.message}`);
+        }
+        console.warn(`[ProxyFetch] Proxy failed, falling back to direct bypass: ${proxyError.message}`);
+      }
+    }
+    // No proxy — manually resolve real IP to bypass DNS spoof
+    try {
+      const parsedUrl = new URL(targetUrl);
+      const realIP = await resolveRealIP(parsedUrl.hostname);
+      if (realIP) return await createBypassRequest(parsedUrl, realIP, options);
+    } catch (error) {
+      console.warn(`[ProxyFetch] MITM bypass failed: ${error.message}`);
+    }
+  }
+
+  if (proxyUrl) {
+    try {
+      const dispatcher = await getDispatcher(proxyUrl);
+      return await originalFetch(url, { ...options, dispatcher });
+    } catch (proxyError) {
+      // If strictProxy is enabled, fail hard instead of falling back to direct
+      if (proxyOptions?.strictProxy === true) {
+        throw new Error(`[ProxyFetch] Proxy required but failed (strictProxy=true): ${proxyError.message}`);
+      }
+      console.warn(`[ProxyFetch] Proxy failed, falling back to direct: ${proxyError.message}`);
+      return originalFetch(url, options);
+    }
+  }
+
+  return originalFetch(url, options);
+}
+
+/**
+ * Patched global fetch with env-proxy support and MITM DNS bypass
+ */
+async function patchedFetch(url, options = {}) {
+  return proxyAwareFetch(url, options, null);
+}
+
+// Idempotency guard — only patch once to avoid wrapping multiple times
+if (!isCloud && globalThis.fetch !== patchedFetch) {
+  globalThis.fetch = patchedFetch;
+}
+
+export default isCloud ? originalFetch : patchedFetch;