[FEATURE]:Support Gemini models with Function Calling through incompatible OpenAI-compatible proxies #11479

#!/usr/bin/env node

/**
 * OpenCode Compatibility Proxy Server
 * Filters incompatible JSON Schema fields for certain proxy APIs
 */

const http = require('http');
const https = require('https');
const url = require('url');
const zlib = require('zlib');

const TARGET_API = 'https://api.v3.cm/v1/';
const API_KEY = 'your_api_key_here';
const PORT = 8080;

/**
 * Recursively clean JSON Schema, removing incompatible fields
 */
function cleanSchema(obj) {
  if (!obj || typeof obj !== 'object') {
    return obj;
  }

  // Remove incompatible fields
  const incompatibleFields = ['$ref', 'ref', 'propertyNames', 'patternProperties', 'additionalProperties', 'allOf', 'anyOf', 'oneOf', 'not'];
  
  if (Array.isArray(obj)) {
    return obj.map(item => cleanSchema(item));
  }

  const cleaned = {};
  for (const key in obj) {
    if (incompatibleFields.includes(key)) {
      console.log(`[Filter] Removing incompatible field: ${key}`);
      continue;
    }
    
    // Special handling for properties
    if (key === 'properties' && typeof obj[key] === 'object') {
      cleaned[key] = {};
      for (const prop in obj[key]) {
        cleaned[key][prop] = cleanSchema(obj[key][prop]);
      }
      continue;
    }
    
    // Special handling for items
    if (key === 'items') {
      cleaned[key] = cleanSchema(obj[key]);
      continue;
    }
    
    // Recursively process nested objects
    cleaned[key] = cleanSchema(obj[key]);
  }
  
  return cleaned;
}

/**
 * Clean function declarations in tools array
 */
function cleanTools(body) {
  if (!body.tools) {
    return body;
  }

  console.log('[Clean] Found tools field, starting cleanup...');
  
  const cleanedTools = body.tools.map(tool => {
    if (tool.function && tool.function.parameters) {
      console.log(`[Clean] Processing function: ${tool.function.name}`);
      return {
        ...tool,
        function: {
          ...tool.function,
          parameters: cleanSchema(tool.function.parameters)
        }
      };
    }
    return tool;
  });

  return {
    ...body,
    tools: cleanedTools
  };
}

/**
 * Handle requests
 */
function handleRequest(req, res) {
  let body = '';
  
  req.on('data', chunk => {
    body += chunk.toString();
  });
  
  req.on('end', () => {
    try {
      const parsedBody = JSON.parse(body);
      console.log(`[Request] Received ${req.method} ${req.url}`);
      
      // Clean incompatible fields
      const cleanedBody = cleanTools(parsedBody);
      
      // Forward to target API
      const targetUrl = url.parse(TARGET_API + req.url.slice(1));
      const options = {
        hostname: targetUrl.hostname,
        port: targetUrl.port || 443,
        path: targetUrl.path,
        method: req.method,
        rejectUnauthorized: false,
        headers: {
          'Content-Type': 'application/json',
          'Authorization': `Bearer ${API_KEY}`,
          'Accept-Encoding': 'identity',
          'User-Agent': 'OpenCode-Proxy/1.0'
        }
      };
      
      const proxyReq = https.request(options, (proxyRes) => {
        const chunks = [];
        
        proxyRes.on('data', chunk => {
          chunks.push(chunk);
        });
        
        proxyRes.on('end', () => {
          console.log(`[Response] Status: ${proxyRes.statusCode}`);
          
          const buffer = Buffer.concat(chunks);
          let responseBody = buffer.toString('utf-8');
          
          // Handle compressed responses
          const encoding = proxyRes.headers['content-encoding'];
          if (encoding === 'gzip' || encoding === 'deflate') {
            try {
              if (encoding === 'gzip') {
                responseBody = zlib.gunzipSync(buffer).toString('utf-8');
              } else if (encoding === 'deflate') {
                responseBody = zlib.inflateSync(buffer).toString('utf-8');
              }
            } catch (decompressError) {
              responseBody = buffer.toString('utf-8');
            }
          }
          
          const responseHeaders = { ...proxyRes.headers };
          delete responseHeaders['content-encoding'];
          delete responseHeaders['content-length'];
          delete responseHeaders['transfer-encoding'];
          
          res.writeHead(proxyRes.statusCode, responseHeaders);
          res.end(responseBody);
        });
      });
      
      proxyReq.on('error', (error) => {
        console.error('[Error] Proxy request failed:', error);
        res.writeHead(500, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ error: 'Proxy request failed', details: error.message }));
      });
      
      proxyReq.write(JSON.stringify(cleanedBody));
      proxyReq.end();
      
    } catch (error) {
      console.error('[Error] Failed to parse request:', error);
      res.writeHead(400, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ error: 'Invalid JSON', details: error.message }));
    }
  });
}

// Start server
const server = http.createServer(handleRequest);
server.listen(PORT, '127.0.0.1', () => {
  console.log(`[Startup] Proxy server running on http://127.0.0.1:${PORT}`);
  console.log(`[Config] Target API: ${TARGET_API}`);
});