protocol-proxy 1.0.0

package/README.md

@@ -0,0 +1,94 @@
+# Protocol Proxy
+
+OpenAI / Anthropic 协议转换透明代理服务。
+
+## 功能特性
+
+- **双向协议转换**：OpenAI ↔ Anthropic 自动识别并转换
+- **多端口代理**：每个代理端口独立运行，互不干扰
+- **默认 Model 注入**：可为每个代理配置默认 Model，请求未携带 model 时自动注入
+- **流式输出支持**：SSE 实时转换，包括工具调用场景
+- **工具调用转换**：functions/tool_calls ↔ tool_use/tool_result 完整映射
+- **管理前端**：内置 Web UI，可视化配置代理和目标
+- **Agent 身份验证**：可选 Bearer Token 认证
+- **配置热更新**：修改目标地址、Model 等配置后即时生效，无需重启代理
+
+## 快速开始
+
+```bash
+# 1. 安装依赖
+npm install
+
+# 2. 启动服务
+npm start
+
+# 3. 打开管理界面
+open http://localhost:3000
+```
+
+## 配置说明
+
+每个代理端口对应一个目标供应商配置：
+
+```json
+{
+  "proxies": [
+    {
+      "id": "default",
+      "name": "默认代理",
+      "port": 8080,
+      "requireAuth": false,
+      "authToken": null,
+      "target": {
+        "providerUrl": "https://api.openai.com",
+        "protocol": "openai",
+        "defaultModel": "gpt-4o",
+        "apiKey": "sk-xxx"
+      }
+    }
+  ]
+}
+```
+
+| 字段 | 说明 |
+|------|------|
+| `port` | 代理监听端口 |
+| `requireAuth` | 是否启用 Agent 认证 |
+| `authToken` | 认证 Token（启用时自动生成） |
+| `target.providerUrl` | 目标供应商地址 |
+| `target.protocol` | 目标协议：`openai` 或 `anthropic` |
+| `target.defaultModel` | 默认 Model，请求未携带 model 时注入 |
+| `target.apiKey` | 供应商 API Key |
+
+## 使用流程
+
+1. 在管理界面（`http://localhost:3000`）创建代理，配置端口和目标供应商
+2. Agent 配置 base URL 为代理地址，例如 `http://localhost:8080`
+3. Agent 正常发送请求（OpenAI 或 Anthropic 格式均可）
+4. 代理自动识别入站协议，必要时进行协议转换后转发到目标供应商
+
+## 技术栈
+
+- Node.js 20+（原生 fetch + ReadableStream）
+- Express（HTTP 服务）
+- 纯 HTML/JS 管理前端
+
+## 文件结构
+
+```
+protocol-proxy/
+├── server.js              # 管理服务器入口
+├── lib/
+│   ├── config-store.js    # 配置持久化
+│   ├── proxy-manager.js   # 代理端口生命周期管理
+│   ├── proxy-server.js    # 单个代理端口的请求处理
+│   ├── detector.js        # 入站协议检测
+│   └── converters/
+│       ├── openai-to-anthropic.js
+│       ├── anthropic-to-openai.js
+│       └── sse-helpers.js
+├── config/
+│   └── proxies.json       # 配置文件
+├── public/                # 前端静态文件
+└── package.json
+```

package/config/proxies.json

@@ -0,0 +1,3 @@
+{
+  "proxies": []
+}

package/lib/config-store.js

@@ -0,0 +1,119 @@
+const fs = require('fs');
+const path = require('path');
+
+const BASE_DIR = process.pkg
+  ? path.dirname(process.execPath)
+  : path.join(__dirname, '..');
+const CONFIG_PATH = path.join(BASE_DIR, 'config', 'proxies.json');
+
+let configCache = null;
+
+function normalizeModels(target) {
+  if (!target) return target;
+  const models = Array.isArray(target.models) ? target.models : [];
+  const normalized = models
+    .filter(model => typeof model === 'string')
+    .map(model => model.trim())
+    .filter(Boolean);
+
+  if (target.defaultModel && !normalized.includes(target.defaultModel)) {
+    normalized.unshift(target.defaultModel);
+  }
+
+  return {
+    ...target,
+    models: Array.from(new Set(normalized)),
+  };
+}
+
+function normalizeProxy(proxy) {
+  if (!proxy) return proxy;
+  return {
+    ...proxy,
+    target: normalizeModels(proxy.target),
+  };
+}
+
+function normalizeConfig(config) {
+  const proxies = Array.isArray(config?.proxies) ? config.proxies : [];
+  return {
+    ...config,
+    proxies: proxies.map(normalizeProxy),
+  };
+}
+
+function loadConfig() {
+  try {
+    if (!fs.existsSync(CONFIG_PATH)) {
+      configCache = { proxies: [] };
+      return configCache;
+    }
+    const raw = fs.readFileSync(CONFIG_PATH, 'utf-8');
+    configCache = normalizeConfig(JSON.parse(raw));
+    return configCache;
+  } catch (err) {
+    console.error('加载配置失败:', err.message);
+    return configCache || { proxies: [] };
+  }
+}
+
+function saveConfig(config) {
+  try {
+    const normalizedConfig = normalizeConfig(config);
+    const dir = path.dirname(CONFIG_PATH);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(CONFIG_PATH, JSON.stringify(normalizedConfig, null, 2), 'utf-8');
+    configCache = normalizedConfig;
+    return true;
+  } catch (err) {
+    console.error('保存配置失败:', err.message);
+    return false;
+  }
+}
+
+function getProxies() {
+  return loadConfig().proxies || [];
+}
+
+function getProxyById(id) {
+  return getProxies().find(p => p.id === id);
+}
+
+function addProxy(proxy) {
+  const config = loadConfig();
+  config.proxies = config.proxies || [];
+  proxy.id = proxy.id || 'proxy-' + Date.now();
+  config.proxies.push(proxy);
+  saveConfig(config);
+  return proxy;
+}
+
+function updateProxy(id, updates) {
+  const config = loadConfig();
+  const idx = (config.proxies || []).findIndex(p => p.id === id);
+  if (idx === -1) return null;
+  config.proxies[idx] = { ...config.proxies[idx], ...updates, id };
+  saveConfig(config);
+  return config.proxies[idx];
+}
+
+function removeProxy(id) {
+  const config = loadConfig();
+  const idx = (config.proxies || []).findIndex(p => p.id === id);
+  if (idx === -1) return null;
+  const removed = config.proxies.splice(idx, 1)[0];
+  saveConfig(config);
+  return removed;
+}
+
+module.exports = {
+  loadConfig,
+  saveConfig,
+  getProxies,
+  getProxyById,
+  addProxy,
+  updateProxy,
+  removeProxy,
+};

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

@@ -0,0 +1,366 @@
+/**
+ * Anthropic → OpenAI 协议转换
+ */
+
+const { encodeOpenAIEvent, encodeOpenAIDone, encodeAnthropicEvent } = require('./sse-helpers');
+
+// ==================== 请求转换 ====================
+
+function generateCallId() {
+  return 'call_' + Math.random().toString(36).slice(2, 11) + Math.random().toString(36).slice(2, 11);
+}
+
+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_sequences !== undefined) result.stop = body.stop_sequences;
+
+  // 构建 tool_use_id 映射表（Anthropic id -> OpenAI id）
+  const idMap = new Map();
+  for (const msg of (body.messages || [])) {
+    if (msg.role === 'assistant' && Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        if (block.type === 'tool_use' && block.id && !idMap.has(block.id)) {
+          idMap.set(block.id, generateCallId());
+        }
+      }
+    }
+  }
+
+  // 构建 messages 数组
+  const messages = [];
+
+  // system 转为 messages 中的 system 角色
+  if (body.system) {
+    const systemContent = typeof body.system === 'string'
+      ? body.system
+      : body.system.map(s => s.text || s).join('\n');
+    messages.push({ role: 'system', content: systemContent });
+  }
+
+  // 转换其他消息
+  for (const msg of (body.messages || [])) {
+    const converted = convertMessage(msg, idMap);
+    if (Array.isArray(converted)) {
+      messages.push(...converted);
+    } else {
+      messages.push(converted);
+    }
+  }
+
+  result.messages = messages;
+
+  // 转换 tools
+  if (body.tools && Array.isArray(body.tools)) {
+    result.tools = body.tools.map(t => ({
+      type: 'function',
+      function: {
+        name: t.name,
+        description: t.description,
+        parameters: t.input_schema || { type: 'object', properties: {} },
+      },
+    }));
+  }
+
+  // 转换 tool_choice
+  if (body.tool_choice) {
+    result.tool_choice = convertToolChoice(body.tool_choice);
+  }
+
+  return result;
+}
+
+function convertMessage(msg, idMap) {
+  if (!msg || !msg.role) return msg;
+
+  // 处理 content 数组
+  if (Array.isArray(msg.content)) {
+    const textParts = [];
+    const toolResults = [];
+    const toolUses = [];
+
+    for (const block of msg.content) {
+      if (block.type === 'text') {
+        textParts.push(block.text);
+      } else if (block.type === 'tool_result') {
+        // 使用映射后的 OpenAI 格式 id
+        const openaiId = idMap?.get(block.tool_use_id) || block.tool_use_id;
+        toolResults.push({
+          role: 'tool',
+          tool_call_id: openaiId,
+          content: typeof block.content === 'string' ? block.content : JSON.stringify(block.content),
+        });
+      } else if (block.type === 'tool_use') {
+        // 使用映射后的 OpenAI 格式 id
+        const openaiId = idMap?.get(block.id) || block.id;
+        toolUses.push({
+          id: openaiId,
+          type: 'function',
+          function: {
+            name: block.name,
+            arguments: JSON.stringify(block.input || {}),
+          },
+        });
+      }
+    }
+
+    // assistant 消息含 tool_use → 需要拆分为 assistant + tool
+    if (msg.role === 'assistant' && toolUses.length > 0) {
+      const result = [];
+      result.push({
+        role: 'assistant',
+        content: textParts.join('') || '',
+        tool_calls: toolUses,
+      });
+      return result;
+    }
+
+    // user 消息含 tool_result → 拆分为多个 tool 消息
+    if (msg.role === 'user' && toolResults.length > 0) {
+      const result = [];
+      // OpenAI 要求 tool 消息紧跟 assistant，user text 如果有的话应该放在 tool 之前
+      // 但通常 tool_result 消息不会有额外的 user text
+      if (textParts.length > 0) {
+        result.push({ role: 'user', content: textParts.join('') });
+      }
+      result.push(...toolResults);
+      return result;
+    }
+
+    // 普通情况
+    return { role: msg.role, content: textParts.join('') };
+  }
+
+  return { role: msg.role, content: msg.content };
+}
+
+function convertToolChoice(tc) {
+  if (typeof tc === 'string') {
+    if (tc === 'auto') return 'auto';
+    if (tc === 'none') return 'none';
+    if (tc === 'any') return 'required';
+    return 'auto';
+  }
+  if (tc.type === 'auto') return 'auto';
+  if (tc.type === 'none') return 'none';
+  if (tc.type === 'any') return 'required';
+  if (tc.type === 'tool') {
+    return { type: 'function', function: { name: tc.name } };
+  }
+  return 'auto';
+}
+
+// ==================== 响应转换 ====================
+
+function convertResponse(openaiBody) {
+  const choice = openaiBody.choices?.[0];
+  if (!choice) {
+    return { id: openaiBody.id, type: 'message', role: 'assistant', content: [] };
+  }
+
+  const content = [];
+  const message = choice.message || {};
+
+  // 文本内容
+  if (message.content) {
+    content.push({ type: 'text', text: message.content });
+  }
+
+  // tool_calls → tool_use
+  if (message.tool_calls) {
+    for (const tc of message.tool_calls) {
+      content.push({
+        type: 'tool_use',
+        id: tc.id,
+        name: tc.function?.name,
+        input: tc.function?.arguments ? JSON.parse(tc.function.arguments) : {},
+      });
+    }
+  }
+
+  return {
+    id: openaiBody.id,
+    type: 'message',
+    role: 'assistant',
+    content,
+    stop_reason: mapFinishReason(choice.finish_reason),
+    usage: openaiBody.usage ? {
+      input_tokens: openaiBody.usage.prompt_tokens,
+      output_tokens: openaiBody.usage.completion_tokens,
+    } : undefined,
+  };
+}
+
+function mapFinishReason(reason) {
+  if (!reason) return null;
+  if (reason === 'stop') return 'end_turn';
+  if (reason === 'length') return 'max_tokens';
+  if (reason === 'tool_calls') return 'tool_use';
+  if (reason === 'content_filter') return 'end_turn';
+  return reason;
+}
+
+// ==================== SSE 流式转换 ====================
+
+function createSSEConverter(targetModel) {
+  const state = {
+    messageId: null,
+    started: false,
+    textBlockStarted: false,
+    toolCalls: new Map(), // index -> { id, name, args }
+    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() {
+      let output = '';
+      if (state.started) {
+        // 确保发送 message_stop
+        output += encodeAnthropicEvent('message_stop', { type: 'message_stop' });
+      }
+      return output;
+    },
+  };
+}
+
+function processLine(line, state, targetModel) {
+  if (!line.startsWith('data:')) return '';
+  const dataStr = line.slice(5).trim();
+  if (dataStr === '[DONE]') {
+    return encodeAnthropicEvent('message_stop', { type: 'message_stop' });
+  }
+
+  let chunk;
+  try {
+    chunk = JSON.parse(dataStr);
+  } catch {
+    return '';
+  }
+
+  if (!chunk || !chunk.choices) return '';
+
+  const choice = chunk.choices[0];
+  if (!choice) return '';
+
+  const delta = choice.delta || {};
+  let output = '';
+
+  // 第一个有 role 的 chunk → message_start
+  if (delta.role && !state.started) {
+    state.started = true;
+    state.messageId = chunk.id;
+    output += encodeAnthropicEvent('message_start', {
+      type: 'message_start',
+      message: {
+        id: chunk.id,
+        type: 'message',
+        role: 'assistant',
+        model: targetModel,
+        content: [],
+        stop_reason: null,
+        stop_sequence: null,
+        usage: { input_tokens: 0, output_tokens: 0 },
+      },
+    });
+  }
+
+  // 文本内容
+  if (delta.content !== undefined && delta.content !== null) {
+    if (!state.textBlockStarted) {
+      state.textBlockStarted = true;
+      output += encodeAnthropicEvent('content_block_start', {
+        type: 'content_block_start',
+        index: 0,
+        content_block: { type: 'text', text: '' },
+      });
+    }
+    output += encodeAnthropicEvent('content_block_delta', {
+      type: 'content_block_delta',
+      index: 0,
+      delta: { type: 'text_delta', text: delta.content },
+    });
+  }
+
+  // tool_calls
+  if (delta.tool_calls && Array.isArray(delta.tool_calls)) {
+    for (const tc of delta.tool_calls) {
+      const idx = tc.index || 0;
+      let tool = state.toolCalls.get(idx);
+
+      if (!tool) {
+        // 新的 tool_call
+        tool = { id: tc.id, name: tc.function?.name, args: '' };
+        state.toolCalls.set(idx, tool);
+        output += encodeAnthropicEvent('content_block_start', {
+          type: 'content_block_start',
+          index: idx + 1, // text block 占 index 0
+          content_block: {
+            type: 'tool_use',
+            id: tc.id,
+            name: tc.function?.name,
+            input: {},
+          },
+        });
+      }
+
+      if (tc.function?.arguments) {
+        tool.args += tc.function.arguments;
+        output += encodeAnthropicEvent('content_block_delta', {
+          type: 'content_block_delta',
+          index: idx + 1,
+          delta: { type: 'input_json_delta', partial_json: tc.function.arguments },
+        });
+      }
+    }
+  }
+
+  // finish_reason
+  if (choice.finish_reason) {
+    const stopReason = mapFinishReason(choice.finish_reason);
+    if (state.textBlockStarted) {
+      output += encodeAnthropicEvent('content_block_stop', {
+        type: 'content_block_stop',
+        index: 0,
+      });
+    }
+    for (let i = 0; i < state.toolCalls.size; i++) {
+      output += encodeAnthropicEvent('content_block_stop', {
+        type: 'content_block_stop',
+        index: i + 1,
+      });
+    }
+    output += encodeAnthropicEvent('message_delta', {
+      type: 'message_delta',
+      delta: { stop_reason: stopReason, stop_sequence: null },
+      usage: { output_tokens: 0 },
+    });
+    output += encodeAnthropicEvent('message_stop', { type: 'message_stop' });
+  }
+
+  return output;
+}
+
+module.exports = {
+  convertRequest,
+  convertResponse,
+  createSSEConverter,
+};