protocol-proxy 1.0.0

package/lib/converters/openai-to-anthropic.js

@@ -0,0 +1,321 @@
+/**
+ * OpenAI → Anthropic 协议转换
+ */
+
+const { encodeAnthropicEvent } = require('./sse-helpers');
+
+// ==================== 请求转换 ====================
+
+function convertRequest(body, targetModel) {
+  const result = {
+    model: targetModel,
+    max_tokens: body.max_tokens || 4096,
+    stream: body.stream || false,
+  };
+
+  if (body.temperature !== undefined) result.temperature = body.temperature;
+  if (body.top_p !== undefined) result.top_p = body.top_p;
+  if (body.stop !== undefined) result.stop_sequences = Array.isArray(body.stop) ? body.stop : [body.stop];
+
+  // 处理 messages 和 system
+  const systemMessages = [];
+  const otherMessages = [];
+
+  for (const msg of (body.messages || [])) {
+    if (msg.role === 'system') {
+      systemMessages.push(typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content));
+    } else {
+      otherMessages.push(msg);
+    }
+  }
+
+  if (systemMessages.length > 0) {
+    result.system = systemMessages.join('\n\n');
+  }
+
+  // 转换消息角色和内容
+  result.messages = otherMessages.map(msg => convertMessage(msg));
+
+  // 转换 tools / functions
+  if (body.tools && Array.isArray(body.tools)) {
+    result.tools = body.tools.map(t => convertTool(t));
+  } else if (body.functions && Array.isArray(body.functions)) {
+    // 旧版 functions 转 tools
+    result.tools = body.functions.map(f => ({
+      name: f.name,
+      description: f.description,
+      input_schema: f.parameters || { type: 'object', properties: {} },
+    }));
+  }
+
+  // 转换 tool_choice
+  if (body.tool_choice) {
+    result.tool_choice = convertToolChoice(body.tool_choice);
+  }
+
+  return result;
+}
+
+function convertMessage(msg) {
+  if (msg.role === 'tool') {
+    // OpenAI tool result → Anthropic tool_result content block
+    return {
+      role: 'user',
+      content: [{
+        type: 'tool_result',
+        tool_use_id: msg.tool_call_id,
+        content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
+      }],
+    };
+  }
+
+  if (msg.role === 'assistant' && msg.tool_calls) {
+    // assistant message with tool_calls → assistant with tool_use blocks
+    const content = [];
+    if (msg.content) {
+      content.push({ type: 'text', text: msg.content });
+    }
+    for (const tc of msg.tool_calls) {
+      content.push({
+        type: 'tool_use',
+        id: tc.id,
+        name: tc.function?.name,
+        input: tc.function?.arguments ? JSON.parse(tc.function.arguments) : {},
+      });
+    }
+    return { role: 'assistant', content };
+  }
+
+  // 普通消息
+  return {
+    role: msg.role,
+    content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
+  };
+}
+
+function convertTool(tool) {
+  return {
+    name: tool.function?.name || tool.name,
+    description: tool.function?.description || tool.description,
+    input_schema: tool.function?.parameters || tool.input_schema || { type: 'object', properties: {} },
+  };
+}
+
+function convertToolChoice(tc) {
+  if (tc === 'auto') return { type: 'auto' };
+  if (tc === 'none') return { type: 'none' };
+  if (tc === 'required') return { type: 'any' };
+  if (typeof tc === 'object' && tc.type === 'function') {
+    return { type: 'tool', name: tc.function?.name };
+  }
+  return { type: 'auto' };
+}
+
+// ==================== 响应转换 ====================
+
+function convertResponse(anthropicBody) {
+  const choice = {
+    index: 0,
+    message: {
+      role: 'assistant',
+      content: '',
+    },
+    finish_reason: null,
+  };
+
+  // 提取文本内容和 tool_calls
+  const toolCalls = [];
+  const textParts = [];
+
+  for (const block of (anthropicBody.content || [])) {
+    if (block.type === 'text') {
+      textParts.push(block.text);
+    } else if (block.type === 'tool_use') {
+      toolCalls.push({
+        id: block.id,
+        type: 'function',
+        function: {
+          name: block.name,
+          arguments: JSON.stringify(block.input || {}),
+        },
+      });
+    }
+  }
+
+  choice.message.content = textParts.join('');
+  if (toolCalls.length > 0) {
+    choice.message.tool_calls = toolCalls;
+  }
+
+  // 映射 stop_reason
+  choice.finish_reason = mapStopReason(anthropicBody.stop_reason);
+
+  return {
+    id: anthropicBody.id,
+    object: 'chat.completion',
+    created: Math.floor(Date.now() / 1000),
+    model: anthropicBody.model,
+    choices: [choice],
+    usage: anthropicBody.usage ? {
+      prompt_tokens: anthropicBody.usage.input_tokens,
+      completion_tokens: anthropicBody.usage.output_tokens,
+      total_tokens: (anthropicBody.usage.input_tokens || 0) + (anthropicBody.usage.output_tokens || 0),
+    } : undefined,
+  };
+}
+
+function mapStopReason(reason) {
+  if (!reason) return null;
+  if (reason === 'end_turn') return 'stop';
+  if (reason === 'max_tokens') return 'length';
+  if (reason === 'tool_use') return 'tool_calls';
+  if (reason === 'stop_sequence') return 'stop';
+  return reason;
+}
+
+// ==================== SSE 流式转换 ====================
+
+function createSSEConverter(targetModel) {
+  const state = {
+    messageId: null,
+    blockType: null,
+    blockIndex: 0,
+    toolUseId: null,
+    toolName: null,
+    sentRole: false,
+    sentToolInit: false,
+    buffer: '',
+  };
+
+  return {
+    convertChunk(chunkText) {
+      let output = '';
+      state.buffer += chunkText;
+      const lines = state.buffer.split('\n');
+      state.buffer = lines.pop() || ''; // 保留不完整的最后一行
+
+      for (const line of lines) {
+        const converted = processLine(line.trim(), state, targetModel);
+        if (converted) output += converted;
+      }
+
+      return output;
+    },
+    flush() {
+      // 结束时不发送额外内容，[DONE] 在 finish_reason 时已经发送
+      return '';
+    },
+  };
+}
+
+function processLine(line, state, targetModel) {
+  if (!line.startsWith('data:')) return '';
+  const dataStr = line.slice(5).trim();
+  if (dataStr === '[DONE]') return '';
+
+  let event;
+  try {
+    event = JSON.parse(dataStr);
+  } catch {
+    return '';
+  }
+
+  if (!event || !event.type) return '';
+
+  switch (event.type) {
+    case 'message_start': {
+      state.messageId = event.message?.id;
+      state.sentRole = false;
+      return '';
+    }
+
+    case 'content_block_start': {
+      state.blockType = event.content_block?.type;
+      state.blockIndex = event.index;
+      state.sentToolInit = false;
+
+      if (state.blockType === 'tool_use') {
+        state.toolUseId = event.content_block.id;
+        state.toolName = event.content_block.name;
+      }
+      return '';
+    }
+
+    case 'content_block_delta': {
+      const delta = event.delta;
+      if (!delta) return '';
+
+      // 发送 role（如果是第一个内容块）
+      let prefix = '';
+      if (!state.sentRole) {
+        prefix = encodeOpenAIChunk(state.messageId, targetModel, { role: 'assistant' });
+        state.sentRole = true;
+      }
+
+      if (delta.type === 'text_delta' && delta.text) {
+        return prefix + encodeOpenAIChunk(state.messageId, targetModel, { content: delta.text });
+      }
+
+      if (delta.type === 'input_json_delta' && delta.partial_json !== undefined) {
+        if (!state.sentToolInit) {
+          state.sentToolInit = true;
+          const toolCallChunk = {
+            tool_calls: [{
+              index: 0,
+              id: state.toolUseId,
+              type: 'function',
+              function: { name: state.toolName, arguments: delta.partial_json },
+            }],
+          };
+          return prefix + encodeOpenAIChunk(state.messageId, targetModel, toolCallChunk);
+        }
+        return prefix + encodeOpenAIChunk(state.messageId, targetModel, {
+          tool_calls: [{ index: 0, function: { arguments: delta.partial_json } }],
+        });
+      }
+
+      return prefix;
+    }
+
+    case 'content_block_stop': {
+      state.blockType = null;
+      return '';
+    }
+
+    case 'message_delta': {
+      const stopReason = event.delta?.stop_reason;
+      if (stopReason) {
+        return encodeOpenAIChunk(state.messageId, targetModel, {}, mapStopReason(stopReason));
+      }
+      return '';
+    }
+
+    case 'message_stop': {
+      return 'data: [DONE]\n\n';
+    }
+
+    default:
+      return '';
+  }
+}
+
+function encodeOpenAIChunk(id, model, delta, finishReason = null) {
+  const chunk = {
+    id: id || 'chatcmpl-proxy',
+    object: 'chat.completion.chunk',
+    created: Math.floor(Date.now() / 1000),
+    model: model || 'proxy-model',
+    choices: [{
+      index: 0,
+      delta,
+      finish_reason: finishReason,
+    }],
+  };
+  return `data: ${JSON.stringify(chunk)}\n\n`;
+}
+
+module.exports = {
+  convertRequest,
+  convertResponse,
+  createSSEConverter,
+};

package/lib/converters/sse-helpers.js

@@ -0,0 +1,51 @@
+/**
+ * SSE 解析与编码辅助函数
+ */
+
+function parseSSELines(buffer) {
+  const lines = buffer.split('\n');
+  const events = [];
+  let currentEvent = { event: null, data: null };
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed === '') {
+      // 空行表示一个事件结束
+      if (currentEvent.data !== null) {
+        events.push(currentEvent);
+      }
+      currentEvent = { event: null, data: null };
+      continue;
+    }
+    if (trimmed.startsWith('event:')) {
+      currentEvent.event = trimmed.slice(6).trim();
+    } else if (trimmed.startsWith('data:')) {
+      const data = trimmed.slice(5).trim();
+      currentEvent.data = currentEvent.data === null ? data : currentEvent.data + '\n' + data;
+    }
+  }
+
+  // 如果最后一行没有空行结束，保留未完成的事件
+  const remainder = currentEvent.data !== null ? currentEvent : null;
+
+  return { events, remainder };
+}
+
+function encodeOpenAIEvent(obj) {
+  return `data: ${JSON.stringify(obj)}\n\n`;
+}
+
+function encodeOpenAIDone() {
+  return 'data: [DONE]\n\n';
+}
+
+function encodeAnthropicEvent(eventName, obj) {
+  return `event: ${eventName}\ndata: ${JSON.stringify(obj)}\n\n`;
+}
+
+module.exports = {
+  parseSSELines,
+  encodeOpenAIEvent,
+  encodeOpenAIDone,
+  encodeAnthropicEvent,
+};

package/lib/detector.js

@@ -0,0 +1,38 @@
+/**
+ * 检测入站请求使用的协议类型
+ */
+
+function detectInboundProtocol(req, body) {
+  const path = req.path || req.url || '';
+
+  // Anthropic 特征路径
+  if (path.includes('/v1/messages')) {
+    return 'anthropic';
+  }
+
+  // OpenAI 特征路径
+  if (path.includes('/v1/chat/completions')) {
+    return 'openai';
+  }
+
+  // 根据 body 结构推断
+  if (body && typeof body === 'object') {
+    // Anthropic: 有 system 顶级字段，messages 中角色没有 system
+    if (body.system !== undefined && Array.isArray(body.messages)) {
+      return 'anthropic';
+    }
+    // OpenAI: messages 数组中包含 role: system
+    if (Array.isArray(body.messages) && body.messages.some(m => m && m.role === 'system')) {
+      return 'openai';
+    }
+    // 默认按 functions/tools 字段判断
+    if (body.functions !== undefined || (body.tools && Array.isArray(body.tools))) {
+      return 'openai';
+    }
+  }
+
+  // 无法确定时，默认 openai
+  return 'openai';
+}
+
+module.exports = { detectInboundProtocol };

package/lib/proxy-manager.js

@@ -0,0 +1,79 @@
+const { createProxyApp } = require('./proxy-server');
+
+class ProxyManager {
+  constructor() {
+    this.servers = new Map(); // id -> { app, server, config }
+  }
+
+  async startProxy(proxyConfig) {
+    const id = proxyConfig.id;
+
+    // 如果已存在，先停止
+    if (this.servers.has(id)) {
+      await this.stopProxy(id);
+    }
+
+    return new Promise((resolve, reject) => {
+      const entry = { app: null, server: null, config: proxyConfig };
+      const app = createProxyApp(() => entry.config);
+      const server = app.listen(proxyConfig.port, () => {
+        console.log(`[Proxy] ${proxyConfig.name} started on port ${proxyConfig.port}`);
+        entry.app = app;
+        entry.server = server;
+        this.servers.set(id, entry);
+        resolve(true);
+      });
+
+      server.on('error', (err) => {
+        console.error(`[Proxy] ${proxyConfig.name} error:`, err.message);
+        this.servers.delete(id);
+        reject(err);
+      });
+    });
+  }
+
+  async stopProxy(id) {
+    const entry = this.servers.get(id);
+    if (!entry) return false;
+
+    return new Promise((resolve) => {
+      entry.server.close(() => {
+        console.log(`[Proxy] ${entry.config.name} stopped on port ${entry.config.port}`);
+        resolve(true);
+      });
+      this.servers.delete(id);
+    });
+  }
+
+  async restartProxy(proxyConfig) {
+    await this.stopProxy(proxyConfig.id);
+    return this.startProxy(proxyConfig);
+  }
+
+  updateProxyConfig(proxyConfig) {
+    const entry = this.servers.get(proxyConfig.id);
+    if (!entry) return false;
+    entry.config = proxyConfig;
+    return true;
+  }
+
+  isRunning(id) {
+    return this.servers.has(id);
+  }
+
+  getRunningPorts() {
+    return Array.from(this.servers.values()).map(s => ({
+      id: s.config.id,
+      name: s.config.name,
+      port: s.config.port,
+    }));
+  }
+
+  async stopAll() {
+    for (const [id] of this.servers) {
+      await this.stopProxy(id);
+    }
+  }
+}
+
+module.exports = new ProxyManager();

package/lib/proxy-server.js

@@ -0,0 +1,216 @@
+const express = require('express');
+const { detectInboundProtocol } = require('./detector');
+const o2a = require('./converters/openai-to-anthropic');
+const a2o = require('./converters/anthropic-to-openai');
+
+function createProxyApp(proxyConfigOrGetter) {
+  const getProxyConfig = typeof proxyConfigOrGetter === 'function'
+    ? proxyConfigOrGetter
+    : () => proxyConfigOrGetter;
+  const app = express();
+  app.use(express.json({ limit: '50mb' }));
+
+  // reasoning_content 缓存（用于 DeepSeek 等 reasoning model）
+  // key: assistant message content, value: reasoning_content
+  const reasoningCache = new Map();
+  const MAX_CACHE_SIZE = 100;
+
+  function setReasoning(content, reasoning) {
+    if (!content || !reasoning) return;
+    if (reasoningCache.size >= MAX_CACHE_SIZE) {
+      const firstKey = reasoningCache.keys().next().value;
+      reasoningCache.delete(firstKey);
+    }
+    reasoningCache.set(content, reasoning);
+  }
+
+  function getReasoning(content) {
+    return reasoningCache.get(content);
+  }
+
+  function injectReasoningToMessages(messages) {
+    if (!Array.isArray(messages)) return;
+    for (const msg of messages) {
+      if (msg.role === 'assistant') {
+        const reasoning = getReasoning(msg.content);
+        // DeepSeek 等 reasoning model 要求 assistant message 必须包含 reasoning_content 字段
+        msg.reasoning_content = reasoning || '';
+      }
+    }
+  }
+
+  function extractReasoningFromResponse(body) {
+    const choice = body.choices?.[0];
+    const message = choice?.message;
+    if (message?.role === 'assistant' && message.reasoning_content) {
+      setReasoning(message.content, message.reasoning_content);
+    }
+  }
+
+  app.use((req, res, next) => {
+    res.header('Access-Control-Allow-Origin', '*');
+    res.header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+    res.header('Access-Control-Allow-Headers', 'Content-Type, Authorization, X-Api-Key');
+    if (req.method === 'OPTIONS') return res.sendStatus(200);
+    next();
+  });
+
+  app.use((req, res, next) => {
+    const proxyConfig = getProxyConfig();
+    if (!proxyConfig.requireAuth || !proxyConfig.authToken) {
+      return next();
+    }
+
+    const token = req.headers.authorization?.replace('Bearer ', '') || req.headers['x-api-key'];
+    if (token !== proxyConfig.authToken) {
+      return res.status(401).json({ error: 'Unauthorized' });
+    }
+    next();
+  });
+
+  app.post('/v1/chat/completions', handleRequest);
+  app.post('/v1/messages', handleRequest);
+
+  async function handleRequest(req, res) {
+    const requestId = `req-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+    try {
+      const proxyConfig = getProxyConfig();
+      const inboundProtocol = detectInboundProtocol(req, req.body);
+      const target = proxyConfig.target;
+
+      if (!target) {
+        return res.status(500).json({ error: 'Proxy target not configured' });
+      }
+
+      const targetProtocol = target.protocol;
+      const isStream = req.body?.stream === true;
+
+      console.log(`[${requestId}] ⬅️  ${inboundProtocol.toUpperCase()} → ${targetProtocol.toUpperCase()} | path=${req.path}`);
+
+      // 决定转换方向
+      let convertReq, convertRes, createSSEConv;
+      if (inboundProtocol === 'openai' && targetProtocol === 'anthropic') {
+        convertReq = o2a.convertRequest;
+        convertRes = o2a.convertResponse;
+        createSSEConv = o2a.createSSEConverter;
+      } else if (inboundProtocol === 'anthropic' && targetProtocol === 'openai') {
+        convertReq = a2o.convertRequest;
+        convertRes = a2o.convertResponse;
+        createSSEConv = a2o.createSSEConverter;
+      } else {
+        convertReq = (body, model) => ({ ...body, model: body.model || model });
+        convertRes = (body) => body;
+        createSSEConv = null;
+      }
+
+      // 如果请求没有 model，注入默认 model
+      const inboundModel = req.body?.model;
+      const effectiveModel = target.defaultModel || inboundModel;
+      if (effectiveModel) {
+        req.body = { ...req.body, model: effectiveModel };
+      }
+
+      const targetBody = convertReq(req.body, effectiveModel);
+
+      // 注入 reasoning_content（针对 DeepSeek 等 reasoning model）
+      injectReasoningToMessages(targetBody.messages);
+
+      // 构建目标 URL
+      const targetUrl = buildTargetUrl(target.providerUrl, targetProtocol, req.path);
+      console.log(`[${requestId}] 🔗 ${targetUrl} | model=${effectiveModel}`);
+
+      // 构建请求头
+      const headers = {
+        'Content-Type': 'application/json',
+        'Accept': isStream ? 'text/event-stream' : 'application/json',
+      };
+
+      if (targetProtocol === 'openai') {
+        headers['Authorization'] = `Bearer ${target.apiKey}`;
+      } else if (targetProtocol === 'anthropic') {
+        headers['X-Api-Key'] = target.apiKey;
+        headers['Anthropic-Version'] = '2023-06-01';
+        headers['Authorization'] = `Bearer ${target.apiKey}`;
+      }
+
+      const fetchRes = await fetch(targetUrl, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(targetBody),
+        signal: AbortSignal.timeout(120000),
+      });
+
+      if (!fetchRes.ok) {
+        const errBody = await fetchRes.text();
+        console.log(`[${requestId}] ❌ Target error: HTTP ${fetchRes.status} | ${errBody.slice(0, 500)}`);
+        res.status(fetchRes.status);
+        res.set('Content-Type', fetchRes.headers.get('content-type') || 'application/json');
+        return res.send(errBody);
+      }
+
+      // 流式响应
+      if (isStream && fetchRes.headers.get('content-type')?.includes('text/event-stream')) {
+        res.setHeader('Content-Type', 'text/event-stream');
+        res.setHeader('Cache-Control', 'no-cache');
+        res.setHeader('Connection', 'keep-alive');
+
+        const sseConverter = createSSEConv ? createSSEConv(effectiveModel) : null;
+        const reader = fetchRes.body.getReader();
+        const decoder = new TextDecoder();
+
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            const chunk = decoder.decode(value, { stream: true });
+            if (sseConverter) {
+              const converted = sseConverter.convertChunk(chunk);
+              if (converted) res.write(converted);
+            } else {
+              res.write(chunk);
+            }
+          }
+          if (sseConverter) {
+            const flushed = sseConverter.flush();
+            if (flushed) res.write(flushed);
+          }
+        } catch (err) {
+          console.error(`[${requestId}] Stream error:`, err.message);
+        } finally {
+          res.end();
+        }
+        return;
+      }
+
+      const responseBody = await fetchRes.json();
+      extractReasoningFromResponse(responseBody);
+      const convertedBody = convertRes(responseBody);
+      res.json(convertedBody);
+
+    } catch (err) {
+      console.error(`[${requestId}] ❌ Proxy error:`, err.message);
+      res.status(500).json({ error: 'Proxy error', message: err.message });
+    }
+  }
+
+  return app;
+}
+
+function buildTargetUrl(providerUrl, targetProtocol, originalPath) {
+  const base = providerUrl.replace(/\/$/, '');
+  const hasV1Suffix = base.endsWith('/v1');
+
+  if (targetProtocol === 'openai') {
+    if (hasV1Suffix) return `${base}/chat/completions`;
+    return `${base}/v1/chat/completions`;
+  }
+
+  if (targetProtocol === 'anthropic') {
+    if (hasV1Suffix) return `${base}/messages`;
+    return `${base}/v1/messages`;
+  }
+
+  return base + originalPath;
+}
+
+module.exports = { createProxyApp };